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.

Commande	Description
<plugin>	Définit un plugin Maven à utiliser pendant le processus de construction. Les plugins peuvent exécuter des tâches spécifiques telles que la compilation de code ou l'empaquetage du projet.
<groupId>	Spécifie l'identifiant de groupe du projet Maven, généralement un nom de domaine inversé.
<artifactId>	Définit l'identifiant de l'artefact, qui est le nom du projet.
<version>	Indique la version actuelle du projet.
<build>	Contient la configuration de build du projet, y compris les plugins et les ressources.
<descriptorRef>	Fait référence à un descripteur prédéfini que le plug-in Maven Assembly doit utiliser, tel que « jar-with-dependencies ».
<mainClass>	Spécifie la classe principale à exécuter lors de l'exécution du fichier JAR.
<execution>	Définit un bloc d'exécution au sein d'un plugin, spécifiant les tâches à effectuer à différentes phases de construction.
mvn clean package	Commande pour nettoyer le projet et le conditionner dans un fichier JAR, y compris toutes les dépendances.
java -jar target/...jar	Commande pour exécuter le fichier JAR généré, en spécifiant le chemin d'accès au JAR.

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 fichier, qui contient la configuration du projet. Au sein de ce fichier, le 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 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 étiquette à l'intérieur du La section est essentielle car elle indique à Maven quelle classe contient la méthode principale à exécuter lorsque le JAR est exécuté.

Le 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 devrait être exécuté pendant la 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 répertoire du projet et nommé selon le et 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 plugin au lieu du 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 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.

1. Comment spécifier la classe principale dans mon JAR ?
2. Vous pouvez spécifier la classe principale en utilisant le étiquette dans le section de la configuration du plugin Maven.
3. Comment puis-je exclure des dépendances spécifiques du JAR final ?
4. Utilisez le balise dans la configuration du plugin pour spécifier les dépendances qui ne doivent pas être incluses dans le JAR final.
5. Qu'est-ce qu'un uber-JAR ?
6. Un uber-JAR est un fichier JAR qui contient non seulement votre code compilé mais également toutes ses dépendances.
7. Comment puis-je éviter les conflits de chemin de classe dans mon JAR ?
8. Le vous permet de renommer le package avec des dépendances pour éviter les conflits.
9. Comment gérer les classes en double dans les dépendances ?
10. Configurez le pour gérer les classes et les ressources en double en spécifiant comment les doublons doivent être traités dans le JAR final.
11. Puis-je inclure uniquement des fichiers spécifiques d’une dépendance ?
12. Oui, vous pouvez configurer le ou pour inclure uniquement des fichiers spécifiques d’une dépendance.
13. Comment exécuter le JAR packagé ?
14. Utilisez le commande suivie du chemin d’accès à votre fichier JAR.
15. Comment puis-je vérifier le contenu de mon fichier JAR ?
16. Vous pouvez utiliser le commande pour lister le contenu du fichier JAR.
17. Que faire si mon fichier JAR est trop volumineux ?
18. Utilisez le pour exclure les fichiers inutiles et minimiser la taille du JAR.

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 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.