Guide de création et d'exécution d'un fichier Jar en Java

1. Vue d'ensemble

Habituellement, il est pratique de regrouper de nombreux fichiers de classe Java dans un seul fichier d'archive.

Dans ce didacticiel, nous allons couvrir les tenants et les aboutissants de l'utilisation des fichiers jar - ou J ava AR chive - en Java.

Plus précisément, nous prendrons une application simple et explorerons différentes façons de l'empaqueter et de l'exécuter en tant que fichier jar. Nous répondrons également à quelques curiosités comme la façon de lire facilement le fichier manifeste d'un fichier jar en cours de route.

2. Configuration du programme Java

Avant de pouvoir créer un fichier jar exécutable, notre application doit avoir une classe avec une méthode main . Cette classe fournit notre point d'entrée dans l'application:

public static void main(String[] args) { System.out.println("Hello Baeldung Reader!"); }

3. Commande Jar

Maintenant que nous sommes tous configurés, compilons notre code et créons notre fichier jar.

Nous pouvons le faire avec javac depuis la ligne de commande:

javac com/baeldung/jar/*.java

La commande javac crée JarExample.class dans le répertoire com / baeldung / jar . Nous pouvons maintenant le conditionner dans un fichier jar.

3.1. Utilisation des valeurs par défaut

Pour créer le fichier jar, nous allons utiliser la commande jar .

Pour utiliser la commande jar pour créer un fichier jar, nous devons utiliser l' option c pour indiquer que nous créons un fichier et l' option f pour spécifier le fichier:

jar cf JarExample.jar com/baeldung/jar/*.class

3.2. Définition de la classe principale

Il est utile que le manifeste du fichier jar inclue la classe principale.

Le manifeste est un fichier spécial dans un fichier jar situé dans le répertoire META-INF et nommé MANIFEST.MF . Le fichier manifeste contient des méta-informations spéciales sur les fichiers du fichier jar.

Quelques exemples de ce pour quoi nous pouvons utiliser un fichier manifeste incluent la définition du point d'entrée, la définition des informations de version et la configuration du chemin de classe.

En utilisant l' option e , nous pouvons spécifier notre point d'entrée, et la commande jar l'ajoutera au fichier manifeste généré.

Exécutons jar avec un point d'entrée spécifié:

jar cfe JarExample.jar com.baeldung.jar.JarExample com/baeldung/jar/*.class

3.3. Mise à jour du contenu

Disons que nous avons modifié l'une de nos classes et l'avons recompilée. Maintenant, nous devons mettre à jour notre fichier jar.

Utilisons la commande jar avec l' option u pour mettre à jour son contenu:

jar uf JarExample.jar com/baeldung/jar/JarExample.class

3.4. Définition d'un fichier manifeste

Dans certains cas, nous pouvons avoir besoin d'avoir plus de contrôle sur ce qui se trouve dans notre fichier manifeste. La commande jar fournit des fonctionnalités pour fournir nos propres informations de manifeste.

Ajoutons un fichier manifeste partiel nommé example_manifest.txt à notre application pour définir notre point d'entrée:

Main-Class: com.baeldung.jar.JarExample

Les informations de manifeste que nous fournissons seront ajoutées à ce que la commande jar génère, c'est donc la seule ligne dont nous avons besoin dans le fichier.

Il est important que nous terminions notre fichier manifeste par une nouvelle ligne . Sans la nouvelle ligne, notre fichier manifeste sera ignoré en silence.

Avec cette configuration, créons à nouveau notre jar en utilisant nos informations de manifeste et l' option m :

jar cfm JarExample.jar com/baeldung/jar/example_manifest.txt com/baeldung/jar/*.class

3.5. Sortie verbeuse

Si nous voulons plus d'informations sur la commande jar , nous pouvons simplement ajouter l' option v pour verbose.

Exécutons notre commande jar avec l' option v :

jar cvfm JarExample.jar com/baeldung/jar/example_manifest.txt com/baeldung/jar/*.class added manifest adding: com/baeldung/jar/JarExample.class(in = 453) (out= 312)(deflated 31%)

4. Utilisation de Maven

4.1. Configuration par défaut

Nous pouvons également utiliser Maven pour créer notre pot. Puisque Maven privilégie la convention à la configuration, nous pouvons simplement exécuter package pour créer notre fichier jar.

mvn package

Par défaut, notre fichier jar sera ajouté au dossier cible de notre projet.

4.2. Indiquer la classe principale

Nous pouvons également configurer Maven pour spécifier la classe principale et créer un fichier jar exécutable.

 org.apache.maven.plugins maven-jar-plugin ${maven-jar-plugin.version}    com.baeldung.jar.JarExample    

5. Utilisation de Spring Boot

5.1. Utilisation de Maven et des valeurs par défaut

If we're using Spring Boot with Maven, we should first confirm that our packaging setting is set to jar rather than war in our pom.xml file.

4.0.0 spring-boot jar spring-boot

Once we know that's configured, we can run the package goal:

mvn package

5.2. Setting the Entry Point

Setting our main class is where we find differences between creating a jar with a regular Java application and a fat jar for a Spring Boot application. In a Spring Boot application, the main class is actually org.springframework.boot.loader.JarLauncher.

Although our example isn't a Spring Boot application, we could easily set it up to be a Spring Boot console application.

Our main class should be specified as the start class:

 com.baeldung.jar.JarExample  

We can also use Gradle to create a Spring Boot fat jar.

6. Running the Jar

Now that we've got our jar file, we can run it. We run jar files using the java command.

6.1. Inferring the Main Class

Since we've gone ahead and made sure our main class is specified in the manifest, we can use the -jar option of the java command to run our application without specifying the main class:

java -jar JarExample.jar

6.2. Specifying the Main Class

We can also specify the main class when we're running our application. We can use the -cp option to ensure that our jar file is in the classpath and then provide our main class in the package.className format:

java -cp JarExample.jar com.baeldung.jar.JarExample

Using path separators instead of package format also works:

java -cp JarExample.jar com/baeldung/jar/JarExample

6.3. Listing the Contents of a Jar

We can use the jar command to list the contents of our jar file:

jar tf JarExample.jar META-INF/ META-INF/MANIFEST.MF com/baeldung/jar/JarExample.class

6.4. Viewing the Manifest File

Since it can be important to know what's in our MANIFEST.MF file, let's look at a quick and easy way we can peek at the contents without leaving the command line.

Let's use the unzip command with the -p option:

unzip -p JarExample.jar META-INF/MANIFEST.MF Manifest-Version: 1.0 Created-By: 1.8.0_31 (Oracle Corporation) Main-Class: com.baeldung.jar.JarExample

7. Conclusion

In this tutorial, we set up a simple Java application with a main class.

Then we looked at three ways of creating jar files: using the jar command, with Maven and with a Maven Spring Boot application.

Après avoir créé nos fichiers jar, nous sommes retournés à la ligne de commande et les avons exécutés avec une classe principale déduite et spécifiée.

Nous avons également appris comment afficher le contenu d'un fichier et comment afficher le contenu d'un seul fichier dans un fichier jar.

L'exemple Java simple et l'exemple Spring Boot sont disponibles à l'adresse over sur GitHub.