Création d'un JAR exécutable avec des dépendances à l'aide de Maven

Conditionnement des projets Maven dans un seul JAR exécutable

Lorsque vous travaillez avec des projets Java, il est souvent nécessaire de regrouper votre application dans un seul fichier JAR exécutable pour une distribution facile. Maven, un puissant outil d'automatisation de build, permet aux développeurs d'inclure toutes les dépendances nécessaires dans ce JAR de sortie unique.

Cet article vous guidera à travers les étapes nécessaires pour configurer votre projet Maven afin d'inclure tous les JAR de dépendances dans votre JAR exécutable final. En suivant ces instructions, vous simplifierez le processus de déploiement et garantirez que votre application fonctionne correctement dans différents environnements.

Créer et exécuter un JAR exécutable avec Maven

Les scripts fournis ci-dessus montrent comment configurer un projet Maven pour regrouper toutes ses dépendances dans un seul fichier JAR exécutable. Le premier script est un Maven pom.xml fichier, qui contient la configuration du projet. Au sein de ce fichier, le <plugin> La balise est utilisée pour définir le plugin Maven Assembly. Ce plugin est crucial pour créer un JAR exécutable incluant toutes les dépendances. Le <descriptorRefs> La balise dans la configuration du plugin spécifie l'utilisation du jar-with-dependencies descripteur, qui garantit que toutes les dépendances du projet sont regroupées dans le fichier JAR final. Le <mainClass> étiquette à l'intérieur du <manifest> La section est essentielle car elle indique à Maven quelle classe contient la méthode principale à exécuter lorsque le JAR est exécuté.

Le <execution> Le bloc à l’intérieur de la configuration du plugin est l’endroit où l’action se produit. Il précise que le but du plugin single devrait être exécuté pendant la package phase du cycle de vie de la construction. C'est ce qui déclenche la création du fichier JAR avec les dépendances. Le deuxième script est une simple instruction en ligne de commande : mvn clean package. Cette commande nettoie le projet (en supprimant les artefacts de construction précédents), compile le code source, exécute des tests et regroupe le projet dans un fichier JAR. Le fichier JAR final se trouvera dans le dix répertoire du projet et nommé selon le artifactId et version précisé dans le pom.xml.

<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>my-app</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.3.0</version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>com.example.MainClass</mainClass>
                        </manifest>
                    </archive>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

mvn clean package
# This command will compile the code, run the tests, and create the JAR file
# The JAR file will include all dependencies specified in the pom.xml
# It will be located in the target directory of the project
# The final JAR file will be named my-app-1.0-SNAPSHOT-jar-with-dependencies.jar

# To run the JAR file, use the following command:
java -jar target/my-app-1.0-SNAPSHOT-jar-with-dependencies.jar
# Ensure that the mainClass specified in the pom.xml is correct
# This will start your application with all dependencies included

Techniques Maven avancées pour l'empaquetage des dépendances

Au-delà de la configuration de base pour créer un JAR exécutable avec Maven, il existe des techniques supplémentaires qui peuvent améliorer votre processus de construction. Une de ces techniques consiste à utiliser le shade plugin au lieu du assembly brancher. Le plugin Maven Shade offre des fonctionnalités plus avancées pour créer des uber-JAR (JAR avec dépendances incluses). Il vous permet de renommer les packages pour éviter les conflits de chemin de classe et offre une meilleure gestion des classes et des ressources en double. De plus, il offre un contrôle précis sur les dépendances incluses dans le JAR final.

Un autre aspect important est la gestion de la taille de votre fichier JAR. Les fichiers JAR volumineux peuvent être fastidieux et lents à transférer ou à charger. Le maven-shade-plugin peut vous aider en vous permettant d'exclure les fichiers et classes inutiles, réduisant ainsi la taille du JAR final. Vous pouvez également configurer le plugin pour minimiser le JAR en supprimant les informations non essentielles telles que les classes inutilisées ou les ressources redondantes. Ces configurations avancées peuvent être particulièrement utiles lorsque vous travaillez sur de grands projets comportant de nombreuses dépendances.

Réflexions finales sur les JAR exécutables Maven

La création d'un JAR exécutable avec des dépendances à l'aide de Maven simplifie le processus de déploiement des applications Java. En configurant correctement le pom.xml et en utilisant des plugins tels que Maven Assembly Plugin ou Maven Shade Plugin, les développeurs peuvent regrouper toutes les dépendances nécessaires dans un seul fichier JAR. Cette approche garantit que l'application peut fonctionner de manière transparente dans divers environnements, ce qui simplifie la distribution et l'exécution. Suivre ces étapes vous aidera à gérer efficacement les dépendances de votre projet et à créer des fichiers JAR fiables et exécutables.