Comment créer un fichier JAR exécutable avec Maven

1. introduction

Dans cet article rapide, nous nous concentrerons sur lespackaging a Maven project into an executable Jar file.

Habituellement, lors de la création d'un fichierjar, nous voulons l'exécuter facilement, sans utiliser l'EDI; à cette fin, nous discuterons de la configuration et des avantages / inconvénients de l'utilisation de chacune de ces approches pour créer l'exécutable.

Lectures complémentaires:

Tutoriel Apache Maven

Un guide rapide et pratique sur la construction et la gestion de projets Java avec Apache Maven.

Où se trouve le référentiel local Maven?

Tutoriel rapide vous montrant où Maven stocke son dépôt local et comment changer cela.

Printemps avec Maven BOM

Apprenez à utiliser une nomenclature, une nomenclature, dans votre projet Spring Maven.

2. Configuration

Pour créer un exécutablejar, nous n'avons pas besoin de dépendances supplémentaires. Nous avons juste besoin de créer un projet Maven Java, et d'avoir au moins une classe avec la méthodemain(…).

Dans notre exemple, nous avons créé une classe Java nomméeExecutableMavenJar.

Nous devons également nous assurer que notrepom.xml contient les éléments suivants:

4.0.0
com.example
core-java
0.1.0-SNAPSHOT
jar

L'aspect le plus important ici est le type - pour créer un exécutablejar, vérifiez que la configuration utilise un typejar.

Nous pouvons maintenant commencer à utiliser les différentes solutions.

2.1. Configuration manuelle

Commençons par une approche manuelle - à l’aide desmaven-dependency-plugin.

Tout d'abord, nous allons copier toutes les dépendances requises dans le dossier que nous spécifierons:


    org.apache.maven.plugins
    maven-dependency-plugin
    
        
            copy-dependencies
            prepare-package
            
                copy-dependencies
            
            
                
                    ${project.build.directory}/libs

Il y a deux aspects importants à noter. Tout d'abord, nous spécifions l'objectifcopy-dependencies, qui indique à Maven de copier ces dépendances dans lesoutputDirectory spécifiés.

Dans notre cas, nous allons créer un dossier nommélibs, dans le répertoire de construction du projet (qui est généralement le dossiertarget).

Dans la deuxième étape, nous allons créer l'exécutable et le chemin de classejar, avec le lien vers les dépendances copié dans la première étape:


    org.apache.maven.plugins
    maven-jar-plugin
    
        
            
                true
                libs/
                
                    org.example.executable.ExecutableMavenJar

La partie la plus importante de ce qui précède est la configurationmanifest. Nous ajoutons un chemin de classe, avec toutes les dépendances (dossierlibs/), et fournissons les informations sur la classe principale.

Veuillez noter que nous devons fournir le nom complet qualifié de la classe, ce qui signifie qu'elle inclura le nom du paquet.

Les avantages et inconvénients de cette approche sont les suivants:

pros - processus transparent, où nous pouvons spécifier chaque étape
cons - manuel, les dépendances sont hors desjar finaux, ce qui signifie que votre exécutablejar ne fonctionnera que si le dossierlibs sera accessible et visible pendant unjar

2.2. Plug-in d'assemblage Apache Maven

Apache Maven Assembly Plugin permet aux utilisateurs d'agréger la sortie du projet ainsi que ses dépendances, ses modules, sa documentation de site et d'autres fichiers dans un seul package exécutable.

L'objectif principal du plugin d'assemblage est l'objectifsingle - utilisé pour créer tous les assemblys (tous les autres objectifs sont obsolètes et seront supprimés dans une prochaine version).

Jetons un œil à la configuration enpom.xml:


    org.apache.maven.plugins
    maven-assembly-plugin
    
        
            package
            
                single
            
            
                
                
                    
                        org.example.executable.ExecutableMavenJar
                    
                
                
                
                    jar-with-dependencies

Comme pour l'approche manuelle, nous devons fournir les informations sur la classe principale; la différence est que le plug-in d'assemblage Maven copiera automatiquement toutes les dépendances requises dans un fichierjar.

Dans la partiedescriptorRefs du code de configuration, nous avons fourni le nom, qui sera ajouté au nom du projet.

La sortie dans notre exemple sera nomméecore-java-jar-with-dependencies.jar.

pros - dépendances dans le fichierjar, un seul fichier
cons - contrôle de base de l'empaquetage de votre artefact, par exemple, il n'y a pas de support de relocation de classe

2.3. Plug-in Apache Maven Shade

Apache Maven Shade Plugin offre la possibilité de conditionner l'artefact dans unuber-jar, qui se compose de toutes les dépendances requises pour exécuter le projet. De plus, il prend en charge l’ombrage - c’est-à-dire renommer - les paquets de certaines des dépendances.

Jetons un œil à la configuration:


    org.apache.maven.plugins
    maven-shade-plugin
    
        
            
                shade
            
            
                true
                
                    
                        org.example.executable.ExecutableMavenJar

Il y a trois parties principales de cette configuration:

Tout d'abord,<shadedArtifactAttached> marque toutes les dépendances à empaqueter dans lesjar.

