Ce site met a disposition le build journalier de la traduction francaise du Maven: The Definitive Guide
Consultez :
  • Les documents de reference sur le projet original
  • Les sources de la traduction fr sur GitHub
  • maven


    Chapitre 4. Cycle de vie du build

    4.1. Introduction

    Maven modélise les projets en entités qui sont définies par un POM. Le POM capture donc l'identité d'un projet : Quel est son contenu ? De quel type de packaging a t-il besoin ? Le projet a-t-il un parent ? Quelles sont ses dépendances ? Nous avons exploré les principes de description d'un projet dans les chapitres précédents, mais nous n'avons pas introduit le mécanisme qui permet à Maven d'agir sur ces objets. Dans Maven, les "actions" (ou verbe) sont représentées par des goals. Ceux-ci sont packagés dans des plugins qui sont attachés à des phases du cycle de vie du build. Le cycle de vie Maven se compose d'une séquence de phases nommées comme prepare-resources, compile, package ou install. Il y a donc, entre autres, une phase pour la compilation et une autre pour le packaging. Il existe également des phases du type pre- et post-. Celles-ci peuvent être utilisées, par exemple, pour enregistrer des goals devant être exécutés avant la compilation ou effectuer certaines tâches après l'exécution d'une phase spécifique. Quand vous demandez à Maven de construire un projet, vous lui demandez de parcourir la liste des différentes phases du cycle de vie et d'exécuter chacun des goals associés à celles-ci.

    Le cycle de vie d'un build est organisé en une séquence de phases qui permettent d'ordonner des groupes de goals. Ces goals sont choisis et rattachés en fonction du type de packaging de leur projet. Il existe trois types de cycle de vie : clean, default (quelquefois appelé build) et site. Dans ce chapitre, vous allez apprendre comment Maven rattache des goals aux phases de ces cycles de vie et comment personnaliser un cycle de vie. Vous apprendrez également les différentes phases du cycle de vie par défaut.

    4.1.1. Cycle de vie Clean (clean)

    Le premier cycle de vie auquel nous allons nous intéresser est le cycle de vie le plus simple de Maven. L'exécution de la commande mvn clean invoque le cycle de vie 'clean'. Celui-ci contient trois phases :

    • pre-clean

    • clean

    • post-clean

    La phase la plus intéressante de ce cycle de vie est celle nommée clean. Le goal 'clean' du plugin Clean (clean:clean) est attaché à la phase clean du cycle de vie clean. Le goal clean:clean efface les traces laissées par la dernière construction en supprimant le répertoire de build. Si vous n'avez pas modifié l'emplacement du répertoire de build, celui-ci se trouve par défaut dans le répertoire ${basedir}/target. Lorsque vous exécutez le goal clean:clean, vous ne l'exécutez pas directement avec mvn clean:clean, vous l'utilisez par l'intermédiaire de la phase clean du cycle de vie du même nom. Exécuter la phase clean donne à Maven l'opportunité d'exécuter les autres goals rattachés à la phase pre-clean.

    Par exemple, supposez que vous vouliez exécuter un goal antrun:run pour afficher une notification lors du pre-clean, ou archiver le répertoire de build du projet avant qu'il ne soit supprimé. Exécuter directement le goal clean:clean ne lancera pas le cycle de vie, vos tâches annexes ne seront donc pas exécutées. Par contre, si vous utilisez la phase clean, vous utiliserez le cycle de vie du même nom (clean) et traverserez de ce fait les trois phases du cycle de vie de jusqu'à la phase clean. L'Exemple 4.1, « Exécuter un goal lors du pre-clean » montre une configuration de build qui permet de rattacher le goal antrun:run à la phase pre-clean pour afficher une alerte avant la suppression de l'artefact en cours de nettoyage. Dans cet exemple, le goal antrun:run est utilisé pour exécuter des commandes Ant qui permettent de tester l'existence d'un artefact de projet. Ainsi, si l'artefact du projet est trouvé et est donc sur le point d'être effacé, une alerte s'affichera à l'écran.

    Exemple 4.1. Exécuter un goal lors du pre-clean

    <project>
      ...
      <build>
        <plugins>... <plugin>
        <artifactId>maven-antrun-plugin</artifactId>
        <executions>
          <execution>
            <id>file-exists</id>
            <phase>pre-clean</phase>
            <goals>
              <goal>run</goal>
            </goals>
            <configuration>
              <tasks>
                <!-- adds the ant-contrib tasks (if/then/else used below) -->
                <taskdef resource="net/sf/antcontrib/antcontrib.properties" />
                <available 
          file="${project.build.directory}/${project.build.finalName}.${project.packaging}"
          property="file.exists" value="true" />
    
                <if>
                  <not>
                    <isset property="file.exists" />
                  </not>
                  <then>
                    <echo>No
                      ${project.build.finalName}.${project.packaging} to
                      delete</echo>
                  </then>
                  <else>
                    <echo>Deleting
                      ${project.build.finalName}.${project.packaging}</echo>
                  </else>
                </if>
              </tasks>
            </configuration>
          </execution>
        </executions>
        <dependencies>
          <dependency>
            <groupId>ant-contrib</groupId>
            <artifactId>ant-contrib</artifactId>
            <version>1.0b2</version>
          </dependency>
        </dependencies>
      </plugin>
      </plugins>
      </build> 
    </project>
    

    Exécuter la commande mvn clean avec une telle configuration sur un projet produira un résultat ressemblant à celui-ci :


    [INFO] Scanning for projects...
    [INFO] ----------------------------------------------------------------------
    [INFO] Building Your Project
    [INFO]    task-segment: [clean]
    [INFO] ----------------------------------------------------------------------
    [INFO] [antrun:run {execution: file-exists}]
    [INFO] Executing tasks
         [echo] Deleting your-project-1.0-SNAPSHOT.jar
    [INFO] Executed tasks
    [INFO] [clean:clean]
    [INFO] Deleting directory ~/corp/your-project/target
    [INFO] Deleting directory ~/corp/your-project/target/classes
    [INFO] Deleting directory ~/corp/your-project/target/test-classes
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESSFUL
    [INFO] ------------------------------------------------------------------------
    [INFO] Total time: 1 second
    [INFO] Finished at: Wed Nov 08 11:46:26 CST 2006
    [INFO] Final Memory: 2M/5M
    [INFO] ------------------------------------------------------------------------
    

    En plus de configurer Maven pour exécuter un goal lors de la phase pre-clean, vous pouvez personnaliser le plugin Clean pour effacer des dossiers en plus du répertoire contenant le build. Vous pouvez configurer le plugin pour supprimer une liste de fichier en lui spécifiant un fileSet. L'exemple ci-dessous configure le plugin Clean pour supprimer tous les fichiers du répertoire target-other/ en utilisant des wildcards standard Ant : * et **.

    Exemple 4.2. Personaliser le comportement du plugin Clean

    <project>
      <modelVersion>4.0.0</modelVersion>
      ...
      <build>
        <plugins>
          <plugin>
            <artifactId>maven-clean-plugin</artifactId>
            <configuration>
              <filesets>
                <fileset>
                  <directory>target-other</directory>
                  <includes>
                    <include>*.class</include>
                  </includes>
                </fileset>
              </filesets>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </project>


    4.1.2. Cycle de vie par défaut (default)

    La plupart des utilisateurs Maven sont familiers avec le cycle de vie par défaut. C'est un modèle général de processus de build pour une application. Ce cycle de vie commence par la phase validate et se termine avec la phase deploy. Les phases du cycle de vie Maven par défaut sont présentées dans le Tableau 4.1, « Phases du cycle de vie Maven ».

    Tableau 4.1. Phases du cycle de vie Maven

    Phase du cycle de vie Description
    validate Valide le projet et la disponibilité de toutes les informations requises pour le build
    generate-sources Génère le code source nécessaire pour l'inclure à la compilation
    process-sources Traite le code source, pour filtrer certaines valeurs par exemple
    generate-resources Génère les ressources à inclure dans le package
    process-resources Copie et traite les ressources dans leur répertoire destination, afin qu'elles soient prêtes pour le packaging
    compile Compile le code source du projet
    process-classes Traitre à posteriori les fichiers générés par la compilation, pour modifier du bytecode par exemple
    generate-test-sources Génère le code source des tests pour l'inclure à la compilation
    process-test-sources Traite le code source des tests, pour filtrer certaines valeurs par exemple
    generate-test-resources Génère les ressources pour les tests
    process-test-resources Copie et traite les ressources de test dans le répertoire destination des tests
    test-compile Compile le code source des tests dans le répertoire destination des tests
    test Exécute les tests en utilisant le framework de test approprié. Le code de ces tests ne doit pas être nécessaire au packaging ni au déploiement.
    prepare-package Effectue les opérations nécessaires pour la préparation du package avant que celui-ci ne soit réellement créé. Il en résulte souvent une version dézippée et prête à été packagée du futur package (Maven 2.1+)
    package Package le code compilé dans un format distribuable tel que JAR, WAR ou EAR
    pre-integration-test Effectue les actions nécessaires avant de lancer les tests d'intégration, comme configurer un environnement par exemple.
    integration-test Traite et déploie si nécessaire le package dans l'environnement où les tests pourront être exécutés
    post-integration-test Effectue les actions nécessaires à la fin de l'exécution des tests d'intégration, comme nettoyer l'environnement par exemple
    verify Lance des points de contrôle pour vérifier que le package est valide et qu'il passe les critères qualité
    install Installe le package dans le dépôt local, celui-ci pourra ainsi être utilisé comme dépendance par d'autres projets locaux
    deploy Copie le package final sur le dépôt distant. Permet de partager le package avec d'autres utilisateurs et projets (souvent pertinent pour une vraie livraison)

    4.1.3. Cycle de vie Site (site)

    Maven fait plus que construire des artefacts, il peut également produire de la documentation et différents rapports d'un ou plusieurs projets. La documentation du projet et la génération du site web ont un cycle de vie séparé. Celui-ci contient quatre phases :

    1. pre-site

    2. site

    3. post-site

    4. site-deploy

    Les goals suivants sont rattachés par défaut à ce cycle de vie :

    1. site - site:site

    2. site-deploy - site:deploy

    Le type de packaging n'a aucune influence sur ce cycle de vie. Les types de packaging influent sur la création des artefacts, pas sur le type de site généré. Le plugin Site lance l'exécution de la production d'un document Doxia et de différents plugins permettant de générer des rapports. Vous pouvez générer un site à partir d'un projet Maven en exécutant la commande suivante :

    $ mvn site
    

    Pour plus d'informations à propos de la génération de site Maven, consultez le Chapitre 10, Génération du Site.