Ant vs Maven vs Gradle

Artikel ini bagian dari serial: • Pengantar Gradle

• Ant vs Maven vs Gradle (artikel saat ini) • Menulis Plugin Gradle Kustom

• Membuat Fat Jar di Gradle

1. Perkenalan

Dalam artikel ini, kita akan mempelajari tiga fitur otomatisasi build Java yang mendominasi ekosistem JVM - Ant, Maven, dan Gradle .

Kami akan memperkenalkan masing-masing dan mempelajari bagaimana alat otomatisasi build Java berevolusi.

2. Apache Ant

Pada awalnya, Make adalah satu-satunya alat otomatisasi rakitan yang tersedia di luar solusi buatan sendiri . Make sudah ada sejak 1976 dan dengan demikian, itu digunakan untuk membangun aplikasi Java pada tahun-tahun awal Java.

Namun, banyak konvensi dari program C tidak sesuai dengan ekosistem Java, sehingga Ant mengambil alih sebagai alternatif yang lebih baik.

Apache Ant (“Another Neat Tool”) adalah pustaka Java yang digunakan untuk mengotomatiskan proses build untuk aplikasi Java . Selain itu, Ant dapat digunakan untuk membangun aplikasi non-Java. Ini awalnya bagian dari basis kode Apache Tomcat dan dirilis sebagai proyek mandiri pada tahun 2000.

Dalam banyak aspek, Ant sangat mirip dengan Make, dan cukup sederhana sehingga siapa pun dapat mulai menggunakannya tanpa prasyarat tertentu. File build Ant ditulis dalam XML, dan menurut konvensi, file tersebut disebut build.xml .

Fase berbeda dari proses build disebut "target".

Berikut adalah contoh file build.xml untuk proyek Java sederhana dengan kelas utama HelloWorld :

File build ini mendefinisikan empat target: clean , compile , jar and run . Misalnya, kita dapat mengkompilasi kode dengan menjalankan:

ant compile

Ini akan memicu pembersihan target terlebih dahulu yang akan menghapus direktori "kelas". Setelah itu, kompilasi target akan membuat ulang direktori dan mengompilasi folder src ke dalamnya.

Manfaat utama Ant adalah fleksibilitasnya. Ant tidak memaksakan konvensi pengkodean atau struktur proyek apa pun. Akibatnya, ini berarti Ant mengharuskan developer untuk menulis semua perintah sendiri, yang terkadang mengarah ke file build XML yang sangat besar yang sulit dikelola.

Karena tidak ada konvensi, hanya mengetahui Ant tidak berarti kita akan segera memahami file build Ant apa pun. Mungkin perlu beberapa waktu untuk membiasakan diri dengan file Ant asing, yang merupakan kerugian dibandingkan dengan alat lain yang lebih baru.

Awalnya, Ant tidak memiliki dukungan bawaan untuk manajemen ketergantungan. Namun, karena manajemen ketergantungan menjadi suatu keharusan di tahun-tahun berikutnya, Apache Ivy dikembangkan sebagai sub-proyek dari proyek Apache Ant. Ini terintegrasi dengan Apache Ant, dan mengikuti prinsip desain yang sama.

Namun, keterbatasan Ant awal karena tidak memiliki dukungan bawaan untuk manajemen ketergantungan dan rasa frustasi saat bekerja dengan file build XML yang tidak dapat diatur menyebabkan pembuatan Maven.

3. Apache Maven

Apache Maven adalah manajemen ketergantungan dan alat otomasi build, terutama digunakan untuk aplikasi Java. Maven terus menggunakan file XML seperti Ant tetapi dengan cara yang jauh lebih mudah dikelola. Nama permainan di sini adalah konvensi atas konfigurasi.

Sementara Ant memberikan fleksibilitas dan mengharuskan semuanya untuk ditulis dari awal, Maven mengandalkan konvensi dan menyediakan perintah (tujuan) yang telah ditentukan sebelumnya.

Sederhananya, Maven memungkinkan kita untuk fokus pada apa yang harus dilakukan oleh build kita, dan memberi kita kerangka kerja untuk melakukannya. Aspek positif lainnya dari Maven adalah menyediakan dukungan bawaan untuk manajemen ketergantungan.

File konfigurasi Maven, yang berisi instruksi build dan manajemen dependensi, menurut konvensi disebut pom.xml . Selain itu, Maven juga menetapkan struktur proyek yang ketat, sementara Ant juga memberikan fleksibilitas di sana.

Berikut adalah contoh file pom.xml untuk proyek Java sederhana yang sama dengan kelas utama HelloWorld dari sebelumnya:

 4.0.0 baeldung mavenExample 0.0.1-SNAPSHOT Maven example   junit junit 4.12 test   

Namun, sekarang struktur proyek tersebut juga telah distandarisasi dan sesuai dengan konvensi Maven:

