Organisez et packagez une application Java avec Apache Maven

De quoi est composé le build lifecycle ?

Afin d'automatiser la construction d'un projet, Maven s'appuie sur des cycles de vie de construction appelés build lifecycle dans le jargon de Maven.

Il y a 3 build lifecycles de base dans Maven :

• default : qui permet de construire et déployer le projet

• clean : qui permet de nettoyer le projet en supprimant les éléments issus de la construction de celui-ci

• site : qui permet de créer un site web pour le projet

Ces build lifecycles sont découpés en phases qui sont exécutées séquentiellement les unes à la suite des autres.

Si je prends l'exemple du build lifecycledefault, nous y retrouvons, entre autres, les phases :

• validate : vérifie que la configuration projet est correcte (POM, pas d'éléments manquants...)

• compile : compile les sources du projet

• test : teste le code compilé avec les classes de tests unitaires contenues dans le projet

• package : package les éléments issus de la compilation dans un format distribuable (JAR, WAR...)

• install : installe le package dans votre repository local

• deploy : envoie le package dans le repository distant défini dans le POM

Ainsi, la construction du projet (le build lifecycle) est un enchaînement d'étapes (les phases) permettant d'obtenir le résultat final.

Lancer un build lifecycle

Quand vous lancez une construction Maven en ligne de commande, vous précisez simplement une phase d'un des build lifecycles et Maven se charge d'exécuter, dans l'ordre, toutes les phases qui composent le build lifecycle jusqu'à la phase indiquée.

Vous vous rappelez de la commande mvn package? Eh bien dans cette commande, vous indiquiez la phase package du build lifecycledefault. Maven avait alors exécuté les phases validate, compile, test et enfin package.

Pour les projets multi-modules, quand vous lancez la commande mvn sur le projet parent, Maven lance le build lifecycle dans chaque sous-projet (module), les uns à la suite des autres, en respectant l'ordre des dépendances inter-modules.

Il vous est aussi possible de chaîner l'exécution de plusieurs build lifecycles dans une seule commande Maven. Si vous lancez mvn clean package par exemple, Maven va :

1. dans un premier temps, nettoyer le projet en exécutant le build lifecycle clean ;

2. puis, il va lancer le build lifecycle default jusqu'à la phase package.

Les goals

Nous avons vu qu'un build lifecycle est constitué d'une série de phases. Mais la granularité de l'exécution de Maven est encore plus fine. En effet, les phases sont découpées en tâches. Chaque tâche est assurée par un plugin Maven. Dans le jargon de Maven, ces tâches s'appellent des goals.

Par exemple, la phase test est réalisée par défaut par le goal surefire:test, c'est-à-dire le goal test du plugin surefire.

Maven fournit de base un certain nombre de plugins. Rappelez-vous, nous en avions déjà vu un dans la partie précédente quand nous avions ajouté la désignation de la classe Main dans le manifest du fichier JAR à générer :

<project>
    ...
    <!-- =============================================================== -->
    <!-- Build -->
    <!-- =============================================================== -->
    <build>
        <!-- Gestion des plugins (version) -->
        <pluginManagement>
            <plugins>
                <!-- Plugin responsable de la génération du fichier JAR -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-jar-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <!-- Création du Manifest pour la définition de la classe Main -->
                        <manifest>
                            <mainClass>org.exemple.demo.App</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
        </plugins>
    </build>
    ...
</project>

Résumons

Afin de construire un projet, Maven s'appuie sur des build lifecycles. Ces build lifecycles sont un enchaînement de différentes étapes : les phases. Les phases sont découpées en tâches, appelées goals, et réalisées par des plugins Maven.

Si vous souhaitez approfondir le sujet, voici quelques liens vers la documentation :

• Introduction to the Build Lifecycle

• Lifecycles Reference

Dans le chapitre suivant, je vais vous présenter les principaux plugins Maven et vous montrer comment personnaliser la construction de votre projet en les câblant aux différentes phases des build lifecycles.