11 February 2014

Memulai Grails (Bagian-2)

Pembaca yang budiman, pada tulisan sebelumnya kita telah belajar mengenal Grails Framework, menyiapkannya sebagai sebuah environment dalam sistem operasi komputer kita, dan sedikit praktek bagaimana membuat sebuah web aplikasi java dengan menggunakan Grails Framework. Pada tulisan kali ini kita akan melanjutkan pembahasan kita tentang Grails Framework tersebut dengan mengikuti rencana yang sudah saya buat pada tulisan sebelumnya.
Sebelum kita memulai melanjutkan pembahasan tersebut ada baiknya kita mencoba mengulas sedikit tentang apa yang sudah kita bahas pada tulisan sebelumnya. Dimana Grails merupakan sebuah framework yang dipakai dalam pembuatan web aplikasi java. Grails datang dengan tujuan agar para developer web aplikasi java langsung bisa melakukan kegiatan coding tanpa harus setup ini dan itu, dan melakukan konfigurasi yang biasanya dilakukan seperti kegiatan pembuatan web aplikasi java dengan framework yang lain. 
Distribusi Grails juga sudah dilengkapi dengan berbagai macam kelengkapan unit-unit yang dibutuhkan dalam pembuatan sebuah web aplikasi java. Salah satu unit kelengkapan yang sudah tersedia dalam distribusi Grails adalah konfigurasi “in memory database”. Konfigurasi ini terletak pada file DataSource.groovy yang ada pada folder grails-app/conf setelah kita membuat sebuah project dengan menggunakan fitur command line pada Grails. Seperti terlihat pada gambar berikut ini:
Sebetulnya segala hal yang berbau konfigurasi web aplikasi yang dibuat menggunakan Grails Framework ada dalam folder ini, hanya saja saat ini kita akan fokus membahas file DataSource.groovy, sebab ini berkaitan langsung dengan materi inti tulisan yang kita akan sama-sama belajar dari sini. 
File DataSource.groovy adalah sebuah file yang menyimpan konfigurasi database yang bisa dipakai dalam web aplikasi yang dibuat dengan menggunakan Grails Framework. Dan sudah barang tentu file ini bisa kita modifikasi sesuai dengan kebutuhan kita. Bagi kita yang sudah biasa menggunakan  Spring + Hibernate Framework dalam membuat sebuah aplikasi java, ketika melihat isi dari file ini tentunya tidak asing dengan isi dari file tersebut. Sekarang mari kita sama-sama lihat isi file DataSource.groovy tersebut.
dataSource {
    pooled = true
    driverClassName = "org.h2.Driver"
    username = "sa"
    password = ""
}

hibernate {
    cache.use_second_level_cache = true
    cache.use_query_cache = false
    cache.region.factory_class = 'net.sf.ehcache.hibernate.EhCacheRegionFactory'
}

// environment specific settings
environments {
    development {
        dataSource {
            dbCreate = "create-drop" // one of 'create', 'create-drop', 'update', 'validate', ''
            url = "jdbc:h2:mem:devDb;MVCC=TRUE;LOCK_TIMEOUT=10000"
        }
    }
    test {
        dataSource {
            dbCreate = "update"
            url = "jdbc:h2:mem:testDb;MVCC=TRUE;LOCK_TIMEOUT=10000"
        }
    }
    production {
        dataSource {
            dbCreate = "update"
            url = "jdbc:h2:prodDb;MVCC=TRUE;LOCK_TIMEOUT=10000"
            pooled = true
            properties {
               maxActive = -1
               minEvictableIdleTimeMillis=1800000
               timeBetweenEvictionRunsMillis=1800000
               numTestsPerEvictionRun=3
               testOnBorrow=true
               testWhileIdle=true
               testOnReturn=true
               validationQuery="SELECT 1"
            }
        }
    }
}
Sedikit kita bahas isi file ini, blok yang pertama adalah blok yang berisi tentang database yang digunakan, kemudian nama database driver, serta atribut username dan password dari database yang nantinya akan dipakai. Kemudian blok kedua adalah bagaimana setting parameter dari Framework Hibernate ORM yang akan digunakan. Yang menarik adalah blok ketiga yaitu blok environment, blok ini terdiri dari 3 macam sub blok yaitu development, test, dan production. Setiap sub blok ini memiliki konfigurasi yang berbeda, bisa dikatakan Grails memang membedakan setting-an setiap environment berdasarkan pengalaman-pengalaman para developer web aplikasi java.
Seperti sudah dijelaskan sebelumnya, secara default, Grails Framework datang dengan salah satunya adalah penggunaan “in memory database” dan pada file DataSource.groovy tersebut terlihat bahwa Grails secara otomatis akan mengalokasikan sebuah database yang siap digunakan untuk web aplikasi, dan ini dibuat secara otomatis pada saat kita memulai menginisialisasi sebuah Grails Project dengan menggunakan command line. Bisa dikatakan Convention over Configuration sangat terasa dalam proses ini. Jika memang kita menggunakan database selain yang sudah dipersiapkan oleh Grails ini, dengan mudah kita hanya mengganti nilai-nilai yang ada dalam file DataSource.groovy tersebut sesuai dengan konfigurasi database lain yang ingin kita gunakan.
Pembaca yang budiman, alasan saya sedikit membahas tentang DataSource tersebut adalah pada tulisan ini kita akan membuat sebuah web aplikasi java yang menggunakan database sehingga kita mendapatkan sedikit gambaran sebenarnya tentang bagaimana Grails Framework terintegrasi dengan database sebagai sebuah kelengkapan peyimpanan data dalam sebuah web aplikasi java.

