Monthly Archives: November 2014

Aplikasi GRAILS dengan persistence GORM ( Grails Object Relational Mapping )

Object relational mapping ( ORM ) pada umumnya menggunakan Framework Hibernate atau EclipseLink sebagai provider-nya. Grails memiliki ORM tersendiri walaupun teknologinya mirip seperti Hibernate ataupun EclipseLink namun sedikit berbeda dalam penggunaanya. Penggunaan GORM dapat dengan mudah merelasikan Object ( Tabel ) yang satu dengan yang lain baik relasi one to many, many to one atau many to many. Sebelum melakukan setup GORM, kita harus setup DataSource terlebih dahulu untuk menentukan database yang akan digunakan, jika tidak kita akan menggunakan database default dari Grails yaitu H2 database yang sifatnya embeddable terhadap aplikasi.
1. Siapkan database dalam contoh ini kita akan menggunakan PostgreSQL dengan nama database simplegrailscrud
Masuk kedalam console psql

Membuat database simplegrailscrud dan menampilkan dalam daftar database

Masuk dan aktif kedalam database simplegrailscrud, dan buat schema master

Menampilkan search_path schema dan aktif kedalam schema master

2. Setup datasource dalam aplikasi grails.
Tampilan datasource awal dalam aplikasi grails

Merubah datasource dan database driver di Grails,

#Part datasource
pooled = true , artinya koneksi database dapat di pool / share
driverClassName = nama driver database, PostgreSQL
username = nama user database
password = password database
#Part environments
development = database untuk fase development program
test = database untuk fase test development program
production = database untuk fase production
karena kita fase development dan test, maka kedua setup environment tersebut harus sama
dbCreate = diubah ke update supaya data tidak hanya disimpan dalam memory tapi juga di-Flush kedalam database
url = diarahkan ke url database yang dituju
3. Tambah dependency driver JDBC PostgreSQL menggunakan gradle pada file BuildConfig.groovy

4. Siapkan desain ORM untuk aplikasi
dalam desain ini, Terdapat class Bank yang memiliki relasi One to Many terhadap class Branch, kemudian class Branch memiliki relasi One to Many terhapad class Account. Sehingga class Bank memiliki relasi Many to Many dengan class Account

5. Memodelkan class sesuai dengan desain yang telah ada
static hasMany = [branches: Branch] artinya class Bank memiliki banyak Branch dengan variabel branches

package simplegrailscrud

class Bank {

    static hasMany = [branches: Branch]

    String bankCode
    String bankName
    String location

    String toString(){
        return "${ bankCode - bankName }"
    }

    static mapping = {
        table name: "bank", schema: "master"
        autoTimestamp( true )
        sort 'bankCode'
        order 'asc'
    }

    static constraints = {
        bankCode( nullable: false, unique: true )
        bankName( nullable: false )
        location( maxSize: 2000 )
        branches();
    }
}

Class Branch, static belongsTo= [bank: Bank] artinya setiap data class Branch akan memiliki 1 relasi dengan class Bank menggunakan variabel bank. static hasMany = [accounts:Accounts] artinya class Branch memiliki banyak accounts.

package simplegrailscrud

class Branch {
    static belongsTo = [bank:Bank]
    static hasMany = [accounts:Accounts]

    String branchName

    static mapping = {
        table name: "branch", schema: "master"
        autoTimestamp( true )
        sort 'branchName'
        order 'asc'
    }

    static constraints = {
        bank()
        branchName()
        accounts()
    }
}

Class Accounts, static belongsTo = [branch: Branch] artinya setiap class Accounts memiliki 1 relasi dengan class Branch

package simplegrailscrud

class Accounts {

    static belongsTo = [branch : Branch]

    String accountName
    String accountType

    static mapping = {
        table name: "accounts", schema: "master"
        autoTimestamp( true )
        sort 'accountName'
        order 'asc'
    }

    static constraints = {
        accountName( nullable: false )
        accountType( inList: [ "basic", "silver", "gold" ])
        branch()
    }
}

setelah selesai membuat semua class/ domain, selanjutnya adalah men-generate class- class tersebut untuk menjadi Controller dan Views menggunakan command grails.
6. Jalankan aplikasi

Membuat aplikasi CRUD dasar menggunakan Grails

