Quels sont les objectifs et les phases Maven et quelle est leur différence?
Quelle est la différence/relation entre les objectifs et les phases de Maven? Comment sont-ils liés les uns aux autres?
Les objectifs sont exécutés par phases, ce qui aide à déterminer l'ordre dans lequel les objectifs sont exécutés. Pour mieux comprendre cela, examinez le liaisons de cycle de vie Maven par défaut , qui indique les objectifs exécutés dans quelles phases par défaut. Les objectifs de la phase de compilation seront toujours exécutés avant les objectifs de la phase de test, lesquels seront toujours exécutés avant les objectifs de la phase de package, etc.
Une partie de la confusion est exacerbée par le fait que lorsque vous exécutez maven, vous pouvez spécifier un objectif ou une phase. Si vous spécifiez une phase, maven exécutera toutes les phases jusqu’à la phase spécifiée dans l’ordre (par exemple, si vous spécifiez un paquet, il sera d'abord exécuté à la phase de compilation, puis à la phase de test et enfin à la phase de paquet) et, pour chaque phase, exécuter tous les objectifs attachés à cette phase.
Lorsque vous créez une exécution de plug-in dans votre fichier de construction Maven et que vous spécifiez uniquement l'objectif, il liera cet objectif à une phase donnée par défaut. Par exemple, l'objectif jaxb: xjc se lie par défaut à la phase de génération de ressources. Toutefois, lorsque vous spécifiez l'exécution, vous pouvez également spécifier explicitement la phase pour cet objectif.
Si vous spécifiez un objectif lors de l'exécution de Maven, toutes les phases seront exécutées jusqu'à la phase correspondant à cet objectif. En d'autres termes, si vous spécifiez l'objectif JAR, toutes les phases seront exécutées jusqu'à la phase de package (et tous les objectifs de ces phases), puis l'objectif jar.
Le cycle de vie est une séquence de nom phases .
Les phases sont exécutées de manière séquentielle. L'exécution d'une phase signifie que toutes les phases précédentes sont exécutées.Le plugin est une collection de buts également appelée MOJO (M aven O ld J ava O bject).
Analogie: Le plugin est une classe et les objectifs sont des méthodes de la classe.
Maven est basé sur le concept central d'un cycles de vie de construction . Dans chaque cycle de vie de construction , il y a phases de construction , et à l'intérieur de chaque phases de construction , il y a Objectifs de construction .
Nous pouvons exécuter une phase de construction ou un objectif de construction. Lors de l'exécution d'une phase de construction, nous exécutons tous les objectifs de construction de cette phase. Les objectifs de construction sont affectés à une ou plusieurs phases de construction. Nous pouvons également exécuter directement un objectif de construction.
Il y a trois principaux intégrés cycles de vie de construction :
- default
- nettoyer
- site
Chaque cycle de vie de construction est composé de phases
Par exemple, le cycle de vie default comprend les éléments suivants Build Phases :
◾validate - validate the project is correct and all necessary information is available
◾compile - compile the source code of the project
◾test - test the compiled source code using a suitable unit testing framework. These tests should not require the code be packaged or deployed
◾package - take the compiled code and package it in its distributable format, such as a JAR.
◾integration-test - process and deploy the package if necessary into an environment where integration tests can be run
◾verify - run any checks to verify the package is valid and meets quality criteria
◾install - install the package into the local repository, for use as a dependency in other projects locally
◾deploy - done in an integration or release environment, copies the final package to the remote repository for sharing with other developers and projects.
Donc, pour passer par les phases ci-dessus, il suffit d'appeler une commande:
mvn <phase> { Ex: mvn install }
Pour la commande ci-dessus, à partir de la première phase, toutes les phases sont exécutées de manière séquentielle jusqu’à la phase d’installation. mvn peut exécuter un objectif ou une phase (ou même plusieurs objectifs ou plusieurs phases) comme suit:
mvn clean install plugin:goal
Toutefois, si vous souhaitez personnaliser le préfixe utilisé pour référencer votre plug-in, vous pouvez le spécifier directement via un paramètre de configuration sur le maven-plugin-plugin de votre POM du plugin.
Une phase de construction est composée de Plugin Goals
La plupart des fonctionnalités de Maven sont dans les plugins. Un plugin fournit un ensemble de buts qui peut être exécuté à l'aide de la syntaxe suivante:
mvn [plugin-name]:[goal-name]
Par exemple, un projet Java peut être compilé avec l'objectif de compilation du plug-in du compilateur en exécutant mvn compiler:compile.
Le cycle de vie de la construction est une liste de phases nommées pouvant être utilisées pour donner un ordre à l'exécution des objectifs.
Les objectifs fournis par les plugins peuvent être associés à différentes phases du cycle de vie. Par exemple, par défaut, l'objectif compiler:compile est associé à la phase compile, tandis que l’objectif surefire:test est associé à la test phase . Considérez la commande suivante:
mvn test
Lorsque la commande précédente est exécutée, Maven exécute tous les objectifs associés à chacune des phases, y compris la phase test. Dans ce cas, Maven exécute l’objectif resources:resources associé à la phase process-resources, puis compiler:compile, et ainsi de suite jusqu’à ce qu’il atteigne enfin l’objectif surefire:test.
Cependant, même si une phase de construction est responsable d'une étape spécifique du cycle de vie de la construction, la manière dont elle s'acquitte de ces responsabilités peut varier. Et cela se fait en déclarant les objectifs du plug-in liés à ces phases de construction.
Un objectif de plug-in représente une tâche spécifique (plus fine qu'une phase de construction) qui contribue à la construction et à la gestion d'un projet. Il peut être lié à zéro ou plusieurs phases de construction. Un objectif non lié à une phase de construction peut être exécuté en dehors du cycle de vie de la construction par une invocation directe. L'ordre d'exécution dépend de l'ordre dans lequel le ou les objectifs et la ou les phases de construction sont appelés. Par exemple, considérons la commande ci-dessous. Les arguments clean et package sont des phases de construction, tandis que le dependency:copy-dependencies est un objectif (d'un plugin).
mvn clean dependency:copy-dependencies package
Si cela devait être exécuté, la phase clean sera exécutée en premier (autrement dit, toutes les phases précédentes du cycle de vie propre seront exécutées, plus la phase clean lui-même), puis le dependency:copy-dependencies objectif, avant d’exécuter enfin la phase package (et toutes les phases de construction précédentes du cycle de vie par défaut).
De plus, si un objectif est lié à une ou plusieurs phases de construction, cet objectif sera appelé dans toutes ces phases.
En outre, une phase de construction peut également avoir zéro objectif ou plus lié à celle-ci. Si une phase de construction n'a pas d'objectifs liés, cette phase de construction ne s'exécutera pas. Mais si un ou plusieurs objectifs sont liés, tous ces objectifs seront exécutés.
Liaisons de cycle de vie intégrées
Certaines phases ont des objectifs qui leur sont liés par défaut. Et pour le cycle de vie par défaut, ces liaisons dépendent de la valeur d'empaquetage.
Architecture Maven:
Exemple Eclipse pour la cartographie du cycle de vie Maven
La réponse choisie est excellente, mais j'aimerais quand même ajouter quelque chose de petit au sujet. Une illustration.
Cela montre clairement comment les différentes phases sont liées aux différents plugins et les objectifs que ces plugins définissent.
Donc, examinons un cas d'exécution de quelque chose comme: mvn compile:
- C'est une phase qui exécute le plugin de compilation avec compile but
- Le plugin du compilateur a des objectifs différents. Pour
mvn compile, il est associé à un objectif spécifique, l’objectif de compilation. - C'est la même chose que de lancer
mvn compiler:compile
Par conséquent, la phase est composée d'objectifs de plug-in .
Lien vers le référence
Les définitions sont détaillées à la page page du site Maven Introduction au cycle de vie de la construction , mais j'ai essayé de résumer :
Maven définit 4 éléments d'un processus de construction:
Cycle de vie
Trois cycles de vie intégrés (aka construisent des cycles de vie ):
default,clean,site. ( Référence du cycle de vie )Phase
Chaque cycle de vie est composé de phases , par ex. pour le cycle de vie
default:compile,test,package,install, etc.Plugin
Un artefact qui fournit un ou plusieurs objectifs.
En fonction du type de packaging (
jar,war, etc.), les objectifs des plugins sont liés aux phases par défaut. ( Liaisons de cycle de vie intégrées )But
La tâche (action) qui est exécutée. Un plugin peut avoir un ou plusieurs objectifs.
Un ou plusieurs objectifs doivent être spécifiés quand configuration d'un plugin dans un POM . De plus, si aucun plugin n'a défini de phase par défaut, le ou les objectifs spécifiés peuvent être liés à une phase.
Maven peut être invoqué avec:
- une phase (par exemple
clean,package) <plugin-prefix>:<goal>(par exemple _dependency:copy-dependencies_)- _
<plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>_ (par exemple _org.Apache.maven.plugins:maven-compiler-plugin:3.7.0:compile_)
avec une ou plusieurs combinaisons de l'une ou de plusieurs, par exemple:
_mvn clean dependency:copy-dependencies package
_Je pense qu'une bonne réponse est déjà fournie, mais je voudrais ajouter un diagramme simple des trois cycles de vie (build, clean et site) et les phases dans chacune.
Les phases en gras - sont les principales phases couramment utilisées.
Crédit à Sandeep Jindal et Premraj. Leur explication m'aide à comprendre après avoir été troublée pendant un moment.
J'ai créé quelques exemples de code complets et quelques explications simples ici https://www.surasint.com/maven-life-cycle-phase-and-goal-easy-explained/ . Je pense que cela peut aider les autres à comprendre.
En bref, du lien, vous ne devriez pas essayer de comprendre les trois en même temps, vous devez d’abord comprendre la relation entre ces groupes:
- Cycle de vie vs phase
- Plugin vs objectif
1. Cycle de vie vs phase
Cycle de vie est un ensemble de phases en séquence, voir ici Références de cycle de vie . Lorsque vous appelez une phase , il appelle également toutes les phases qui précèdent. .
Par exemple, le cycle de vie propre comporte 3 phases (: pré-nettoyage, nettoyage, post-nettoyage ).
mvn clean
Il appellera pré-nettoyer et propre .
2. Plugin vs objectif
L'objectif est comme une action dans le plugin . Donc, si le plugin est une classe, goal est une méthode.
vous pouvez appeler un objectif comme ceci:
mvn clean:clean
Cela signifie "appeler le but propre, dans le plugin clean" (Rien ne se rapporte ici à la phase de nettoyage. Ne laissez pas la Parole "nettoyer" qui vous embrouille, ils ne sont pas pareils!)
3. Maintenant la relation entre phase et objectif:
La phase peut (avant) être liée à But (s) .Par exemple , normalement, la phase de nettoyage est liée à l’objectif de nettoyage. Alors, quand vous appelez cette commande:
mvn clean
Il appellera la phase de pré-nettoyage et la phase de nettoyage qui est liée à l'objectif Nettoyer: nettoyer.
C'est presque la même chose que:
mvn pre-clean clean:clean
Des informations plus détaillées et des exemples complets figurent dans https://www.surasint.com/maven-life-cycle-phase-and-goal-easy-explained/
La terminologie de travail Maven ayant des phases et des objectifs.
Phase: La phase Maven est un ensemble d’actions associé à 2 ou 3 objectifs.
exemple: - si vous exécutez mvn clean
c'est la phase qui exécutera l'objectif mvn clean: clean
But: but Maven lié à la phase
pour référence http://books.sonatype.com/mvnref-book/reference/lifecycle-sect-structure.html
Les trois cycles de construction intégrés suivants sont les suivants:
- default
- nettoyer
- site
cycle de vie par défaut -> [valider, initialiser, générer-sources, processus-sources, générer-ressources, ressources-processus, compiler, classes de processus, générer-test-sources, processus-test-sources, generate-test-resources, ressources-process-test, compilation-test, classes-process-test, test, préparation-package, package, test de pré-intégration, test d'intégration, test de post-intégration, vérification, installation, déployer]
cycle de vie propre -> [pré-nettoyé, nettoyé, post-nettoyé]
site Lifecycle -> [pré-site, site, post-site, déploiement de site]
Le flux est séquentiel, par exemple, pour le cycle de vie par défaut , il commence par validate , puis initialise et ainsi de suite ...
Vous pouvez vérifier le cycle de vie en activant le mode de débogage de mvn c'est-à-dire mvn -X <your_goal>