Maven - Construire le cycle de vie

Qu'est-ce que Build Lifecycle?

Un cycle de vie de construction est une séquence bien définie de phases, qui définissent l'ordre dans lequel les objectifs doivent être exécutés. Ici, la phase représente une étape du cycle de vie. À titre d'exemple, unMaven Build Lifecycle se compose de la séquence de phases suivante.

Phase Poignées La description
préparer-ressources copie de ressources La copie des ressources peut être personnalisée dans cette phase.
valider Valider les informations Valide si le projet est correct et si toutes les informations nécessaires sont disponibles.
compiler compilation La compilation du code source est effectuée dans cette phase.
Tester Essai Teste le code source compilé adapté au framework de test.
paquet emballage Cette phase crée le package JAR / WAR comme mentionné dans le package dans POM.xml.
installer installation Cette phase installe le package dans le référentiel maven local / distant.
Déployer Déploiement Copie le package final dans le référentiel distant.

Il y a toujours pre et post phases pour s'inscrire goals, qui doit s'exécuter avant ou après une phase particulière.

Lorsque Maven commence à construire un projet, il parcourt une séquence définie de phases et exécute des objectifs, qui sont enregistrés avec chaque phase.

Maven a les trois cycles de vie standard suivants -

  • clean
  • default (ou build)
  • site

UNE goalreprésente une tâche spécifique qui contribue à la construction et à la gestion d'un projet. Il peut être lié à zéro ou plusieurs phases de construction. Un objectif qui n'est lié à aucune phase de construction peut être exécuté en dehors du cycle de vie de construction par appel direct.

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érez la commande ci-dessous. leclean et package les arguments sont des phases de construction tandis que les dependency:copy-dependencies est un objectif.

mvn clean dependency:copy-dependencies package

Ici, la phase de nettoyage sera exécutée en premier, suivie de ladependency:copy-dependencies goal, et enfin la phase du package sera exécutée.

Cycle de vie propre

Lorsque nous exécutons la commande mvn post-clean , Maven appelle le cycle de vie propre composé des phases suivantes.

  • pre-clean
  • clean
  • post-clean

But Maven propre (propre: propre) est lié à la propre phase du cycle de vie propre. Sesclean:cleangoalsupprime la sortie d'une construction en supprimant le répertoire de construction. Ainsi, lorsque la commande mvn clean s'exécute, Maven supprime le répertoire de construction.

Nous pouvons personnaliser ce comportement en mentionnant des objectifs dans l'une des phases ci-dessus du cycle de vie propre.

Dans l'exemple suivant, nous allons attacher maven-antrun-plugin: run goal aux phases de pré-nettoyage, de nettoyage et de post-nettoyage. Cela nous permettra de faire écho aux messages texte affichant les phases du cycle de vie propre.

Nous avons créé un pom.xml dans le dossier 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-clean phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            
               <execution>
                  <id>id.clean</id>
                  <phase>clean</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>clean phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            
               <execution>
                  <id>id.post-clean</id>
                  <phase>post-clean</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>post-clean phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            </executions>
         </plugin>
      </plugins>
   </build>
</project>

Ouvrez maintenant la console de commande, accédez au dossier contenant pom.xml et exécutez ce qui suit mvn commander.

C:\MVN\project>mvn post-clean

Maven commencera le traitement et affichera toutes les phases du cycle de vie propre.