+---src | +---main | | +---java | | | \---com | | | \---baeldung | | | \---maven | | | HelloWorld.java | | | | | \---resources | \---test | +---java | \---resources

Berbeda dengan Ant, Anda tidak perlu menentukan setiap fase dalam proses build secara manual. Sebagai gantinya, kita cukup memanggil perintah bawaan Maven.

Misalnya, kita dapat mengkompilasi kode dengan menjalankan:

mvn compile

Pada intinya, seperti disebutkan di halaman resmi, Maven dapat dianggap sebagai kerangka kerja eksekusi plugin, karena semua pekerjaan dilakukan oleh plugin. Maven mendukung berbagai macam plugin yang tersedia, dan masing-masing dapat dikonfigurasi tambahan.

Salah satu plugin yang tersedia adalah Apache Maven Dependency Plugin yang memiliki tujuan copy-dependencies yang akan menyalin dependensi kita ke direktori yang ditentukan.

Untuk menunjukkan plugin ini beraksi, mari sertakan plugin ini di file pom.xml kita dan konfigurasikan direktori output untuk dependensi kita:

   org.apache.maven.plugins maven-dependency-plugin   copy-dependencies package  copy-dependencies   target/dependencies       

Plugin ini akan dijalankan dalam fase paket , jadi jika kita menjalankan:

mvn package

Kami akan menjalankan plugin ini dan menyalin dependensi ke folder target / dependencies.

Ada juga artikel tentang cara membuat JAR yang dapat dijalankan menggunakan plugin Maven yang berbeda. Selain itu, untuk gambaran umum Maven yang mendetail, lihat panduan inti di Maven ini, tempat beberapa fitur utama Maven dieksplorasi.

Maven menjadi sangat populer karena file build sekarang distandarisasi dan membutuhkan lebih sedikit waktu untuk mempertahankan file build, dibandingkan dengan Ant. Namun, meskipun lebih terstandarisasi daripada file Ant, file konfigurasi Maven masih cenderung menjadi besar dan rumit.

Konvensi ketat Maven datang dengan harga jauh lebih fleksibel daripada Ant. Penyesuaian sasaran sangat sulit, jadi menulis skrip build khusus jauh lebih sulit dilakukan, dibandingkan dengan Ant.

Although Maven has made some serious improvements regarding making application's build processes easier and more standardized, it still comes with a price due to being a lot less flexible than Ant. This lead to the creation of Gradle which combines the best of both worlds – Ant's flexibility and Maven's features.

4. Gradle

Gradle is a dependency management and a build automation tool that was built upon the concepts of Ant and Maven.

One of the first things we can note about Gradle is that it's not using XML files, unlike Ant or Maven.

Over time, developers became more and more interested in having and working with a domain-specific language – which, simply put, would allow them to solve problems in a specific domain using a language tailored for that particular domain.

This was adopted by Gradle, which is using a DSL based either on Groovy or Kotlin. This led to smaller configuration files with less clutter since the language was specifically designed to solve specific domain problems. Gradle's configuration file is by convention called build.gradle in Groovy, or build.gradle.kts in Kotlin.

Notice that Kotlin offers better IDE support than Groovy for auto-completion and error detection.

Here is an example of a build.gradle file for the same simple Java project with the HelloWorld main class from before:

apply plugin: 'java' repositories { mavenCentral() } jar { baseName = 'gradleExample' version = '0.0.1-SNAPSHOT' } dependencies { testImplementation 'junit:junit:4.12' }

We can compile the code by running:

gradle classes

At its core, Gradle intentionally provides very little functionality. Plugins add all useful features. In our example, we were using java plugin which allows us to compile Java code and other valuable features.

Gradle gave its build steps name “tasks”, as opposed to Ant's “targets” or Maven's “phases”. With Maven, we used Apache Maven Dependency Plugin, and it's a specific goal to copy dependencies to a specified directory. With Gradle, we can do the same by using tasks:

task copyDependencies(type: Copy) { from configurations.compile into 'dependencies' }

We can run this task by executing:

gradle copyDependencies

5. Conclusion

In this article, we presented Ant, Maven, and Gradle – three Java build automation tools.

Not surprisingly, Maven holds the majority of the build tool market today.

Namun, Gradle telah melihat adopsi yang baik dalam basis kode yang lebih kompleks, karena alasan berikut:

  • Banyak proyek sumber terbuka seperti Spring yang menggunakannya sekarang
  • Ini lebih cepat daripada Maven untuk sebagian besar skenario, berkat build tambahannya
  • Ini menawarkan analisis lanjutan dan layanan debugging

Namun Gradle itu tampaknya memiliki kurva belajar yang lebih curam, terutama jika Anda tidak terbiasa dengan Groovy atau Kotlin.

Berikutnya » Menulis Plugin Gradle Kustom « Pengantar Sebelumnya Gradle