Anleitung zum Erstellen und Ausführen einer Jar-Datei in Java

1. Übersicht

Normalerweise ist es praktisch, viele Java-Klassendateien in einer einzigen Archivdatei zu bündeln.

In diesem Tutorial werden wir decken die Ins und Outs der Arbeit mit Glas - oder J ava AR schnittlauch - Dateien in Java.

Insbesondere nehmen wir eine einfache Anwendung und untersuchen verschiedene Möglichkeiten, sie als JAR zu verpacken und auszuführen. Wir werden auch einige Kuriositäten beantworten, wie man die Manifestdatei eines Glases auf dem Weg leicht lesen kann.

2. Java-Programm einrichten

Bevor wir eine lauffähiges JAR - Datei erstellen können, muss unsere Anwendung eine Klasse mit einem haben Hauptverfahren. Diese Klasse bietet unseren Einstieg in die Anwendung:

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

3. Jar Command

Nachdem wir alle eingerichtet sind, kompilieren wir unseren Code und erstellen unsere JAR-Datei.

Wir können dies mit javac von der Kommandozeile aus tun :

javac com/baeldung/jar/*.java

Der Befehl javac erstellt JarExample.class im Verzeichnis com / baeldung / jar . Wir können das jetzt in eine JAR-Datei packen.

3.1. Standardeinstellungen verwenden

Um die JAR-Datei zu erstellen, verwenden wir den Befehl jar .

Um den Befehl jar zum Erstellen einer JAR-Datei zu verwenden, müssen Sie die Option c verwenden, um anzugeben, dass wir eine Datei erstellen, und die Option f , um die Datei anzugeben:

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

3.2. Hauptklasse einstellen

Es ist hilfreich, wenn das JAR-Dateimanifest die Hauptklasse enthält.

Das Manifest ist eine spezielle Datei in einem JAR, das sich im META-INF- Verzeichnis befindet und den Namen MANIFEST.MF trägt . Die Manifestdatei enthält spezielle Metainformationen zu Dateien in der JAR-Datei.

Einige Beispiele dafür, wofür wir eine Manifestdatei verwenden können, sind das Festlegen des Einstiegspunkts, das Festlegen von Versionsinformationen und das Konfigurieren des Klassenpfads.

Mit der Option e können wir unseren Einstiegspunkt angeben, und der Befehl jar fügt ihn der generierten Manifestdatei hinzu.

Lassen Sie uns jar mit einem angegebenen Einstiegspunkt ausführen :

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

3.3. Aktualisieren des Inhalts

Nehmen wir an, wir haben eine unserer Klassen geändert und neu kompiliert. Jetzt müssen wir unsere JAR-Datei aktualisieren.

Verwenden wir den Befehl jar mit der Option u , um den Inhalt zu aktualisieren:

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

3.4. Festlegen einer Manifestdatei

In einigen Fällen müssen wir möglicherweise mehr Kontrolle darüber haben, was in unserer Manifestdatei enthalten ist. Der Befehl jar bietet Funktionen zum Bereitstellen eigener Manifestinformationen.

Fügen wir unserer Anwendung eine teilweise Manifestdatei mit dem Namen example_manifest.txt hinzu , um unseren Einstiegspunkt festzulegen :

Main-Class: com.baeldung.jar.JarExample

Die von uns bereitgestellten Manifestinformationen werden zu dem hinzugefügt, was der Befehl jar generiert. Dies ist also die einzige Zeile, die wir in der Datei benötigen.

Es ist wichtig, dass wir unsere Manifestdatei mit einem Zeilenumbruch beenden . Ohne den Zeilenumbruch wird unsere Manifestdatei stillschweigend ignoriert.

With that setup, let's create our jar again using our manifest information and the m option:

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

3.5. Verbose Output

If we want more information out of the jar command, we can simply add the v option for verbose.

Let's run our jar command with the v option:

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

4.1. Default Configuration

We can also use Maven to create our jar. Since Maven favors convention over configuration, we can just run package to create our jar file.

mvn package

By default, our jar file will be added to the target folder in our project.

4.2. Indicating the Main Class

We can also configure Maven to specify the main class and create an executable jar file.

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

5. Using Spring Boot

5.1. Using Maven and Defaults

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.

Nachdem wir unsere JAR-Dateien erstellt hatten, kehrten wir zur Befehlszeile zurück und führten sie mit einer abgeleiteten und einer angegebenen Hauptklasse aus.

Wir haben auch gelernt, wie man den Inhalt einer Datei anzeigt und wie man den Inhalt einer einzelnen Datei in einem Glas anzeigt.

Sowohl das einfache Java-Beispiel als auch das Spring Boot-Beispiel sind auf GitHub verfügbar.