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


    8.2.4. Construction d'assemblies à partir d'assemblies dépendances

    Assez perturbant ce titre n'est ce pas ? Essayons de mettre en place un scénario pour expliquer cette notion d'assemblage d'assembly. Imaginez que vous voulez construire une archive qui elle-même contient des assemblies d'un projet. Supposons que vous ayez un build multimodule et que vous vouliez déployer un assembly qui contient un ensemble d'assemblies de ce projet liés entre eux. Dans l'exemple de cette section, nous créons un package qui rassemble des répertoires "constructibles" des sous-modules d'un projet qui sont utilisés ensemble. Pour essayer de rester simple nous utiliserons les descripteurs d'assembly dont nous venons de parler - project et jar-with-dependencies. Dans cet exemple particulier, nous supposerons que chaque projet construit son assembly en plus de son artefact JAR principal. Nous supposerons aussi que chaque projet de ce build multimodule rattache le goal single à la phase package et qu'il utilise la balise descriptorRef. Tous les projets de ce build multimodule héritent de la configuration du fichier pom.xml de plus haut niveau et notamment de sa balise pluginManagement qui est décrite dans l'Exemple 8.2, « Configuration de l'assembly du projet dans le POM de plus haut niveau ».

    Exemple 8.2. Configuration de l'assembly du projet dans le POM de plus haut niveau

    <project>
      ...
      <build>
        <pluginManagement>
          <plugins>
            <plugin>
              <artifactId>maven-assembly-plugin</artifactId>
              <version>2.2-beta-2</version>
              <executions>
                <execution>
                  <id>create-project-bundle</id>
                  <phase>package</phase>
                  <goals>
                    <goal>single</goal>
                  </goals>
                  <configuration>
                    <descriptorRefs>
                      <descriptorRef>project</descriptorRef>
                    </descriptorRefs>
                  </configuration>
                </execution>
              </executions>
            </plugin>
          </plugins>
        </pluginManagement>
      </build>
      ...
    </project>

    Le POM de chaque projet référence le plugin dont la configuration est décrite dans l'Exemple 8.2, « Configuration de l'assembly du projet dans le POM de plus haut niveau » par une déclaration minimale dans son build comme le montre l' Exemple 8.3, « Activation de la configuration du plugin Assembly dans les projets fils ».

    Exemple 8.3. Activation de la configuration du plugin Assembly dans les projets fils

    <build>
      <plugins>
        <plugin>
          <artifactId>maven-assembly-plugin</artifactId>
        </plugin>
      </plugins>
    </build>
    

    Pour produire l'ensemble des assemblies du projet, exécutez la commande mvn install depuis le répertoire racine. Vous devriez voir Maven installer les artefacts avec des classifieurs dans votre dépôt.

    $ mvn install
    ...
    Installing ~/mvn-examples-1.0/assemblies/as-dependencies/project-parent/\
               second-project/target/second-project-1.0-SNAPSHOT-project.tar.gz to 
      ~/.m2/repository/org/sonatype/mavenbook/assemblies/second-project/1.0-SNAPSHOT/\
               second-project-1.0-SNAPSHOT-project.tar.gz
    ...
    Installing ~/mvn-examples-1.0/assemblies/as-dependencies/project-parent/\
               second-project/target/second-project-1.0-SNAPSHOT-project.tar.bz2 to 
      ~/.m2/repository/org/sonatype/mavenbook/assemblies/second-project/1.0-SNAPSHOT/\
               second-project-1.0-SNAPSHOT-project.tar.bz2
    ...
    Installing ~/mvn-examples-1.0/assemblies/as-dependencies/project-parent/\
               second-project/target/second-project-1.0-SNAPSHOT-project.zip to 
      ~/.m2/repository/org/sonatype/mavenbook/assemblies/second-project/1.0-SNAPSHOT/\\
               second-project-1.0-SNAPSHOT-project.zip
    ...

    Lorsque vous exécutez install, Maven va copier l'artefact principal de chaque projet ainsi que chaque assembly dans votre dépôt Maven local. Tous ces artefacts sont maintenant disponibles comme dépendance pour d'autres projets localement. Si votre but final est de créer un paquet qui inclut les assemblies de différents projets vous pouvez créer un autre projet qui référence comme dépendances les assemblies de ces projets. Ce projet chapeau prend la responsabilité de construire l'assembly englobant tous les autres. Le POM de ce projet assembly chapeau ressemblerait au document XML décrit dans l'Exemple 8.4, « POM du projet assembly chapeau ».

    Exemple 8.4. POM du projet assembly chapeau

    <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/maven-v4_0_0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>org.sonatype.mavenbook.assemblies</groupId>
      <artifactId>project-bundle</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>pom</packaging>
      <name>Assemblies-as-Dependencies Example Project Bundle</name>
      <url>http://sonatype.com/book</url>
      <dependencies>
        <dependency>
          <groupId>org.sonatype.mavenbook.assemblies</groupId>
          <artifactId>first-project</artifactId>
          <version>1.0-SNAPSHOT</version>
          <classifier>project</classifier>
          <type>zip</type>
        </dependency>
        <dependency>
          <groupId>org.sonatype.mavenbook.assemblies</groupId>
          <artifactId>second-project</artifactId>
          <version>1.0-SNAPSHOT</version>
          <classifier>project</classifier>
          <type>zip</type>
        </dependency>
      </dependencies>
      <build>
        <plugins>
          <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.2-beta-2</version>
            <executions>
              <execution>
                <id>bundle-project-sources</id>
                <phase>package</phase>
                <goals>
                  <goal>single</goal>
                </goals>
                <configuration>
                  <descriptorRefs>
                    <descriptorRef>
                      jar-with-dependencies
                    </descriptorRef>
                  </descriptorRefs>
                </configuration>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </project>
    

    Le POM de ce projet assembly chapeau fait référence aux assemblies des projets first-project et second-project. Au lieu de référencer l'artefact principal de chaque projet, le POM de ce projet assembly spécifie un classifieur project et un type zip. Cela indique à Maven qu'il va devoir résoudre une archive de type ZIP qui a été créée par l'assembly project. Remarquez que le projet assembly produit lui-même un assembly jar-with-dependencies. L'assembly produit par jar-with-dependencies n'est pas une archive particulièrement élégante puisqu'il construit un fichier JAR contenant toutes les dépendances décompressées. jar-with-dependencies demande à Maven de récupérer toutes les dépendances, de les décompresser et ensuite de créer une archive unique en y incluant le résultat du projet courant. Dans ce projet, cela produit un unique fichier JAR qui agrège les contenus des assemblies de first-project et de second-project.

    Cet exemple illustre comment les capacités de base du plugin Maven Assembly peuvent être combinées sans nécessiter un descripteur d'assembly. Il crée une unique archive qui contient les répertoires de plusieurs projets les uns à côté des autres. Cette fois, le jar-with-dependencies est juste un format de stockage et nous n'avons pas besoin de spécifier l'attribut de manifest Main-Class. Pour construire ce paquet, nous exécutons le projet project-bundle comme d'habitude :

    $ mvn package
    ...
    [INFO] [assembly:single {execution: bundle-project-sources}]
    [INFO] Processing DependencySet (output=)
    [INFO] Building jar: ~/downloads/mvn-examples-1.0/assemblies/as-dependencies/\
      project-bundle/target/project-bundle-1.0-SNAPSHOT-jar-with-dependencies.jar
    

    Pour vérifier que l'assembly project-bundle contient bien les éléments décompressés et combinés des assemblies dépendances, exécutez la commande jar tf :

    $ jar tf \
      target/project-bundle-1.0-SNAPSHOT-jar-with-dependencies.jar
    ...
    first-project-1.0-SNAPSHOT/pom.xml
    first-project-1.0-SNAPSHOT/src/main/java/org/sonatype/mavenbook/App.java
    first-project-1.0-SNAPSHOT/src/test/java/org/sonatype/mavenbook/AppTest.java
    ...
    second-project-1.0-SNAPSHOT/pom.xml
    second-project-1.0-SNAPSHOT/src/main/java/org/sonatype/mavenbook/App.java
    second-project-1.0-SNAPSHOT/src/test/java/org/sonatype/mavenbook/AppTest.java

    Maintenant que vous avez lu cette section, son titre devrait avoir un peu plus de sens. Vous avez combiné les assemblies de deux projects dans un assembly grâce à un projet assembly dépendant de chacun de ces assemblies.