So erstellen Sie ein Maven-Plugin

1. Einleitung

Maven bietet eine Vielzahl von Plugins an, die uns beim Aufbau unseres Projekts helfen. Es kann jedoch vorkommen, dass diese Plugins nicht ausreichen und wir unsere eigenen entwickeln müssen.

Glücklicherweise bietet Maven einige nützliche Tools, die uns bei diesem Prozess helfen.

In diesem Tutorial werden wir sehr praktisch sein und Schritt für Schritt zeigen, wie Sie ein Maven-Plugin von Grund auf neu erstellen.

Wir werden auch zeigen, wie man es in unseren Projekten verwendet und wie man Dokumentation dafür erstellt.

2. Erstellen eines Plugins

In diesem Tutorial entwickeln wir ein Plugin namens Counter-Maven-Plugin , das die Anzahl der Abhängigkeiten zählt, die ein Projekt enthält. Es ist sehr wichtig, die Plugin-Namenskonvention zu befolgen, die Maven empfiehlt, wenn wir den Namen für unser Plugin auswählen.

Nachdem wir wissen, was wir entwickeln werden, müssen wir als nächstes ein Maven-Projekt erstellen. In der Datei pom.xml definieren wir die Gruppen-ID , die Artefakt- ID und die Version unseres Plugins:

 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  

Beachten Sie, dass wir die Verpackung auf Maven-Plugin setzen .

In diesem Fall haben wir das Projekt manuell erstellt, aber wir können es auch mit dem maven-archetype-mojo tun :

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

Dabei sollten wir die Standardversionen der Abhängigkeiten aktualisieren, um die neuesten zu verwenden.

3. Ein Mojo erstellen

Jetzt ist es Zeit, unser erstes Mojo zu erstellen. Mojo ist eine Java-Klasse, die ein Ziel darstellt, das unser Plugin ausführen wird . Ein Plugin enthält ein oder mehrere Mojos.

Unser Mojo ist dafür verantwortlich, die Anzahl der Abhängigkeiten eines Projekts zu zählen.

3.1. Abhängigkeiten hinzufügen

Bevor wir das Mojo erstellen, müssen wir unserer pom.xml einige Abhängigkeiten hinzufügen :

  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  

Die Maven-Plugin-API- Abhängigkeit ist erforderlich und enthält die erforderlichen Klassen und Schnittstellen, um unser Mojo zu erstellen . Die Abhängigkeit von Maven-Plugin-Annotationen ist praktisch, um Annotationen in unseren Klassen zu verwenden. Über die Maven-Projektabhängigkeit können wir auf die Informationen zu dem Projekt zugreifen, in das wir das Plugin aufnehmen.

3.2. Erstellen der Mojo-Klasse

Jetzt sind wir bereit, unser Mojo zu erstellen!

Ein Mojo muss die Mojo- Schnittstelle implementieren . In unserem Fall erweitern wir AbstractMojo, sodass wir nur die Methode execute implementieren müssen :

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

Wie wir sehen können, ist der Abhängigkeitszähler der Name des Ziels. Auf der anderen Seite haben wir es standardmäßig an die Kompilierungsphase angehängt, sodass wir bei Verwendung dieses Ziels nicht unbedingt eine Phase angeben müssen.

Um auf die Projektinformationen zugreifen zu können, müssen wir ein MavenProject als Parameter hinzufügen :

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

Dieses Objekt wird von Maven beim Erstellen des Kontexts eingefügt.

Zu diesem Zeitpunkt können wir die Ausführungsmethode implementieren und die Anzahl der Abhängigkeiten des Projekts zählen:

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

Die Methode getLog () bietet Zugriff auf das Maven-Protokoll. Das AbstractMojo verwaltet bereits seinen Lebenszyklus.

3.3. Parameter hinzufügen

Der zuvor hinzugefügte Parameter ist schreibgeschützt und kann vom Benutzer nicht konfiguriert werden. Außerdem wird es von Maven injiziert, also können wir sagen, dass es etwas Besonderes ist.

In diesem Abschnitt fügen wir einen Parameter hinzu, in dem Benutzer den Umfang der Abhängigkeiten angeben können, die gezählt werden sollen.

Erstellen wir daher einen Bereichsparameter in unserem Mojo:

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

Wir haben nur das Eigenschaftsattribut festgelegt . Es ermöglicht uns, diese Eigenschaft über die Befehlszeile oder eine pom- Eigenschaft festzulegen . Für den Rest der Attribute sind die Standardwerte in Ordnung.

Jetzt ändern wir unsere Ausführungsmethode , um diesen Parameter zu verwenden und die Abhängigkeiten beim Zählen zu filtern:

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

Weiterführende Arten von Parametern werden in der offiziellen Dokumentation erläutert.

4. Testen des Plugins

Wir sind mit der Entwicklung des Plugins fertig. Testen wir es, um zu sehen, ob es funktioniert!

Zunächst müssen wir das Plugin in unserem lokalen Repository installieren:

mvn clean install

In den nächsten Abschnitten erfahren Sie zunächst, wie Sie unser Plugin über die Befehlszeile ausführen. Anschließend erfahren Sie auch, wie Sie es in einem Maven-Projekt verwenden.

4.1. Unser Plugin ausführen

Wir können das Ziel eines Plugins in der Befehlszeile ausführen, indem wir seinen vollständig qualifizierten Namen angeben:

mvn groupId:artifactId:version:goal

In unserem Fall sieht es so aus:

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

Aber wenn wir die Plug - Namenskonvention befolgt haben , dass wir am Anfang dieses Tutorials erwähnt, Maven wird das Präfix unserer Plugin lösen und wir können den Befehl verkürzen:

mvn counter:dependency-counter

Notice that this command is using the latest version of the plugin. Also, keep in mind that we have to add our groupId to the pluginGroups of our settings.xml so Maven also searches in this group:

 com.baeldung 

If we check the output of the command, we can see that the plugin counted the number of dependencies in the pom.xml of our plugin:

[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] ------------------------------------------------------------------------

We can also set the scope parameter via command line properties:

mvn counter:dependency-counter -Dscope=test

Notice that the scope name is the one that we defined in the property attribute of our parameter in the mojo.

4.2. Using Our Plugin in a Project

Let's test now our plugin by using it in a project!

We're going to create a very simple Maven project with some dependencies that our plugin will count:

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

The last thing is to add our plugin to the build. We have to explicitly set that we want to run the dependency-counter goal:

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

Notice that we've specified the scope parameter in the configuration node. Also, we haven't specified any phase because our mojo is attached to the compile phase by default.

Now, we just need to run the compile phase to execute our plugin:

mvn clean compile

And our plugin will print the number of test dependencies:

[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] ------------------------------------------------------------------------

In this tutorial, we're not covering how to write unit or integration tests for our plugin but Maven provides some mechanisms to do it.

5. Adding Documentation

When we create a Maven plugin, it's important to generate documentation to make it easy for other people to use it.

We'll briefly cover how to generate this documentation with maven-plugin-plugin.

maven-plugin-plugin is already included in the project, but we're gonna update it to use the latest version.

Also, we'll do the same for maven-site-plugin:

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

Then, we have to make sure that we've added javadoc to our Mojo and also add some metadata in the pom.xml of the plugin:

 Baeldung //www.baeldung.com/ 

After that, we need to add a reporting section in our pom.xml:

   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.

Wie immer ist der vollständige Quellcode für die Beispiele auf GitHub verfügbar.