Grails dengan GORM (Grails Object Relational Mapping)
Sebelum kita masuk ke pembahasan GORM ini, sedikit saya ulas kembali tentang ORM. ORM adalah suatu teknik dalam pemrograman yang secara prakteknya akan meng-generate table di dalam database berdasarkan object model yang dibuat dalam sebuah project aplikasi. Jadi secara gambaran dapat terlihat seperti ilustrasi berikut ini:
GORM adalah implementasi ORM pada Grails Framework, kenapa dinamakan GORM? Sebab memang ada aturan tersendiri yang dibuat oleh Grails Framework untuk penggunaan ORM dalam web aplikasi dengan menggunakan Grails Framework ini, untuk lebih jelasnya tentang GORM silahkan dibuka saja link berikut ini http://grails.org/doc/latest/guide/GORM.html.
Baiklah pembaca, sekarang saatnya kita mulai membangun sebuah web aplikasi dengan Grails Framework yang tentunya melibatkan GORM ini. Untuk aplikasi ini kita beri nama grails-book-catalog sebagai nama project-nya, dan skenarionya adalah membuat sebuah web aplikasi yang berupa katalog buku. Mari kita mulai, seperti pada tulisan sebelumnya, kita akan membuat web aplikasi ini dengan bantuan Grails command line, maka silahkan ketikkan perintah ini “grails create-app grails-book-catalog” pada console (command prompt).
Setelah project tersebut tercipta dengan sukses, langkah selanjutnya adalah kita akan membuat 2 buah domain model yaitu Author dan Book. Ketiklah perintah berikut ini dalam console (command prompt) “grails create-domain-class org.learn.grails.Author”, perintah tersebut berfungsi untuk meminta kepada Grails membuatkan sebuah class domain dengan nama Author dan diletakkan dalam package org.learn.grails, kemudian lakukan kembali cara tersebut namun kali ini nama domain-nya adalah Book, seperti pada gambar berikut ini:
Ya, dalam gambar terlihat Grails membuat dua buah class domain dan diletakkan pada folder grails-app/domain/org/learn/grails/. Langkah selanjutnya adalah kita menambahkan beberapa baris pada masing-masing file class domain tersebut dengan tujuan memberi properti-properti pada class tersebut dan beberapa tambahan lain terkait permasalahan relational class domain. Adapun isi dari file Author.groovy adalah sebagai berikut:
package org.learn.grails

class Author {
    String authorName
    Integer age
    String address
    
    static constraints = {
        address nullable:true, blank: true 
    }
}
Sekarang kita telah memiliki sebuah class domain bernama Author dengan properti-properti sebagai berikut: authorName dengan tipe data String, age dengan tipe data Integer dan address dengan tipe data String. Sementara untuk file Book.groovy isinya seperti berikut ini:
package org.learn.grails

class Book {

    String bookTitle
    Author author
    Integer publishedYear
    