Grails merupakan framework bentukan dari Spring yang bersifat robust dan agile. Terinspirasi oleh ruby, akhirnya framework grails memiliki kapabilitas sepertu Ruby, bahkan saya katakan lebih baik. Dalam implementasinya, setelah menginstall Grails dalam OS dan setup aplikasi, Grails dapat membuat aplikasi CRUD dengan sangat cepat karena telah memiliki standar dalam scaffolding sebuah aplikasi, yakni meliputi MVC ( model , view dan controller ). Terminologi dalam konsep MVC Grails, Model dinamakan domain. Setelah domain dibuat, developer dapat men-generate view dan controller secara otomatis menggunakan command atau terminal. Sehingga, developer hanya perlu memikirkan business process aplikasi yang akan dibangun. Dalam kesempatan kali ini, saya akan share bagaimana membuat aplikasi CRUD dengan sangat cepat menggunakan Grails. IDE yang akan saya gunakan kali ini adalah Intellij IDEA. Tapi hal ini bias di gantikan oleh Eclipse, Netbeans, STS ( Spring Tool Suite ), GGTS ( Groovy and Grails Tool Suite) So, let’s start it.
1. Buat project

2. Spesifikasikan Grails sebagai framework yang akan digunakan, dan masukkan nama project

3. Struktur project aplikasi Grails. Domain classes, merupakan directory model/ POJO. Contollers directory untuk membuat business logic aplikasi. Views, merupakan directory file gsp ( servlet dalam grails ). Configuration directory untuk setup konfigurasi program. Services directory untuk menyimpan service aplikasi. Web-app untuk menyimpan file- file tambahan untuk mempercantik web seperti image, css dan java script.

4. Jalankan aplikasi grails apakah sudah bisa berjalan dengan baik atau belum.

5. Aplikasi Grails dipastikan bisa berjalan dengan baik apabila browser dapat menampilkan gambar seperti berikut

6. Selanjutnya, kita akan membuat satu domain Bank dalam project ini, yang nantinya akan otomatis men-generate controller dan view.

7. Domain Bank diatas, mirip seperti POJO pada umumnya, hanya saja tidak ada method getter dan setter. Static mapping berfungsi untuk custom display data dalam aplikasi yaitu penambahan time stamp dan sorting berdasarkan bankcode. Static constraints berfungsi seperti constraints dalam JPA pada umumnya yaitu untuk memvalidasi inputan dari user dengan batas- batas tersebut. Setelah membuat Domain, maka Controller dan View dapat degenerate secara otomatis.

8. Tampilan Controller dan View setelah degenerate Otomatis menggunakan IDE.

9. Jalankan aplikasi Grails kembali, kemudian akan Nampak salah satu url BankController. Yang mana link tersebut akan menuju scaffolding untuk domain Bank

10. Tampilan Scaffolding domain Bank. Untuk menambah data, kita gunakan New Bank

11. Penambahan data dalam domain bank. Penyimpanan data ini hanya bersifat sementara ( dalam memory ) karena kita masih belum men-set penyimpanan kedalam disk.

12. Tampilan dalam bentuk table dari data yang telah disimpan. Kita bisa melakukan modifikasi maupun penghapusan data melalui link dari masing- masing data yang ada.

13. Apabila salah satu link di klik, maka akan mengarah ke detail data tersebut. Dan terdapat tombol untuk edit maupun delete dari data yang dipilih. Proses diatas merupakan delete data setelah view detail.

14. Proses berikut menunjukkan data sedang di-update setelah view detail

15. Hasil dari data yang telah diupdate.

Install and configure Posgresql 9.3 in Linux ( Centos ) within VMWare – part II

After postgresql installer has executable access, then we can run it as an installer

Choose installation directory

Choose data directory ( Cluster )

Setup password for root, in this case root/ super user is a super user for database not in OS

Choose port where to listen

select locale

installation processing

just uncheck the stackbuilder installer, we don’t need it at this time. It will be usefull when we need additional tools/ services from Postgresql

Once the installation done, the next step is configuration and make an example to verify that our database has been installed as well. To make operation lighter, i’ll access the Linux(Centos)
through sshclient.

Terminal is on, start configuration

/*Go to installed PostgreSQL directory*/
[root@localhost /]# cd /opt/PostgreSQL/9.3/

