Gradle - Panduan Cepat

"Gradle is an open source build automation system"

Ant dan Maven berbagi kesuksesan besar di pasar JAWA. Ant adalah alat build pertama yang dirilis pada tahun 2000 dan dikembangkan berdasarkan ide pemrograman prosedural. Kemudian ditingkatkan dengan kemampuan untuk menerima plug-in dan manajemen ketergantungan melalui jaringan dengan bantuan Apache-IVY. Kelemahan utama adalah XML sebagai format untuk menulis skrip build, menjadi hierarki tidak baik untuk pemrograman prosedural, dan XML cenderung menjadi besar yang tidak terkelola.

Maven diperkenalkan pada tahun 2004. Ia datang dengan banyak peningkatan dibandingkan ANT. Ini mengubah strukturnya dan terus menggunakan XML untuk menulis spesifikasi build. Maven mengandalkan konvensi dan dapat mengunduh dependensi melalui jaringan. Manfaat utama maven adalah siklus hidupnya. Saat mengikuti siklus hidup yang sama untuk beberapa proyek secara terus menerus. Ini menimbulkan biaya fleksibilitas. Maven juga menghadapi beberapa masalah dalam manajemen ketergantungan. Itu tidak menangani konflik dengan baik antara versi pustaka yang sama dan skrip build kustomisasi yang kompleks sebenarnya lebih sulit untuk ditulis di maven daripada di ANT.

Akhirnya Gradle muncul pada tahun 2012. Gradle membawa beberapa fitur efisien dari kedua alat tersebut.

Fitur Gradle

Berikut ini adalah daftar fitur yang disediakan Gradle.

• Declarative builds and build-by-convention- Gradle tersedia dengan Domain Specific Language (DSL) terpisah berdasarkan bahasa Groovy. Gradle menyediakan elemen bahasa deklaratif. Elemen tersebut juga menyediakan dukungan build-by-convention untuk Java, Groovy, OSGI, Web, dan Scala.

• Language for dependency based programming - Bahasa deklaratif terletak di atas grafik tugas tujuan umum, yang dapat Anda manfaatkan sepenuhnya dalam build Anda.

• Structure your build- Gradle akhirnya memungkinkan Anda menerapkan prinsip desain umum pada bangunan Anda. Ini akan memberi Anda struktur yang sempurna untuk dibangun, sehingga Anda dapat merancang bangunan yang terstruktur dengan baik dan mudah dipelihara dan dipahami.

• Deep API - Menggunakan API ini, Anda dapat memantau dan menyesuaikan konfigurasi dan perilaku eksekusi ke intinya.

• Gradle scales - Gradle dapat dengan mudah meningkatkan produktivitasnya, dari build proyek tunggal dan sederhana hingga build multi-project perusahaan besar.

• Multi-project builds- Dukungan Gradle untuk build multi-project dan mendukung build parsial. Jika Anda membangun subproyek, Gradle akan menangani pembuatan semua subproyek yang bergantung padanya.

• Different ways to manage your builds - Gradle mendukung berbagai strategi untuk mengelola dependensi Anda.

• Gradle is the first build integration tool- Gradle didukung penuh untuk tugas ANT Anda, Maven dan infrastruktur repositori lvy untuk menerbitkan dan mengambil dependensi. Gradle juga menyediakan konverter untuk mengubah Maven pom.xml menjadi skrip Gradle.

• Ease of migration- Gradle dapat dengan mudah beradaptasi dengan struktur apa pun yang Anda miliki. Oleh karena itu, Anda selalu dapat mengembangkan build Gradle di cabang yang sama tempat Anda dapat membuat skrip langsung.

• Gradle Wrapper- Gradle Wrapper memungkinkan Anda menjalankan build Gradle pada mesin yang tidak menginstal Gradle. Ini berguna untuk integrasi server yang berkelanjutan.

• Free open source - Gradle adalah proyek sumber terbuka, dan dilisensikan di bawah Lisensi Perangkat Lunak Apache (ASL).

• Groovy- Skrip build Gradle ditulis dalam Groovy. Seluruh desain Gradle diorientasikan untuk digunakan sebagai bahasa, bukan sebagai kerangka kerja yang kaku. Dan Groovy memungkinkan Anda menulis skrip Anda sendiri dengan beberapa abstraksi. Seluruh Gradle API sepenuhnya dirancang dalam bahasa Groovy.

Mengapa Groovy?

Gradle API lengkap dirancang menggunakan bahasa Groovy. Ini adalah keuntungan dari DSL internal dibandingkan XML. Gradle adalah alat pembangunan tujuan umum pada intinya; fokus utamanya adalah proyek Java. Dalam project seperti itu, anggota tim akan sangat memahami Java dan lebih baik build dibuat setransparan mungkin untuk semua anggota tim.

Bahasa seperti Python, Groovy, atau Ruby lebih baik untuk framework build. Mengapa Groovy dipilih adalah, karena Groovy menawarkan transparansi terbesar bagi orang-orang yang menggunakan Java. Sintaks dasar Groovy sama dengan Java. Groovy memberikan lebih banyak lagi di atas itu.

Gradle adalah alat build yang dibangun berdasarkan java. Ada beberapa prasyarat yang harus diinstal sebelum menginstal pekerjaan bingkai Gradle.

Prasyarat

JDK dan Groovy adalah prasyarat untuk penginstalan Gradle.

• Gradle membutuhkan JDK versi 6 atau yang lebih baru untuk diinstal di sistem Anda. Ini menggunakan perpustakaan JDK yang diinstal dan disetel ke variabel lingkungan JAVA_HOME.

• Gradle membawa library Groovy-nya sendiri, oleh karena itu, kami tidak perlu menginstal Groovy secara eksplisit. Jika sudah diinstal, itu diabaikan oleh Gradle.

Berikut adalah langkah-langkah untuk menginstal Gradle di sistem Anda.

Langkah 1 - Verifikasi Instalasi JAVA

Pertama-tama, Anda harus menginstal Java Software Development Kit (SDK) di sistem Anda. Untuk memverifikasi ini, jalankanJava –version perintah di salah satu platform yang Anda kerjakan.

Di Windows -

Jalankan perintah berikut untuk memverifikasi instalasi Java. Saya telah menginstal JDK 1.8 di sistem saya.

C:\> java -version

Keluaran -

java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b18)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b18, mixed mode)

Di Linux -

Jalankan perintah berikut untuk memverifikasi instalasi Java. Saya telah menginstal JDK 1.8 di sistem saya.

$ java - version

Keluaran -

java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b18)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b18, mixed mode)

Kami berasumsi bahwa pembaca tutorial ini telah menginstal Java SDK versi 1.8.0_66 di sistem mereka.

Langkah 2 - Unduh File Gradle Build

Unduh Gradle versi terbaru dari tautan Unduh Gradle . Di halaman referensi, klikComplete Distributiontautan. Langkah ini umum untuk platform apa pun. Untuk ini, Anda akan mendapatkan file distribusi lengkap ke folder Unduhan Anda.

Langkah 3 - Siapkan Lingkungan untuk Gradle

Menyiapkan lingkungan berarti kita harus mengekstrak file distribusi, menyalin file perpustakaan ke lokasi yang tepat. PengaturanGRADLE_HOME dan PATH variabel lingkungan.

Langkah ini bergantung pada platform.

Di Windows -

Ekstrak file zip yang diunduh bernama gradle-2.11-all.zip dan salin file distribusi dari Downloads\gradle-2.11\ untuk C:\gradle\ lokasi.

Setelah itu tambahkan C:\gradle dan C:\gradle\bin direktori ke GRADLE_HOME dan PATHvariabel sistem. Ikuti instruksi yang diberikanright click on my computers -> click on properties -> advanced system settings -> click on environmental variables. Di sana Anda akan menemukan kotak dialog untuk membuat dan mengedit variabel sistem. Klik tombol baru untuk membuat variabel GRADLE_HOME (ikuti tangkapan layar sebelah kiri). Klik Edit untuk mengedit variabel sistem Path yang ada (ikuti gambar di sebelah kanan). Ikuti screenshot yang diberikan di bawah ini.

Di Linux -

Ekstrak file zip yang diunduh bernama gradle-2.11-all.zip maka Anda akan menemukan file yang diekstrak bernama gradle-2.11.

Anda dapat menggunakan berikut ini untuk memindahkan file distribusi dari Downloads/gradle-2.11/ untuk /opt/gradle/lokasi. Jalankan operasi ini dari direktori Download.

$ sudo mv gradle-2.11 /opt/gradle

Edit file ~ / .bashrc dan tempel konten berikut ke dalamnya dan simpan.

