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


    14.6. Best Practices

    Le plugin Assembly est assez flexible pour permettre de résoudre la plupart des problèmes de différentes manières. Si vous avez un besoin unique pour votre projet, il ya de bonnes chances que vous puissiez utiliser directement l'une des méthodes documentées dans ce chapitre pour obtenir votre structure d'assembly désirée. Cette section décrit quelques-unes des bonnes pratiques qui, si elles sont respectées, rendront l'utilisation du plugin Assembly plus productive et moins pénible.

    14.6.1. Descripteurs d'assembly standards et réutilisables

    Jusqu'à présent, nous avons principalement parlé des différentes solutions pour construire certains types d'assembly. Mais que ferez-vous si vous avez des dizaines de projets qui ont tous besoin d'un type particulier d'assembly ? En bref, comment pouvons-nous réutiliser les efforts investis sur plusieurs projets sans avoir à copier-coller notre descripteur d'assembly ?

    Le moyen le plus simple est de créer un artefact standardisé et versionné pour externaliser le descripteur d'assembly, et de le déployer. Une fois cela fait, vous pouvez configurer le plugin Assembly dans votre POM pour inclure ce descripteur d'assembly comme une dépendance de plugin. À ce stade, vous pouvez utiliser ce descripteur de l'Assembly par l'intermédiaire de la balise de configuration descriptorRefs dans la déclaration du plugin Assembly. Pour illustrer ceci, voici, en exemple, ce descripteur d'assembly :

    <assembly>
      <id>war-fragment</id>
      <formats>
        <format>zip</format>
      </formats>
     <includeBaseDirectory>false</includeBaseDirectory>
      <dependencySets>
        <dependencySet>
          <outputDirectory>WEB-INF/lib</outputDirectory>
        </dependencySet>
      </dependencySets>
      <fileSets>
        <fileSet>
          <directory>src/main/webapp</directory>
          <outputDirectory>/</outputDirectory>
          <excludes>
            <exclude>**/web.xml</exclude>
          </excludes>
        </fileSet>
      </fileSets>
    </assembly>

    Inclus dans votre projet, ce descripteur serait un bon moyen de packager le contenu afin qu'il puisse être décompressé directement dans une application web existante pour fusionner avec celle-ci (pour ajouter une fonctionnalité, par exemple). Toutefois, si votre équipe construit plusieurs de ces projets "web-fragment", vous aurez probablement envie de réutiliser ce descripteur plutôt que de le dupliquer. Pour déployer ce descripteur dans son propre artefact, nous allons le mettre dans le répertoire src/main/resources/assemblies d'un projet qui lui sera dédié.

    La structure de projet de cet artefact assembly-descriptor devrait ressembler à cela :

    |-- pom.xml
    `-- src
        `-- main
            `-- resources
                `-- assemblies
                    `-- web-fragment.xml
    

    Notez le chemin vers le fichier descripteur web-fragment. Par défaut, Maven inclus les fichiers du répertoire src/main/resources dans le JAR final. Ainsi, notre descripteur d'assembly sera inclu sans aucune autre configuration de notre part. Notez également le préfixe de chemin assemblies/, le plugin Assembly s'attend à ce préfixe de chemin pour tous les descripteurs fournis dans le classpath des plugins. Il est important de mettre notre descripteur à l'emplacement relatif approprié. Ainsi, il sera récupéré par le plugin Assembly lors de son exécution.

    Souvenez-vous, ce projet est maintenant en dehors de votre projet web-fragment. Le descripteur d'assembly possède son propre artefact avec sa propre version et, peut-être, son propre cycle de release. Une fois que vous avez installé ce nouveau projet via Maven, vous pourrez le référencer dans vos projets web-fragment. Pour plus de clarté, le processus devrait ressembler à ceci :

    $ mvn install
    (...)
    [INFO] [install:install]
    [INFO] Installing (...)/web-fragment-descriptor/target/\
                      web-fragment-descriptor-1.0-SNAPSHOT.jar 
           to /Users/~/.m2/repository/org/sonatype/mavenbook/assemblies/\
              web-fragment-descriptor/1.0-SNAPSHOT/\
              web-fragment-descriptor-1.0-SNAPSHOT.jar
    [INFO] ---------------------------------------------------------------
    [INFO] BUILD SUCCESSFUL
    [INFO] ---------------------------------------------------------------
    [INFO] Total time: 5 seconds
    (...)

    Comme notre projet web-fragment-descriptor ne contient pas de code source, le JAR résultant ne contiendra rien d'autre que notre descripteur d'assembly web-fragment. Maintenant, utilisons ce nouvel artefact :

    <project>
      (...)
      <artifactId>my-web-fragment</artifactId>
      (...)
      <build>
        <plugins>
          <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.2-beta-2</version>
            <dependencies>
              <dependency>
                <groupId>org.sonatype.mavenbook.assemblies</groupId>
                <artifactId>web-fragment-descriptor</artifactId>
                <version>1.0-SNAPSHOT</version>
              </dependency>
            </dependencies>
            <executions>
              <execution>
                <id>assemble</id>
                <phase>package</phase>
                <goals>
                  <goal>single</goal>
                </goals>
                <configuration>
                  <descriptorRefs>
                    <descriptorRef>web-fragment</descriptorRef>
                  </descriptorRefs>
                </configuration>
              </execution>
            </executions>
          </plugin>
          (...)
        </plugins>
      </build>
      (...)
    </project>
    

    Deux choses sont particulières sur cette configuration du plugin Assembly :

    • Nous devons inclure la déclaration de la dépendance vers notre web-fragment-descriptor au niveau de la déclaration des plugins afin d'avoir accès au descripteur d'Assembly par l'intermédiaire du classpath du plugin.

    • Comme nous utilisons des références du classpath plutôt qu'un fichier local, nous devons utiliser la balise descriptorRefs à la place de la balise descriptor. Notez également, que même si le descripteur d'assembly se trouve en fait dans assemblies/web-fragment.xml dans le classpath du plugin, nous pouvons le référencer sans utiliser le préfixe assemblies/. Ceci est rendu possible car le plugin Assembly suppose que les descripteurs d'assembly se trouvent effectivement à cet emplacement.

    Maintenant, vous êtes libre de réutiliser la configuration du POM ci-dessus dans autant de projets que vous voulez, avec l'assurance que la totalité des fragments web de l'assembly soient pris en compte. Si vous avez besoin de faire des ajustements sur le format de votre assembly - peut-être pour d'inclure d'autres ressources, ou pour affiner les dépendances ou le fileSet - vous pouvez tout simplement incrémenter la version du projet de votre descripteur d'assembly, et le déployer à nouveau. Les POMs référençant l'artefact assembly-descriptor peuvent ainsi adopter cette nouvelle version du descripteur s'ils le souhaitent.

    Un dernier point concernant la réutilisation de l'assembly-descriptor : vous souhaiterez peut-être partager la configuration du plugin. Pour cela, ajoutez la configuration ci-dessus à la section pluginManagement de votre POM parent, puis référencez la configuration de votre plugin dans votre POM comme ceci :

    (...)
      <build>
        <plugins>
          <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
          </plugin>
    (...)

    Si vous avez ajouté le reste de la configuration du plugin - comme décrit dans l'exemple précédent - dans la section pluginManagement du POM parent de votre projet, tous les projets qui en héritent profiteront du format d'assemblage avancé dans leurs propres builds en ajoutant ces quelques lignes.