Java >> Tutoriel Java >  >> Java

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

1. Présentation

En règle générale, 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 du travail avec jar - ou J ava AR ciboulette - fichiers en Java.

Plus précisément, nous prendrons une application simple et explorerons différentes manières de la conditionner et de l'exécuter sous forme de fichier jar. Nous répondrons également à certaines curiosités comme comment lire facilement le fichier manifeste d'un pot  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 un main méthode. 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

Le javac la commande crée JarExample.class dans le com/baeldung/jar annuaire. Nous pouvons maintenant le regrouper dans un fichier jar.

3.1. Utilisation des valeurs par défaut

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

Pour utiliser le pot commande pour créer un fichier jar, nous devons utiliser le c option pour indiquer que nous créons un fichier et le f option 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 jar situé dans le META-INF répertoire et nommé MANIFEST.MF . Le fichier manifeste contient des méta-informations spéciales sur les fichiers dans le 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 le e option, nous pouvons spécifier notre point d'entrée, et le jar la commande 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 apporté une modification à l'une de nos classes et que nous l'avons recompilée. Maintenant, nous devons mettre à jour notre fichier jar.

Utilisons le jar commande avec le possibilité de 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 passe dans notre fichier manifeste. Le pot La commande fournit une fonctionnalité permettant de 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 un nouvelle ligne . Sans la nouvelle ligne, notre fichier manifeste sera silencieusement ignoré.

Avec cette configuration, créons à nouveau notre pot en utilisant nos informations de manifeste et le choix :

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

3.5. Sortie détaillée

Si nous voulons plus d'informations sur le pot commande, nous pouvons simplement ajouter le v option pour verbeux.

Lançons notre jar commande avec le v choix :

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

4.1. Configuration par défaut

Nous pouvons également utiliser Maven pour créer notre pot. Étant donné que Maven privilégie la convention plutôt que la configuration, nous pouvons simplement exécuter package pour créer notre fichier jar.

mvn package

Par défaut, notre fichier jar sera ajouté à la cible dossier dans 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.

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>${maven-jar-plugin.version}</version>
    <configuration>
        <archive>
            <manifest>
                <mainClass>com.baeldung.jar.JarExample</mainClass>
            </manifest>
        </archive>
    </configuration>
</plugin>

5. Utilisation de Spring Boot

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

Si nous utilisons Spring Boot avec Maven, nous devons d'abord confirmer que notre paramètre d'emballage est défini sur jar plutôt que la guerre dans notre pom.xml fichier.

<modelVersion>4.0.0</modelVersion>
<artifactId>spring-boot</artifactId>
<packaging>jar</packaging>
<name>spring-boot</name>

Une fois que nous savons que c'est configuré, nous pouvons exécuter le package objectif :

mvn package

5.2. Définition du point d'entrée

La définition de notre classe principale est l'endroit où nous trouvons des différences entre la création d'un pot avec une application Java standard et un gros pot pour une application Spring Boot. Dans une application Spring Boot, la classe principale est en fait org.springframework.boot.loader.JarLauncher .

Bien que notre exemple ne soit pas une application Spring Boot, nous pourrions facilement le configurer comme une application console Spring Boot.

Notre classe principale doit être spécifiée comme classe de départ :

<properties>
    <start-class>com.baeldung.jar.JarExample</start-class>
    <!-- Other properties -->
</properties>

Nous pouvons également utiliser Gradle pour créer un pot de graisse Spring Boot.

6. Faire fonctionner le bocal

Maintenant que nous avons notre fichier jar, nous pouvons l'exécuter. Nous exécutons des fichiers jar en utilisant java commande.

6.1. Déduire la classe principale

Puisque nous sommes allés de l'avant et nous sommes assurés que notre classe principale est spécifiée dans le manifeste, nous pouvons utiliser le -jar option du java commande pour exécuter notre application sans spécifier la classe principale :

java -jar JarExample.jar

6.2. Spécification de la classe principale

Nous pouvons également spécifier la classe principale lorsque nous exécutons notre application. Nous pouvons utiliser le -cp option pour s'assurer que notre fichier jar est dans le chemin de classe, puis fournir notre classe principale dans le package.className format :

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

L'utilisation de séparateurs de chemin au lieu du format de package fonctionne également :

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

6.3. Lister le contenu d'un bocal

Nous pouvons utiliser le pot commande pour lister le contenu de notre fichier jar :

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

6.4. Affichage du fichier manifeste

Puisqu'il peut être important de savoir ce qu'il y a dans notre MANIFEST.MF file, regardons un moyen rapide et facile de jeter un coup d'œil au contenu sans quitter la ligne de commande.

Utilisons le décompresser commande avec l'option -p :

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

Dans ce tutoriel, nous avons configuré une application Java simple avec un élément main classe.

Ensuite, nous avons examiné trois manières de créer des fichiers jar :en utilisant le jar commande, avec Maven et avec une application Maven Spring Boot.

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 une classe principale spécifiée.

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

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


Balise Java