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

1. Introduction

Dans cet article rapide, nous allons nous concentrer sur l' empaquetage d'un projet Maven dans un fichier Jar exécutable .

Habituellement, lors de la création d'un fichier jar , nous voulons l'exécuter facilement, sans utiliser l'IDE; à 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.

2. Configuration

Afin de créer un fichier jar exécutable , 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éthode main (…) .

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

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

4.0.0 com.baeldung core-java 0.1.0-SNAPSHOT jar

Le aspect le plus important est ici le type - pour créer un exécutable pot , vérifiez la configuration utilise un pot de type.

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

2.1. Configuration manuelle

Commençons par une approche manuelle - avec l'aide du plugin maven-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'objectif des dépendances de copie , qui indique à Maven de copier ces dépendances dans le outputDirectory spécifié .

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 dossier cible ).

Dans la deuxième étape, nous allons créer le chemin exécutable et classe courant pot , avec le lien vers les dépendances copiés dans la première étape:

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

La partie la plus importante de ce qui précède est la configuration du manifeste . Nous ajoutons un classpath, avec toutes les dépendances (dossier libs / ), et fournissons les informations sur la classe principale.

Veuillez noter que nous devons fournir un nom complet de la classe, ce qui signifie qu'il inclura le nom du package.

Les avantages et inconvénients de cette approche sont:

  • pros - processus transparent, où nous pouvons spécifier chaque étape
  • contre - manuel, les dépendances sont hors du jar final , ce qui signifie que votre jar exécutable ne fonctionnera que si le dossier libs sera accessible et visible pour un jar

2.2. Plug-in d'assemblage Apache Maven

Le plugin Apache Maven Assembly permet aux utilisateurs d'agréger la sortie du projet avec ses dépendances, ses modules, la documentation du site et d'autres fichiers dans un seul package exécutable.

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

Jetons un coup d'œil à la configuration dans pom.xml :

 org.apache.maven.plugins maven-assembly-plugin   package  single      com.baeldung.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 fichier jar .

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

La sortie de notre exemple sera nommée core-java-jar-with-dependencies.jar.

  • pros - dépendances dans le fichier jar , un seul fichier
  • inconvénients - contrôle de base de l'empaquetage de votre artefact, par exemple, il n'y a pas de support de relocalisation de classe

2.3. Plug-in Apache Maven Shade

Apache Maven Shade Plugin offre la possibilité de conditionner l'artefact dans un uber-jar , qui comprend 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 dépendances.

Jetons un œil à la configuration:

 org.apache.maven.plugins maven-shade-plugin    shade   true   com.baeldung.executable.ExecutableMavenJar      

Il y a trois parties principales de cette configuration:

Première, marque toutes les dépendances à empaqueter dans le fichier jar .

Deuxièmement, nous devons spécifier l'implémentation du transformateur; 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 fichier jar , contrôle avancé de l'empaquetage de votre artefact, avec ombrage et déplacement de classe
  • inconvénients - configuration complexe (surtout si on veut utiliser des fonctionnalités avancées)

2.4. Plugin One Jar Maven

Une autre option pour créer un fichier jar exécutable 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 de jars dans le système de fichiers.

Jetons un œil à la configuration:

 com.jolira onejar-maven-plugin    org.baeldung.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 utilisant attachToBuild = true .

Also, we should provide the output filename. Moreover, the goal for Maven is one-jar. Please note, that One Jar is a commercial solution, that will make dependency jars not expanded into the filesystem at runtime.

  • pros – clean delegation model, allows classes to be at the top-level of the One Jar, supports external jars and can support Native libraries
  • cons – not actively supported since 2012

2.5. Spring Boot Maven Plugin

Finally, the last solution we'll look at is the Spring Boot Maven Plugin.

This allows to package executable jar or war archives and run an application “in-place”.

To use it we need to use at least Maven version 3.2. The detailed description is available here.

Let's have a look at the config:

 org.springframework.boot spring-boot-maven-plugin    repackage   spring-boot  com.baeldung.executable.ExecutableMavenJar     

There are two differences between Spring plugin and the others. First, the goal of the execution is called repackage, and the classifier is named spring-boot.

Please note, that we don't need to have Spring Boot application in order to use this plugin.

  • pros – dependencies inside a jar file, you can run it in every accessible location, advanced control of packaging your artifact, with excluding dependencies from the jar file etc., packaging of war files as well
  • cons – adds potentially unnecessary Spring and Spring Boot related classes

2.6. Web Application With Executable Tomcat

In the last part, we want to cover the topic of having a standalone web application, that is packed inside a jar file. In order to do that, we need to use different plugin, designed for creating executable jar files:

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

The goal is set as exec-war-only, path to your server is specified inside configuration tag, with additional properties, like finalName, charset etc. To build a jar, run man package, which will result in creating webapp.jar in your target directory. To run

To run the application, just write this in your console: java -jar target/webapp.jar and try to test it by specifying the localhost:8080/ in a browser.

  • pros – having one file, easy to deploy and run
  • cons – a size of the file is much larger, due to packing Tomcat embedded distribution inside a war file

Please note, that this is the latest version of this plugin, which supports Tomcat7 server. To avoid errors, please check that your dependency for Servlets has scope set as provided, otherwise, there will be a conflict at the runtime of executable jar:

 javax.servlet javax.servlet-api provided 

3. Conclusion

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

L'implémentation complète de ce tutoriel peut être trouvée dans ce (jar exécutable) et ce (exécutable war) projets Github.

Comment tester? Afin de compiler le projet dans un fichier jar exécutable , veuillez exécuter Maven avec la commande mvn clean package .

Espérons que cet article vous donne plus d'informations 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 considéré.