export ORIENT_HOME = /opt/gradle
export PATH = $PATH:

Jalankan perintah berikut untuk mengeksekusi ~/.bashrc mengajukan.

$ source ~/.bashrc

Langkah 4: Verifikasi penginstalan Gradle

Di windows:

Anda dapat menjalankan perintah berikut di command prompt.

C:\> gradle –v

Output: di sana Anda akan menemukan versi Gradle.

------------------------------------------------------------
Gradle 2.11
------------------------------------------------------------

Build time: 2016-02-08 07:59:16 UTC
Build number: none
Revision: 584db1c7c90bdd1de1d1c4c51271c665bfcba978
Groovy: 2.4.4

Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_60 (Oracle Corporation 24.60-b09)
OS: Windows 8.1 6.3 amd64

Di Linux:

Anda dapat menjalankan perintah berikut di terminal.

$ gradle –v

Output: di sana Anda akan menemukan versi Gradle.

------------------------------------------------------------
Gradle 2.11
------------------------------------------------------------

Build time: 2016-02-08 07:59:16 UTC
Build number: none
Revision: 584db1c7c90bdd1de1d1c4c51271c665bfcba978

Groovy: 2.4.4
Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_60 (Oracle Corporation 24.60-b09)
OS: Linux 3.13.0-74-generic amd64

Gradle membuat file skrip untuk menangani dua hal; satu adalahprojects dan satu lagi tasks. Setiap build Gradle mewakili satu atau beberapa project. Sebuah proyek mewakili JAR perpustakaan atau aplikasi web atau mungkin mewakili ZIP yang dirakit dari JAR yang dihasilkan oleh proyek lain. Dengan kata sederhana, sebuah proyek terdiri dari berbagai tugas. Tugas berarti bagian dari pekerjaan yang dilakukan oleh build. Sebuah tugas mungkin mengumpulkan beberapa kelas, membuat JAR, membuat Javadoc, atau menerbitkan beberapa arsip ke repositori.

Gradle menggunakan Groovy language untuk menulis skrip.

Menulis Build Script

Gradle menyediakan Domain Specific Language (DSL), untuk mendeskripsikan build. Ini menggunakan bahasa Groovy agar lebih mudah mendeskripsikan build. Setiap skrip build Gradle dienkode menggunakan UTF-8, disimpan secara offline, dan dinamai sebagai build.gradle.

build.gradle

Kami menjelaskan tentang tugas dan proyek dengan menggunakan skrip Groovy. Anda dapat menjalankan build Gradle menggunakan perintah Gradle. Perintah ini mencari file bernamabuild.gradle. Perhatikan contoh berikut yang mewakili skrip kecil yang dicetaktutorialspoint. Salin dan simpan skrip berikut ke dalam file bernamabuild.gradle. Skrip build ini mendefinisikan nama tugas hello, yang digunakan untuk mencetak string tutorialspoint.

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

Jalankan perintah berikut di prompt perintah. Ini mengeksekusi skrip di atas. Anda harus menjalankan ini, tempat file build.gradle disimpan.

C:\> gradle –q hello

Keluaran:

tutorialspoint

Jika menurut Anda tugas berfungsi mirip dengan target ANT, maka itu benar - tugas Gradle setara dengan target ANT.

Anda dapat menyederhanakan tugas hello ini dengan menentukan pintasan (mewakili simbol <<) ke doLastpernyataan. Jika Anda menambahkan pintasan ini ke tugas di atashello itu akan terlihat seperti skrip berikut.

task hello << {
   println 'tutorialspoint'
}

Seperti di atas, Anda dapat menjalankan skrip di atas menggunakan gradle –q hello perintah.

Skrip Grade terutama menggunakan dua Objek nyata, satu Objek Proyek dan satu lagi adalah Objek Skrip.

Project Object- Setiap skrip menjelaskan tentang satu atau beberapa proyek. Sementara dalam eksekusi skrip ini mengkonfigurasi Objek Proyek. Anda dapat memanggil beberapa metode dan menggunakan properti dalam skrip build Anda yang didelegasikan ke Objek Proyek.

Script Object- Gradle mengambil kode skrip ke dalam kelas yang mengimplementasikan Antarmuka Skrip dan kemudian mengeksekusinya. Ini berarti bahwa dari semua properti dan metode yang dideklarasikan oleh antarmuka skrip tersedia di skrip Anda.

Tabel berikut menjelaskan daftar standard project properties. Semua properti ini tersedia dalam skrip build Anda.

Dasar-dasar yang Groovy

Skrip build Gradle menggunakan Groovy API dengan panjang penuh. Sebagai permulaan, lihat contoh berikut.

Contoh berikut menjelaskan tentang mengonversi string menjadi huruf besar.

Salin dan simpan kode yang diberikan di bawah ini ke build.gradle mengajukan.

task upper << {
   String expString = 'TUTORIALS point'
   println "Original: " + expString
   println "Upper case: " + expString.toUpperCase()
}

Jalankan perintah berikut di prompt perintah. Ini mengeksekusi skrip yang diberikan di atas. Anda harus menjalankan ini, tempat file build.gradle disimpan.

C:\> gradle –q upper

Keluaran:

Original: TUTORIALS point
Upper case: TUTORIALS POINT

Contoh berikut menjelaskan tentang mencetak nilai parameter implisit ($ it) sebanyak 4 kali.

Salin dan simpan kode berikut ke build.gradle mengajukan.

task count << {
   4.times { 
      print "$it " 
   }
}

Jalankan perintah berikut di prompt perintah. Ini mengeksekusi skrip yang diberikan di atas. Anda harus menjalankan ini, tempat file build.gradle disimpan.

$ gradle –q count

Keluaran:

0 1 2 3

Bahasa groovy menyediakan banyak fitur di dalamnya beberapa fitur penting dibahas di bawah ini.

Metode JDK Groovy

Groovy menambahkan banyak metode berguna ke kelas Java standar. Misalnya, Iterable API dari JDK mengimplementasikan fileeach() metode yang mengulang elemen Antarmuka Iterable.

Salin dan simpan kode berikut ke build.gradle mengajukan.

task groovyJDK << {
   String myName = "Marc";
   myName.each() { 
      println "${it}" 
   };
}

Jalankan perintah berikut di prompt perintah. Ini mengeksekusi skrip yang diberikan di atas. Anda harus menjalankan ini, di mana file build.gradle disimpan.

C:\> gradle –q groovyJDK

Keluaran:

M
a
r
c

Pengakses Properti

Anda bisa secara otomatis mengakses metode pengambil dan penyetel yang sesuai dari properti tertentu dengan menentukan referensinya.

Cuplikan berikut mendefinisikan sintaksis metode pengambil dan penyetel properti buildDir.

// Using a getter method
println project.buildDir
println getProject().getBuildDir()

// Using a setter method
project.buildDir = 'target'
getProject().setBuildDir('target')

Tanda Kurung Opsional pada Panggilan Metode

Groovy berisi fitur khusus dalam pemanggilan metode, yaitu tanda kurung opsional untuk pemanggilan metode. Fitur ini juga berlaku untuk skrip Gradle.

Perhatikan sintaks berikut. Itu mendefinisikan pemanggilan metodesystemProperty dari test obyek.

test.systemProperty 'some.prop', 'value'
test.systemProperty('some.prop', 'value')

Penutupan sebagai Parameter Terakhir Metode

Gradle DSL menggunakan penutupan di banyak tempat. Di mana parameter terakhir dari suatu metode adalah penutupan, Anda dapat menempatkan penutupan setelah pemanggilan metode.

Cuplikan berikut mendefinisikan sintaks yang digunakan Closures sebagai parameter metode repositories ().

repositories {
   println "in a closure"
}
repositories() { 
   println "in a closure" 
}
repositories({ println "in a closure" })

Impor Default

Gradle secara otomatis menambahkan satu set pernyataan import ke skrip Gradle. Daftar berikut menunjukkan paket impor default ke skrip Gradle.

