streamalism.org

1. Introduktion

Maven tilbyder et stort udvalg af plugins, der hjælper os med opbygningen af ​​vores projekt. Vi kan dog finde tilfælde, hvor disse plugins ikke er nok, og vi er nødt til at udvikle vores egne.

Heldigvis giver Maven nogle nyttige værktøjer til at hjælpe os i denne proces.

I denne vejledning er vi ganske praktiske og viser trin for trin, hvordan du opretter et Maven-plugin fra bunden.

Vi viser også, hvordan man bruger det i vores projekter, og hvordan man opretter dokumentation til det.

2. Oprettelse af et plugin

I løbet af denne tutorial udvikler vi et plugin kaldet counter-maven-plugin der tæller antallet af afhængigheder, som et projekt indeholder. Det er meget vigtigt at følge konventionens navngivningskonvention, som Maven anbefaler når vi vælger navnet på vores plugin.

Nu hvor vi ved, hvad vi skal udvikle, er den næste ting, vi skal gøre, at oprette et Maven-projekt. I pom.xml vi definerer groupId, artefaktId og version af vores plugin:

 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 

Bemærk, at vi indstiller emballagen til maven-plugin.

I dette tilfælde har vi oprettet projektet manuelt, men vi kunne også gøre det ved at bruge maven-arketype-mojo:

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

Når du gør dette, skal vi opdatere standardversionerne af afhængighederne for at bruge de nyeste.

3. Oprettelse af en Mojo

Nu er det tid til at oprette vores første mojo. Mojo er en Java-klasse, der repræsenterer et mål, som vores plugin vil udføre. Et plugin indeholder en eller flere mojos.

Vores mojo vil være ansvarlig for at tælle antallet af afhængigheder i et projekt.

3.1. Tilføjelse af afhængigheder

Før vi opretter mojo, skal vi tilføje nogle afhængigheder til vores pom.xml:

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

Det maven-plugin-api afhængighed er påkrævet og indeholder de nødvendige klasser og grænseflader til at skabe vores mojo. Det maven-plugin-kommentarer afhængighed er praktisk at bruge annoteringer i vores klasser. Det maven-projekt afhængighed giver os adgang til oplysningerne om projektet, hvor vi inkluderer pluginet.

3.2. Oprettelse af Mojo-klassen

Nu er vi klar til at oprette vores mojo!

En mojo skal implementere Mojo interface. I vores tilfælde strækker vi os fra Abstrakt Mojo så vi bliver kun nødt til at implementere udføre metode:

