Hoe u een Maven-plug-in maakt

1. Inleiding

Maven biedt een grote verscheidenheid aan plug-ins om ons te helpen bij het bouwen van ons project. We kunnen echter gevallen vinden waarin deze plug-ins niet voldoende zijn en we onze eigen plug-ins moeten ontwikkelen.

Gelukkig biedt Maven enkele handige tools om ons bij dit proces te helpen.

In deze zelfstudie zullen we behoorlijk praktisch zijn en stap voor stap laten zien hoe u vanaf het begin een Maven-plug-in kunt maken.

We laten ook zien hoe u het in onze projecten kunt gebruiken en hoe u er documentatie voor kunt maken.

2. Een plug-in maken

Tijdens deze tutorial ontwikkelen we een plug-in met de naam counter-maven-plugin dat telt het aantal afhankelijkheden dat een project bevat. Het is erg belangrijk om de naamgevingsconventie voor plug-ins te volgen die Maven aanbeveelt wanneer we de naam voor onze plug-in kiezen.

Nu we weten wat we gaan ontwikkelen, is het volgende dat we moeten doen, een Maven-project maken. In de pom.xml we zullen de groupId, artefact-id en versie van onze plug-in:

 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 

Merk op dat we de verpakking hebben ingesteld op maven-plugin.

In dit geval hebben we het project handmatig gemaakt, maar we kunnen het ook doen door de maven-archetype-mojo:

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

Wanneer we dit doen, moeten we de standaardversies van de afhankelijkheden bijwerken om de nieuwste te gebruiken.

3. Een Mojo maken

Nu is het tijd om onze eerste mojo te maken. Mojo is een Java-klasse die een doel vertegenwoordigt dat onze plug-in zal uitvoeren. Een plug-in bevat een of meer mojo's.

Onze mojo is verantwoordelijk voor het tellen van het aantal afhankelijkheden van een project.

3.1. Afhankelijkheden toevoegen

Voordat we de mojo maken, moeten we enkele afhankelijkheden toevoegen aan onze pom.xml:

  org.apache.maven maven-plugin-api 3.6.3 org.apache.maven.plugin-tools maven-plugin-annotaties 3.6.0 voorzien org.apache.maven maven-project 2.2.1 

De maven-plugin-api afhankelijkheid is vereist en bevat de nodige klassen en interfaces om onze mojo te maken. De maven-plugin-annotaties afhankelijkheid is handig om annotaties in onze lessen te gebruiken. De maven-project afhankelijkheid geeft ons toegang tot de informatie over het project waarin we de plug-in opnemen.

3.2. De Mojo-klasse maken

Nu zijn we klaar om onze mojo te maken!

Een mojo moet de Mojo koppel. In ons geval gaan we uit van AbstractMojo dus we hoeven alleen het uitvoeren methode:

@Mojo (name = "dependency-counter", defaultPhase = LifecyclePhase.COMPILE) openbare klasse DependencyCounterMojo breidt AbstractMojo uit {// ...}

Zoals we kunnen zien, afhankelijkheidsteller is de naam van het doel. Aan de andere kant hebben we het aan de compileren fase standaard, dus we hoeven niet per se een fase te specificeren wanneer we dit doel gebruiken.

Om toegang te krijgen tot de projectinformatie, moeten we een MavenProject als parameter:

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

Dit object wordt door Maven geïnjecteerd wanneer de context wordt gemaakt.

Op dit punt kunnen we de execute-methode implementeren en het aantal afhankelijkheden van het project tellen:

public void execute () gooit MojoExecutionException, MojoFailureException {List dependencies = project.getDependencies (); long numDependencies = dependencies.stream (). count (); getLog (). info ("Aantal afhankelijkheden:" + aantalDependencies); }

De getLog () methode biedt toegang tot het Maven-logboek. De AbstractMojo handelt al zijn levenscyclus af.

3.3. Parameters toevoegen

De parameter die we eerder hebben toegevoegd, is alleen-lezen en kan niet door de gebruiker worden geconfigureerd. Het is ook geïnjecteerd door Maven, dus we zouden kunnen zeggen dat het een beetje speciaal is.

In deze sectie gaan we een parameter toevoegen waarmee gebruikers het bereik kunnen specificeren van de afhankelijkheden die we willen tellen.

Laten we daarom een reikwijdte parameter in onze mojo:

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

We hebben alleen de eigendom attribuut. Hiermee kunnen we deze eigenschap instellen via de opdrachtregel of een pom eigendom. Voor de rest van de attributen zijn we in orde met de standaardwaarden.

Nu gaan we onze uitvoeren methode om deze parameter te gebruiken en de afhankelijkheden te filteren bij het tellen:

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

Meer geavanceerde soorten parameters worden uitgelegd in de officiële documentatie.

4. Testen van de plug-in

We zijn klaar met de ontwikkeling van de plug-in. Laten we het testen om te zien of het werkt!

Allereerst moeten we de plug-in installeren in onze lokale repository:

mvn schone installatie

In de volgende secties zullen we eerst zien hoe u onze plug-in kunt uitvoeren vanaf de opdrachtregel. Vervolgens bespreken we ook hoe u het in een Maven-project kunt gebruiken.

4.1. Onze plug-in uitvoeren

We kunnen het doel van een plug-in uitvoeren op de opdrachtregel door de volledig gekwalificeerde naam op te geven:

mvn groupId: artifactId: version: goal

In ons geval ziet het er als volgt uit:

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

Echter, als we de naamgevingsconventie voor plug-ins hebben gevolgd die we aan het begin van deze tutorial noemden, zal Maven het voorvoegsel van onze plug-in oplossen en we kunnen het commando verkorten:

mvn-teller: afhankelijkheidsteller

Merk op dat deze opdracht de nieuwste versie van de plug-in gebruikt. Houd er ook rekening mee dat we onze groupId naar de pluginGroups van onze settings.xml dus Maven zoekt ook in deze groep:

 com.baeldung 

Als we de uitvoer van de opdracht controleren, kunnen we zien dat de plug-in het aantal afhankelijkheden in het pom.xml van onze plug-in:

[INFO] Scannen naar projecten ... [INFO] [INFO] ----------------------------------- [INFO] Counter-maven-plugin bouwen 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] Aantal afhankelijkheden: 3 [INFO] --------------------- -------------------------------------------------- - [INFO] SUCCES OPBOUWEN [INFO] ----------------------------------------- ------------------------------- [INFO] Totale tijd: 0,529 s [INFO] Beëindigd op: 2019-11-30T20 : 43: 41 + 01: 00 [INFO] --------------------------------------- ---------------------------------