import org.gradle.*
import org.gradle.api.*
import org.gradle.api.artifacts.*
import org.gradle.api.artifacts.cache.*
import org.gradle.api.artifacts.component.*
import org.gradle.api.artifacts.dsl.*
import org.gradle.api.artifacts.ivy.*
import org.gradle.api.artifacts.maven.*
import org.gradle.api.artifacts.query.*
import org.gradle.api.artifacts.repositories.*
import org.gradle.api.artifacts.result.*
import org.gradle.api.component.*
import org.gradle.api.credentials.*
import org.gradle.api.distribution.*
import org.gradle.api.distribution.plugins.*
import org.gradle.api.dsl.*
import org.gradle.api.execution.*
import org.gradle.api.file.*
import org.gradle.api.initialization.*
import org.gradle.api.initialization.dsl.*
import org.gradle.api.invocation.*
import org.gradle.api.java.archives.*
import org.gradle.api.logging.*
import org.gradle.api.plugins.*
import org.gradle.api.plugins.announce.*
import org.gradle.api.plugins.antlr.*
import org.gradle.api.plugins.buildcomparison.gradle.*
import org.gradle.api.plugins.jetty.*
import org.gradle.api.plugins.osgi.*
import org.gradle.api.plugins.quality.*
import org.gradle.api.plugins.scala.*
import org.gradle.api.plugins.sonar.*
import org.gradle.api.plugins.sonar.model.*
import org.gradle.api.publish.*
import org.gradle.api.publish.ivy.*
import org.gradle.api.publish.ivy.plugins.*
import org.gradle.api.publish.ivy.tasks.*
import org.gradle.api.publish.maven.*
import org.gradle.api.publish.maven.plugins.*
import org.gradle.api.publish.maven.tasks.*
import org.gradle.api.publish.plugins.*
import org.gradle.api.reporting.*
import org.gradle.api.reporting.components.*
import org.gradle.api.reporting.dependencies.*
import org.gradle.api.reporting.model.*
import org.gradle.api.reporting.plugins.*
import org.gradle.api.resources.*
import org.gradle.api.specs.*
import org.gradle.api.tasks.*
import org.gradle.api.tasks.ant.*
import org.gradle.api.tasks.application.*
import org.gradle.api.tasks.bundling.*
import org.gradle.api.tasks.compile.*
import org.gradle.api.tasks.diagnostics.*
import org.gradle.api.tasks.incremental.*
import org.gradle.api.tasks.javadoc.*
import org.gradle.api.tasks.scala.*
import org.gradle.api.tasks.testing.*
import org.gradle.api.tasks.testing.junit.*
import org.gradle.api.tasks.testing.testng.*
import org.gradle.api.tasks.util.*
import org.gradle.api.tasks.wrapper.*
import org.gradle.authentication.*
import org.gradle.authentication.http.*
import org.gradle.buildinit.plugins.*
import org.gradle.buildinit.tasks.*
import org.gradle.external.javadoc.*
import org.gradle.ide.cdt.*
import org.gradle.ide.cdt.tasks.*
import org.gradle.ide.visualstudio.*
import org.gradle.ide.visualstudio.plugins.*
import org.gradle.ide.visualstudio.tasks.*
import org.gradle.ivy.*
import org.gradle.jvm.*
import org.gradle.jvm.application.scripts.*
import org.gradle.jvm.application.tasks.*
import org.gradle.jvm.platform.*
import org.gradle.jvm.plugins.*
import org.gradle.jvm.tasks.*
import org.gradle.jvm.tasks.api.*
import org.gradle.jvm.test.*
import org.gradle.jvm.toolchain.*
import org.gradle.language.assembler.*
import org.gradle.language.assembler.plugins.*
import org.gradle.language.assembler.tasks.*
import org.gradle.language.base.*
import org.gradle.language.base.artifact.*
import org.gradle.language.base.plugins.*
import org.gradle.language.base.sources.*
import org.gradle.language.c.*
import org.gradle.language.c.plugins.*
import org.gradle.language.c.tasks.*
import org.gradle.language.coffeescript.*
import org.gradle.language.cpp.*
import org.gradle.language.cpp.plugins.*
import org.gradle.language.cpp.tasks.*
import org.gradle.language.java.*
import org.gradle.language.java.artifact.*
import org.gradle.language.java.plugins.*
import org.gradle.language.java.tasks.*
import org.gradle.language.javascript.*
import org.gradle.language.jvm.*
import org.gradle.language.jvm.plugins.*
import org.gradle.language.jvm.tasks.*
import org.gradle.language.nativeplatform.*
import org.gradle.language.nativeplatform.tasks.*
import org.gradle.language.objectivec.*
import org.gradle.language.objectivec.plugins.*
import org.gradle.language.objectivec.tasks.*
import org.gradle.language.objectivecpp.*
import org.gradle.language.objectivecpp.plugins.*
import org.gradle.language.objectivecpp.tasks.*
import org.gradle.language.rc.*
import org.gradle.language.rc.plugins.*
import org.gradle.language.rc.tasks.*
import org.gradle.language.routes.*
import org.gradle.language.scala.*
import org.gradle.language.scala.plugins.*
import org.gradle.language.scala.tasks.*
import org.gradle.language.scala.toolchain.*
import org.gradle.language.twirl.*
import org.gradle.maven.*
import org.gradle.model.*
import org.gradle.nativeplatform.*
import org.gradle.nativeplatform.platform.*
import org.gradle.nativeplatform.plugins.*
import org.gradle.nativeplatform.tasks.*
import org.gradle.nativeplatform.test.*
import org.gradle.nativeplatform.test.cunit.*
import org.gradle.nativeplatform.test.cunit.plugins.*
import org.gradle.nativeplatform.test.cunit.tasks.*
import org.gradle.nativeplatform.test.googletest.*
import org.gradle.nativeplatform.test.googletest.plugins.*
import org.gradle.nativeplatform.test.plugins.*
import org.gradle.nativeplatform.test.tasks.*
import org.gradle.nativeplatform.toolchain.*
import org.gradle.nativeplatform.toolchain.plugins.*
import org.gradle.platform.base.*
import org.gradle.platform.base.binary
import org.gradle.platform.base.component.*
import org.gradle.platform.base.plugins.*
import org.gradle.platform.base.test.*
import org.gradle.play.*
import org.gradle.play.distribution.*
import org.gradle.play.platform.*
import org.gradle.play.plugins.*
import org.gradle.play.tasks.*
import org.gradle.play.toolchain.*
import org.gradle.plugin.use.*
import org.gradle.plugins.ear.*
import org.gradle.plugins.ear.descriptor.*
import org.gradle.plugins.ide.api.*
import org.gradle.plugins.ide.eclipse.*
import org.gradle.plugins.ide.idea.*
import org.gradle.plugins.javascript.base.*
import org.gradle.plugins.javascript.coffeescript.*
import org.gradle.plugins.javascript.envjs.*
import org.gradle.plugins.javascript.envjs.browser.*
import org.gradle.plugins.javascript.envjs.http.*
import org.gradle.plugins.javascript.envjs.http.simple.*
import org.gradle.plugins.javascript.jshint.*
import org.gradle.plugins.javascript.rhino.*
import org.gradle.plugins.javascript.rhino.worker.*
import org.gradle.plugins.signing.*
import org.gradle.plugins.signing.signatory.*
import org.gradle.plugins.signing.signatory.pgp.*
import org.gradle.plugins.signing.type.*
import org.gradle.plugins.signing.type.pgp.*
import org.gradle.process.*
import org.gradle.sonar.runner.*
import org.gradle.sonar.runner.plugins.*
import org.gradle.sonar.runner.tasks.*
import org.gradle.testing.jacoco.plugins.*
import org.gradle.testing.jacoco.tasks.*
import org.gradle.testkit.runner.*
import org.gradle.util.*

Skrip build Gradle menjelaskan tentang satu atau beberapa Project. Setiap proyek terdiri dari tugas yang berbeda. Tugas adalah bagian dari pekerjaan yang dilakukan oleh build. Tugas tersebut mungkin mengompilasi beberapa kelas, menyimpan file kelas ke dalam folder target terpisah, membuat JAR, membuat Javadoc, atau menerbitkan beberapa pencapaian ke repositori.

Bab ini menjelaskan tentang apa itu tugas dan bagaimana menghasilkan dan melaksanakan tugas.

Mendefinisikan Tugas

Tugas adalah kata kunci yang digunakan untuk mendefinisikan tugas ke dalam skrip build. Perhatikan contoh berikut yang mewakili tugas bernamahello yang mencetak tutorialspoint. Salin dan simpan skrip berikut ke dalam file bernamabuild.gradle. Skrip build ini mendefinisikan nama tugas hello yang digunakan untuk mencetak string tutorialspoint.

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

Jalankan perintah berikut di prompt perintah. Ini mengeksekusi skrip di atas. Anda harus menjalankan ini di tempat file build.gradle disimpan.

C:\> gradle –q hello

Keluaran:

tutorialspoint

Anda dapat menyederhanakan tugas hello ini dengan menentukan pintasan (mewakili simbol <<) ke doLastpernyataan. Jika Anda menambahkan pintasan ini ke tugas di atashello itu akan terlihat seperti skrip berikut.