@Mojo (navn = "afhængighedstæller", defaultPhase = LifecyclePhase.COMPILE) offentlig klasse DependencyCounterMojo udvider AbstractMojo {// ...}

Som vi kan se, afhængighedstæller er navnet på målet. På den anden side har vi knyttet det til udarbejde fase som standard, så vi behøver ikke nødvendigvis at specificere en fase, når vi bruger dette mål.

For at få adgang til projektoplysningerne skal vi tilføje en MavenProject som parameter:

@Parameter (defaultValue = "$ {project}", krævet = sand, readonly = sand) MavenProject-projekt;

Dette objekt injiceres af Maven, når konteksten oprettes.

På dette tidspunkt er vi i stand til at implementere eksekveringsmetoden og tælle antallet af afhængigheder af projektet:

public void execute () kaster MojoExecutionException, MojoFailureException {List dependencies = project.getDependencies (); lange numDependencies = afhængigheder.stream (). count (); getLog (). info ("Antal afhængigheder:" + numDependencies); }

Det getLog () metode giver adgang til Maven-loggen. Det Abstrakt Mojo håndterer allerede sin livscyklus.

3.3. Tilføjelse af parametre

Parameteren, vi tidligere har tilføjet, er skrivebeskyttet og kan ikke konfigureres af brugeren. Det injiceres også af Maven, så vi kunne sige, det er lidt specielt.

I dette afsnit vil vi tilføje en parameter, hvor brugerne kan specificere omfanget af de afhængigheder, som vi vil tælle.

Lad os derfor oprette en rækkevidde parameter i vores mojo:

@Parameter (property = "scope") Strengområde;

Vi har kun indstillet ejendom attribut. Det giver os mulighed for at indstille denne egenskab via kommandolinjen eller a pom ejendom. For resten af ​​attributterne har vi det godt med standardværdierne.

Nu ændrer vi vores udføre metode til at bruge denne parameter og filtrere afhængighederne ved tælling:

public void execute () kaster MojoExecutionException, MojoFailureException List afhængigheder = project.getDependencies (); lange numDependencies = afhængigheder.stream () .filter (d -> (scope == null 

Mere avancerede typer parametre forklares i den officielle dokumentation.

4. Test af pluginet

Vi er færdige med udviklingen af ​​pluginet. Lad os teste det for at se, om det fungerer!

Først og fremmest skal vi installere pluginet i vores lokale lager:

mvn ren installation

I de næste sektioner vil vi først se, hvordan vi kører vores plugin fra kommandolinjen. Derefter vil vi også dække, hvordan man bruger det i et Maven-projekt.

4.1. Udførelse af vores plugin

Vi kan køre målet med et plugin i kommandolinjen ved at angive dets fuldt kvalificerede navn:

mvn groupId: artifactId: version: mål

I vores tilfælde ser det sådan ud:

mvn com.baeldung: counter-maven-plugin: 0.0.1-SNAPSHOT: afhængighedstæller

Imidlertid, hvis vi har fulgt den konventionelle navngivningskonvention, som vi nævnte i begyndelsen af ​​denne tutorial, vil Maven løse præfikset for vores plugin og vi kan forkorte kommandoen:

mvn tæller: afhængighedstæller

Bemærk, at denne kommando bruger den nyeste version af pluginet. Husk også, at vi er nødt til at tilføje vores groupId til pluginGroups af vores settings.xml så Maven søger også i denne gruppe:

 com.baeldung 

Hvis vi kontrollerer output af kommandoen, kan vi se, at pluginet tællede antallet af afhængigheder i pom.xml af vores plugin:

[INFO] Scanning efter projekter ... [INFO] [INFO] ----------------------------------- [INFO] Bygger mod-maven-plugin Maven Mojo 0.0.1-SNAPSHOT [INFO] ---------------------------- [maven- plugin] ---------------------------- [INFO] [INFO] --- counter-maven-plugin: 0.0.1-SNAPSHOT : afhængighedstæller (standard-cli) @ modermaven-plugin --- [INFO] Antal afhængigheder: 3 [INFO] --------------------- -------------------------------------------------- - [INFO] BYGG SUCCES [INFO] ----------------------------------------- ------------------------------- [INFO] Samlet tid: 0,529 s [INFO] Færdig kl .: 2019-11-30T20 : 43: 41 + 01: 00 [INFO] -------------------------------------- ---------------------------------

Vi kan også indstille rækkevidde parameter via kommandolinjegenskaber:

mvn-tæller: afhængigheds-tæller -Dscope = test

Bemærk, at rækkevidde navnet er det, vi definerede i ejendom attribut for vores parameter i mojo.

4.2. Brug af vores plugin i et projekt

Lad os teste nu vores plugin ved at bruge det i et projekt!

Vi opretter et meget simpelt Maven-projekt med nogle afhængigheder, som vores plugin tæller:

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

Den sidste ting er at tilføje vores plugin til bygningen. Vi skal udtrykkeligt indstille, at vi vil køre afhængighedstæller mål:

   com.baeldung counter-maven-plugin 0.0.1-SNAPSHOT afhængighedstællertest 

Bemærk, at vi har specificeret rækkevidde parameter i konfiguration knude. Vi har heller ikke angivet nogen fase, fordi vores mojo er knyttet til udarbejde fase som standard.

Nu skal vi bare køre udarbejde fase for at udføre vores plugin:

mvn ren kompilering

Og vores plugin udskriver antallet af prøve afhængigheder:

[INFO] Scanning efter projekter ... [INFO] [INFO] ----------------------------------- ------------- [INFO] Bygningseksempel 0.0.1-SNAPSHOT [INFO] ------------------------ -------- [pom] --------------------------------- [INFO] [INFO] --- maven-clean-plugin: 2.5: clean (standard-clean) @ eksempel --- [INFO] [INFO] --- counter-maven-plugin: 0.0.1-SNAPSHOT: afhængighedstæller (standard) @ eksempel --- [INFO] Antal afhængigheder: 1 [INFO] ----------------------------------- ------------------------------------ [INFO] BYG SUCCES [INFO] ----- -------------------------------------------------- ----------------- [INFO] Samlet tid: 0,627 s [INFO] Færdig ved: 2019-11-25T18: 57: 22 + 01: 00 [INFO] --- -------------------------------------------------- -------------------

I denne vejledning dækker vi ikke, hvordan man skriver enheds- eller integrationstest til vores plugin, men Maven giver nogle mekanismer til at gøre det.

5. Tilføjelse af dokumentation

Når vi opretter et Maven-plugin, er det vigtigt at generere dokumentation for at gøre det let for andre mennesker at bruge det.

Vi vil kort dække, hvordan man genererer denne dokumentation med maven-plugin-plugin.

maven-plugin-plugin er allerede inkluderet i projektet, men vi opdaterer det til at bruge den nyeste version.

Vi gør også det samme for maven-site-plugin:

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

Derefter skal vi sørge for, at vi har tilføjet javadoc til vores Mojo og tilføj også nogle metadata i pom.xml af pluginet:

 Baeldung //www.baeldung.com/ 

Derefter skal vi tilføje et rapporteringsafsnit i vores pom.xml:

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

Endelig genererer vi dokumentationen med kommandoen maven site:

mvn websted

Inde i målmappen kan vi finde en websted bibliotek med alle genererede HTML-filer. Det plugin-info.html er den, der indeholder plugindokumentationen:

Flere muligheder for at tilføje til vores dokumentation kan findes i dokumentationsvejledningen til Maven-plugin.

6. Konklusion

I denne vejledning har vi vist, hvordan man opretter et Maven-plugin. Vi implementerede først et simpelt plugin, som hjalp os med at se en typisk Maven-plugin-projektstruktur. Derefter dækkede vi nogle af de værktøjer, som Maven giver for at hjælpe os med at udvikle plugins.

Vi har holdt det simpelt at gøre tingene klarere, men på samme tid har vi leveret nogle nyttige links med de nødvendige oplysninger om, hvordan du opretter et mere kraftfuldt plugin.

Som altid er den fulde kildekode til eksemplerne tilgængelig på GitHub.