Cara Membuat Plugin Maven

1. Perkenalan

Maven menawarkan berbagai macam plugin untuk membantu kami membangun proyek kami. Namun, kami mungkin menemukan kasus di mana plugin ini tidak cukup dan kami harus mengembangkannya sendiri.

Untungnya, Maven menyediakan beberapa alat yang berguna untuk membantu kami dalam proses ini.

Dalam tutorial ini, kami akan cukup praktis dan akan menunjukkan langkah demi langkah cara membuat plugin Maven dari awal.

Kami juga akan menunjukkan cara menggunakannya dalam proyek kami dan cara membuat dokumentasi untuk itu.

2. Membuat Plugin

Selama tutorial ini, kita akan mengembangkan sebuah plugin yang disebut counter-maven-plugin yang akan menghitung jumlah dependensi yang terdapat dalam sebuah proyek. Sangat penting untuk mengikuti konvensi penamaan plugin yang direkomendasikan Maven saat kita memilih nama untuk plugin kita.

Sekarang kita tahu apa yang akan kita kembangkan, hal berikutnya yang perlu kita lakukan adalah membuat proyek Maven. Di pom.xml kita akan menentukan groupId , artifactId dan versi plugin kita:

 4.0.0 com.baeldung counter-maven-plugin maven-plugin 0.0.1-SNAPSHOT counter-maven-plugin Maven Mojo //maven.apache.org  1.8 1.8  

Perhatikan bahwa kami mengatur pengemasan ke maven-plugin .

Dalam kasus ini, kami telah membuat proyek secara manual tetapi kami juga dapat melakukannya dengan menggunakan maven-archetype-mojo :

mvn archetype:generate -DgroupId=com.baeldung -DartifactId=counter-maven-plugin -Dversion=0.0.1-SNAPSHOT -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-mojo

Saat melakukan ini, kita harus memperbarui versi default dari dependensi untuk menggunakan yang terbaru.

3. Membuat Mojo

Sekarang saatnya membuat mojo pertama kita. Mojo adalah kelas Java yang mewakili tujuan yang akan dijalankan oleh plugin kami . Sebuah plugin berisi satu atau lebih mojo.

Mojo kami akan bertanggung jawab untuk menghitung jumlah ketergantungan suatu proyek.

3.1. Menambahkan Dependensi

Sebelum membuat mojo, kita perlu menambahkan beberapa dependensi ke pom.xml kita :

  org.apache.maven maven-plugin-api 3.6.3   org.apache.maven.plugin-tools maven-plugin-annotations 3.6.0 provided   org.apache.maven maven-project 2.2.1  

The maven-plugin-api ketergantungan diperlukan dan berisi kelas dan interface yang diperlukan untuk membuat mojo kami . The maven-plugin-penjelasan ketergantungan sangat berguna untuk menggunakan penjelasan dalam kelas kami. The maven-proyek ketergantungan memungkinkan kita mengakses informasi tentang proyek di mana kita termasuk plugin.

3.2. Menciptakan Kelas Mojo

Sekarang kami siap membuat mojo kami!

Mojo harus mengimplementasikan antarmuka Mojo . Dalam kasus kami, kami akan memperluas dari AbstractMojo jadi kami hanya perlu mengimplementasikan metode eksekusi :