task hello << {
   println 'tutorialspoint'
}

Anda dapat menjalankan skrip di atas menggunakan gradle –q hello perintah.

Berikut adalah beberapa variasi dalam mendefinisikan tugas, lihatlah. Contoh berikut mendefinisikan tugashello.

Salin dan simpan kode berikut ke build.gradle mengajukan.

task (hello) << {
   println "tutorialspoint"
}

Jalankan perintah berikut di prompt perintah. Ini mengeksekusi skrip yang diberikan di atas. Anda harus menjalankan ini, di mana file build.gradle disimpan.

C:\> gradle –q hello

Keluaran:

tutorialspoint

Anda juga dapat menggunakan string untuk nama tugas. Lihatlah contoh halo yang sama. Di sini kita akan menggunakan String sebagai tugas.

Salin dan simpan kode berikut ke build.gradle mengajukan.

task('hello') << {
   println "tutorialspoint"
}

Jalankan perintah berikut di prompt perintah. Ini mengeksekusi skrip yang diberikan di atas. Anda harus menjalankan ini, di mana file build.gradle disimpan.

C:\> gradle –q hello

Keluaran:

tutorialspoint

Anda juga dapat menggunakan sintaks alternatif untuk menentukan tugas. Itu menggunakan metode create () untuk mendefinisikan tugas. Lihatlah contoh halo yang sama yang diberikan di bawah ini.

Salin dan simpan kode yang diberikan di bawah ini ke build.gradle mengajukan.

tasks.create(name: 'hello') << {
   println "tutorialspoint"
}

Jalankan perintah berikut di prompt perintah. Ini mengeksekusi skrip yang diberikan di atas. Anda harus menjalankan ini, di mana file build.gradle disimpan.

C:\> gradle –q hello

Keluaran:

tutorialspoint

Menemukan Tugas

Jika Anda ingin menemukan tugas yang Anda tentukan dalam file build, Anda harus menggunakan properti proyek standar masing-masing. Itu berarti setiap tugas tersedia sebagai properti proyek, menggunakan nama tugas sebagai nama properti.

Perhatikan kode berikut yang mengakses tugas sebagai properti.

Salin dan simpan kode yang diberikan di bawah ini ke build.gradle mengajukan.

task hello

println hello.name
println project.hello.name

Jalankan perintah berikut di prompt perintah. Ini mengeksekusi skrip yang diberikan di atas. Anda harus menjalankan ini, di mana file build.gradle disimpan.

C:\> gradle –q hello

Keluaran:

hello
hello

Anda juga dapat menggunakan semua properti melalui kumpulan tugas.

Salin dan simpan kode berikut ke build.gradle mengajukan.

task hello

println tasks.hello.name
println tasks['hello'].name

Jalankan perintah berikut di prompt perintah. Ini mengeksekusi skrip yang diberikan di atas. Anda harus menjalankan ini, di mana file build.gradle disimpan.

C:\> gradle –q hello

Keluaran:

hello
hello

Anda juga dapat mengakses jalur tugas menggunakan tugas. Untuk ini, Anda bisa memanggil metode getByPath () dengan nama tugas, atau jalur relatif, atau jalur absolut.

Salin dan simpan kode yang diberikan di bawah ini ke build.gradle mengajukan.

project(':projectA') {
   task hello
}
task hello

println tasks.getByPath('hello').path
println tasks.getByPath(':hello').path
println tasks.getByPath('projectA:hello').path
println tasks.getByPath(':projectA:hello').path

Jalankan perintah berikut di prompt perintah. Ini mengeksekusi skrip yang diberikan di atas. Anda harus menjalankan ini, di mana file build.gradle disimpan.

C:\> gradle –q hello

Keluaran:

:hello
:hello
:projectA:hello
:projectA:hello

Menambahkan Dependensi ke Tugas

Anda dapat membuat suatu tugas bergantung pada tugas lain yang berarti ketika satu tugas selesai maka hanya tugas lain yang akan dimulai. Setiap tugas dibedakan dengan nama tugas. Kumpulan nama tugas dirujuk oleh kumpulan tugasnya. Untuk merujuk ke tugas di proyek lain, Anda harus menggunakan jalur proyek sebagai awalan ke nama tugas masing-masing.

Contoh berikut yang menambahkan ketergantungan dari taskX ke taskY.

Salin dan simpan kode yang diberikan di bawah ini ke build.gradlemengajukan. Perhatikan kode berikut.

task taskX << {
   println 'taskX'
}
task taskY(dependsOn: 'taskX') << {
   println "taskY"
}

Jalankan perintah berikut di prompt perintah. Ini mengeksekusi skrip yang diberikan di atas. Anda harus menjalankan ini, di manabuild.gradle penyimpanan file.

C:\> gradle –q taskY

Keluaran:

taskX
taskY

Contoh di atas menambahkan ketergantungan pada tugas dengan menggunakan namanya. Ada cara lain untuk mencapai ketergantungan tugas yang mendefinisikan ketergantungan menggunakan objek Tugas.

Mari kita ambil contoh yang sama dari taskY yang bergantung pada taskX tetapi kita menggunakan objek tugas daripada nama referensi tugas.

Salin dan simpan kode berikut ke build.gradle mengajukan.

task taskY << {
   println 'taskY'
}
task taskX << {
   println 'taskX'
}
taskY.dependsOn taskX

Jalankan perintah berikut di prompt perintah. Anda harus menjalankan ini di tempat file build.gradle disimpan.

C:\> gradle –q taskY

Keluaran:

taskX
taskY

Contoh di atas menambahkan ketergantungan pada tugas dengan menggunakan namanya. Ada cara lain untuk mencapai ketergantungan tugas yaitu mendefinisikan ketergantungan menggunakan objek Tugas.

Di sini kita mengambil contoh yang sama bahwa taskY bergantung pada taskX tetapi kita menggunakan objek tugas daripada nama referensi tugas. Coba lihat.

Salin dan simpan kode yang diberikan di bawah ini ke build.gradlemengajukan. Perhatikan kode berikut.

task taskX << {
   println 'taskX'
}
taskX.dependsOn {
   tasks.findAll { 
      task → task.name.startsWith('lib') 
   }
}
task lib1 << {
   println 'lib1'
}
task lib2 << {
   println 'lib2'
}
task notALib << {
   println 'notALib'
}

Jalankan perintah berikut di prompt perintah. Ini mengeksekusi skrip yang diberikan di atas. Anda harus menjalankan ini, di manabuild.gradle penyimpanan file.

C:\> gradle –q taskX

Keluaran:

lib1
lib2
taskX

Menambahkan Deskripsi ke Tugas

Anda dapat menambahkan deskripsi ke tugas Anda. Deskripsi ini ditampilkan saat menjalankanGradle tasks. Ini dimungkinkan dengan menggunakan kata kunci deskripsi.

Salin dan simpan kode berikut ke build.gradlemengajukan. Perhatikan kode berikut.

task copy(type: Copy) {
   description 'Copies the resource directory to the target directory.'
   from 'resources'
   into 'target'
   include('**/*.txt', '**/*.xml', '**/*.properties')
   println("description applied")
}

Jalankan perintah berikut di prompt perintah. Anda harus menjalankan ini di tempat file build.gradle disimpan.

C:\> gradle –q copy

Jika perintah berhasil dijalankan, Anda akan mendapatkan output berikut.

description applied

Melewati Tugas

Melewati tugas dapat dilakukan dengan melewati penutupan predikat. Ini hanya mungkin jika metode tugas atau penutupan melemparStopExecutionException sebelum pekerjaan sebenarnya dari suatu tugas dijalankan.

Salin dan simpan kode berikut ke build.gradle mengajukan.

task eclipse << {
   println 'Hello Eclipse'
}

// #1st approach - closure returning true, if the task should be executed, false if not.
eclipse.onlyIf {
   project.hasProperty('usingEclipse')
}

// #2nd approach - alternatively throw an StopExecutionException() like this
eclipse.doFirst {
   if(!usingEclipse) {
      throw new StopExecutionException()
   }
}

Jalankan perintah berikut di prompt perintah. Anda harus menjalankan ini di tempat file build.gradle disimpan.

C:\> gradle –q eclipse

Struktur Tugas

Gradle memiliki fase yang berbeda, saat mengerjakan tugas. Pertama-tama, ada fase konfigurasi, di mana kode, yang ditentukan secara langsung dalam penutupan tugas, dijalankan. Blok konfigurasi dijalankan untuk setiap tugas yang tersedia dan tidak hanya untuk tugas-tugas yang kemudian benar-benar dijalankan.