We kunnen ook de reikwijdte parameter via opdrachtregeleigenschappen:

mvn-teller: afhankelijkheidsteller -Dscope = test

Merk op dat de reikwijdte name is degene die we hebben gedefinieerd in de eigendom attribuut van onze parameter in de mojo.

4.2. Onze plug-in gebruiken in een project

Laten we nu onze plug-in testen door deze in een project te gebruiken!

We gaan een heel eenvoudig Maven-project maken met enkele afhankelijkheden die onze plug-in telt:

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

Het laatste is om onze plug-in aan de build toe te voegen. We moeten expliciet instellen dat we het afhankelijkheidsteller doel:

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

Merk op dat we de reikwijdte parameter in het configuratie knooppunt. We hebben ook geen fase gespecificeerd omdat onze mojo is bevestigd aan de compileren fase standaard.

Nu hoeven we alleen maar het compileren fase om onze plug-in uit te voeren:

mvn schoon compileren

En onze plug-in zal het aantal test afhankelijkheden:

[INFO] Scannen naar projecten ... [INFO] [INFO] ----------------------------------- ------------- [INFO] Bouwvoorbeeld 0.0.1-SNAPSHOT [INFO] ------------------------ -------- [pom] --------------------------------- [INFO] [INFO] --- maven-clean-plugin: 2.5: clean (default-clean) @ voorbeeld --- [INFO] [INFO] --- counter-maven-plugin: 0.0.1-SNAPSHOT: afhankelijkheidsteller (standaard) @ voorbeeld --- [INFO] Aantal afhankelijkheden: 1 [INFO] ----------------------------------- ------------------------------------- [INFO] SUCCES BOUWEN [INFO] ----- -------------------------------------------------- ----------------- [INFO] Totale tijd: 0,627 s [INFO] Afgewerkt op: 2019-11-25T18: 57: 22 + 01: 00 [INFO] --- -------------------------------------------------- -------------------

In deze zelfstudie behandelen we niet hoe u unit- of integratietests voor onze plug-in schrijft, maar Maven biedt enkele mechanismen om dit te doen.

5. Documentatie toevoegen

Wanneer we een Maven-plug-in maken, is het belangrijk om documentatie te genereren zodat andere mensen deze gemakkelijk kunnen gebruiken.

We zullen kort bespreken hoe u deze documentatie kunt genereren met maven-plugin-plugin.

maven-plugin-plugin zit al in het project, maar we gaan het updaten om de nieuwste versie te gebruiken.

We zullen ook hetzelfde doen voor maven-site-plugin:

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

Vervolgens moeten we ervoor zorgen dat we hebben toegevoegd javadoc naar onze Mojo en voeg ook wat metadata toe in het pom.xml van de plug-in:

 Baeldung //www.baeldung.com/ 

Daarna moeten we een rapportage-sectie toevoegen aan onze pom.xml:

   org.apache.maven.plugins maven-plugin-plugin rapport 

Ten slotte genereren we de documentatie met de opdracht maven site:

mvn-site

In de doelmap kunnen we een site directory met alle gegenereerde HTML-bestanden. De plugin-info.html is degene die de documentatie van de plug-in bevat:

Meer opties om toe te voegen aan onze documentatie zijn te vinden in de documentatiehandleiding van de Maven-plug-in.

6. Conclusie

In deze zelfstudie hebben we laten zien hoe u een Maven-plug-in kunt maken. We hebben eerst een eenvoudige plug-in geïmplementeerd, waardoor we een typische Maven-plug-in-projectstructuur konden zien. Vervolgens hebben we enkele van de tools besproken die Maven biedt om ons te helpen plug-ins te ontwikkelen.

We hebben het simpel gehouden om dingen duidelijker te maken, maar tegelijkertijd hebben we een aantal handige links gegeven met de nodige informatie over hoe je een krachtigere plug-in kunt maken.

Zoals altijd is de volledige broncode voor de voorbeelden beschikbaar op GitHub.