    static constraints = {
        
    }
}
Dan untuk file class domain Book, kita memiliki sebuah properti yang terhubung dengan class domain Author, yaitu author dengan tipe data Author. Secara default setiap class domain yang kita buat dengan menggunakan perintah “grails create-domain-class” akan menambahkan blok static constraints di dalam file tersebut. Blok ini berfungsi memberikan aturan terhadap properti-properti pada class domain tersebut, secara default jika blok ini kita biarkan kosong maka seluruh properti yang ada dalam class domain tersebut bersifat mandatory (harus di isi). Dalam blok inilah kita memasukkan aturan-aturan sesuai dengan yang kita inginkan, seperti contoh class domain Author, saya membuatnya supaya properti address harus diisi. Hal lain yang perlu kita perhatikan adalah kita tidak perlu membuat tanda titik-koma ";" pada setiap baris yang hendak kita buat, sebab groovy script memang membolehkan kita tidak membubuhkan tanda titik-koma pada setiap akhir statement, dan jika anda ingin menambahkannya tentu saja dibolehkan, jadi ada tidaknya titik-koma pada akhir baris tidak mempengaruhi jalannya proses aplikasi kita.
Sampai disini pekerjaan coding kita sesungguhnya telah selesai, sekarang yang kita lakukan adalah membuat masing-masing controller dan views untuk class domain tersebut. Silahkan masukkan perintah berikut ini pada console (command prompt) milik anda, “grails generate-all org.learn.grails.Author” seperti pada gambar berikut ini:
Perintah tersebut berguna untuk meng-generate controller dan views dengan berdasarkan pada class domain Author yang sudah kita buat sebelumnya. Lakukan perintah itu kembali, tapi kali ini class domain-nya adalah Book, seperti pada gambar berikut ini:
Jika kedua perintah tersebut bisa dengan sukses kita lakukan maka selanjutnya kita periksa hasil perintah tersebut pada masing-masing folder yang ada, setiap controller akan tercipta pada folder grails-app/controller dan setiap view akan tercipta pada folder grails-app/views seperti pada gambar berikut ini:
Untuk tidak memperpanjang waktu, saya akan memberikan penjelasan tentang isi dari masing-masing file yang sudah secara otomatis ter-generated tadi setelah praktek ini selesai, karena menurut saya kalo kita break-down satu demi satu file tersebut untuk dibahas, maka tulisan ini akan sangat panjang sekali. Jadi lebih baik kita lanjutkan saja pekerjaan kita, sebab sesungguhnya sampai pada tahap ini pembuatan web aplikasi kita dengan menggunakan Grails Framework secara proses pembuatan sudah selesai.

Langkah selanjutnya adalah tinggal menjalankan aplikasi ini dengan cara mengetikkan perintah berikut ini dalam console (command prompt) anda “grails run-app” seperti pada gambar berikut ini:
Dan langkah berikutnya adalah membuka browser favorit anda dengan alamat URL http://localhost:8080/grails-book-catalog/ sehingga tampilan pada browser anda kira-kita seperti gambar berikut ini:
Pada tampilan tersebut terlihat, controller mana saja yang dapat kita akses pada web aplikasi yang sudah kita buat tadi. Halaman ini adalah halaman default yang otomatis sudah ada pada saat kita pertama kali melakukan inisiasi project menggunakan Grails command, halaman ini adalah file index.gsp yang terletak pada folder grails-app/views/ dan tentu saja nantinya kita bisa memodifikasi file ini sesuai dengan yang kita inginkan.
Sebelum kita melakukan ke langkah selanjutnya ada baiknya kita mundur sedikit untuk memahami tahapan pada saat proses generate-all yang kita lakukan sebelumnya. Pada saat kita selesai melakukan proses generate-all yang mengacu pada sebuah class domain, Grails akan membuatkan beberapa file dengan fungsi yang berbeda. File tersebut adalah:

1. Controller
File controller akan secara otomatis dibuat ketika kita melakukan perintah generate-all, file yang hasilkan pun sudah lengkap terisi code standar CRUD(create, read, update, delete) yang dibutuhkan oleh sebuah web aplikasi untuk melakukan manipulasi data ke dalam database. Perhatikan gambar anatomi controller Author yang sudah kita buat dengan mekanisme Grails command dibawah ini:
Pada file ini kita bisa melihat bahwa sebuah class domain yang kita buat melalui mekanisme Grails command sudah secara otomatis terimplementasi fungsi-fungsi CRUD, impelementasi fungsi CRUD ini dilakukan dengan mekanisme mixins, sehingga class domain yang kita buat tidak berubah code-nya, namun class domain tersebut telah meng-ekstend fungsi-fungsi CRUD. Perhatikan potongan code yang saya ambil dari salah satu controller yang sudah di-generate tadi dibawah ini:
def delete(Long id) {
        def authorInstance = Author.get(id)
        if (!authorInstance) {
              flash.message = message(code: 'default.not.found.message', args: [message(code: 'author.label', default: 'Author'), id])
              redirect(action: "list")
              return
        }

        try {
            authorInstance.delete(flush: true)
            flash.message = message(code: 'default.deleted.message', args: [message(code: 'author.label', default: 'Author'), id])
            redirect(action: "list")
        }
        catch (DataIntegrityViolationException e) {
            flash.message = message(code: 'default.not.deleted.message', args: [message(code: 'author.label', default: 'Author'), id])
            redirect(action: "show", id: id)
        }
    }