Setelah fase konfigurasi, fase eksekusi menjalankan kode di dalam file doFirst atau doLast penutupan tugas-tugas tersebut, yang sebenarnya dijalankan.

Skrip build Gradle mendefinisikan proses untuk membangun proyek; setiap proyek berisi beberapa dependensi dan beberapa publikasi. Dependensi berarti hal-hal yang mendukung untuk membangun proyek Anda seperti file JAR yang diperlukan dari proyek lain dan JAR eksternal seperti JDBC JAR atau Eh-cache JAR di jalur kelas. Publikasi berarti hasil dari proyek, seperti file kelas pengujian dan file build, seperti file perang.

Hampir semua proyek tidak berdiri sendiri. Mereka membutuhkan file yang dibangun oleh proyek lain untuk mengompilasi dan menguji file sumber. Misalnya, untuk menggunakan Hibernate dalam proyek ini, Anda perlu menyertakan beberapa JAR Hibernasi di jalur kelas. Gradle menggunakan beberapa skrip khusus untuk menentukan dependensi, yang perlu diunduh.

Gradle menangani pembuatan dan penerbitan hasilnya di suatu tempat. Penerbitan didasarkan pada tugas yang Anda tentukan. Ini mungkin ingin menyalin file ke direktori lokal, atau mengunggahnya ke Maven jarak jauh atau repositori lvy atau Anda mungkin menggunakan file dari proyek lain dalam multi-proyek build yang sama. Kita bisa menyebut proses penerbitan tugas adalah publikasi.

Menyatakan Ketergantungan Anda

Konfigurasi ketergantungan tidak lain adalah mendefinisikan sekumpulan ketergantungan. Anda dapat menggunakan fitur ini untuk mendeklarasikan sarana ketergantungan eksternal yang ingin Anda unduh dari web. Ini mendefinisikan standart berbeda seperti berikut.

apply plugin: 'java'

repositories {
   mavenCentral()
}

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
   testCompile group: 'junit', name: 'junit', version: '4.+'
}

Konfigurasi Ketergantungan

Konfigurasi dependensi tidak lain adalah mendefinisikan sekumpulan dependensi. Anda dapat menggunakan fitur ini untuk mendeklarasikan dependensi eksternal, yang ingin Anda download dari web. Ini mendefinisikan konfigurasi standar yang berbeda berikut ini.

• Compile - Ketergantungan yang diperlukan untuk menyusun sumber produksi proyek.

• Runtime- Dependensi yang diperlukan oleh kelas produksi pada waktu proses. Secara default, juga menyertakan dependensi waktu kompilasi.

• Test Compile- Ketergantungan yang diperlukan untuk mengompilasi sumber pengujian proyek. Secara default, ini menyertakan kelas produksi yang dikompilasi dan dependensi waktu kompilasi.

• Test Runtime- Ketergantungan yang diperlukan untuk menjalankan tes. Secara default, ini menyertakan runtime dan uji kompilasi dependensi.

Dependensi Eksternal

Dependensi eksternal adalah salah satu jenis dependensi. Ini adalah ketergantungan pada beberapa file yang dibangun di luar pada build saat ini, dan disimpan dalam beberapa jenis repositori, seperti Maven central, atau Maven perusahaan atau repositori lvy, atau direktori I sistem file lokal.

Potongan kode berikut adalah untuk menentukan ketergantungan eksternal. Gunakan kode ini dibuild.gradle mengajukan.

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
}

Ketergantungan eksternal mendeklarasikan ketergantungan eksternal dan formulir pintasan terlihat seperti "group: name: version".

Repositori

Sambil menambahkan dependensi eksternal. Gradle mencarinya di repositori. Repositori hanyalah kumpulan file, diatur berdasarkan grup, nama dan versi. Secara default, Gradle tidak mendefinisikan repositori apa pun. Kami harus mendefinisikan setidaknya satu repositori secara eksplisit. Potongan kode berikut menjelaskan bagaimana mendefinisikan repositori maven. Gunakan kode ini dibuild.gradle mengajukan.

repositories {
   mavenCentral()
}

Kode berikut adalah untuk mendefinisikan maven jauh. Gunakan kode ini dibuild.gradle mengajukan.

repositories {
   maven {
      url "http://repo.mycompany.com/maven2"
   }
}

Penerbitan Artefak

Konfigurasi ketergantungan juga digunakan untuk menerbitkan file. File yang dipublikasikan ini disebut artefak. Biasanya, kami menggunakan plugin untuk menentukan artefak. Namun, Anda perlu memberi tahu Gradle tempat memublikasikan artefak tersebut. Anda dapat melakukannya dengan melampirkan repositori ke tugas arsip unggah. Lihatlah sintaks berikut untuk menerbitkan repositori Maven. Saat menjalankan, Gradle akan menghasilkan dan mengupload Pom.xml sesuai persyaratan proyek. Gunakan kode ini dibuild.gradle mengajukan.

apply plugin: 'maven'

uploadArchives {
   repositories {
      mavenDeployer {
         repository(url: "file://localhost/tmp/myRepo/")
      }
   }
}

Plugin tidak lain adalah serangkaian tugas, hampir semua tugas yang berguna seperti tugas kompilasi, pengaturan objek domain, pengaturan file sumber, dll ditangani oleh plugin. Menerapkan plugin ke sebuah proyek berarti memungkinkan plugin untuk memperluas kemampuan proyek. Plugin dapat melakukan hal-hal seperti -

• Perluas model Gradle dasar (misalnya, tambahkan elemen DSL baru yang dapat dikonfigurasi).
• Konfigurasi proyek sesuai dengan konversi (misalnya menambahkan tugas baru atau mengkonfigurasi default yang masuk akal).
• Terapkan konfigurasi khusus (misalnya menambahkan repositori organisasi atau menegakkan standar).

Jenis Plugin

Ada dua jenis plugin di Gradle, plugin skrip dan plugin biner. Plugin skrip adalah skrip build tambahan yang memberikan pendekatan deklaratif untuk memanipulasi build. Ini biasanya digunakan dalam build. Plugin biner adalah kelas yang mengimplementasikan antarmuka plugin dan mengadopsi pendekatan terprogram untuk memanipulasi build. Plugin biner dapat ditempatkan dengan skrip build, dengan hierarki proyek, atau secara eksternal dalam JAR plugin.

Menerapkan Plugin

Project.apply()Metode API digunakan untuk menerapkan plugin tertentu. Anda dapat menggunakan plugin yang sama untuk beberapa kali. Ada dua jenis plugin, satu adalah plugin skrip dan yang kedua adalah plugin biner.

Plugin Skrip

Plugin skrip dapat diterapkan dari skrip pada sistem file lokal atau di lokasi yang jauh. Lokasi sistem file relatif terhadap direktori proyek, sedangkan lokasi skrip jarak jauh menentukan URL HTTP. Lihatlah cuplikan kode berikut. Ini digunakan untuk menerapkanother.gradleplugin ke skrip build. Gunakan kode ini dibuild.gradle mengajukan.

apply from: 'other.gradle'

Plugin Biner

Setiap plugin diidentifikasi oleh id plugin di beberapa plugin inti menggunakan nama pendek untuk menerapkannya dan beberapa plugin Komunitas menggunakan nama yang memenuhi syarat untuk plugin id. Beberapa waktu memungkinkan untuk menentukan kelas plugin.

Perhatikan cuplikan kode berikut. Ini menunjukkan bagaimana menerapkan plugin java dengan menggunakan tipenya. Gunakan kode ini dibuild.gradle mengajukan.

apply plugin: JavaPlugin

Lihatlah kode berikut untuk menerapkan plugin inti menggunakan nama pendek. Gunakan kode ini dibuild.gradle mengajukan.

plugins {
   id 'java'
}

Lihatlah kode berikut untuk menerapkan plugin komunitas menggunakan nama pendek. Gunakan kode ini dibuild.gradle mengajukan.

plugins {
   id "com.jfrog.bintray" version "0.4.1"
}

Menulis Plugin Kustom

Saat membuat plugin khusus, Anda perlu menulis implementasi plugin. Gradle membuat instance plugin dan memanggil instance plugin menggunakan metode Plugin.apply (). Contoh berikut berisi plugin salam, yang menambahkan tugas halo ke proyek. Perhatikan kode berikut. Gunakan kode ini dibuild.gradle mengajukan.

apply plugin: GreetingPlugin

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.task('hello') << {
         println "Hello from the GreetingPlugin"
      }
   }
}

Gunakan kode berikut untuk menjalankan skrip di atas.

C:\> gradle -q hello

Keluaran:

Hello from the GreetingPlugin

Mendapatkan Input dari Build

Sebagian besar plugin memerlukan dukungan konfigurasi dari skrip build. Proyek Gradle memiliki objek ExtensionContainer terkait yang membantu melacak semua setelan dan properti yang diteruskan ke plugin.

Mari tambahkan objek ekstensi sederhana ke proyek. Di sini kami menambahkan objek ekstensi salam ke proyek, yang memungkinkan Anda untuk mengkonfigurasi salam. Gunakan kode ini dibuild.gradle mengajukan.

apply plugin: GreetingPlugin

greeting.message = 'Hi from Gradle'

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      // Add the 'greeting' extension object
      project.extensions.create("greeting", GreetingPluginExtension)
		
      // Add a task that uses the configuration
      project.task('hello') << {
         println project.greeting.message
      }
   }
}

class GreetingPluginExtension {
   def String message = 'Hello from GreetingPlugin'
}

Gunakan kode berikut untuk menjalankan skrip di atas.

C:\> gradle -q hello

Keluaran:

Hi from Gradle

Dalam contoh ini, GreetingPlugin adalah objek Groovy biasa dengan bidang bernama pesan. Objek ekstensi ditambahkan ke daftar plugin dengan salam nama. Objek ini kemudian akan tersedia sebagai properti proyek dengan nama yang sama dengan objek ekstensi.

Gradle menambahkan penutupan konfigurasi untuk setiap objek ekstensi, sehingga Anda dapat mengelompokkan setelan tersebut menjadi satu. Perhatikan kode berikut. Gunakan kode ini dibuild.gradle mengajukan.

apply plugin: GreetingPlugin

greeting {
   message = 'Hi'
   greeter = 'Gradle'
}

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.extensions.create("greeting", GreetingPluginExtension)
		
      project.task('hello') << {
         println "${project.greeting.message} from ${project.greeting.greeter}"
      }
   }
}

class GreetingPluginExtension {
   String message
   String greeter
}

Gunakan kode berikut untuk menjalankan skrip di atas.

C:\> gradle -q hello

Keluaran:

Hello from Gradle

Plugin Gradle Standar

Ada berbagai plugin yang disertakan dalam distribusi Gradle.

Plugin Bahasa

Plugin ini menambahkan dukungan untuk berbagai bahasa yang dapat dikompilasi dan dijalankan di JVM.

Menginkubasi Plugin Bahasa

Plugin ini menambahkan dukungan untuk berbagai bahasa.

Gradle menyediakan baris perintah untuk menjalankan skrip build. Itu dapat menjalankan lebih dari satu tugas dalam satu waktu. Bab ini menjelaskan cara menjalankan beberapa tugas menggunakan opsi berbeda.

Menjalankan Banyak Tugas

Anda dapat menjalankan banyak tugas dari satu file build. Gradle bisa menangani file build itu menggunakangradle command. Perintah ini akan mengkompilasi setiap tugas dalam urutan yang terdaftar dan menjalankan setiap tugas bersama dengan dependensi menggunakan opsi yang berbeda.

Example- Ada empat tugas - tugas1, tugas2, tugas3, dan tugas4. Task3 dan task4 bergantung pada tugas 1 dan tugas2. Perhatikan diagram berikut.

Dalam 4 tugas di atas saling bergantung yang diwakili dengan simbol panah. Perhatikan kode berikut. Salin dapat menempelkannya kebuild.gradle mengajukan.

task task1 << {
   println 'compiling source'
}

task task2(dependsOn: task1) << {
   println 'compiling unit tests'
}

task task3(dependsOn: [task1, task2]) << {
   println 'running unit tests'
}

task task4(dependsOn: [task1, task3]) << {
   println 'building the distribution'
}

Anda dapat menggunakan kode berikut untuk menyusun dan menjalankan tugas di atas.

C:\> gradle task4 test

Keluaran:

:task1
compiling source
:task2
compiling unit tests
:task3
running unit tests
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

Tidak Termasuk Tugas

Saat mengecualikan tugas dari eksekusi, Anda dapat menggunakan opsi –x bersama dengan perintah gradle dan menyebutkan nama tugas, yang ingin Anda kecualikan.

Gunakan perintah berikut untuk mengecualikan task4 dari skrip di atas.

C:\> gradle task4 -x test

Keluaran:

:task1
compiling source
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

Melanjutkan Build Saat Terjadi Kegagalan

Gradle akan membatalkan eksekusi dan gagal membangun segera setelah ada tugas yang gagal. Anda dapat melanjutkan eksekusi bahkan ketika terjadi kegagalan. Untuk ini, Anda harus menggunakan opsi –lanjutkan dengan perintah gradle. Ini menangani setiap tugas secara terpisah bersama dengan ketergantungannya. Dan poin penting utamanya adalah akan menangkap setiap kegagalan yang dihadapi dan melaporkan di akhir eksekusi build. Misalkan jika suatu tugas gagal maka tugas selanjutnya yang bergantung juga tidak akan dijalankan.

Memilih Build Yang Akan Dilakukan

Saat Anda menjalankan perintah gradle, ini mencari file build di direktori saat ini. Anda dapat menggunakan opsi –b untuk memilih file build tertentu bersama dengan jalur absolut. Contoh berikut memilih proyek hello frommyproject.gradle file yang terletak di subdir/ lihatlah itu.

task hello << {
   println "using build file '$buildFile.name' in '$buildFile.parentFile.name'."
}

Anda dapat menggunakan perintah berikut untuk menjalankan skrip di atas.

C:\> gradle -q -b subdir/myproject.gradle hello

Keluaran:

using build file 'myproject.gradle' in 'subdir'.

Memperoleh Informasi Build

Gradle menyediakan beberapa tugas bawaan untuk mengambil detail informasi terkait tugas dan proyek. Ini dapat berguna untuk memahami struktur dan dependensi build Anda dan untuk masalah debugging. Anda dapat menggunakan plugin laporan proyek untuk menambahkan tugas ke proyek Anda, yang akan menghasilkan laporan ini.

Daftar Proyek

Anda dapat membuat daftar hierarki proyek dari proyek yang dipilih dan sub proyek mereka menggunakan gradle –q projectsperintah. Berikut adalah contohnya, gunakan perintah berikut untuk mencantumkan semua proyek dalam file build.

C:\> gradle -q projects

Keluaran:

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'projectReports'
+--- Project ':api' - The shared API for the application
\--- Project ':webapp' - The Web application implementation

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :api:tasks

Laporan tersebut menunjukkan deskripsi setiap proyek jika ditentukan. Anda dapat menggunakan perintah berikut untuk menentukan deskripsi. Tempel dibuild.gradle mengajukan.

description = 'The shared API for the application'

Daftar Tugas

Anda dapat membuat daftar semua tugas yang termasuk dalam beberapa proyek dengan menggunakan perintah berikut.

C:\> gradle -q tasks

Keluaran:

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Default tasks: dists

Build tasks
-----------
clean - Deletes the build directory (build)
dists - Builds the distribution
libs - Builds the JAR

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'projectReports'.
components - Displays the components produced by root project 'projectReports'. [incubating]
dependencies - Displays all dependencies declared in root project 'projectReports'.
dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'.
help - Displays a help message.
model - Displays the configuration model of root project 'projectReports'. [incubating]
projects - Displays the sub-projects of root project 'projectReports'.
properties - Displays the properties of root project 'projectReports'.
tasks - Displays the tasks runnable from root project 'projectReports' 
   (some of the displayed tasks may belong to subprojects).

To see all tasks and more detail, run gradle tasks --all

To see more detail about a task, run gradle help --task <task>

Anda dapat menggunakan perintah berikut untuk menampilkan informasi dari semua tugas.

C:\> gradle -q tasks --all

Keluaran:

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Default tasks: dists

Build tasks
-----------
clean - Deletes the build directory (build)
api:clean - Deletes the build directory (build)
webapp:clean - Deletes the build directory (build)
dists - Builds the distribution [api:libs, webapp:libs]
   docs - Builds the documentation
api:libs - Builds the JAR
   api:compile - Compiles the source files
