Tutoriel Maven 3 – partie 2

Objectif de la partie 2 du tutoriel Maven: Cette 2eme partie du tutoriel Maven vise à construire pas à pas une application java qui s’exécute simplement en ligne de commande en invoquant le nom du fichier. L’application ne fait qu’afficher un message sur la console (sortie standard) mais peut servir de point de départ afin de construire ce type d’application. Prére-requis: le JDK est installé, cf. l’article: Installer Java sur Ubuntu ou compatible et Maven 3 est installé cf. l’artice: Tutoriel Maven 3 – partie 1

1. Première partie de ce tutoriel Maven: génerer un squelette d’application en ligne de commande

La commande à utiliser est:
mvn archetype:generate -DgroupId=com.example.hello \
    -DartifactId=helloworld -Dversion=1.0 -Dpackage=com.example.helloworld \
    -DarchetypeArtifactId=maven-archetype-quickstart \
    -DinteractiveMode=false
Remplacer: com.exemple.hello, helloworld, 1.0, com.example.helloworld  par les valeurs personnalisées de votre choix. Ceci crée l’arborescence de code source Java suivante: tutoriel maven structure helloworldIl s’agit de l’arborescence par défaut d’un projet Java Maven. Les codes source sont dans un dossier qui s’appelle src. Deux branches sont sous src:
  • test: contient les sources des test unitaires. Ce sujet ne sera pas abordé pour le moment.
  • main: contient les sources de l’application (dans le sous dossier java)
On remarque aussi la génération d’une classe Java unique qui constitue le point d’entrée de l’application App.java.

1.1. Construire l’application

Depuis le dossier helloworld/ de l’application:
mvn package
Ceci génère le fichier jar de l’application: helloworld-1.0.jar dans le sous-dossier target/

1.2. Exécuter cette application modèle

Depuis le dossier helloworld/ de l’application:
java -cp target/helloworld-1.0.jar com.example.helloworld.App
Hello World !
On est encore loin du but car il a fallu invoquer java avec deux paarmètres: le classpath et la classe principale.

2. Deuxième partie de ce tutoriel Maven: créer un jar exécutable

Pour cela on va utiliser le plug-in maven-assembly-plugin. On modifie donc le fichier pom.xml généré pour y ajouter toute la partie entre les balises <build>
 <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>com.example.hello</groupId>
  <artifactId>helloworld</artifactId>
  <packaging>jar</packaging>
  <version>1.0</version>
  <name>helloworld</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-assembly-plugin</artifactId>
        <configuration>
          <archive>
            <manifest>
              <mainClass>com.example.helloworld.App</mainClass>
            </manifest>
          </archive>
          <descriptorRefs>
             <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
          <appendAssemblyId>false</appendAssemblyId>
        </configuration>
        <executions>
          <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
              <goal>single</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>
Ensuite, après la reconstruction du fichier jar, l’exécution devient plus simple. On n’a plus à indiquer le nom de la classe principale. Le jar est exécutable de lui même.
mvn clean package
java -jar target/helloworld-1.0.jar
Hello World!
Il reste, toutefois, encore une étape pour atteindre l’objectif de n’invoquer que le nom du fichier.

3. Troisième partie de ce tutoriel Maven: créer un fichier exécutable.

3.1. Créer un script shell de démarrage

Dans un éditeur de texte, insérer le script suivant puis enregistrer sous le nom de boot.sh dans le dossier helloworld/
#!/bin/sh
EXEC=`which "$0" 2>/dev/null`
[ $? -gt 0 -a -f "$0" ] && EXEC="./$0"
java=java
if test -n "$JAVA_HOME"; then
  java="$JAVA_HOME/bin/java"
fi
exec "$java" $java_args -jar $EXEC "$@"
exit 1

3.2. Créer un fichier exécutable manuellement

Maintenant si on exécute la commande:
cat boot.sh target/helloworld-1.0.jar > hello && chmod +x hello
On obtient un fichier exécutable autonome hello, qui peut être exécuté tout simplement par:
./hello
Hello World!

3.3. Créer le fichier exécutable par Maven

Pour inclure cette dernière tâche au cycle de vie Maven de notre projet, on utilise le plug-in exec-maven-plugin. Pour cela on rajoute cette portion de code au fichier pom.xml. Insérer juste après le dernier plug-in ajouté.
<plugin>
  <groupId>org.codehaus.mojo</groupId>
  <artifactId>exec-maven-plugin</artifactId>
  <version>1.3.2</version>
  <executions>
    <execution>
      <phase>package</phase>
      <goals>
        <goal>exec</goal>
      </goals>
    </execution>
  </executions>
  <configuration>
    <executable>buildexec.sh</executable>
  </configuration>
</plugin>
Remarquez le buildexec.sh inclu dans la balise <executable>. Il s’agit du script que Maven va exécuter pour générer le fichier final et qu’on doit créer. Ce fichier doit effectuer les mêmes tâches que la commande manuelle effectuée précédemment. Il doit inclure donc
#!/bin/sh
cat boot.sh target/helloworld-1.0.jar > hello
chmod +x hello
A l’aide d’un éditeur de texte, créer ce fichier et le rendre exécutable:
chmod +x buildexec.sh
Enfin Maven pourra créer le fichier hello exécutable java autonome.
mvn package
./hello
Hello World!
]]>