Mengapa menggunakan Gradle, bukan Ant atau Maven? [Tutup]

Apa yang benar-benar saya dapatkan dari alat pembangunan yang ditargetkan pada Java?

Jika Anda menggunakan Gradle di atas alat lain, mengapa?

Saya sendiri tidak menggunakan Gradle dalam kemarahan (hanya proyek mainan) [penulis berarti mereka telah menggunakan Gradle hanya pada proyek mainan sejauh ini, bukan bahwa Gradle adalah proyek mainan - lihat komentar] , tetapi saya akan mengatakan bahwa alasan orang akan mempertimbangkan menggunakannya adalah karena frustrasi Ant dan Maven.

Dalam pengalaman saya, Ant sering menulis-saja (ya saya tahu adalah mungkin untuk menulis modular dengan indah, build yang elegan , tetapi kenyataannya kebanyakan orang tidak). Untuk setiap proyek non-sepele itu menjadi melelahkan pikiran, dan sangat berhati-hati untuk memastikan bahwa membangun kompleks benar-benar portabel. Sifatnya yang imperatif dapat menyebabkan replikasi konfigurasi antar build (meskipun macro dapat membantu di sini).

Maven mengambil pendekatan yang berlawanan dan mengharapkan Anda untuk sepenuhnya berintegrasi dengan siklus hidup Maven. Pengguna Ant yang berpengalaman menemukan ini sangat menggelisahkan karena Maven menghapus banyak kebebasan yang Anda miliki di Ant. Misalnya ada blog Sonatype yang menyebutkan banyak kritik Maven dan tanggapan mereka.

Mekanisme plugin Maven memungkinkan untuk konfigurasi bangunan yang sangat kuat, dan model warisan berarti Anda dapat menentukan sekelompok kecil POM induk yang merangkum konfigurasi bangunan Anda untuk keseluruhan perusahaan dan proyek individual dapat mewarisi konfigurasi tersebut, menjadikannya ringan. Konfigurasi Maven sangat verbose (meskipun Maven 3 berjanji untuk mengatasi ini), dan jika Anda ingin melakukan apa pun yang "bukan cara Maven" Anda harus menulis sebuah plugin atau menggunakan integrasi Ant yang hacky. Catatan Saya kebetulan suka menulis plugin Maven tetapi menghargai bahwa banyak akan keberatan dengan upaya yang terlibat.

Gradle berjanji untuk memukul sweet spot antara Ant dan Maven. Ini menggunakan pendekatan Ivy untuk resolusi ketergantungan. Hal ini memungkinkan untuk konvensi atas konfigurasi tetapi juga mencakup tugas Ant sebagai warga negara kelas satu. Ini juga dengan bijaksana memungkinkan Anda untuk menggunakan repositori Maven / Ivy yang ada.

Jadi, jika Anda menekan dan terjebak dengan salah satu poin nyeri Ant / Maven, mungkin patut dicoba Gradle, meskipun menurut saya itu masih harus dilihat jika Anda tidak akan hanya memperdagangkan masalah yang diketahui untuk yang tidak diketahui. Bukti dari puding ada di dalam makanan, jadi saya akan menghakimi sampai produknya sedikit lebih matang dan yang lain telah menghilangkan kerutan (mereka menyebutnya sebagai pendarahan karena suatu alasan). Saya masih akan menggunakannya dalam proyek mainan saya, Itu selalu baik untuk mengetahui opsi.

Gradle dapat digunakan untuk banyak tujuan - ini adalah pisau tentara Swiss yang jauh lebih baik daripada Ant - tetapi secara khusus berfokus pada pembangunan multi-proyek.

Pertama-tama, Gradle adalah alat pemrograman ketergantungan yang juga berarti alat pemrograman. Dengan Gradle Anda dapat menjalankan tugas acak apa pun dalam pengaturan Anda dan Gradle akan memastikan semua ketergantungan yang dinyatakan dijalankan dengan benar dan tepat waktu. Kode Anda dapat tersebar di banyak direktori dalam segala jenis tata letak (pohon, flat, tersebar, ...).

Gradle memiliki dua fase berbeda: evaluasi dan pelaksanaan. Pada dasarnya, selama evaluasi, Gradle akan mencari dan mengevaluasi skrip pembangunan di direktori yang seharusnya dicari. Selama eksekusi, Gradle akan menjalankan tugas-tugas yang telah dimuat selama evaluasi dengan mempertimbangkan saling ketergantungan tugas akun.

Di atas semua fitur pemrograman dependensi ini, Gradle menambahkan fitur ketergantungan proyek dan JAR melalui integrasi dengan Apache Ivy. Seperti yang Anda ketahui, Ivy adalah alat manajemen ketergantungan yang jauh lebih kuat dan jauh lebih sedikit pendapat daripada yang dikatakan Maven.