webapp:libs - Builds the JAR [api:libs]
   webapp:compile - Compiles the source files

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'projectReports'.
api:buildEnvironment - Displays all buildscript dependencies declared in project ':api'.
webapp:buildEnvironment - Displays all buildscript dependencies declared in project ':webapp'.
components - Displays the components produced by root project 'projectReports'. [incubating]
api:components - Displays the components produced by project ':api'. [incubating]
webapp:components - Displays the components produced by project ':webapp'. [incubating]
dependencies - Displays all dependencies declared in root project 'projectReports'.
api:dependencies - Displays all dependencies declared in project ':api'.
webapp:dependencies - Displays all dependencies declared in project ':webapp'.
dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'.
api:dependencyInsight - Displays the insight into a specific dependency in project ':api'.
webapp:dependencyInsight - Displays the insight into a specific dependency in project ':webapp'.
help - Displays a help message.
api:help - Displays a help message.
webapp:help - Displays a help message.
model - Displays the configuration model of root project 'projectReports'. [incubating]
api:model - Displays the configuration model of project ':api'. [incubating]
webapp:model - Displays the configuration model of project ':webapp'. [incubating]
projects - Displays the sub-projects of root project 'projectReports'.
api:projects - Displays the sub-projects of project ':api'.
webapp:projects - Displays the sub-projects of project ':webapp'.
properties - Displays the properties of root project 'projectReports'.
api:properties - Displays the properties of project ':api'.
webapp:properties - Displays the properties of project ':webapp'.
tasks - Displays the tasks runnable from root project 'projectReports' 
   (some of the displayed tasks may belong to subprojects).
api:tasks - Displays the tasks runnable from project ':api'.
webapp:tasks - Displays the tasks runnable from project ':webapp'.

Berikut adalah beberapa daftar perintah dalam deskripsi tabel opsi yang berbeda.

Bab ini menjelaskan tentang cara membuat project java menggunakan file build Gradle.

Pertama-tama kita harus menambahkan plugin java ke skrip build karena plugin tersebut menyediakan tugas untuk mengompilasi kode sumber Java, menjalankan pengujian unit, membuat Javadoc, dan membuat file JAR. Gunakan baris berikut dalambuild.gradle mengajukan.

apply plugin: 'java'

Tata Letak Proyek Default Java

Kapan pun Anda menambahkan plugin ke build Anda, itu mengasumsikan pengaturan tertentu dari proyek Java Anda (mirip dengan Maven). lihatlah struktur direktori berikut.

• src / main / java berisi kode sumber Java
• src / test / java berisi pengujian Java

Jika Anda mengikuti penyiapan ini, file build berikut cukup untuk mengompilasi, menguji, dan memaketkan project Java.

Untuk memulai build, ketik perintah berikut di command line.

C:\> gradle build

SourceSetsdapat digunakan untuk menentukan struktur proyek yang berbeda. Misalnya, sumber disimpan di filesrc folder bukan di src/main/java. Perhatikan struktur direktori berikut.

apply plugin: 'java'
sourceSets {
   main {
      java {
         srcDir 'src'
      }
   }
	
   test {
      java {
         srcDir 'test'
      }
   }
}

Eksekusi Tugas init

Gradle belum mendukung banyak template proyek. Tapi itu menawarkaninittugas untuk membuat struktur proyek Gradle baru. Tanpa parameter tambahan, tugas ini membuat proyek Gradle, yang berisi file gradle wrapper, abuild.gradle dan settings.gradle mengajukan.

Saat menambahkan --type parameter dengan java-library sebagai nilai, struktur proyek java dibuat dan build.gradlefile berisi template Java tertentu dengan Junit. Lihatlah kode berikut untukbuild.gradle mengajukan.

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

Di bagian repositories, ini menentukan di mana menemukan dependensi. Jcenteradalah untuk menyelesaikan dependensi Anda. Bagian dependensi adalah untuk memberikan informasi tentang dependensi eksternal.

Menentukan Versi Java

Biasanya, proyek Java memiliki versi dan JRE target yang dikompilasi. Ituversion dan sourceCompatibility properti dapat diatur di build.gradle mengajukan.

version = 0.1.0
sourceCompatibility = 1.8

Jika artefak adalah aplikasi Java yang dapat dijalankan, file MANIFEST.MF file harus mengetahui kelas dengan metode utama.

apply plugin: 'java'

jar {
   manifest {
      attributes 'Main-Class': 'com.example.main.Application'
   }
}

Example:

Buat struktur direktori seperti yang ditunjukkan pada gambar di bawah.

Salin kode java yang diberikan di bawah ini ke dalam file App.java dan simpan ke consumerbanking\src\main\java\com\bank directory.

package com.bank;

/**
* Hello world!
*
*/

public class App {
   public static void main( String[] args ){
      System.out.println( "Hello World!" );
   }
}

Salin kode java yang diberikan di bawah ini ke dalam file AppTset.java dan simpan ke consumerbanking\src\test\java\com\bank directory.

package com.bank;

/**
* Hello world!
*
*/

public class App{
   public static void main( String[] args ){
      System.out.println( "Hello World!" );
   }
}

Salin kode yang diberikan di bawah ini ke dalam file build.gradle dan tempatkan ke consumerbanking\ direktori.

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

jar {
   manifest {
      attributes 'Main-Class': 'com.example.main.Application'
   }
}

Untuk mengkompilasi dan menjalankan skrip di atas, gunakan perintah yang diberikan di bawah ini.

consumerbanking\> gradle tasks
consumerbanking\> gradle assemble
consumerbanking\> gradle build

Periksa semua file kelas di direktori masing-masing dan periksa consumerbanking\build\lib folder untuk consumerbanking.jar mengajukan.

Bab ini menjelaskan cara mengompilasi dan menjalankan proyek Groovy menggunakan build.gradle mengajukan.

Plug-in yang Groovy

Plug-in Groovy untuk Gradle memperluas plug-in Java dan menyediakan tugas untuk program Groovy. Anda dapat menggunakan baris berikut untuk menerapkan plugin groovy.

apply plugin: 'groovy'

File skrip build lengkapnya adalah sebagai berikut. Salin kode berikut kebuild.gradle mengajukan.

apply plugin: 'groovy'

repositories {
   mavenCentral()
}

dependencies {
   compile 'org.codehaus.groovy:groovy-all:2.4.5'
   testCompile 'junit:junit:4.12'
}

Anda dapat menggunakan perintah berikut untuk menjalankan skrip build.

gradle build

Tata Letak Proyek Default dari Proyek Groovy

Plugin Groovy mengasumsikan pengaturan tertentu dari proyek Groovy Anda.

• src / main / groovy berisi kode sumber Groovy
• src / test / groovy berisi pengujian Groovy
• src / main / java berisi kode sumber Java
• src / test / java berisi pengujian Java

Periksa direktori masing-masing di mana build.gradle tempat file untuk membangun folder.

Tugas pengujian secara otomatis mendeteksi dan menjalankan semua pengujian unit di set sumber pengujian. Ini juga menghasilkan laporan setelah eksekusi uji selesai. JUnit dan TestNG adalah API yang didukung.

Tugas tes menyediakan a Test.getDebug()metode yang dapat disetel untuk diluncurkan agar JVM menunggu debugger. Sebelum melanjutkan ke eksekusi, ini menetapkan pos debugger ke5005.

Deteksi Tes

Itu Test Taskmendeteksi kelas mana yang merupakan kelas pengujian dengan memeriksa kelas pengujian yang dikompilasi. Secara default memindai semua file .class. Anda dapat mengatur penyertaan / pengecualian khusus, hanya kelas-kelas itu yang akan dipindai. Bergantung pada framework pengujian yang digunakan (JUnit / TestNG), deteksi kelas pengujian menggunakan kriteria yang berbeda.

Saat menggunakan JUnit, kami memindai kelas pengujian JUnit 3 dan 4. Jika salah satu kriteria berikut cocok, kelas tersebut dianggap sebagai kelas pengujian JUnit -

• Kelas atau kelas super memperluas TestCase atau GroovyTestCase
• Kelas atau kelas super dianotasi dengan @RunWith
• Kelas atau kelas super berisi metode yang dianotasi dengan @Test
• Saat menggunakan TestNG, kami memindai metode yang dianotasi dengan @Test

Note- Kelas abstrak tidak dijalankan. Gradle juga memindai pohon warisan menjadi file jar di jalur kelas pengujian.

Jika Anda tidak ingin menggunakan deteksi kelas pengujian, Anda dapat menonaktifkannya dengan menyetel scanForTestClasses menjadi salah.

Menguji Pengelompokan

JUnit dan TestNG memungkinkan pengelompokan metode pengujian yang canggih. Untuk pengelompokan, kelas pengujian JUnit dan metode JUnit 4.8 memperkenalkan konsep kategori. Tugas pengujian memungkinkan spesifikasi kategori JUnit yang ingin Anda sertakan dan kecualikan.

Anda dapat menggunakan cuplikan kode berikut dalam file build.gradle untuk mengelompokkan metode pengujian.

test {
   useJUnit {
      includeCategories 'org.gradle.junit.CategoryA'
      excludeCategories 'org.gradle.junit.CategoryB'
   }
}

