Maven: The definitive Guide FR

Le plugin Assembly peut être exécuté de deux manières : vous pouvez l'invoquer directement depuis la ligne de commande ou le configurer comme un élément standard de votre processus de build en le rattachant à une phase du cycle de vie du build de votre projet. L'invocation directe a son utilité, particulièrement pour les assemblies qui ne font pas partie des principaux délivrables de votre projet. Dans la plupart des cas, vous voudrez produire les assemblies de votre projet au cours de son processus de build standard. Ainsi, vos packagings personnalisés sont inclus lorsque votre projet est installé ou déployé dans les dépôts Maven et ils sont donc toujours disponibles pour vos utilisateurs.

Comme exemple d'invocation directe du plugin Assembly, imaginez que vous voulez livrer une copie de votre projet que l'on puisse construire à partir des sources. Au lieu de déployer uniquement le produit final du build, vous voulez aussi inclure le code source. Ce n'est pas une opération que vous avez besoin de répéter souvent, donc ça n'a pas de sens que d'ajouter cette configuration à votre POM. Au lieu de cela, vous pouvez utiliser la commande suivante :

$ mvn -DdescriptorId=project assembly:single 
...
[INFO] [assembly:single] 
[INFO] Building tar : /Users/~/mvn-examples-1.0/assemblies/direct-invocation/\
                      target/direct-invocation-1.0-SNAPSHOT-project.tar.gz 
[INFO] Building tar : /Users/~/mvn-examples-1.0/assemblies/direct-invocation/\
                      target/direct-invocation-1.0-SNAPSHOT-project.tar.bz2
[INFO] Building zip: /Users/~/mvn-examples-1.0/assemblies/direct-invocation/\
                      target/direct-invocation-1.0-SNAPSHOT-project.zip
...

Imaginez que vous voulez produire un JAR exécutable à partir de votre projet. Si votre projet est autosuffisant et sans dépendance, vous pouvez obtenir ce résultat à partir de votre artefact avec un peu de configuration du plugin JAR. Cependant, la plupart des projets ont des dépendances et celles-ci doivent être incorporées pour obtenir un JAR exécutable. Dans ce cas, vous voulez vous assurer qu'à chaque fois que vous installez ou déployez l'artefact JAR de votre projet, le JAR exécutable le soit aussi.

Supposons que la classe principale de votre projet est org.sonatype.mavenbook.App, la configuration de POM suivante permet de créer un JAR exécutable :

<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>executable-jar</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>
  <name>Assemblies Executable Jar Example</name>
  <url>http://sonatype.com/book</url>
  <dependencies>
    <dependency>
      <groupId>commons-lang</groupId>
      <artifactId>commons-lang</artifactId>
      <version>2.4</version>
    </dependency>
  </dependencies>
 <build>
    <plugins>
      <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <version>2.2-beta-2</version>
        <executions>
          <execution>
            <id>create-executable-jar</id>
            <phase>package</phase>
            <goals>
              <goal>single</goal>
            </goals>
            <configuration>
              <descriptorRefs>
                <descriptorRef>
                  jar-with-dependencies
                </descriptorRef>
              </descriptorRefs>
              <archive>
                <manifest>
                  <mainClass>org.sonatype.mavenbook.App</mainClass>
                </manifest>
              </archive>
           </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>

Il y a deux points auxquels il faut prêter attention dans la configuration ci-dessus. Premièrement, nous utilisons l'élément descriptorRefs dans configuration plutôt que le paramètre descriptorId que nous avions utilisé précédemment. Cela nous permet de construire différents packages durant la même exécution du plugin Assembly tout en supportant notre cas d'utilisation avec très peu de configuration supplémentaire. Deuxièmement, la balise archive sous configuration spécifie l'attribut Main-Class du fichier manifest dans le JAR produit. Cette section est généralement disponible dans les plugins qui créent des fichiers JAR comme le plugin JAR utilisé pour le packaging par défaut des projets.

Maintenant, vous pouvez produire un JAR exécutable simplement en exécutant la commande mvn package. Après, nous listerons le contenu du répertoire target pour vérifier que le JAR exécutable a bien été généré. Enfin, pour prouver qu'il s'agit bien d'un JAR exécutable, nous essayerons de l'exécuter :

$ mvn package
... (output omitted) ...
[INFO] [jar:jar]
[INFO] Building jar: ~/mvn-examples-1.0/assemblies/executable-jar/target/\
                     executable-jar-1.0-SNAPSHOT.jar
[INFO] [assembly:single {execution: create-executable-jar}]
[INFO] Processing DependencySet (output=)
[INFO] Building jar: ~/mvn-examples-1.0/assemblies/executable-jar/target/\
                     executable-jar-1.0-SNAPSHOT-jar-with-dependencies.jar
... (output omitted) ...
$ ls -1 target
... (output omitted) ...
executable-jar-1.0-SNAPSHOT-jar-with-dependencies.jar
executable-jar-1.0-SNAPSHOT.jar
... (output omitted) ...
$ java -jar \
        target/executable-jar-1.0-SNAPSHOT-jar-with-dependencies.jar 
Hello, World!

Des traces présentées ci-dessus vous pouvez voir que maintenant le build normal du projet produit un nouvel artefact en plus du principal fichier JAR. Ce nouvel artefact a le classifieur jar-with-dependencies. Enfin, nous avons vérifié que ce nouveau JAR est réellement exécutable et que son exécution produit le résultat attendu : l'affichage de “Hello, World!”.