Fichier de configuration de construction Maven POM Maven

Cycle de construction Maven

Le cycle de vie de construction de Maven définit le processus de construction et de publication d'un projet.

Un cycle de vie de construction (build) typique de Maven est composé de la séquence des phases suivantes :

Phase	Traitement	description
Vérification validate	Vérifier le projet	Vérifier si le projet est correct et que toutes les informations nécessaires sont disponibles
Compilation compile	Exécuter la compilation	La compilation du code source est terminée à cette phase
Tests Test	Tests	Exécuter les tests en utilisant le cadre de tests unitaires approprié (par exemple, JUnit)
Empaquetage package	Empaquetage	Créer un JAR/Le paquet WAR est mentionné dans le pom.xml
Vérification verify	Vérification	Vérifier les résultats des tests intégrés pour garantir que la qualité atteint les normes
Installation install	Installation	Installer le projet打包 au dépôt local pour être utilisé par d'autres projets
Déploiement deploy	Déploiement	Copier le paquet de projet final vers le dépôt distant pour le partager avec d'autres développeurs et projets

Pour achever le cycle de vie default, ces phases (y compris d'autres phases de cycle de vie non énumérées ici) seront exécutées en ordre.

Maven possède les trois phases de cycle de vie standard suivantes :

clean：Traitement de la nettoyage du projet
default (ou build)：Traitement du déploiement du projet
site：Traitement de la création des documents du site du projet

Les phases de construction sont constituées de cibles d'extension

Une cible d'extension représente une tâche spécifique (plus fine que la phase de construction), ce qui aide à la construction et à la gestion du projet. Ces cibles peuvent être liées à plusieurs phases ou non liées. Les cibles non liées à aucune phase de construction peuvent être exécutées directement à l'extérieur du cycle de vie de construction. L'ordre d'exécution de ces cibles dépend de l'ordre d'appel des cibles et des phases de construction.

Par exemple, considérez la commande suivante :

clean et pakage sont des phases de construction, dependency:copy-Les dépendances sont des cibles

mvn clean dependency:copy-dépendances package

La phase clean ici sera d'abord exécutée, puis dependency:copy-Les dépendances cibles seront exécutées, et finalement, la phase package sera exécutée.

Cycle de vie Clean

Lorsque nous executons mvn post-lorsque nous execute mvn clean, Maven appelle le cycle de vie clean, qui contient les etapes suivantes :

pre-clean : execute des travaux qui doivent etre completes avant clean
clean : supprime tous les fichiers generes par la derniere construction
post-clean : execute des travaux qui doivent etre completes immediatement apres clean

Dans mvn clean, clean est celui du dessus. Dans un cycle de vie, lors de l'execution d'une etape, toutes les etapes precedentes seront executees, c'est-a-dire, si mvn clean est execute, les deux etapes suivantes du cycle de vie seront executees :

pre-clean, clean

Si nous execute mvn post-si clean est execute, les trois etapes suivantes du cycle de vie seront executees :

pre-clean, clean, post-clean

Nous pouvons modifier le comportement de cette operation en definissant un objectif a n'importe quelle etape du cycle de vie clean.

Dans l'exemple suivant, nous allons utiliser maven-antrun-l'objectif plugin:run ajoute a pre-clean, clean et post-dans la phase de clean. De cette facon, nous pouvons afficher des informations textuelles a chaque etape du cycle de vie clean.

Nous avons cree un fichier pom.xml dans le repertoire C:\MVN\project.

<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.1</version>
　　　<executions>
　　　　　　<execution>
　　　　　　　　　<id>id.pre-clean</id>
　　　　　　　　　<phase>pre-clean</phase>
　　　　　　　　　<goals>
　　　　　　　　　　　　<goal>run</goal>
　　　　　　　　　</goals>
　　　　　　　　　<configuration>
　　　　　　　　　　　　<tasks>
　　　　　　　　　　　　　　　<echo>pre-phase de clean</echo>
　　　　　　　　　　　　</tasks>
　　　　　　　　　</configuration>
　　　　　　</execution>
　　　　　　<execution>
　　　　　　　　　<id>id.clean</id>
　　　　　　　　　<phase>clean</phase>
　　　　　　　　　<goals>
　　　　　　　　　　<goal>run</goal>
　　　　　　　　　</goals>
　　　　　　　　　<configuration>
　　　　　　　　　　　　<tasks>
　　　　　　　　　　　　　　　<echo>phase de clean</echo>
　　　　　　　　　　　　</tasks>
　　　　　　　　　</configuration>
　　　　　　</execution>
　　　　　　<execution>
　　　　　　　　　<id>id.post-clean</id>
　　　　　　　　　<phase>post-clean</phase>
　　　　　　　　　<goals>
　　　　　　　　　　　　<goal>run</goal>
　　　　　　　　　</goals>
　　　　　　　　　<configuration>
　　　　　　　　　　　　<tasks>
　　　　　　　　　　　　　　　<echo>post-phase de clean</echo>
　　　　　　　　　　　　</tasks>
　　　　　　　　　</configuration>
　　　　　　</execution>
　　　</executions>
　　　</plugin>
</plugins>
</build>
</project>

Maintenant, ouvrez la console de commande, allez dans le repertoire ou se trouve pom.xml, et executez la commande mvn suivante.

C:\MVN\project>mvn post-clean

Maven commencera a traiter et a afficher toutes les etapes du cycle de vie clean.

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

Vous pouvez essayer de modifier l'commande mvn clean pour afficher pre-clean et clean, et dans post-La phase de clean ne execute aucune operation.

Cycle de vie par défaut (Construction)

C'est le cycle de vie principal de Maven, utilisé pour construire les applications, y compris les éléments suivants : 23 étape :

étape de cycle de vie	description
validate (valider)	Vérifier que le projet est correct et que toutes les informations nécessaires peuvent achever le processus de construction du projet.
initialize (initialiser)	Initialiser l'état de construction, par exemple, définir les valeurs des propriétés.
generate-sources (générer le code source)	Générer tout le code source inclus dans la phase de compilation.
process-sources (traiter le code source)	Traiter le code source, par exemple, filtrer les valeurs arbitraires.
generate-resources (générer les fichiers de ressources)	Générer les fichiers de ressources qui seront inclus dans le paquet de projet.
process-resources (traiter les fichiers de ressources)	Copier et traiter les ressources vers le répertoire cible, pour préparer au mieux la phase de packaging.
compile (compiler)	Compiler le code source du projet.
process-classes (traiter les fichiers de classes)	Traiter les fichiers générés par la compilation, par exemple, optimiser les bytecode des fichiers Java class.
generate-test-sources (générer le code source de test)	Générer tout le code source de test inclus dans la phase de compilation.
process-test-sources (traiter le code source de test)	Traiter le code source de test, par exemple, filtrer les valeurs arbitraires.
generate-test-resources (générer les fichiers de ressources)	Créer des fichiers de ressources pour le test.
process-test-resources (traiter les fichiers de ressources de test)	Copier et traiter les ressources de test vers le répertoire cible.
test-compile (compiler le code source de test)	Compiler le code source de test dans le répertoire cible de test.
process-test-classes (traiter les fichiers de classes de test)	Traiter les fichiers générés par la compilation du code de test.
test (test)	Exécuter les tests avec le cadre de test unitaire approprié (Juint en est un).
prepare-package (préparer le packaging)	Exécuter toutes les opérations nécessaires pour préparer le paquetage avant le packaging réel.
package (packager)	Packager le code compilé en fichiers de format distribuable, tels que les fichiers JAR, WAR ou EAR.
pre-integration-test (avant test d'intégration)	Effectuer les actions nécessaires avant l'exécution des tests d'intégration. Par exemple, construire l'environnement nécessaire.
integration-test (test d'intégration)	Traiter et déployer le projet dans un environnement où les tests d'intégration peuvent être exécutés.
post-integration-test (après test d'intégration)	Effectuer les actions nécessaires après l'exécution des tests d'intégration. Par exemple, nettoyer l'environnement de test d'intégration.
verify (vérifier)	Exécuter des vérifications arbitraires pour valider que le paquet de projet est valide et atteint les normes de qualité.
install (installer)	Installer le paquet de projet dans le dépôt local pour qu'il puisse être utilisé comme dépendance pour d'autres projets locaux.
deploy (déployer)	Copier le paquet de projet final dans le dépôt distant pour le partager avec d'autres développeurs et projets.

Il y a quelques concepts importants liés au cycle de vie Maven qui doivent être expliqués :

quand une phase est appelée par une commande Maven, par exemple mvn compile, seules les phases avant et incluses dans la phase seront exécutées.

différents objectifs Maven seront basés sur le type de paquetage (JAR / WAR / EAR), lié à différentes phases du cycle de vie Maven.

Dans l'exemple suivant, nous allons utiliser maven-antrun-plugin:run l'objectif est ajouté à une phase de la vie du Build. De cette manière, nous pouvons afficher les informations textuelles du cycle de vie.

Nous avons mis à jour le fichier pom.xml dans le répertoire C:\MVN\project.

<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.1</version>
<executions>
　　　<execution>
　　　　　　<id>id.validate</id>
　　　　　　<phase>validate</phase>
　　　　　　<goals>
　　　　　　　　　<goal>run</goal>
　　　　　　</goals>
　　　　　　<configuration>
　　　　　　　　　<tasks>
　　　　　　　　　　　　<echo>phase de validation</echo>
　　　　　　　　　</tasks>
　　　　　　</configuration>
　　　</execution>
　　　<execution>
　　　　　　<id>id.compile</id>
　　　　　　<phase>compile</phase>
　　　　　　<goals>
　　　　　　　　　<goal>run</goal>
　　　　　　</goals>
　　　　　　<configuration>
　　　　　　　　　<tasks>
　　　　　　　　　　　　<echo>phase de compilation</echo>
　　　　　　　　　</tasks>
　　　　　　</configuration>
　　　</execution>
　　　<execution>
　　　　　　<id>id.test</id>
　　　　　　<phase>test</phase>
　　　　　　<goals>
　　　　　　　　　<goal>run</goal>
　　　　　　</goals>
　　　　　　<configuration>
　　　　　　　　　<tasks>
　　　　　　　　　　　　<echo>phase de test</echo>
　　　　　　　　　</tasks>
　　　　　　</configuration>
　　　</execution>
　　　<execution>
　　　　　　　　　<id>id.package</id>
　　　　　　　　　<phase>package</phase>
　　　　　　　　　<goals>
　　　　　　　　　　　　<goal>run</goal>
　　　　　　　　　</goals>
　　　　　　　　　<configuration>
　　　　　　　　　<tasks>
　　　　　　　　　　　　<echo>phase de paquetage</echo>
　　　　　　　　　</tasks>
　　　　　　</configuration>
　　　</execution>
　　　<execution>
　　　　　　<id>id.deploy</id>
　　　　　　<phase>deploy</phase>
　　　　　　<goals>
　　　　　　　　　<goal>run</goal>
　　　　　　</goals>
　　　　　　<configuration>
　　　　　　<tasks>
　　　　　　　　　<echo>phase de déploiement</echo>
　　　　　　</tasks>
　　　　　　</configuration>
　　　</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

Ouvrez　maintenant　la　console　de　commande，allez　dans　le　répertoire　contenant　pom.xml　et　exécutez　la　commande　mvn suivante.

C:\MVN\project>mvn compile

Maven va commencer à traiter et à afficher les différentes phases du cycle de vie de la construction jusqu'à la phase de compilation .

[INFO]　Scanning　for　projects...
[INFO]　------------------------------------------------------------------
[INFO]　Building　Unnamed　-　com.companyname.projectgroup:project:jar:1.0
[INFO]　　　　task-segment: [compile]
[INFO]　------------------------------------------------------------------
[INFO] [antrun:run {exécution: id.validate}]
[INFO]　Executing　tasks
　　　　　[echo] phase de validation
[INFO]　Executed　tasks
[INFO] [ressources:ressources {exécution: default-ressources}]
[WARNING] Utilisation de l'encodage de la plateforme (Cp1252　en fait) pour copier les ressources filtrées ,
c'est-à-dire que la construction dépend de la plateforme !
[INFO] sauter le répertoire de ressources inexistant C:\MVN\project\src\main\resources
[INFO] [compilateur:compiler {exécution: default-compiler}]
[INFO] Pas de fichier à compiler　-　toutes les classes sont à jour
[INFO] [antrun:run {execution: id.compile}]
[INFO]　Executing　tasks
　　　　　[echo] phase compile
[INFO]　Executed　tasks
[INFO]　------------------------------------------------------------------
[INFO]　BUILD　SUCCESSFUL
[INFO]　------------------------------------------------------------------
[INFO]　Total　time:　2　seconds
[INFO]　Finished　at:　Sat　Jul　07　20:18:25　IST　2012
[INFO]　Final　Memory:　7M/64M
[INFO]　------------------------------------------------------------------

Appel en ligne de commande

Dans l'environnement de développement, utiliser la commande suivante pour construire et installer le projet dans le dépôt local

mvn install

Cette commande exécute les phases du cycle de vie par défaut (validate, compile, package, etc.) dans l'ordre avant l'exécution de la phase install, nous devons appeler la dernière phase, comme ici, install.

Dans l'environnement de construction, utiliser l'appel suivant pour construire et déployer purement le projet vers le dépôt partagé

mvn clean deploy

Cette commande peut également être utilisée dans le cas de projets multimodules, c'est-à-dire des projets contenant plusieurs sous-projets, Maven exécutera la commande clean pour chaque sous-projet, puis la commande deploy.

Cycle de vie Site

Le plugin Maven Site est généralement utilisé pour créer de nouveaux documents de rapport, déployer des sites, etc.

pre-site : exécuter certains travaux qui doivent être accomplis avant la génération des documents de site
site : générer les documents de site du projet
post-site : exécuter certains travaux qui doivent être accomplis après la génération des documents de site et préparer le déploiement
site-deploy : déployer les documents de site générés sur un serveur spécifique

Ici, les phases site et site-la phase deploy, pour générer et publier le site Maven, une fonction très puissante de Maven, appréciée par le gestionnaire, la génération automatique de la documentation et des statistiques, c'est très joli. Dans l'exemple suivant, nous allons utiliser maven-antrun-L'objectif plugin:run a été ajouté à toutes les phases du cycle de vie de Site. De cette manière, nous pouvons afficher toutes les informations textuelles du cycle de vie.