Sertakan dan Kecualikan Tes Tertentu

Itu Test kelas memiliki include dan excludemetode. Metode ini dapat digunakan untuk menentukan, pengujian mana yang sebenarnya harus dijalankan.

Jalankan hanya tes yang disertakan -

test {
   include '**my.package.name/*'
}

Lewati tes yang dikecualikan -

test {
   exclude '**my.package.name/*'
}

Contoh build.gradle file seperti yang ditunjukkan di bawah ini menunjukkan opsi konfigurasi yang berbeda.

apply plugin: 'java' // adds 'test' task

test {
   // enable TestNG support (default is JUnit)
   useTestNG()

   // set a system property for the test JVM(s)
   systemProperty 'some.prop', 'value'

   // explicitly include or exclude tests
   include 'org/foo/**'
   exclude 'org/boo/**'

   // show standard out and standard error of the test JVM(s) on the console
   testLogging.showStandardStreams = true

   // set heap size for the test JVM(s)
   minHeapSize = "128m"
   maxHeapSize = "512m"

   // set JVM arguments for the test JVM(s)
   jvmArgs '-XX:MaxPermSize=256m'
   
   // listen to events in the test execution lifecycle
   beforeTest { 
      descriptor → logger.lifecycle("Running test: " + descriptor)
   }

   // listen to standard out and standard error of the test JVM(s)
   onOutput { 
      descriptor, event → logger.lifecycle
         ("Test: " + descriptor + " produced standard out/err: " 
         + event.message )
   }
}

Anda dapat menggunakan sintaks perintah berikut untuk menjalankan beberapa tugas pengujian.

gradle <someTestTask> --debug-jvm

Gradle dapat menangani proyek terkecil dan terbesar dengan mudah. Proyek kecil memiliki satu file build dan pohon sumber. Sangat mudah untuk mencerna dan memahami proyek yang telah dipecah menjadi modul yang lebih kecil dan saling bergantung. Gradle sangat mendukung skenario ini yaitu multi-project build.

Struktur untuk Multi-project Build

Bangunan seperti itu datang dalam berbagai bentuk dan ukuran, tetapi mereka memiliki beberapa karakteristik yang sama -

• SEBUAH settings.gradle file di root atau direktori master proyek.

• SEBUAH build.gradle file di root atau direktori master.

• Direktori anak yang memiliki miliknya sendiri *.gradle file build (beberapa build multi-project mungkin mengabaikan skrip build project anak).

Untuk mencantumkan semua proyek dalam file build, Anda dapat menggunakan perintah berikut.

C:\> gradle -q projects

Keluaran:

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'projectReports'
+--- Project ':api' - The shared API for the application
\--- Project ':webapp' - The Web application implementation

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :api:tasks

Laporan tersebut menunjukkan deskripsi setiap proyek, jika ditentukan. Anda dapat menggunakan perintah berikut untuk menentukan deskripsi. Tempel dibuild.gradle mengajukan.

description = 'The shared API for the application'

Menentukan Konfigurasi Build Umum

Di sebuah build.gradle file di root_project, konfigurasi umum dapat diterapkan ke semua proyek atau hanya ke sub proyek.

allprojects {
   group = 'com.example.gradle'
   version = '0.1.0'
}

subprojects {
   apply plugin: 'java'
   apply plugin: 'eclipse'
}

Ini menentukan yang umum com.example.gradle kelompok dan 0.1.0versi untuk semua proyek. Itusubprojects closure menerapkan konfigurasi umum untuk semua sub proyek, tetapi tidak untuk proyek akar, seperti allprojects penutupan tidak.

Konfigurasi dan Ketergantungan Khusus Proyek

Inti ui dan util subproyek juga bisa memiliki sendiri build.gradle file, jika mereka memiliki kebutuhan khusus, yang belum diterapkan oleh konfigurasi umum proyek root.

Misalnya, proyek ui biasanya memiliki ketergantungan pada proyek inti. Jadi proyek ui membutuhkannya sendiribuild.gradle file untuk menentukan ketergantungan ini.

dependencies {
   compile project(':core')
   compile 'log4j:log4j:1.2.17'
}

Ketergantungan proyek ditentukan dengan metode proyek.

Gradle menawarkan beberapa cara untuk menerapkan repositori artefak build. Saat menerapkan tanda tangan untuk artefak Anda ke repositori Maven, Anda juga ingin menandatangani file POM yang diterbitkan.

Menggunakan Plugin Maven-publish

maven-publishplugin, yang disediakan oleh Gradle secara default. Digunakan untuk menerbitkan skrip gradle. Perhatikan kode berikut.

apply plugin: 'java'
apply plugin: 'maven-publish'

publishing {
   publications {
      mavenJava(MavenPublication) {
         from components.java
      }
   }

   repositories {
      maven {
         url "$buildDir/repo"
      }
   }
}

Ada beberapa opsi terbitkan, jika Java dan maven-publishplugin diterapkan. Lihatlah kode berikut, ini akan menerapkan proyek ke dalam repositori jarak jauh.

apply plugin: 'groovy'
apply plugin: 'maven-publish'

group 'workshop'
version = '1.0.0'

publishing {
   publications {
      mavenJava(MavenPublication) { 
         from components.java 
      }
   }
	
   repositories {
      maven {
          default credentials for a nexus repository manager
         credentials {
            username 'admin'
            password 'admin123'
         }
         // url to the releases maven repository
            url "http://localhost:8081/nexus/content/repositories/releases/"
      }
   }
}

Mengonversi Proyek dari Maven ke Gradle

Ada perintah khusus untuk mengubah Apache Maven pom.xml file ke file build Gradle, jika semua plug-in Maven yang digunakan diketahui untuk tugas ini.

Pada bagian ini berikut ini pom.xmlkonfigurasi maven akan diubah menjadi proyek Gradle. Coba lihat.

<project xmlns = "http://maven.apache.org/POM/4.0.0" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
	
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.example.app</groupId>
   <artifactId>example-app</artifactId>
   <packaging>jar</packaging>
   
   <version>1.0.0-SNAPSHOT</version>
	
   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>

         <version>4.11</version>
         <scope>test</scope>
      </dependency>
   </dependencies>
	
</project>

Anda dapat menggunakan perintah berikut pada command line yang menghasilkan konfigurasi Gradle berikut.

C:\> gradle init --type pom

Itu init tugas tergantung pada tugas pembungkus sehingga pembungkus Gradle dibuat.

Hasilnya build.gradle File terlihat seperti ini -

apply plugin: 'java'
apply plugin: 'maven'

group = 'com.example.app'
version = '1.0.0-SNAPSHOT'

description = """"""

sourceCompatibility = 1.5
targetCompatibility = 1.5

repositories {
   maven { url "http://repo.maven.apache.org/maven2" }
}

dependencies {
   testCompile group: 'junit', name: 'junit', version:'4.11'
}

Bab ini menjelaskan tentang integrasi eclipse dan Gradle. Ikuti langkah-langkah yang diberikan di bawah ini untuk menambahkan plugin Gradle ke eclipse.

Langkah 1 - Buka Eclipse Marketplace

Pertama-tama buka gerhana yang diinstal di sistem Anda. Pergi ke bantuan -> klik EclipseMarketplace. Simak screenshot berikut.

Langkah 2 - Instal Plugin Buildship

Setelah mengklik Eclipse Marketplace di sana Anda akan menemukan tangkapan layar berikut. Di sini, di jenis bilah pencarian sisi kiribuildship. Buildship is a Gradle integration plugin. When you find the buildship on your screen click on install on the right side. Take a look into the following screenshot.

After that you will find the following screenshot there you need to confirm the software installation by click on the confirm button. Take a look into the following screenshot.

After that you need to click on accept license agreement in the following screen and click finish. Take a look into the following screenshot.

It will take some time to install. Take a look at the following screenshot.

After that, it will ask for restarting Eclipse. There you will select Yes.

Step 3 − Verifying Gradle Plugin

While verifying we will create a new project by following given procedure. In the eclipse go to file -> click on new-> click on other projects. There you will find the following screen. There select Gradle project and click next. Take a look into the following screen shot.

After clicking next button there you will find the following screen. There you will provide the Gradle home directory path of local file system and click on next button. Take a look into the following screenshot.

Take a look into the following screenshot here you will provide the name for Gradle project. In this tutorial we are using demoproject and click finish button.

Take a look into the following screenshot there we need to confirm the project. For that we have click finish button in the following screen.

Step 4 − Verifying Directory Structure

After successful installation of Gradle plugin, please check the demo project directory structure for the default files and folders as shown in the following screenshot.