Maven-Build-Konfigurationsdatei Maven-POM

Maven-Build-Lebenszyklus

Der Maven-Build-Lebenszyklus definiert den Prozess der Projektbouw und -veröffentlichung.

Ein typischer Maven-Build-(build)-Lebenszyklus besteht aus einer Reihe von Phasen:

Stadium	Verarbeiten	Beschreibung
Überprüfen validate	Überprüfen Sie das Projekt	Überprüfen Sie, ob das Projekt korrekt ist und alle erforderlichen Informationen verfügbar sind
Kompilierung compile	Führen Sie die Kompilierung aus	Kompilierung der Quelldateien wird in diesem Stadium abgeschlossen
Tests Test	Tests	Führen Sie Tests mit einem geeigneten Unit-Test-Framework (z.B. JUnit) aus.
Verpackung package	Paketerstellung	Erstellen von JAR/WAR-Pakete, die in pom.xml definierten Paketen entsprechen
Überprüfen verify	Überprüfen	Überprüfen der Ergebnisse der Integrationstests, um sicherzustellen, dass die Qualität den Anforderungen entspricht
Installation install	Installation	Installation des gepackten Projekts in das lokale Repository, um es anderen Projekten zur Verfügung zu stellen
Deployment deploy	Deployment	Kopieren des endgültigen Projektpakets in das Remote-Repository, um es anderen Entwicklern und Projekten zur Verfügung zu stellen

Um den default-Lebenszyklus abzuschließen, werden diese Phasen (einschließlich anderer nicht aufgeführter Lebenszyklusphasen) in der Reihenfolge ausgeführt.

Maven hat folgende drei Standard-Lebenszyklen:

clean: Verarbeiten der Projektbereinigung
default (oder build): Verarbeiten der Projektdeployment
site: Verarbeiten der Dokumentation der Projektwebsite

Die Bauphasen bestehen aus Plugin-Zielen

Ein Plugin-Ziel repräsentiert eine spezifische Aufgabe (feiner als Bauphasen), was die Projektbouw und -verwaltung unterstützt. Diese Ziele können mit mehreren Phasen oder ohne Bindung verknüpft werden. Ziele, die nicht mit einer Bauphase verbunden sind, können außerhalb des Baulebenszyklus durch direkte Aufrufe ausgeführt werden. Die Ausführungsreihenfolge der Ziele hängt von der Reihenfolge des Aufrufs und der Bauphase ab.

Beispielsweise, betrachten Sie den folgenden Befehl:

clean und pakage sind Bauphasen, dependency:copy-dependencies sind Ziele

mvn clean dependency:copy-dependencies package

Dieser clean-Stadium wird zunächst ausgeführt, gefolgt von dependency:copy-Die Ziele werden ausgeführt, und letztlich wird das Paket-Stadium ausgeführt.

Clean Lebenszyklus

Wenn wir mvn post ausführen-Wenn der clean-Befehl ausgeführt wird, ruft Maven den clean Lebenszyklus auf, der folgende Stufen enthält:

pre-clean: Führt einige Arbeiten aus, die vor clean abgeschlossen werden müssen
clean: Entfernt alle Dateien, die während der letzten Build generiert wurden
post-clean: Führt einige Arbeiten aus, die sofort nach clean abgeschlossen werden müssen

mvn clean bezieht sich auf clean oben, in einem Lebenszyklus werden alle Phasen vor der aktuellen Phase ausgeführt, das heißt, wenn mvn clean ausgeführt wird, werden folgende zwei Lebenszyklusphasen ausgeführt:

pre-clean, clean

Wenn wir mvn post ausführen-wenn clean ausgeführt wird, werden folgende drei Lebenszyklusphasen ausgeführt:

pre-clean, clean, post-clean

Wir können das Verhalten dieses Abschnitts ändern, indem wir Ziele in jeder beliebigen Phase des clean Lebenszyklus definieren.