/*open configuration file for Postgresql within pg_env.sh using VI editor*/
[root@localhost 9.3]# vi pg_env.sh 

/*copy the all lines that contain export command to setup environment variables*/
#!/bin/sh
# The script sets environment variables helpful for PostgreSQL

export PATH=/opt/PostgreSQL/9.3/bin:$PATH
export PGDATA=/opt/PostgreSQL/9.3/data
export PGDATABASE=postgres
export PGUSER=postgres
export PGPORT=5432
export PGLOCALEDIR=/opt/PostgreSQL/9.3/share/locale
export MANPATH=$MANPATH:/opt/PostgreSQL/9.3/share/man

/*Login as postgres user*/
[root@localhost 9.3]# su - postgres 
Last login: Sat Nov  8 09:45:22 EST 2014 on pts/1
-bash-4.2$ 

/*Open file ~/.bash_profile
paste the command that we've copied before, and this will be environment variables for postgresql within OS/*

[ -f /etc/profile ] && source /etc/profile

export PATH=/opt/PostgreSQL/9.3/bin:$PATH
export PGDATA=/opt/PostgreSQL/9.3/data
export PGDATABASE=postgres
export PGUSER=postgres
export PGPORT=5432
export PGLOCALEDIR=/opt/PostgreSQL/9.3/share/locale
export MANPATH=$MANPATH:/opt/PostgreSQL/9.3/share/man

/*save and logout from the postgres user session
then login again as postgres user/*

[root@localhost 9.3]# su - postgres 

/*let's try to connect to postgresql
-bash-4.2$ psql
Password: 
psql.bin (9.3.5)
Type "help" for help.

postgres=# 
/*postgresql connected already*/

/*show all database using meta data command*/

postgres=# \l
                                  List of databases
   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges   
-----------+----------+----------+-------------+-------------+-----------------------
 postgres  | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | 
 template0 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
 template1 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
(3 rows)

Install and configure Posgresql 9.3 in Linux ( Centos ) within VMWare – part I

In this chance i’d like to share with you guys about installing and configuring Postgresql 9.3 in Linux. In this post i’ll use VMWare to simulate that. The distribution of Linux that i’m going to use is Centos or we can use Red Hat. So, let’s start it.
1. Create a new virtual machine

specify linux distribution that we are going to use

Input the name of machine and location of virtual machine files

Specify disk capacity

Click customize hardware

Change the memory for virtual machine into 2GB minimum

Specify ISO file for the Operating system that will be installed

Once setup is done, click Play virtual machine

Process to instal Centos

Setup input language

Click on software selection to add standard Desktop environment

Check server with GUI and select all packages

when done, click installation destination, just check the disk to instal the OS

Start installation by clicking begin installation

On installation progress click root password to add password for root in installed OS

also create a user for the os

when done, wait installation until finished

after installation, click license information

Check accept terms

Once installation is done, login as root user then open terminal, to check IP Address

use sshclient from windows to connect with the virtual machine then upload Postgresql installer for Linux

upload done, then go to terminal again to access the uploaded file. and change the permission to be executable, and run it.

Implement C/ C++ Lib using ANDROID NDK on Android

Android uses Java as it’s native programming language. The developers should use Java to develop Android app. Unfortunately, in some case developers can’t use Java to develop. For example : to communicate with network protocol interface/ radio interface, developers better use C/ C++ library or write an Android program using C/ C++. In order to make it works, we will use Android NDK.
“The NDK is a toolset that allows you to implement parts of your app using native-code languages such as C and C++. For certain types of apps, this can be helpful so you can reuse existing code libraries written in these languages, but most apps do not need the Android NDK (taken from developers.android.com)”. Here is the steps how to do that.
1. Download Android NDK here : https://developer.android.com/tools/sdk/ndk/index.html
2. After download Android NDK, I got following file android-ndk-r10c-windows-x86_64.exe
3. Move the file into sdk directory of your Android Studio Installer

4. Just click the file, it will extract it self.
5. After self extraction successful, we will have file and directory like following

6. Create simple project using Eclipse ADT or Android Studio like following.



7. Create a directory called ‘jni’ within the root application. Like following

Jni ==> java native interface
8. Within jni directory, create a file called jni.h ( this file contains header ) and type following.
===> continue