Cara Membuat Plugin Maven

1. Pengenalan

Maven menawarkan pelbagai jenis plugin untuk membantu kami membina projek kami. Walau bagaimanapun, kita mungkin menemui kes di mana pemalam ini tidak mencukupi dan kita harus mengembangkan sendiri.

Nasib baik, Maven menyediakan beberapa alat berguna untuk membantu kami dalam proses ini.

Dalam tutorial ini, kita akan cukup praktikal dan akan menunjukkan langkah demi langkah bagaimana membuat plugin Maven dari awal.

Kami juga akan menunjukkan cara menggunakannya dalam projek kami dan bagaimana membuat dokumentasi untuknya.

2. Membuat Plugin

Semasa tutorial ini, kami akan mengembangkan plugin yang disebut counter-maven-plugin yang akan menghitung jumlah pergantungan yang terdapat dalam projek. Sangat penting untuk mengikuti konvensyen penamaan pemalam yang dicadangkan oleh Maven ketika kami memilih nama untuk pemalam kami.

Sekarang kita tahu apa yang akan kita bangunkan, perkara seterusnya yang perlu kita lakukan ialah membuat projek Maven. Dalam pom.xml kami akan menentukan groupId , artifactId dan versi plugin kami:

 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 bahawa kami menetapkan pembungkusan ke maven-plugin .

Dalam kes ini, kami telah membuat projek 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

Semasa melakukan ini, kita harus mengemas kini versi dependensi lalai untuk menggunakan yang terbaru.

3. Membuat Mojo

Kini tiba masanya untuk membuat mojo pertama kami. Mojo adalah kelas Java yang mewakili matlamat yang akan dilaksanakan oleh plugin kami . Plugin mengandungi satu atau lebih mojos.

Mojo kami akan bertanggungjawab untuk menghitung jumlah kebergantungan projek.

3.1. Menambah Ketergantungan

Sebelum membuat mojo, kita perlu menambahkan beberapa kebergantungan pada pom.xml kami :

  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 pergantungan diperlukan dan mengandungi kelas dan antara muka yang diperlukan untuk mewujudkan mojo kami . The maven-plugin-anotasi pergantungan datang dalam berguna untuk digunakan penjelasan dalam kelas kami. The maven-projek pergantungan membolehkan kita mengakses maklumat tentang projek ini di mana kita termasuk plugin.

3.2. Membuat Kelas Mojo

Sekarang kita sudah bersedia untuk membuat mojo kita!

Seorang mojo harus melaksanakan antara muka Mojo . Dalam kes kami, kami akan melanjutkan dari AbstractMojo jadi kami hanya perlu menerapkan kaedah eksekusi :

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

Seperti yang kita lihat, ketergantungan-kaunter adalah nama matlamat. Sebaliknya, kami telah melampirkannya ke fasa kompilasi secara lalai sehingga kami tidak semestinya harus menentukan fasa ketika menggunakan tujuan ini.

Untuk mempunyai akses ke maklumat projek, kita harus menambahkan MavenProject sebagai parameter:

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

Objek ini akan disuntik oleh Maven ketika konteksnya dibuat.

Pada ketika ini, kami dapat melaksanakan kaedah pelaksanaan dan mengira jumlah kebergantungan projek:

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

Kaedah getLog () memberikan akses ke log Maven. The AbstractMojo sudah mengendalikan kitaran hayatnya.

3.3. Menambah Parameter

Parameter yang kami tambahkan sebelumnya hanya boleh dibaca dan tidak dapat dikonfigurasi oleh pengguna. Juga, ia disuntik oleh Maven sehingga kita boleh mengatakan ia adalah sesuatu yang istimewa.

Di bahagian ini, kita akan menambahkan parameter di mana pengguna dapat menentukan ruang lingkup kebergantungan yang ingin kita hitung.

Oleh itu, mari buat parameter skop di mojo kami:

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