Im folgenden Beispiel werden wir den Maven-antrun-plugin:run Ziel wird zu pre hinzugefügt-clean, clean und post-im clean Stadium. Auf diese Weise können wir Textinformationen in den verschiedenen Stufen des clean Lebenszyklus anzeigen.

Wir haben im Verzeichnis C:\MVN\project eine Datei pom.xml erstellt.

<project　xmlns="http://maven.apache.org/POM/4.0.0"
　　　xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
　　　xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
　　　http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.projectgroup</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
<build>
<plugins>
　　　<plugin>
　　　<groupId>org.apache.maven.plugins/groupId>
　　　<artifactId>maven-antrun-plugin>/artifactId>
　　　<version>1.1build>/version>
　　　<id>id.pre
　　　　　　site phase<
　　　　　　　　　id>-clean</<id>id.site
　　　　　　　　　<phase>pre-clean</deploy<
　　　　　　　　　phase>
　　　　　　　　　　　　<goals>/<goal>run<
　　　　　　　　　build>/goal>
　　　　　　　　　goals>
　　　　　　　　　　　　<configuration>
　　　　　　　　　　　　　　　<echo>pre-clean Phase</deploy phase<
　　　　　　　　　　　　build>/echo>
　　　　　　　　　build>/tasks>
　　　　　　build>/configuration>
　　　　　　site phase<
　　　　　　　　　<id>id.clean</<id>id.site
　　　　　　　　　<phase>clean</deploy<
　　　　　　　　　phase>
　　　　　　　　　　<goals>/<goal>run<
　　　　　　　　　build>/goal>
　　　　　　　　　goals>
　　　　　　　　　　　　<configuration>
　　　　　　　　　　　　　　　<echo>clean Phase</deploy phase<
　　　　　　　　　　　　build>/echo>
　　　　　　　　　build>/tasks>
　　　　　　build>/configuration>
　　　　　　site phase<
　　　　　　　　　<id>id.post-clean</<id>id.site
　　　　　　　　　id>-clean</deploy<
　　　　　　　　　phase>
　　　　　　　　　　　　<goals>/<goal>run<
　　　　　　　　　build>/goal>
　　　　　　　　　goals>
　　　　　　　　　　　　<configuration>
　　　　　　　　　　　　　　　site<-clean Phase</deploy phase<
　　　　　　　　　　　　build>/echo>
　　　　　　　　　build>/tasks>
　　　　　　build>/configuration>
　　　build>/execution>
　　　build>/executions>
build>/plugin>
build>/plugins>
build>/<

Öffnen Sie nun die Befehlskonsole, wechseln Sie zum Verzeichnis von pom.xml und führen Sie den folgenden mvn-Befehl aus.

C:\MVN\project>mvn post-clean

Maven beginnt mit der Verarbeitung und zeigt alle Stufen des clean Lebenszyklus an.

Maven beginnt mit der Verarbeitung und Anzeige der verschiedenen Phasen des Lebenszyklus von site bis zur site-Stufe.
[INFO]　------------------------------------------------------------------
[INFO] Durchsuchen nach Projekten...　-　[INFO] Erstellung von Unnamed1.0
[INFO]          task-Segment: [post-clean]
[INFO]　------------------------------------------------------------------
[INFO] [antrun:run {execution: id.pre-clean}]
[INFO]　Durchführung　von　Aufgaben
　　　　　[echo] pre-clean Phase
[INFO]　Durchgeführte　Aufgaben
[INFO] [clean:clean {execution: default}-clean}]
[INFO] [antrun:run {execution: id.clean}]
[INFO]　Durchführung　von　Aufgaben
　　　　　[echo] clean Phase
[INFO]　Durchgeführte　Aufgaben
[INFO] [antrun:run {execution: id.post}-clean}]
[INFO]　Durchführung　von　Aufgaben
　　　　　[echo] post-clean Phase
[INFO]　Durchgeführte　Aufgaben
[INFO]　------------------------------------------------------------------
[INFO]　BAUERFOLG ERFOGENLICH
[INFO]　------------------------------------------------------------------
[INFO] Gesamte Zeit: <　1　second
[INFO]　Beendet　um:　Sat　Jul　07　13:38:59　IST　2012
[INFO]　Endgültiges　Speicher:　4M/44M
[INFO]　------------------------------------------------------------------

Sie können versuchen, den Befehl mvn clean zu ändern, um den pre anzuzeigen-clean und clean, während im post-Der clean-Stadium führt keine Operationen aus.

Default (Build) Lebenszyklus

Dies ist der Haupt-Lebenszyklus von Maven, der zum Bau von Anwendungen verwendet wird, einschließlich der folgenden 23 Phasen:

Lebenszyklusphase	Beschreibung
validate (Validieren)	Überprüfen Sie, ob das Projekt korrekt ist und alle notwendigen Informationen vorhanden sind, um den Bauvorgang des Projekts abzuschließen.
initialize (Initialisieren)	Initialisieren Sie den Baustatus, zum Beispiel, stellen Sie Attributwerte ein.
generate-sources (Erstellung des Quellcodes)	Erstellen Sie alle Quellcode, die im Kompilierungsstadium enthalten sind.
process-sources (Behandlung der Quellcode)	Behandeln Sie den Quellcode, zum Beispiel, filtern Sie beliebige Werte.
generate-resources (Erstellung der Ressourcen-Dateien)	Erstellen Sie die Ressourcen-Dateien, die im Projekt-Paket enthalten sein werden.
process-resources (Behandlung der Ressourcen-Dateien)	Kopieren und behandeln Sie die Ressourcen in das Zielverzeichnis, um die beste Vorbereitung für die Packungsphase zu gewährleisten.
compile (Kompilieren)	Kompilieren Sie die Quellcode des Projekts.
process-classes (Behandlung der Klassendateien)	Behandeln Sie die durch die Kompilierung generierten Dateien, zum Beispiel, verbessern Sie die Bytecode-Optimierung für Java-Klassen.
generate-test-sources (Erstellung des Test-Quellcodes)	Erstellen Sie alle Test-Quellcode, die im Kompilierungsstadium enthalten sind.
process-test-sources (Behandlung der Test-Quellcode)	Behandeln Sie den Test-Quellcode, zum Beispiel, filtern Sie beliebige Werte.
generate-test-resources (Erstellung der Test-Ressourcen-Dateien)	Erstellen Sie Ressourcen-Dateien für den Test.
process-test-resources (Behandlung der Test-Ressourcen-Dateien)	Kopieren und behandeln Sie die Test-Ressourcen in das Zielverzeichnis.
test-compile (Kompilieren des Test-Quellcodes)	Kompilieren Sie den Test-Quellcode in das Zielverzeichnis der Tests.
process-test-classes (Behandlung der Test-Klassen-Dateien)	Behandeln Sie die Dateien, die durch die Kompilierung der Test-Quellcode-Dateien generiert werden.
test (Testen)	Führen Sie Tests mit einem geeigneten Unit-Test-Framework aus (Juint ist eines davon).
prepare-package (Vorbereitung auf das Paketieren)	Führen Sie alle notwendigen Aktionen durch, um das Paketieren vorzubereiten.
package (Paketen)	Paketen Sie den kompilierten Code in ein verteilungsfähiges Dateiformat ein, wie z.B. JAR, WAR oder EAR-Dateien.
pre-integration-test (Vor dem Integrations test)	Führen Sie notwendige Aktionen durch, die vor der Durchführung der Integrations tests erforderlich sind. Zum Beispiel, die erforderlichen Umgebungen aufbauen.
integration-test (Integrations test)	Behandeln und das Projekt in eine Umgebung bereitstellen, in der Integrations tests ausgeführt werden können.
post-integration-test (Nach dem Integrations test)	Führen Sie notwendige Aktionen durch, die nach der Durchführung der Integrations tests erforderlich sind. Zum Beispiel, die Integrations testumgebung bereinigen.
verify (Überprüfen)	Führen Sie beliebige Überprüfungen durch, um zu bestätigen, dass das Projekt-Paket gültig und den Qualitätsstandards entspricht.
install (Installieren)	Installieren Sie das Projekt-Paket in ein lokales Repository, damit es als Abhängigkeit für andere lokale Projekte verwendet werden kann.
deploy (Dеплой)	Kopieren Sie das endgültige Projekt-Paket in ein Remote-Repository, um es mit anderen Entwicklern und Projekten zu teilen.

Es gibt einige wichtige Konzepte im Zusammenhang mit dem Maven-Lebenszyklus, die erläutert werden müssen:}}

wenn eine Phase durch das Maven-Kommando aufgerufen wird, z.B. mvn kompilieren, werden nur die Phasen vor und einschließlich dieser Phase ausgeführt.

verschiedene Maven-Ziele werden basierend auf dem Packungstyp (JAR / WAR / EAR)，ist mit verschiedenen Maven-Lebenszyklusphasen verknüpft.

Im folgenden Beispiel werden wir den Maven-antrun-Plugin: Ausführung Ziel wird zu einer Phase des Build-Lebenszyklus hinzugefügt. Auf diese Weise können wir die Textinformationen des Lebenszyklus anzeigen.

Wir haben die pom.xml-Datei im Verzeichnis C:\MVN\project aktualisiert.

<project　xmlns="http://maven.apache.org/POM/4.0.0"
　　xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
　　xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
　　http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.projectgroup</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins/groupId>
<artifactId>maven-antrun-plugin>/artifactId>
<version>1.1build>/version>
<id>id.pre
　　　site phase<
　　　　　　<id>id.validierung</<id>id.site
　　　　　　<phase>validierung</deploy<
　　　　　　phase>
　　　　　　　　　<goals>/<goal>run<
　　　　　　build>/goal>
　　　　　　goals>
　　　　　　　　　<configuration>
　　　　　　　　　　　　<echo>Validierungsphase</deploy phase<
　　　　　　　　　build>/echo>
　　　　　　build>/tasks>
　　　build>/configuration>
　　　site phase<
　　　　　　<id>id.kompilieren</<id>id.site
　　　　　　<phase>kompilieren</deploy<
　　　　　　phase>
　　　　　　　　　<goals>/<goal>run<
　　　　　　build>/goal>
　　　　　　goals>
　　　　　　　　　<configuration>
　　　　　　　　　　　　<echo>Kompilierungsphase</deploy phase<
　　　　　　　　　build>/echo>
　　　　　　build>/tasks>
　　　build>/configuration>
　　　site phase<
　　　　　　<id>id.test</<id>id.site
　　　　　　<phase>test</deploy<
　　　　　　phase>
　　　　　　　　　<goals>/<goal>run<
　　　　　　build>/goal>
　　　　　　goals>
　　　　　　　　　<configuration>
　　　　　　　　　　　　<echo>Testphase</deploy phase<
　　　　　　　　　build>/echo>
　　　　　　build>/tasks>
　　　build>/configuration>
　　　site phase<
　　　　　　　　　<id>id.paketierung</<id>id.site
　　　　　　　　　<phase>paketierung</deploy<
　　　　　　　　　phase>
　　　　　　　　　　　　<goals>/<goal>run<
　　　　　　　　　build>/goal>
　　　　　　　　　goals>
　　　　　　　　　<configuration>
　　　　　　　　　　　　<echo>Paketierungsphase</deploy phase<
　　　　　　　　　build>/echo>
　　　　　　build>/tasks>
　　　build>/configuration>
　　　site phase<
　　　　　　<id>id.deployment</<id>id.site
　　　　　　<phase>deployment</deploy<
　　　　　　phase>
　　　　　　　　　<goals>/<goal>run<
　　　　　　build>/goal>
　　　　　　goals>
　　　　　　<configuration>
　　　　　　　　　<echo>Deployment-Phase</deploy phase<
　　　　　　build>/echo>
　　　　　　build>/tasks>
　　　build>/configuration>
build>/execution>
build>/executions>
build>/plugin>
build>/plugins>
build>/<

project>

C:\MVN\project>mvn kompilieren

Maven wird mit der Verarbeitung beginnen und die verschiedenen Phasen des Bau-Lebenszyklus bis zum Kompilierungsstadium anzeigen.

Maven beginnt mit der Verarbeitung und Anzeige der verschiedenen Phasen des Lebenszyklus von site bis zur site-Stufe.
[INFO]　------------------------------------------------------------------
[INFO] Durchsuchen nach Projekten...　-　[INFO] Erstellung von Unnamed1.0
[INFO]          task-Segment: [kompilieren]
[INFO]　------------------------------------------------------------------
[INFO] [antrun:ausführen {Ausführung: id.validate}]
[INFO]　Durchführung　von　Aufgaben
　　　　　[echo] Validierungsphase
[INFO]　Durchgeführte　Aufgaben
[INFO] [Ressourcen:ressourcen {Ausführung: default}-ressourcen}]
[WARNUNG] Plattformencodierung (Cp1252　tatsächlich) um gefilterte Ressourcen zu kopieren,
d.h. der Bau ist plattformabhängig!
[INFO] Überspringe nicht vorhandene Ressourcenverzeichnis C:\MVN\project\src\main\resources
[INFO] [Kompilierer:kompilieren {Ausführung: default}-kompilieren}]
[INFO] Es gibt nichts zum Kompilieren　-　alle Klassen sind auf dem neuesten Stand
[INFO]　[antrun:run　{execution:　id.compile}]
[INFO]　Durchführung　von　Aufgaben
　　　　　[echo]　compile　phase
[INFO]　Durchgeführte　Aufgaben
[INFO]　------------------------------------------------------------------
[INFO]　BAUERFOLG ERFOGENLICH
[INFO]　------------------------------------------------------------------
[INFO]　Gesamte　Zeit:　2　Sekunden
[INFO]　Beendet　um:　Sat　Jul　07　20:18:25　IST　2012
[INFO]　Endgültiges　Speicher:　7M/64M
[INFO]　------------------------------------------------------------------

Kommandozeilenaufruf

Im Entwicklungsmodus verwenden Sie den folgenden Befehl, um das Projekt zu bauen und in das lokale Repository zu installieren

mvn　install

Dieser Befehl führt vor dem Ausführen der Phase "install" in der richtigen Reihenfolge die Phasen des Standard-Lebenszyklus aus (validate, compile, package, usw.), wir müssen nur die letzte Phase aufrufen, wie hier "install".

Im Bauumgebung, verwenden Sie den folgenden Aufruf, um das Projekt rein zu bauen und in die gemeinsame Bibliothek zu deployen

mvn　clean　deploy

Dieser Befehl kann auch in Fällen mit mehreren Modulen verwendet werden, d.h. in Projekten, die mehrere Unterprojekte enthalten, führt Maven den Befehl "clean" in jedem Unterprojekt aus und führt dann den Befehl "deploy" aus.

Site-Lebenszyklus

Der Maven Site-Plugin wird in der Regel verwendet, um neue Berichtsdateien zu erstellen, Websites zu deployen und so weiter.

pre-site: Führt einige Arbeiten durch, die vor der Generierung der Dokumente der Website abgeschlossen werden müssen
site: Generiert die Dokumente der Website des Projekts
post-site: Führt einige Arbeiten durch, die nach der Generierung der Dokumente der Website abgeschlossen werden müssen, und bereitet die Bereitstellung vor
site-deploy: Deploiert die generierten Dokumente der Website auf einen bestimmten Server

Hier wird oft die Phase "site" und "site" verwendet-deploy-Phase verwenden, um die Maven-Website zu generieren und zu veröffentlichen, was eine sehr starke Funktion von Maven ist, die Manager bevorzugt, Dokumentation und Statistiken werden automatisch generiert und sind sehr schön. Im folgenden Beispiel werden wir den Maven-antrun-Der Ziel "plugin:run" wurde zu allen Phasen des Site-Lebenszyklus hinzugefügt. So können wir alle Textinformationen des Lebenszyklus anzeigen.