Deuxièmement, nous devons spécifierthe transformer implementation; nous avons utilisé le standard dans notre exemple.

Enfin, nous devons spécifier la classe principale de notre application.

Le fichier de sortie sera nommécore-java-0.1.0-SNAPSHOT-shaded.jar, oùcore-java est le nom de notre projet, suivi de la version de l'instantané et du nom du plugin.

pros - dépendances dans le fichierjar, contrôle avancé de l'empaquetage de votre artefact, avec ombrage et relocalisation de classe
cons - configuration complexe (surtout si nous voulons utiliser des fonctionnalités avancées)

2.4. Plugin One Jar Maven

Une autre option pour créer l'exécutablejar est le projet One Jar.

Cela fournit un chargeur de classe personnalisé qui sait comment charger des classes et des ressources à partir de jars dans une archive, au lieu dejars dans le système de fichiers.

Jetons un œil à la configuration:


    com.jolira
    onejar-maven-plugin
    
        
            
                org.example.executable.
                  ExecutableMavenJar
                true
                
                  ${project.build.finalName}.${project.packaging}
                
            
            
                one-jar

Comme indiqué dans la configuration, nous devons spécifier la classe principale et attacher toutes les dépendances à construire, en utilisantattachToBuild= true.

En outre, nous devrions fournir le nom de fichier de sortie. De plus, l'objectif pour Maven est deone-jar. Veuillez noter que One Jar est une solution commerciale, qui rendra la dépendancejars non étendue dans le système de fichiers lors de l'exécution.

pros - modèle de délégation propre, permet aux classes d'être au niveau supérieur du One Jar, prend en charge lesjars externes et peut prendre en charge les bibliothèques natives
cons - non pris en charge activement depuis 2012

2.5. Plugin Spring Boot Maven

Enfin, la dernière solution que nous examinerons est le plugin Spring Boot Maven.

Cela permet de regrouper les archives exécutablesjar ouwar et d'exécuter une application «en place».

Pour l'utiliser, nous devons au moins utiliser la version 3.2 de Maven. La description détaillée est disponiblehere.

Jetons un œil à la configuration:


    org.springframework.boot
    spring-boot-maven-plugin
    
        
            
                repackage
            
            
                spring-boot
                
                  org.example.executable.ExecutableMavenJar

Il y a deux différences entre le plugin Spring et les autres. Tout d'abord, le but de l'exécution est appelérepackage, et le classificateur est nomméspring-boot.

Veuillez noter que nous n'avons pas besoin de l'application Spring Boot pour utiliser ce plugin.

pros - dépendances à l'intérieur d'un fichierjar, vous pouvez l'exécuter dans tous les emplacements accessibles, contrôle avancé de l'empaquetage de votre artefact, avec exclusion des dépendances du fichierjar etc. t3) s également
cons - ajoute des classes potentiellement inutiles liées à Spring et Spring Boot

2.6. Application Web avec exécutable Tomcat

Dans la dernière partie, nous voulons couvrir le sujet d'avoir une application Web autonome, qui est emballée dans un fichier jar. Pour ce faire, nous devons utiliser un plugin différent, conçu pour créer des fichiers jar exécutables:


    org.apache.tomcat.maven
    tomcat7-maven-plugin
    2.0
    
        
            tomcat-run
            
                exec-war-only
            
            package
            
                /
                false
                webapp.jar
                utf-8

Legoal est défini commeexec-war-only,path sur votre serveur est spécifié dans la baliseconfiguration, avec des propriétés supplémentaires, commefinalName, charset etc. Pour construire un jar, exécutezman package, ce qui entraînera la création dewebapp.jar dans votre répertoiretarget. Courir

Pour exécuter l'application, écrivez simplement ceci dans votre console:java -jar target/webapp.jar et essayez de le tester en spécifiant lelocalhost:8080 / dans un navigateur.

pros - avoir un fichier, facile à déployer et à exécuter
cons - une taille du fichier est beaucoup plus grande, en raison de l'empaquetage de la distribution intégrée Tomcat dans un fichier war

Veuillez noter qu'il s'agit de la dernière version de ce plugin, qui prend en charge le serveur Tomcat7. Pour éviter les erreurs, veuillez vérifier que votre dépendance pour les servlets ascope défini commeprovided, sinon, il y aura un conflit au niveau desruntime de l'exécutablejar:


    javax.servlet
    javax.servlet-api
    provided

3. Conclusion

Dans cet article, nous avons décrit de nombreuses façons de créer un exécutablejar avec divers plugins Maven.

L'implémentation complète de ce didacticiel se trouve dans les projets Githubthis (executable jar) etthis (executable war).

How to test? Afin de compiler le projet dans un exécutablejar, veuillez exécuter Maven avec la commandemvn clean package.

Espérons que cet article vous donne plus de perspicacités sur le sujet et que vous trouverez votre approche préférée en fonction de vos besoins.

Une dernière remarque rapide: assurez-vous que les licences des fichiers JAR que vous regroupez n'interdisent pas ce type d'opération. En général, ce ne sera pas le cas, mais c’est quelque chose qui mérite d’être envisagé.

TOC

Comment créer un fichier JAR exécutable avec Maven