[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 régler mvn clean commande, qui affichera pre-cleanet propre. Rien ne sera exécuté pourpost-clean phase.

Cycle de vie par défaut (ou build)

Il s'agit du cycle de vie principal de Maven et est utilisé pour créer l'application. Il comprend les 21 phases suivantes.

N ° Sr. Phase et description du cycle de vie
1

validate

Valide si le projet est correct et si toutes les informations nécessaires sont disponibles pour terminer le processus de génération.
2

initialize

Initialise l'état de construction, par exemple définir les propriétés.
3

generate-sources

Générez tout code source à inclure dans la phase de compilation.
4

process-sources

Traitez le code source, par exemple, filtrez n'importe quelle valeur.
5

generate-resources

Générez des ressources à inclure dans le package.
6

process-resources

Copiez et traitez les ressources dans le répertoire de destination, prêt pour la phase d'empaquetage.
sept

compile

Compilez le code source du projet.
8

process-classes

Post-traiter les fichiers générés à partir de la compilation, par exemple pour améliorer / optimiser le bytecode sur les classes Java.
9

generate-test-sources

Générez tout code source de test à inclure dans la phase de compilation.
dix

process-test-sources

Traitez le code source du test, par exemple, filtrez toutes les valeurs.
11

test-compile

Compilez le code source du test dans le répertoire de destination du test.
12

process-test-classes

Traitez les fichiers générés à partir de la compilation du fichier de code de test.
13

test

Exécutez des tests à l'aide d'un cadre de test unitaire approprié (Junit en est un).
14

prepare-package

Effectuer toutes les opérations nécessaires pour préparer un colis avant l'emballage proprement dit.
15

package

Prenez le code compilé et conditionnez-le dans son format distribuable, tel qu'un fichier JAR, WAR ou EAR.
16

pre-integration-test

Effectuez les actions requises avant l'exécution des tests d'intégration. Par exemple, configurer l'environnement requis.
17

integration-test

Traitez et déployez le package si nécessaire dans un environnement où des tests d'intégration peuvent être exécutés.
18

post-integration-test

Effectuez les actions requises après l'exécution des tests d'intégration. Par exemple, nettoyer l'environnement.
19

verify

Exécutez tous les contrôles pour vérifier que le colis est valide et répond aux critères de qualité.
20

install

Installez le package dans le référentiel local, qui peut être utilisé comme dépendance dans d'autres projets localement.
21

deploy

Copie le package final dans le référentiel distant pour le partager avec d'autres développeurs et projets.

Il y a peu de concepts importants liés aux cycles de vie Maven, qui valent la peine d'être mentionnés -

  • Lorsqu'une phase est appelée via la commande Maven, par exemple mvn compile, seules les phases jusqu'à et y compris cette phase seront exécutées.

  • Différents objectifs de maven seront liés à différentes phases du cycle de vie de Maven en fonction du type d'emballage (JAR / WAR / EAR).

Dans l'exemple suivant, nous allons attacher maven-antrun-plugin: run goal à quelques-unes des phases du cycle de vie de Build. Cela nous permettra de faire écho aux messages texte affichant les phases du cycle de vie.

Nous avons mis à jour pom.xml dans le dossier 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>validate phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            
               <execution>
                  <id>id.compile</id>
                  <phase>compile</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>compile phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            
               <execution>
                  <id>id.test</id>
                  <phase>test</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>test phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            
               <execution>
                  <id>id.package</id>
                  <phase>package</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>package phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            
               <execution>
                  <id>id.deploy</id>
                  <phase>deploy</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>deploy phase</echo>
                     </tasks>
                  </configuration>
               </execution>
            </executions>
         </plugin>
      </plugins>
   </build>
</project>

Ouvrez maintenant la console de commande, accédez au dossier contenant pom.xml et exécutez ce qui suit mvn commander.

C:\MVN\project>mvn compile

Maven commencera le traitement et affichera les phases du cycle de vie de 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 {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] -----------------------------------------------------------------
-

Cycle de vie du site

Le plugin Maven Site est généralement utilisé pour créer de la documentation fraîche pour créer des rapports, déployer le site, etc. Il comporte les phases suivantes -

  • pre-site
  • site
  • post-site
  • site-deploy

Dans l'exemple suivant, nous attacherons maven-antrun-plugin:runobjectif à toutes les phases du cycle de vie du site. Cela nous permettra de faire écho aux messages texte affichant les phases du cycle de vie.

Nous avons mis à jour pom.xml dans le dossier 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-site</id>
                  <phase>pre-site</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>pre-site phase</echo>
                     </tasks>
                  </configuration>
               </execution>
               
               <execution>
                  <id>id.site</id>
                  <phase>site</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>site phase</echo>
                     </tasks>
                  </configuration>
               </execution>
               
               <execution>
                  <id>id.post-site</id>
                  <phase>post-site</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>post-site phase</echo>
                     </tasks>
                  </configuration>
               </execution>
               
               <execution>
                  <id>id.site-deploy</id>
                  <phase>site-deploy</phase>
                  <goals>
                     <goal>run</goal>
                  </goals>
                  <configuration>
                     <tasks>
                        <echo>site-deploy phase</echo>
                     </tasks>
                  </configuration>
               </execution>
               
            </executions>
         </plugin>
      </plugins>
   </build>
</project>

Ouvrez maintenant la console de commande, accédez au dossier contenant pom.xml et exécutez ce qui suit mvn commander.

C:\MVN\project>mvn site

Maven commencera à traiter et afficher les phases du cycle de vie du site jusqu'à la phase du 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] ------------------------------------------------------------------
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved