streamalism.org

1. Introduksjon

Maven tilbyr et stort utvalg av plugins for å hjelpe oss med byggingen av prosjektet vårt. Vi kan imidlertid finne tilfeller der disse pluginene ikke er nok, og vi må utvikle våre egne.

Heldigvis gir Maven noen nyttige verktøy for å hjelpe oss i denne prosessen.

I denne veiledningen vil vi være ganske praktiske og vise trinn for trinn hvordan du lager et Maven-plugin fra bunnen av.

Vi viser også hvordan du bruker det i prosjektene våre og hvordan du lager dokumentasjon for det.

2. Opprette et plugin

I løpet av denne opplæringen utvikler vi et plugin som heter mot-maven-plugin som teller antall avhengigheter som et prosjekt inneholder. Det er veldig viktig å følge navnet på plugin-navnene som Maven anbefaler når vi velger navnet på pluginet vårt.

Nå som vi vet hva vi skal utvikle, er det neste vi må gjøre å lage et Maven-prosjekt. I pom.xml vi definerer groupId, artefaktId og versjon av pluginet vårt:

 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 

Legg merke til at vi setter emballasjen til maven-plugin.

I dette tilfellet har vi opprettet prosjektet manuelt, men vi kan også gjøre det ved å bruke maven-archetype-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 gjør dette, bør vi oppdatere standardversjonene av avhengighetene for å bruke de nyeste.

3. Lage en Mojo

Nå er det på tide å lage vår første mojo. Mojo er en Java-klasse som representerer et mål som pluginet vårt vil utføre. Et plugin inneholder en eller flere mojos.

Vår mojo vil være ansvarlig for å telle antall avhengigheter i et prosjekt.

3.1. Legge til avhengigheter

Før vi oppretter mojo, må vi legge til noen avhengigheter til vår pom.xml:

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

De maven-plugin-api avhengighet er nødvendig og inneholder de nødvendige klassene og grensesnittene for å skape mojo. De maven-plugin-merknader avhengighet er nyttig for å bruke merknader i klassene våre. De maven-prosjekt avhengighet lar oss få tilgang til informasjonen om prosjektet der vi inkluderer pluginet.

3.2. Opprette Mojo-klassen

Nå er vi klare til å lage mojo!

En mojo må implementere Mojo grensesnitt. I vårt tilfelle strekker vi oss fra Abstrakt Mojo så vi trenger bare å implementere henrette metode:

@Mojo (name = "avhengighetsteller", defaultPhase = LifecyclePhase.COMPILE) offentlig klasse DependencyCounterMojo utvider AbstractMojo {// ...}

Som vi kan se, avhengighetsteller er navnet på målet. På den annen side har vi festet den til kompilere fase som standard, slik at vi ikke nødvendigvis trenger å spesifisere en fase når vi bruker dette målet.

For å få tilgang til prosjektinformasjonen, må vi legge til en MavenProject som parameter:

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

Dette objektet vil bli injisert av Maven når konteksten er opprettet.

På dette punktet er vi i stand til å implementere kjøremetoden og telle antall avhengigheter av prosjektet:

public void execute () kaster MojoExecutionException, MojoFailureException {List avhengigheter = project.getDependencies (); lange numDependencies = avhengigheter.stream (). count (); getLog (). info ("Antall avhengigheter:" + numavhengigheter); }

De getLog () metoden gir tilgang til Maven-loggen. De Abstrakt Mojo håndterer allerede livssyklusen.

3.3. Legge til parametere

Parameteren vi har lagt til før er skrivebeskyttet og kan ikke konfigureres av brukeren. Dessuten injiseres det av Maven, så vi kan si at det er litt spesielt.

I denne delen skal vi legge til en parameter der brukere kan spesifisere omfanget av avhengighetene vi vil telle.

La oss derfor opprette en omfang parameter i vår mojo:

@Parameter (eiendom = "omfang") Strengområde;

Vi har bare satt eiendom Egenskap. Det lar oss sette denne egenskapen via kommandolinjen eller a pom eiendom. For resten av attributtene går vi bra med standardverdiene.

Nå vil vi endre vår henrette metode for å bruke denne parameteren og filtrere avhengighetene når man teller:

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

Mer avanserte parametertyper er forklart i den offisielle dokumentasjonen.

4. Testing av programtillegget

Vi er ferdige med utviklingen av programtillegget. La oss teste det for å se om det fungerer!

Først og fremst må vi installere pluginet i vårt lokale depot:

mvn ren installasjon

I de neste avsnittene vil vi først se hvordan vi kjører pluginet vårt fra kommandolinjen. Deretter vil vi også dekke hvordan du bruker det i et Maven-prosjekt.

4.1. Utfører pluginet vårt

Vi kan kjøre målet med et plugin i kommandolinjen ved å spesifisere dets fullstendige navn:

mvn groupId: artifactId: versjon: mål

I vårt tilfelle ser det slik ut:

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

Derimot, hvis vi har fulgt pluginnavnkonvensjonen som vi nevnte i begynnelsen av denne opplæringen, vil Maven løse prefikset til pluginet vårt og vi kan forkorte kommandoen:

mvn teller: avhengighetsteller

Legg merke til at denne kommandoen bruker den nyeste versjonen av pluginet. Husk også at vi må legge til vårt groupId til pluginGrupper av vår settings.xml så Maven søker også i denne gruppen:

 com.baeldung 

Hvis vi sjekker utdataene fra kommandoen, kan vi se at pluginet teller antall avhengigheter i pom.xml av pluginet vårt:

[INFO] Skanner etter prosjekter ... [INFO] [INFO] ----------------------------------- [INFO] Bygger mot-maven-plugin Maven Mojo 0.0.1-SNAPSHOT [INFO] ---------------------------- [maven- plugin] ---------------------------- [INFO] [INFO] --- counter-maven-plugin: 0.0.1-SNAPSHOT : avhengighetsteller (standard-cli) @ mot-maven-plugin --- [INFO] Antall avhengigheter: 3 [INFO] --------------------- -------------------------------------------------- - [INFO] BYGG SUKSESS [INFO] ----------------------------------------- ------------------------------- [INFO] Total tid: 0,529 s [INFO] Ferdig kl: 2019-11-30T20 : 43: 41 + 01: 00 [INFO] -------------------------------------- ---------------------------------

Vi kan også stille inn omfang parameter via kommandolinjeegenskaper:

mvn teller: avhengighet-teller -Dscope = test

Legg merke til at omfang navnet er det vi definerte i eiendom attributt til parameteren vår i mojo.

4.2. Bruke pluginet vårt i et prosjekt

La oss teste nå pluginet vårt ved å bruke det i et prosjekt!

Vi skal lage et veldig enkelt Maven-prosjekt med noen avhengigheter som pluginet vårt vil telle:

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

Den siste tingen er å legge til pluginet vårt til bygningen. Vi må eksplisitt sette at vi vil kjøre avhengighetsteller mål:

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

Legg merke til at vi har spesifisert omfang parameter i konfigurasjon node. Vi har heller ikke spesifisert noen fase fordi mojo er knyttet til kompilere fase som standard.

Nå trenger vi bare å kjøre kompilere fase for å utføre pluginet vårt:

mvn ren kompilering

Og pluginet vårt skriver ut antall test avhengigheter:

[INFO] Skanner etter prosjekter ... [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: avhengighetsteller (standard) @ eksempel --- [INFO] Antall avhengigheter: 1 [INFO] ----------------------------------- ------------------------------------ [INFO] BYGG SUKSESS [INFO] ----- -------------------------------------------------- ----------------- [INFO] Total tid: 0.627 s [INFO] Ferdig kl: 2019-11-25T18: 57: 22 + 01: 00 [INFO] --- -------------------------------------------------- -------------------

I denne opplæringen dekker vi ikke hvordan vi skal skrive enhets- eller integrasjonstester for pluginet vårt, men Maven gir noen mekanismer for å gjøre det.

5. Legge til dokumentasjon

Når vi oppretter et Maven-plugin, er det viktig å generere dokumentasjon for å gjøre det enkelt for andre å bruke det.

Vi vil kort dekke hvordan du genererer denne dokumentasjonen med maven-plugin-plugin.

maven-plugin-plugin er allerede inkludert i prosjektet, men vi skal oppdatere det for å bruke den nyeste versjonen.

Vi vil også gjøre 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 

Så må vi sørge for at vi har lagt til javadoc til vår Mojo og legg også til noen metadata i pom.xml av plugin:

 Baeldung //www.baeldung.com/ 

Etter det må vi legge til en rapporteringsdel i vår pom.xml:

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

Til slutt genererer vi dokumentasjonen med kommandoen maven site:

mvn nettsted

Inne i målmappen kan vi finne en nettstedet katalog med alle genererte HTML-filer. De plugin-info.html er den som inneholder plugin-dokumentasjonen:

Flere alternativer å legge til i dokumentasjonen vår finner du i dokumentasjonsveiledningen for Maven plugin.

6. Konklusjon

I denne veiledningen har vi vist hvordan du lager et Maven-plugin. Vi implementerte først et enkelt plugin, som hjalp oss med å se en typisk Maven plugin-prosjektstruktur. Deretter dekket vi noen av verktøyene som Maven tilbyr for å hjelpe oss med å utvikle plugins.

Vi har holdt det enkelt å gjøre ting tydeligere, men samtidig har vi gitt noen nyttige lenker med nødvendig informasjon om hvordan du lager et kraftigere plugin.

Som alltid er hele kildekoden for eksemplene tilgjengelig på GitHub.