Gradle mendeteksi ketergantungan antara proyek dan antara proyek dan JAR. Gradle bekerja dengan repositori Maven (unduh dan unggah) seperti iBiblio atau repositori Anda sendiri tetapi juga mendukung dan jenis infrastruktur repositori lain yang mungkin Anda miliki.

Dalam multi-proyek build, Gradle dapat beradaptasi dan beradaptasi dengan struktur dan arsitektur build. Anda tidak harus menyesuaikan struktur atau arsitektur Anda dengan alat bangun Anda seperti yang diperlukan dengan Maven.

Gradle berusaha sangat keras untuk tidak menghalangi jalanmu, upaya yang hampir tidak pernah dilakukan Maven. Konvensi bagus tetapi fleksibilitas. Gradle memberi Anda lebih banyak fitur daripada Maven, tetapi yang paling penting dalam banyak kasus Gradle akan menawarkan Anda jalur transisi tanpa rasa sakit jauh dari Maven.

Ini mungkin sedikit kontroversial, tetapi Gradle tidak menyembunyikan fakta bahwa itu adalah bahasa pemrograman yang lengkap.

Ant + ant-contrib pada dasarnya adalah turing bahasa pemrograman lengkap yang tidak seorang pun benar-benar ingin memprogramnya.

Maven mencoba untuk mengambil pendekatan yang berlawanan dari mencoba untuk sepenuhnya deklaratif dan memaksa Anda untuk menulis dan menyusun plugin jika Anda memerlukan logika. Ini juga memaksakan model proyek yang sepenuhnya tidak fleksibel. Gradle menggabungkan yang terbaik dari semua alat ini:

• Ini mengikuti konvensi-over-konfigurasi (ala Maven) tetapi hanya sejauh yang Anda inginkan
• Ini memungkinkan Anda menulis tugas kustom yang fleksibel seperti di Ant
• Ini memberikan dukungan proyek multi-modul yang lebih unggul dari Ant dan Maven
• Ini memiliki DSL yang membuat 80% hal mudah dan 20% hal mungkin (tidak seperti alat build lainnya yang membuat 80% mudah, 10% mungkin, dan 10% secara efektif tidak mungkin).

Gradle adalah alat build yang paling dapat dikonfigurasi dan fleksibel yang belum saya gunakan. Dibutuhkan investasi di muka untuk mempelajari DSL dan konsep-konsep seperti konfigurasi tetapi jika Anda memerlukan alat build JVM yang tidak masuk akal dan sepenuhnya dapat dikonfigurasi, sulit dikalahkan.

Gradle menggabungkan Ant dan Maven dengan baik, mengambil yang terbaik dari kedua kerangka kerja. Fleksibilitas dari Ant dan konvensi atas konfigurasi, manajemen ketergantungan, dan plugin dari Maven.

Jadi, jika Anda ingin memiliki bangunan java standar, seperti di maven, tetapi tugas uji harus melakukan beberapa langkah khusus yang bisa terlihat seperti di bawah ini.

build.gradle:

apply plugin:'java'
task test{
  doFirst{
    ant.copy(toDir:'build/test-classes'){fileset dir:'src/test/extra-resources'}
  }
  doLast{
    ...
  }
}

Selain itu menggunakan sintaks groovy yang memberikan kekuatan ekspresi lebih banyak daripada xml semut / maven.

Ini adalah superset dari Ant - Anda dapat menggunakan semua tugas Ant secara bertahap dengan sintaks yang lebih bagus, seperti asyik, yaitu.

ant.copy(file:'a.txt', toDir:"xyz")

atau

ant.with{
  delete "x.txt"
  mkdir "abc"
  copy file:"a.txt", toDir: "abc"
}

Kami menggunakan Gradle dan memilihnya daripada Maven dan Ant. Semut memberi kami fleksibilitas total, dan Ivy memberikan manajemen ketergantungan yang lebih baik daripada Maven, tetapi tidak ada dukungan besar untuk pembangunan multi-proyek. Anda akhirnya melakukan banyak pengkodean untuk mendukung pembangunan multi-proyek. Juga memiliki beberapa build-by-convention bagus dan membuat skrip build lebih ringkas. Dengan Maven, terlalu banyak membangun dengan konvensi, dan menyesuaikan proses pembuatan Anda menjadi retasan. Juga, Maven mempromosikan setiap proyek penerbitan artefak. Kadang-kadang Anda memiliki proyek yang dipecah menjadi sub-proyek tetapi Anda ingin semua sub proyek dibangun dan diversi menjadi satu. Bukan sesuatu yang dirancang untuk Maven.

