Senin, 08 Juni 2015

Gradle Instalasi For Desktop

Menginstall Gradle

Berikut ini langkah-langkah setup gradle di komputer kita:
  1. Download gradle di websitenya lalu ekstrak di direktori mana saja.
  2. Buat environment variable bernama GRADLE_HOME dan isi valuenya dengan path menuju direktori gradle yang diekstrak tadi.
  3. Logout dari sistem, login lagi. Selesai. :)

Java Project Layout

Project layout sebetulnya terserah kita mau bagaimana. Tapi java punya konvensi terhadap project layout ini. Project layout yang saya gunakan biasanya ada 3 yaitu untuk project java, java web dan java enterprise. Untuk mendukung contoh penggunaan Gradle pada pembahasan artikel ini, saya akan memilih menggunakan project layout java. Layoutnya seperti ini:
1
2
3
4
5
6
7
8

+-projectRootDir
  +-src
    +-main
    | +-java
    | +-resources
    +-test
      +-java
      +-resources
Layout di atas adalah layout untuk project tunggal. Nanti kita akan buat menjadi layout multi project menggunakan Gradle. Multi project pengertiannya adalah ada satu atau banyak project di dalam satu project. Kenapa harus multi project? Karena menurut saya project akan lebih jelas peranannya karena lebih modular dan lebih gampang memaintainnya.

Gradle Project dan Task

Untuk membuat project Gradle, cukup buat direktori biasa. Misalkan direktorinya kita beri nama coba_gradle. Direktori ini nantinya akan berlaku sebagai root project. Untuk membuatnya menjadi root project Gradle, di dalam direktori coba_gradle kita harus membuat file bernama build.gradle. Sudah, cukup itu saja. :)
Gradle task adalah task yang kita coding sendiri menggunakan bahasa pemrograman Groovy. Karena kita akan membuat project java kita akan menggunakan plugin java pada Gradle. Apa peran atau fungsi plugin? Plugin pada Gradle adalah untuk meringankan kita dalam membuat task. Jika kita menggunakan plugin maka kita tidak perlu membuat task lagi.
Selanjutnya kita akan bahas isi dari file build.gradle ini yang merupakan konfigurasi dari root project yang kita buat. Saya beri contoh isi filenya:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

// Dengan apply java plugin, kita dibuatkan task-task untuk membuild program java kita
// Untuk mengeceknya, kita bisa jalankan perintah: gradle tasks
// nanti akan tampil task-task apa saja yang available. Bandingkan daftar tasknya ketika kita belum apply plugin java
apply plugin: 'java'

// Ini adalah project properties. Saya menggunakannya untuk listing masing-masing versi dari dependency yang digunakan
// Project properties ini digunakan ketika mendeklarasikan dependency
project.ext {
    JUNIT_VERSION = '4.11'
    SPRING_CORE_VERSION = '4.0.5.RELEASE'
}

// Konfigurasi untuk semua project
allprojects {
    // Konfigurasi repository maven
    // Kita menggunakan 2 repository. Local dan maven central
    repositories {
        // Konfigurasi repository lokal maven. Kita arahkan ke komputer lokal di direktori
        // /home/budi/.m2/repository
        // Bisa juga diarahkan ke local repository server seperti nexus atau artifactory
        maven {
            url "file://home/budi/.m2/repository"
        }

        // Special Gradle notation yang berguna untuk memberitahu Gradle bahwa kita menggunakan repository maven central
        mavenCentral()
    }
}

// Konfigurasi untuk tiap subproject
// Nantinya ketika kita membuat subproject, konfigurasi ini akan diwariskan ke subproject tersebut
subprojects {
    apply plugin: 'java'

    // Supaya kita tidak usah repot membuat maven task.
    apply plugin: 'maven'

    // Konfigurasi maven plugin supaya mengupload artifact ke path yang kita inginkan
    uploadArchives {
        repositories {
            mavenDeployer {
                // Path kita set ke direktori komputer lokal /home/budi/.m2/repository
                repository(url: "file://home/budi/.m2/repository/")
            }
        }
    }

    // Deklarasi dependency untuk setiap subproject
    dependencies {
        // Syntaxnya adalah <scope> "<groupId>:<artifactId>:<version>"
        // Scope ada 4, yaitu compile, runtime, testCompile, testRuntime
        // compile: dependency diperlukan saat compile ataupun development
        // runtime: dependency diperlukan saat runtime
        // testCompile: dependency diperlukan saat ngetes-ngetes program
        // testRuntime: dependency diperlukan saat program yang untuk ngetes-ngetes berjalan

        // Sebagai contoh, kita menggunakan 2 library. JUnit dan spring-context
        // Bisa kita lihat pada deklarasi version menggunakan variable dari project properties
        testCompile "junit:junit:${project.JUNIT_VERSION}"
        compile "org.springframework:spring-context:${project.SPRING_CORE_VERSION}"
    }
}

Membuat Subproject

Root project sudah dibuat. Saatnya kita membuat subproject. Untuk membuatnya sangat gampang. Cukup membuat direktori baru di dalam direktori root project. Misalkan kita buat namanya coba_gradle_subproject. Di dalam direktori ini, kita buat layout project java yang sudah dibahas sebelumnya. Jangan lupa kita juga wajib membuat file build.gradle di dalam direktori coba_gradle_subproject ini. Sebagai contoh, isinya hanya seperti ini:
1

version = '1.0.0.SNAPSHOT'
Walaupun isinya hanya seperti itu, namun karena root project sudah mendefinisikan konfigurasi pada block subprojects, maka otomatis subproject ini mewarisi apa yang sudah dideklarasikan di sana, dari plugin dan dependencynya. Variabel version ini perlu kita deklarasikan supaya nanti ketika subproject ini kita compile menjadi bentuk jar misalnya, filenamenya akan ditambahkan version dari project ini. Jadi misalkan versionnya kita set 1.0.0.SNAPSHOT, maka file yang tercipta nantinya akan bernama coba_gradle_subproject-1.0.0.SNAPSHOT.jar.
Pada file ini, kita juga bisa mendeklarasikan lagi konfigurasi yang sama dengan yang sudah ada di root project atau yang lain. Nantinya Gradle pertama kali akan membaca build.gradle dari direktori subproject, lalu membaca lagi build.gradle dari direktori root project dan mengakumulasikannya.
Nah, subproject sudah dibuat. Bagaimana caranya supaya root project mengenali subproject ini? Mari kita kembali lagi ke direktori coba_gradle. Dalam direktori tersebut, buatlah file bernama settings.gradle dan deklarasikan subprojectnya di dalam file tersebut seperti berikut:
1
2
3
4
5
6

include 'coba_gradle_subproject'

// tambahkan subproject lain jika ada
// include 'subproject2'
// include 'subproject3'
// dst...
Gambaran akhir dari struktur direktorinya adalah sebagai berikut:
1
2
3
4
5
6
7
8
9
10
11

+-coba_gradle
  +-coba_gradle_subproject
  |  +-src
  |  |  +-main
  |  |  | +-java
  |  |  | +-resources
  |  |  +-test
  |  |    +-java
  |  +-build.gradle
  +-build.gradle
  +-settings.gradle
Setup project sudah selesai :). Kekurangan dari Gradle ini adalah belum mempunyai archetype generator seperti maven. Jadi setiap kali kita membuat subproject, kita membuat layout direktori secara manual. Ke depannya Gradle diharapkan mempunyai fitur seperti maven archetype.
Diposting oleh di

Tidak ada komentar:

Posting Komentar

Langganan: Posting Komentar (Atom)