@Mojo(name = "dependency-counter", defaultPhase = LifecyclePhase.COMPILE) public class DependencyCounterMojo extends AbstractMojo { // ... }

Seperti yang bisa kita lihat, penghitung ketergantungan adalah nama tujuan. Di sisi lain, kami telah melampirkannya ke fase kompilasi secara default sehingga kami tidak perlu menentukan fase saat menggunakan tujuan ini.

Untuk memiliki akses ke informasi proyek, kita harus menambahkan MavenProject sebagai parameter:

@Parameter(defaultValue = "${project}", required = true, readonly = true) MavenProject project;

Objek ini akan diinjeksi oleh Maven saat konteks dibuat.

Pada titik ini, kami dapat mengimplementasikan metode eksekusi dan menghitung jumlah dependensi proyek:

public void execute() throws MojoExecutionException, MojoFailureException { List dependencies = project.getDependencies(); long numDependencies = dependencies.stream().count(); getLog().info("Number of dependencies: " + numDependencies); }

Metode getLog () menyediakan akses ke log Maven. The AbstractMojo sudah menangani siklus hidup.

3.3. Menambahkan Parameter

Parameter yang telah kami tambahkan sebelumnya bersifat hanya baca dan tidak dapat dikonfigurasi oleh pengguna. Juga, itu disuntikkan oleh Maven jadi kami bisa bilang ini spesial.

Di bagian ini, kami akan menambahkan parameter di mana pengguna dapat menentukan cakupan dependensi yang ingin kami hitung.

Karenanya, mari buat parameter lingkup di mojo kita:

@Parameter(property = "scope") String scope;

Kami hanya menyetel atribut properti . Ini memungkinkan kita menyetel properti ini melalui baris perintah atau properti pom . Untuk atribut lainnya, kami baik-baik saja dengan nilai default.

Sekarang kami akan memodifikasi metode eksekusi kami untuk menggunakan parameter ini dan memfilter dependensi saat menghitung:

public void execute() throws MojoExecutionException, MojoFailureException  List dependencies = project.getDependencies(); long numDependencies = dependencies.stream() .filter(d -> (scope == null 

Jenis parameter yang lebih canggih dijelaskan dalam dokumentasi resmi.

4. Menguji Plugin

Kami sudah selesai dengan pengembangan plugin. Mari kita uji untuk melihat apakah itu berhasil!

Pertama-tama, kita harus menginstal plugin di repositori lokal kita:

mvn clean install

Di bagian selanjutnya, pertama-tama kita akan melihat cara menjalankan plugin kita dari baris perintah. Kemudian, kami juga akan membahas cara menggunakannya dalam proyek Maven.

4.1. Menjalankan Plugin Kami

Kita dapat menjalankan tujuan plugin di baris perintah dengan menentukan nama yang sepenuhnya memenuhi syarat:

mvn groupId:artifactId:version:goal

Dalam kasus kami, ini terlihat seperti ini:

mvn com.baeldung:counter-maven-plugin:0.0.1-SNAPSHOT:dependency-counter

Namun, jika kami telah mengikuti konvensi penamaan plugin yang kami sebutkan di awal tutorial ini, Maven akan menyelesaikan awalan plugin kami dan kami dapat mempersingkat perintah:

mvn counter:dependency-counter

Perhatikan bahwa perintah ini menggunakan plugin versi terbaru. Juga, perlu diingat bahwa kita harus menambahkan groupId kita ke pluginGroups dari settings.xml kita sehingga Maven juga mencari di grup ini:

 com.baeldung 

Jika kita memeriksa output dari perintah tersebut, kita dapat melihat bahwa plugin menghitung jumlah dependensi di pom.xml plugin kita:

[INFO] Scanning for projects... [INFO] [INFO] ----------------------------------- [INFO] Building counter-maven-plugin Maven Mojo 0.0.1-SNAPSHOT [INFO] ----------------------------[ maven-plugin ]---------------------------- [INFO] [INFO] --- counter-maven-plugin:0.0.1-SNAPSHOT:dependency-counter (default-cli) @ counter-maven-plugin --- [INFO] Number of dependencies: 3 [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 0.529 s [INFO] Finished at: 2019-11-30T20:43:41+01:00 [INFO] ------------------------------------------------------------------------

Kami juga dapat mengatur parameter cakupan melalui properti baris perintah:

mvn counter:dependency-counter -Dscope=test

Perhatikan bahwa nama ruang lingkup adalah yang kita definisikan di atribut properti parameter kita di mojo.

4.2. Menggunakan Plugin Kami dalam Proyek

Mari kita uji sekarang plugin kita dengan menggunakannya dalam sebuah proyek!

Kami akan membuat proyek Maven yang sangat sederhana dengan beberapa dependensi yang akan dihitung oleh plugin kami:

 4.0.0 com.baeldung example pom 0.0.1-SNAPSHOT   org.apache.commons commons-lang3 3.9   junit junit 4.12 test   

Hal terakhir adalah menambahkan plugin kami ke build. Kami harus secara eksplisit menetapkan bahwa kami ingin menjalankan tujuan penghitung ketergantungan :

   com.baeldung counter-maven-plugin 0.0.1-SNAPSHOT    dependency-counter     test    

Perhatikan bahwa kami telah menetapkan parameter cakupan di node konfigurasi . Juga, kami belum menentukan fase apa pun karena mojo kami dilampirkan ke fase kompilasi secara default.

Sekarang, kita hanya perlu menjalankan fase kompilasi untuk menjalankan plugin kita:

mvn clean compile

Dan plugin kami akan mencetak jumlah dependensi uji :

[INFO] Scanning for projects... [INFO] [INFO] ------------------------------------------------ [INFO] Building example 0.0.1-SNAPSHOT [INFO] --------------------------------[ pom ]--------------------------------- [INFO] [INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ example --- [INFO] [INFO] --- counter-maven-plugin:0.0.1-SNAPSHOT:dependency-counter (default) @ example --- [INFO] Number of dependencies: 1 [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 0.627 s [INFO] Finished at: 2019-11-25T18:57:22+01:00 [INFO] ------------------------------------------------------------------------

Dalam tutorial ini, kami tidak membahas bagaimana menulis unit atau tes integrasi untuk plugin kami tetapi Maven menyediakan beberapa mekanisme untuk melakukannya.

5. Menambahkan Dokumentasi

Saat kami membuat plugin Maven, penting untuk membuat dokumentasi untuk memudahkan orang lain menggunakannya .

Kami akan membahas secara singkat cara membuat dokumentasi ini dengan maven-plugin-plugin .

maven-plugin-plugin sudah termasuk dalam proyek ini, tapi kami akan memperbaruinya untuk menggunakan versi terbaru.

Juga, kami akan melakukan hal yang sama untuk maven-site-plugin :

    org.apache.maven.plugins maven-plugin-plugin 3.6.0   org.apache.maven.plugins maven-site-plugin 3.8.2    

Kemudian, kami harus memastikan bahwa kami telah menambahkan javadoc ke Mojo kami dan juga menambahkan beberapa metadata di pom.xml plugin:

 Baeldung //www.baeldung.com/ 

Setelah itu, kita perlu menambahkan bagian pelaporan di pom.xml kita :

   org.apache.maven.plugins maven-plugin-plugin    report      

Finally, we'll generate the documentation with the maven site command:

mvn site

Inside the target folder, we can find a site directory with all the HTML files generated. The plugin-info.html is the one containing the plugin documentation:

More options to add to our documentation can be found on the Maven plugin documentation guide.

6. Conclusion

In this tutorial, we've shown how to create a Maven plugin. We first implemented a simple plugin, which helped us see a typical Maven plugin project structure. Then, we covered some of the tools that Maven provides to help us develop plugins.

We've kept it simple to make things clearer, but at the same time, we've provided some useful links with the necessary information on how to create a more powerful plugin.

Seperti biasa, kode sumber lengkap untuk contoh tersedia di GitHub.