Dengan Gradle Anda dapat memiliki fleksibilitas Semut dan membangun dengan konvensi Maven. Sebagai contoh, itu sepele untuk memperpanjang siklus hidup konvensional dengan tugas Anda sendiri. Dan Anda tidak dipaksa untuk menggunakan konvensi jika Anda tidak mau. Groovy jauh lebih bagus untuk dikodekan daripada XML. Di Gradle, Anda dapat menentukan dependensi antara proyek pada sistem file lokal tanpa perlu mempublikasikan artefak untuk masing-masing ke repositori. Akhirnya, Gradle menggunakan Ivy, sehingga memiliki manajemen ketergantungan yang sangat baik. Satu-satunya downside nyata bagi saya sejauh ini adalah kurangnya integrasi Eclipse yang matang, tetapi opsi untuk Maven tidak benar-benar jauh lebih baik.

Ini bukan jawaban saya , tetapi pasti beresonansi dengan saya. Ini dari Radar Teknologi ThoughtWorks 'dari Oktober 2012 :

Dua hal telah menyebabkan kelelahan dengan alat membangun berbasis XML seperti Ant dan Maven: terlalu banyak kawat runcing yang marah dan kekasaran arsitektur plug-in. Sementara masalah sintaksis dapat ditangani melalui generasi, arsitektur plug-in sangat membatasi kemampuan untuk membangun alat untuk tumbuh dengan anggun karena proyek menjadi lebih kompleks. Kami mulai merasa bahwa plug-in adalah level abstraksi yang salah, dan lebih memilih alat berbasis bahasa seperti Gradle dan Rake, karena mereka menawarkan abstraksi berbutir halus dan fleksibilitas jangka panjang yang lebih fleksibel.

Gradle mengembalikan kesenangannya dalam membangun / merakit perangkat lunak. Saya menggunakan semut untuk membangun perangkat lunak sepanjang karier saya dan saya selalu menganggap bagian "buildit" yang sebenarnya dari pekerjaan dev sebagai kejahatan yang perlu. Beberapa bulan yang lalu perusahaan kami mulai bosan tidak menggunakan repo biner (alias memeriksa stoples ke dalam vcs) dan saya diberi tugas untuk menyelidiki ini. Dimulai dengan ivy karena bisa dibaut di atas semut, tidak punya banyak keberuntungan membuat artefak buatan saya diterbitkan seperti yang saya inginkan. Saya menggunakan maven dan meretas xml, bekerja dengan sangat baik untuk beberapa lib helper yang sederhana tetapi saya mengalami masalah serius ketika mencoba untuk menggabungkan aplikasi yang siap untuk digunakan. Kerumitan beberapa saat googling plugins dan membaca forum dan akhirnya mengunduh triliunan guci dukungan untuk berbagai plugin yang saya mengalami kesulitan menggunakan.

Tapi sejak hari pertama suasana hati saya mulai membaik. Saya mendapatkan suatu tempat. Butuh waktu dua jam untuk memigrasi modul semut pertama saya dan file build pada dasarnya tidak ada. Mudah dipasang satu layar. "Wow" besarnya adalah: membuat skrip dalam xml, sebodoh apa itu? fakta bahwa mendeklarasikan satu dependensi membutuhkan SATU baris sangat menarik bagi saya -> Anda dapat dengan mudah melihat semua dependensi untuk proyek tertentu pada satu halaman. Sejak saat itu saya terus-menerus bergerak, untuk setiap masalah yang saya hadapi sejauh ini ada solusi yang sederhana dan elegan. Saya pikir inilah alasannya:

• groovy sangat intuitif untuk pengembang java
• dokumentasi sangat bagus untuk mengagumkan
• fleksibilitas tidak ada habisnya

Sekarang saya menghabiskan hari-hari saya mencoba memikirkan fitur baru untuk ditambahkan ke proses build kami. Seberapa sakit itu?

Ini juga jauh lebih mudah untuk mengelola bangunan bawaan. Semut dan Maven hanya efektif untuk Java. Ada beberapa plugin untuk Maven yang mencoba menangani beberapa proyek asli, tetapi mereka tidak melakukan pekerjaan yang efektif. Tugas semut dapat ditulis yang mengkompilasi proyek asli, tetapi mereka terlalu kompleks dan canggung.

Kami menggunakan Java dengan JNI dan banyak bit asli lainnya. Gradle menyederhanakan kekacauan semut kami. Ketika kami mulai memperkenalkan manajemen ketergantungan pada proyek-proyek asli itu berantakan. Kami meminta Maven untuk melakukannya, tetapi kode Gradle yang setara adalah sebagian kecil dari apa yang diperlukan di Maven, dan orang-orang dapat membacanya dan memahaminya tanpa menjadi guru Maven.

Saya setuju sebagian dengan Ed Staub. Gradle jelas lebih kuat dibandingkan dengan pakar dan memberikan lebih banyak fleksibilitas dalam jangka panjang.

Setelah melakukan evaluasi untuk beralih dari pakar ke gradle, kami memutuskan untuk tetap menggunakan pakar untuk dua masalah yang kami temui dengan gradle (kecepatan lebih lambat daripada pakar, proksi tidak berfungsi).