Maven-Plugins

Maven-Plugins sind ausführbare Komponenten, die die Funktionalität von Maven erweitern. Jedes Plugin enthält ein oder mehrere Ziele, die verwendet werden, um bestimmte Aufgaben auszuführen (z. B. Kompilieren, Testen, Paketieren usw.).

Die Beziehung zwischen Plugins und dem Lebenszyklus:

• Lebenszyklus: Definiert die Reihenfolge der Build-Phasen

• Plugin: Stellt konkrete Implementierungen (Ziele) bereit, um die Aufgaben dieser Phasen zu erledigen

Maven hat die folgenden drei Standard-Lebenszyklen:

• clean: Übernimmt die Bereinigung des Projekts
• default (oder build): Übernimmt die Bereitstellung des Projekts
• site: Übernimmt die Erstellung der Projektsite-Dokumentation

Jeder Lebenszyklus enthält eine Reihe von Phasen. Diese Phasen entsprechen den von Maven bereitgestellten einheitlichen Schnittstellen, und die Implementierung dieser Phasen erfolgt durch Maven-Plugins.

Wenn wir einen mvn-Befehl eingeben, zum Beispielmvn clean, entspricht clean der clean-Phase des Clean-Lebenszyklus. Die konkrete Ausführung von clean hängt jedoch vonmaven-clean-pluginab, um sie umzusetzen.

Daher wird die konkrete Implementierung jeder Phase im Maven-Lebenszyklus durch Maven-Plugins realisiert.

Maven ist eigentlich ein Framework, das zur Ausführung auf Plugins angewiesen ist. Jede Aufgabe wird tatsächlich von Plugins erledigt. Maven-Plugins werden häufig verwendet, um:

• JAR-Dateien erstellen
• WAR-Dateien erstellen
• Codedateien kompilieren
• Unit-Tests für Code durchführen
• Projektdokumentation erstellen
• Projektberichte erstellen

Plugins bieten normalerweise eine Sammlung von Goals und können mit der folgenden Syntax ausgeführt werden:

<code>mvn [plugin-name]:[goal-name]</code>

Beispielsweise kann ein Java-Projekt das compile-Goal des maven-compiler-plugin verwenden, um zu kompilieren, und zwar mit dem folgenden Befehl:

<code>mvn compiler:compile</code>

Plugin-Kernmechanismus

Plugin-Koordinaten

Ähnlich wie Abhängigkeiten werden Plugins ebenfalls eindeutig durch groupId, artifactId und version identifiziert:

Plugin-Ziele

Jedes Plugin kann mehrere Ziele enthalten, zum Beispiel:

• maven-compiler-plugin：

  • compile: Hauptcode kompilieren

  • testCompile: Testcode kompilieren

• maven-surefire-plugin：

  • test: Unit-Tests ausführen

Plugin-Bindungsmethoden

1. Integrierte Bindung

Maven hat Plugin-Ziele vorab an Lebenszyklusphasen gebunden:

2. Benutzerdefinierte Bindung

Explizit in pom.xml konfigurieren:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <executions>
                <execution>
                    <phase>compile</phase>  <!-- 绑定到 compile 阶段 -->
                    <goals>
                        <goal>compile</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Gängige offizielle Plugins

Kompilierungsbezogen

Konfigurationsbeispiel:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.8.1</version>
    <configuration>
        <source>11</source>  <!-- Java 版本 -->
        <target>11</target>
    </configuration>
</plugin>

Testbezogen

Konfiguration zum Überspringen von Tests:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.22.2</version>
    <configuration>
        <skipTests>true</skipTests>  <!-- 跳过测试 -->
    </configuration>
</plugin>

Verpackungsbezogen

Konfiguration für ausführbare JAR-Dateien:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>3.2.0</version>
    <configuration>
        <archive>
            <manifest>
                <mainClass>com.example.Main</mainClass>  <!-- 指定主类 -->
            </manifest>
        </archive>
    </configuration>
</plugin>

Deployment-bezogen

Plugin-Aufrufmethoden

Über den Lebenszyklus aufrufen:

mvn compile  # 触发 maven-compiler-plugin:compile

Ein Plugin-Ziel direkt aufrufen:

mvn compiler:compile  # 直接调用编译目标

Konfiguration von Kommandozeilenparametern:

mvn compiler:compile -Dmaven.compiler.source=11

Benutzerdefinierte Plugin-Konfiguration

Parameterkonfiguration

Überconfiguration-Tag-Einstellungen:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.22.2</version>
    <configuration>
        <includes>
            <include>**/*Test.java</include>  <!-- 只包含特定测试 -->
        </includes>
    </configuration>
</plugin>

Ausführung mehrerer Ziele:

<executions>
    <execution>
        <id>run-tests</id>
        <phase>test</phase>
        <goals>
            <goal>test</goal>
        </goals>
    </execution>
</executions>

Grundlagen der Plugin-Entwicklung

Mojo-Konzept

• Die Java-Klasse, die einem Plugin-Ziel entspricht, wird alsMojobezeichnet（Maven Plain Old Java Object）。

• Muss erben vonAbstractMojound implementieren dieexecute()Methode.

Einfaches Plugin-Beispiel

Paketierung und Installation von Plugins

mvn clean install  # 将插件安装到本地仓库

Plugin-Typen

Maven bietet die folgenden zwei Arten von Plugins:

Nachfolgend finden Sie eine Liste einiger häufig verwendeter Plugins:

Beispiel

Wir haben in unseren Beispielen bereits ausgiebigmaven-antrun-pluginverwendet, um Daten auf der Konsole auszugeben. Bitte lesen Sie das KapitelMaven - Build Profiles. Lassen Sie uns diesen Inhalt besser verstehen. Erstellen Sie eine pom.xml-Datei im Verzeichnis C:\MVN\project.

Öffnen Sie als Nächstes ein Befehlsterminal, navigieren Sie zu dem Verzeichnis, in dem sich pom.xml befindet, und führen Sie den folgenden mvn-Befehl aus.

mvn clean

Maven wird mit der Verarbeitung beginnen und die clean-Phase des clean-Lebenszyklus anzeigen.

[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO]    task-segment: [post-clean]
[INFO] ------------------------------------------------------------------
[INFO] [clean:clean {execution: default-clean}]
[INFO] [antrun:run {execution: id.clean}]
[INFO] Executing tasks
     [echo] clean phase
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------
[INFO] Total time: < 1 second
[INFO] Finished at: Sat Jul 07 13:38:59 IST 2012
[INFO] Final Memory: 4M/44M
[INFO] ------------------------------------------------------------------

Das obige Beispiel veranschaulicht die folgenden Schlüsselkonzepte:

• Plugins werden in pom.xml mit dem plugins-Element definiert.
• Jedes Plugin kann mehrere Ziele haben.
• Sie können eine Phase definieren, und das Plugin verwendet sein phase-Element, um mit der Verarbeitung zu beginnen. Wir haben diecleanPhase verwendet.
• Sie können die Aufgaben konfigurieren, die ausgeführt werden sollen, indem Sie sie an die Ziele des Plugins binden. Wir haben dieechoAufgabe an dasrunZiel von maven-antrun-plugin gebunden.
• Das war's. Maven kümmert sich um den Rest. Es lädt Plugins herunter, die nicht im lokalen Repository verfügbar sind, und beginnt mit der Verarbeitung.