Kami hanya menetapkan atribut harta tanah . Ini membolehkan kita menetapkan harta ini melalui baris perintah atau harta pom . Untuk atribut selebihnya, kami baik-baik saja dengan nilai lalai.

Sekarang kita akan mengubah kaedah pelaksanaan untuk menggunakan parameter ini dan menyaring kebergantungan ketika menghitung:

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

Jenis parameter yang lebih maju dijelaskan dalam dokumentasi rasmi.

4. Menguji Plugin

Kami sudah selesai dengan pengembangan pemalam. Mari uji untuk melihat sama ada ia berfungsi!

Pertama sekali, kita mesti memasang plugin di repositori tempatan kita:

mvn clean install

Pada bahagian seterusnya, pertama-tama kita akan melihat cara menjalankan pemalam kita dari baris arahan. Kemudian, kami juga akan membincangkan cara menggunakannya dalam projek Maven.

4.1. Melaksanakan Pemalam Kami

Kita boleh menjalankan tujuan pemalam dalam baris arahan dengan menentukan namanya yang memenuhi syarat:

mvn groupId:artifactId:version:goal

Dalam kes kami, ia kelihatan seperti ini:

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

Namun, jika kita mengikuti konvensyen penamaan plugin yang kita sebutkan pada awal tutorial ini, Maven akan menyelesaikan awalan plugin kita dan kita dapat memendekkan perintah:

mvn counter:dependency-counter

Perhatikan bahawa arahan ini menggunakan versi terbaru plugin. Juga, perlu diingat bahawa kita perlu menambah kami groupId kepada pluginGroups satu kami settings.xml supaya Maven juga mencari dalam kumpulan ini:

 com.baeldung 

Sekiranya kita memeriksa output perintah, kita dapat melihat bahawa plugin menghitung jumlah kebergantungan dalam pom.xml plugin kami:

[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 menetapkan parameter lingkup melalui sifat baris perintah:

mvn counter:dependency-counter -Dscope=test

Notis bahawa skop nama adalah salah satu yang kita ditakrifkan dalam harta sifat parameter kami di mojo itu.

4.2. Menggunakan Plugin Kami dalam Projek

Mari uji sekarang plugin kami dengan menggunakannya dalam projek!

Kami akan membuat projek Maven yang sangat sederhana dengan beberapa pergantungan yang akan dikira 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   

Perkara terakhir ialah menambahkan pemalam kami ke binaan. Kita harus menetapkan secara jelas bahawa kita ingin menjalankan tujuan ketergantungan :

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

Perhatikan bahawa kami telah menentukan parameter skop dalam simpul konfigurasi . Kami juga belum menentukan fasa apa pun kerana mojo kami dilampirkan ke fasa kompilasi secara lalai.

Sekarang, kita hanya perlu menjalankan fasa kompilasi untuk melaksanakan plugin kita:

mvn clean compile

Dan plugin kami akan mencetak bilangan kebergantungan ujian :

[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 ujian unit atau integrasi untuk plugin kami tetapi Maven menyediakan beberapa mekanisme untuk melakukannya.

5. Menambah Dokumentasi

Semasa kita membuat plugin Maven, penting untuk menghasilkan dokumentasi untuk memudahkan orang lain menggunakannya .

Kami akan mengulas secara ringkas bagaimana menghasilkan dokumentasi ini dengan maven-plugin-plugin .

maven-plugin-plugin sudah termasuk dalam projek, tetapi kami akan mengemas kini untuk menggunakan versi terkini.

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

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

Kemudian, kita harus memastikan bahawa kita telah menambahkan javadoc ke Mojo kita dan juga menambahkan beberapa metadata dalam pom.xml pemalam:

 Baeldung //www.baeldung.com/ 

Selepas itu, kita perlu menambahkan bahagian pelaporan di pom.xml kami :

   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, kod sumber penuh untuk contoh boleh didapati di GitHub.