Perhatikan pada codedef authorInstance = Author.get(id)” dan baris “authorInstance.delete(flush:true)”, disanalah mixins itu befungsi, setiap class domain yang dibuat secara otomatis memiliki metode-metode seperti contoh diatas. Untuk lebih lengkapnya fungsi-fungsi apa saja yang ditempelkan secara otomatis pada class domain yang kita buat, anda dapat membaca selengkapnya pada link berikut ini http://grails.org/doc/latest/ref/Domain%20Classes/Usage.html.

2. Views
Grails Framework juga secara otomatis membuatkan views dari beberapa action yang ada pada controllerviews standar yang dibuat oleh Grails merupakan file GSP (groovy server pages) yang terdiri dari file-file : list.gsp, create.gsp, edit.gsp, show.gsp, dan _form.gsp. File yang terakhir merupakan file template dan tidak mewakili action apapun dalam controller yang dibuat. 
Seperti yang saya sebutkan di paragrap sebelumnya bahwa Grails Framework juga mengenal templating dalam implementasi GSP yang digunakannya. GSP membaca sebuah file yang merupakan template dengan sintaks code yang sudah ditentukan. Perhatikan baris code berikut ini yang saya ambil dari file edit.gsp
<fieldset class="form">
     <g:render template="form"/>
</fieldset>

Begitulah cara Grails mengenali sebuah template yang bisa dipanggil dari sebuah file GSP, sementara kesepakatan yang dibuat dalam Grails setiap file template yang akan digunakan harus didahului oleh karakter “_” (underscore) sebelum nama file-nya, contohnya file_form.gsp” tadi. Kekuatan lain dari templating yang dimiliki oleh Grails adalah penggunaan layout yang secara otomatis langsung berfungsi menjadi template sebuah form atau halaman web dari GSP itu sendiri. Perhatikan semua file GSP yang dicreate oleh Grails kecuali file _form.gsp tadi, pada baris-baris awal ada meta tag yang dituliskan untuk menentukan layout apa yang akan dipakai oleh setiap file GSP tersebut, berikut ini adalah snippet code dimana Grails menempatkan layout sebagai fungsi template-nya:
<meta name="layout" content="main">
“Content=main” artinya file tersebut menggunakan file main.gsp sebagai sebuah container. File main.groovy ini bisa ditemukan pada folder grails-app/views/layout/. Pada direktori inilah kita dapat membuat layout-layout baru yang mungkin lebih menarik dari pada yang dibuat secara otomatis oleh Grails Framework itu sendiri. Sementara untuk mempersingkat penjelasan saya akan membiarkan anda mengamati sendiri isi dari file main.gsp tadi, silahkan.

Kembali ke diskusi kita selanjutnya, langkah selanjutnya setelah anda berhasil membuka alamat http://localhost:8080/grails-book-catalog/ pada browser anda, silahkan klik link AuthorController pada halaman tersebut maka seharusnya tampilannya akan seperti gambar berikut ini:
Oleh karena data tersebut masih kosong ya, memang kita harus mengisinya, silahkan anda klik sendiri tombol New Author, dan teruskanlah melakukan kegiatan yang bisa membuktikan bahwa fungsi-fungsi CRUD dalam Grails Framework berhasil dan dapat dijalankan dengan sempurna, demikian juga dengan controller Book tadi, silahkan anda mencoba sendiri dan saya sengaja meninggalkan sebuah permasalahan yang seharusnya akan menjadi pertanyaan, silahkan cari sendiri permasalahan tersebut, dan temukan sendiri jawabannya, tanpa penjelasan dari saya, jika anda sudah menemukan permasalah tersebut dan juga jawabannya, mohon kiranya sudi men-share hal tersebut dalam komentar pada artikel ini, sehingga pembaca yang lain juga bisa merasakan hal yang sama.
Demikianlah kiranya pembahasan Grails bagian ke-dua yang bisa saya bagikan melalui tulisan ini. Sebetulnya saya sendiri mengalami sebuah pengalaman yang luar biasa ketika saya pertama kali berkenalan dengan Grails Framework ini, terutama dalam kecepatan pembuatan web aplikasi, saya sangat merasakan perbedaan yang luar biasa. Kemudian saya mencoba bermain-main dengan templating layout, semakin mengasyikkan pengalaman yang saya temui. Mungkin pada tulisan selanjutnya saya akan mencoba membagi kembali pengalaman tersebut melalui blog ini.
Sekian dulu dari saya, semoga bermanfaat dan salam.


Menteng, 11 Februari 2014

Josescalia

No comments: