Cycle de vie de build Maven
Le cycle de vie de build Maven définit un processus pour construire et publier un projet, et comprend trois cycles de vie standard :
- clean : nettoie le projet
- default (ou build) : le processus de build principal
- site : génère la documentation du projet

Chaque cycle de vie se compose de plusieurs phases, qui sont exécutées dans l'ordre.
1. Cycle de vie Clean
Le cycle de vie clean est responsable du nettoyage des fichiers et répertoires temporaires du projet (principalement target/), et comprend les principales phases suivantes :
| Phase | Description | Objectifs de plugin liés automatiquement |
|---|---|---|
pre-clean | Travail effectué avant le nettoyage | Aucune liaison par défaut |
clean | Deletetarget/répertoire | maven-clean-plugin:clean |
post-clean | Travaux de finalisation après clean | Aucune liaison par défaut |
Commandes courantes :
mvn clean # 执行clean阶段(包含pre-clean和clean)
2. Cycle de vie par défaut
Le cycle de vie par défaut est le cycle de vie le plus important de Maven, contenant toutes les étapes essentielles pour construire et déployer un projet.
Un cycle de vie de build Maven typique se compose de la séquence de phases suivante :

| Phase | Opération | Description |
|---|---|---|
| validate | Valider le projet | Valider que le projet est correct et que toutes les informations nécessaires sont disponibles. |
| compile | Effectuer la compilation | La compilation du code source est effectuée dans cette phase. |
| test | Test | Exécuter les tests à l'aide d'un framework de tests unitaires approprié (par exemple, JUnit). |
| package | Paquet | Empaqueter le code compilé dans un format distribuable, tel que JAR ou WAR. |
| verify | Vérifier | Vérifier les résultats des tests d'intégration pour s'assurer que la qualité répond aux normes. |
| install | Installer | Installer le projet empaqueté dans le référentiel local afin qu'il soit utilisé par d'autres projets. |
| deploy | Déployer | Copiez le paquet final du projet vers le dépôt distant pour le partager avec d'autres développeurs et projets. |
Pour terminer le cycle de vie par défaut, ces phases (y compris d'autres phases du cycle de vie non listées ci-dessus) seront exécutées dans l'ordre.
Dépendances entre les phases :

Commandes courantes :
mvn compile # 编译主代码 mvn test # 运行测试 mvn package # 打包(生成target/*.jar) mvn install # 安装到本地仓库(~/.m2/repository) mvn deploy # 部署到远程仓库(需配置distributionManagement)
3. Cycle de vie du site
Le cycle de vie du site est utilisé pour générer la documentation du site du projet :
| Phase | Description | Objectifs de plugin liés automatiquement |
|---|---|---|
pre-site | Préparation avant la génération du site | Aucune liaison par défaut |
site | Générer la documentation du site du projet | maven-site-plugin:site |
post-site | Finalisation après le site | Aucune liaison par défaut |
site-deploy | Déployer le site sur un serveur | maven-site-plugin:deploy |
Commandes courantes :
mvn site # 生成站点(输出在target/site/) mvn site-deploy # 部署站点(需配置site URL)
Résumé du cycle de vie
Maven dispose des trois cycles de vie standard suivants :
1. Cycle de vie Clean :
- clean: Supprime les fichiers de sortie compilés dans le répertoire cible. Il est généralement exécuté avant la construction pour garantir que le projet démarre dans un état propre.
2. Cycle de vie par défaut (également appelé cycle de vie de build) :
- validate: Valider l'exactitude du projet, par exemple, vérifier si la version du projet est correcte.
- compile: Compile le code source du projet.
- test: Exécute les tests unitaires du projet.
- package: Empaquette le code compilé dans un format distribuable, tel que JAR ou WAR.
- verify: Effectue des vérifications supplémentaires sur le projet pour garantir la qualité.
- install: Installe le résultat de build du projet dans le dépôt Maven local pour utilisation par d'autres projets.
- deploy: Copie le résultat de build du projet vers le dépôt distant pour utilisation par d'autres développeurs ou équipes.
3. Cycle de vie Site :
- site: Génère la documentation du projet et les informations du site.
- deploy-site: Publier les informations du site généré sur un serveur distant pour partager la documentation du projet.
Les phases de construction sont composées de goals de plugins
Un goal de plugin représente une tâche spécifique (plus fine qu'une phase de construction), qui aide à la construction et à la gestion d'un projet. Ces goals peuvent être liés à plusieurs phases ou à aucune phase du tout. Les goals qui ne sont liés à aucune phase de construction peuvent être exécutés en dehors du cycle de vie de construction par invocation directe. L'ordre d'exécution de ces goals dépend de l'ordre des goals et des phases de construction invoqués.
Par exemple, considérez la commande suivante :
clean et package sont des phases de construction, et dependency:copy-dependencies est un goal.
mvn clean dependency:copy-dependencies package
Ici, la phase clean sera exécutée en premier, puis le goal dependency:copy-dependencies sera exécuté, et enfin la phase package est exécutée.
1. Cycle de vie Clean
Lorsque nous exécutons la commande mvn post-clean, Maven invoque le cycle de vie clean, qui inclut les phases suivantes :
- pre-clean : effectue un travail qui doit être terminé avant clean.
- clean : supprime tous les fichiers générés par la construction précédente.
- post-clean : effectue un travail qui doit être fait immédiatement après clean.
Le clean dans mvn clean est le même clean que ci-dessus. Dans un cycle de vie, lorsqu'une certaine phase est exécutée, toutes les phases qui la précèdent sont également exécutées. C'est-à-dire que si vous exécutez mvn clean, les deux phases du cycle de vie suivantes seront exécutées :
pre-clean, clean
Si nous exécutons mvn post-clean, les trois phases du cycle de vie suivantes seront exécutées :
pre-clean, clean, post-clean
Nous pouvons modifier le comportement opérationnel de cette partie en définissant des objectifs dans n'importe quelle phase du cycle de vie clean décrit ci-dessus.
Dans l'exemple suivant, nous ajoutons l'objectif maven-antrun-plugin:run aux phases pre-clean, clean et post-clean. De cette façon, nous pouvons afficher des informations textuelles à chaque phase du cycle de vie clean.
Nous avons créé un fichier pom.xml dans le répertoire C:\MVN\project.
Ouvrez maintenant la console de commande, naviguez jusqu'au répertoire contenant pom.xml, puis exécutez la commande mvn suivante.
C:\MVN\project>mvn post-clean
Maven commencera le traitement et affichera toutes les phases 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-clean phase
[INFO] Executed tasks
[INFO] [clean:clean {execution: default-clean}]
[INFO] [antrun:run {execution: id.clean}]
[INFO] Executing tasks
[echo] clean phase
[INFO] Executed tasks
[INFO] [antrun:run {execution: id.post-clean}]
[INFO] Executing tasks
[echo] post-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] ------------------------------------------------------------------Vous pouvez essayer de modifier la commande mvn clean pour afficher pre-clean et clean, sans exécuter d'opérations dans la phase post-clean.
2. Cycle de vie par défaut (Build)
Il s'agit du cycle de vie principal de Maven, utilisé pour construire des applications, et comprend les 23 phases suivantes :
| Phase du cycle de vie | Description |
|---|---|
| validate (validation) | Vérifiez que le projet est correct et que toutes les informations nécessaires sont disponibles pour terminer le processus de construction du projet. |
| initialize (initialisation) | Initialisez l'état de construction, par exemple en définissant les valeurs des propriétés. |
| generate-sources (générer le code source) | Générer tout code source qui sera inclus dans la phase de compilation. |
| process-sources (traiter le code source) | Traiter le code source, par exemple, filtrer des valeurs. |
| generate-resources (générer les fichiers de ressources) | Générer les fichiers de ressources qui seront inclus dans le paquet du projet. |
| process-resources (traiter les fichiers de ressources) | Copier et traiter les ressources vers le répertoire cible, en préparant la phase d'empaquetage. |
| compile (compilation) | Compiler le code source du projet. |
| process-classes (traiter les fichiers de classe) | Traiter les fichiers générés par la compilation, par exemple, effectuer l'amélioration et l'optimisation du bytecode sur les fichiers de classe Java. |
| generate-test-sources (générer le code source de test) | Générer tout code source de test qui sera inclus dans la phase de compilation. |
| process-test-sources (traiter le code source de test) | Traiter le code source de test, par exemple, filtrer toutes les valeurs. |
| generate-test-resources (générer les fichiers de ressources de test) | Créer des fichiers de ressources pour les tests. |
| 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 vers le répertoire cible des tests. |
| process-test-classes (traiter les fichiers de classes de test) | Traiter les fichiers générés par la compilation du code source de test. |
| test (test) | Exécutez les tests à l'aide d'un framework de tests unitaires approprié (JUnit en fait partie). |
| prepare-package (préparer l'empaquetage) | Effectuez toutes les opérations nécessaires pour préparer l'empaquetage avant l'empaquetage proprement dit. |
| package (empaquetage) | Empaquetez le code compilé dans un format distribuable, tel que des fichiers JAR, WAR ou EAR. |
| pre-integration-test (avant les tests d'intégration) | Effectuez les actions nécessaires avant d'exécuter les tests d'intégration. Par exemple, configurez l'environnement requis. |
| integration-test (test d'intégration) | Traitez et déployez le projet dans un environnement où les tests d'intégration peuvent être exécutés. |
| post-integration-test (après les tests d'intégration) | Effectuez les actions nécessaires après l'exécution des tests d'intégration. Par exemple, nettoyez l'environnement de test d'intégration. |
| verify (vérifier) | Exécutez toutes les vérifications pour vous assurer que le package du projet est valide et répond aux normes de qualité. |
| install (install) | Installez le package du projet dans le dépôt local, afin qu'il puisse être utilisé comme dépendance pour d'autres projets locaux. |
| deploy (deploy) | Copiez le package final du projet vers le dépôt distant pour le partager avec d'autres développeurs et projets. |
Certains concepts importants liés au cycle de vie Maven doivent être expliqués :
Lorsqu'une phase est invoquée via une commande Maven, telle que mvn compile, toutes les phases jusqu'à cette phase incluse, et uniquement celles-ci, seront exécutées.
Différents objectifs Maven seront liés à différentes phases du cycle de vie Maven selon le type d'empaquetage (JAR / WAR / EAR).
Dans l'exemple suivant, nous allons ajouter l'objectif maven-antrun-plugin:run à certaines phases du cycle de vie Build. De cette façon, nous pouvons afficher les informations textuelles du cycle de vie.
Nous avons déjà mis à jour le fichier pom.xml dans le répertoire C:\MVN\project.
Ouvrez maintenant la console de commande, naviguez jusqu'au répertoire contenant pom.xml, puis exécutez la commande mvn suivante.
C:\MVN\project>mvn compile
Maven commencera le traitement et affichera les différentes phases du cycle de vie de build jusqu'à la phase compile.
[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO] task-segment: [compile]
[INFO] ------------------------------------------------------------------
[INFO] [antrun:run {execution: id.validate}]
[INFO] Executing tasks
[echo] validate phase
[INFO] Executed tasks
[INFO] [resources:resources {execution: default-resources}]
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVN\project\src\main\resources
[INFO] [compiler:compile {execution: default-compile}]
[INFO] Nothing to compile - all classes are up to date
[INFO] [antrun:run {execution: id.compile}]
[INFO] Executing tasks
[echo] compile phase
[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] ------------------------------------------------------------------
Invocation en ligne de commande
Dans un environnement de développement, utilisez la commande suivante pour construire et installer le projet dans le référentiel local.
mvn install
Cette commande exécute les phases du cycle de vie par défaut (validate, compile, package, etc.) dans l'ordre avant d'exécuter la phase install. Il suffit d'invoquer la dernière phase, comme install ici.
Dans un environnement de build, utilisez l'invocation suivante pour construire et déployer proprement le projet vers le référentiel partagé.
mvn clean deploy
Cette commande peut également être utilisée dans un scénario multi-modules, c'est-à-dire un projet contenant plusieurs sous-projets. Maven exécutera la commande clean sur chaque sous-projet, puis exécutera la commande deploy.
3. Cycle de vie du 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 : Effectuer certains travaux qui doivent être terminés avant de générer la documentation du site.
- site : Générer la documentation du site du projet.
- post-site : Effectuer certains travaux qui doivent être terminés après la génération de la documentation du site, et préparer le déploiement.
- site-deploy : Déployer la documentation de site générée sur un serveur spécifique.
Les phases les plus couramment utilisées ici sont la phase site et la phase site-deploy, qui servent à générer et publier le site Maven. C'est une fonctionnalité assez puissante de Maven, et les managers l'apprécient beaucoup car la documentation et les statistiques sont générées automatiquement et sont très esthétiques. Dans l'exemple suivant, nous ajouterons l'objectif maven-antrun-plugin:run à toutes les phases du cycle de vie Site. De cette façon, nous pouvons afficher toutes les informations textuelles du cycle de vie.
Nous avons déjà mis à jour le fichier pom.xml dans le répertoire C:\MVN\project.
Ouvrez maintenant la console de commande, naviguez jusqu'au répertoire contenant pom.xml, puis exécutez la commande mvn suivante.
C:\MVN\project>mvn site
Maven commencera à traiter et affichera les différentes phases du cycle de vie Site jusqu'à la phase site.
[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO] task-segment: [site]
[INFO] ------------------------------------------------------------------
[INFO] [antrun:run {execution: id.pre-site}]
[INFO] Executing tasks
[echo] pre-site phase
[INFO] Executed tasks
[INFO] [site:site {execution: default-site}]
[INFO] Generating "About" report.
[INFO] Generating "Issue Tracking" report.
[INFO] Generating "Project Team" report.
[INFO] Generating "Dependencies" report.
[INFO] Generating "Project Plugins" report.
[INFO] Generating "Continuous Integration" report.
[INFO] Generating "Source Repository" report.
[INFO] Generating "Project License" report.
[INFO] Generating "Mailing Lists" report.
[INFO] Generating "Plugin Management" report.
[INFO] Generating "Project Summary" report.
[INFO] [antrun:run {execution: id.site}]
[INFO] Executing tasks
[echo] site phase
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------
[INFO] Total time: 3 seconds
[INFO] Finished at: Sat Jul 07 15:25:10 IST 2012
[INFO] Final Memory: 24M/149M
[INFO] ------------------------------------------------------------------``` Autres extensions