Guida alla creazione e all'esecuzione di un file Jar in Java

1. Panoramica

Di solito, è conveniente raggruppare molti file di classe Java in un unico file di archivio.

In questo tutorial, tratteremo i dettagli del lavoro con i file jar - o J ava AR chive - in Java.

Nello specifico, prenderemo una semplice applicazione ed esploreremo diversi modi per pacchettizzarla ed eseguirla come un jar. Risponderemo anche ad alcune curiosità come come leggere facilmente il file manifest di un jar lungo la strada.

2. Installazione del programma Java

Prima di poter creare un file jar eseguibile, la nostra applicazione deve avere una classe con un metodo principale . Questa classe fornisce il nostro punto di ingresso nell'applicazione:

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

3. Jar Command

Ora che siamo tutti pronti, compiliamo il nostro codice e creiamo il nostro file jar.

Possiamo farlo con javac dalla riga di comando:

javac com/baeldung/jar/*.java

Il comando javac crea JarExample.class nella directory com / baeldung / jar . Ora possiamo impacchettarlo in un file jar.

3.1. Utilizzo dei valori predefiniti

Per creare il file jar, useremo il comando jar .

Per utilizzare il comando jar per creare un file jar, dobbiamo usare l' opzione c per indicare che stiamo creando un file e l' opzione f per specificare il file:

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

3.2. Impostazione della classe principale

È utile che il manifest del file jar includa la classe principale.

Il manifest è un file speciale in un jar situato nella directory META-INF e denominato MANIFEST.MF . Il file manifest contiene meta informazioni speciali sui file all'interno del file jar.

Alcuni esempi di ciò che possiamo utilizzare per un file manifest includono l'impostazione del punto di ingresso, l'impostazione delle informazioni sulla versione e la configurazione del percorso di classe.

Usando l' opzione e , possiamo specificare il nostro punto di ingresso e il comando jar lo aggiungerà al file manifest generato.

Eseguiamo jar con un punto di ingresso specificato:

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

3.3. Aggiornamento dei contenuti

Supponiamo di aver apportato una modifica a una delle nostre classi e di averla ricompilata. Ora dobbiamo aggiornare il nostro file jar.

Usiamo il comando jar con l' opzione u per aggiornarne il contenuto:

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

3.4. Impostazione di un file manifest

In alcuni casi, potrebbe essere necessario avere un maggiore controllo su ciò che va nel nostro file manifest. Il comando jar fornisce funzionalità per fornire le nostre informazioni sul manifest.

Aggiungiamo un file manifest parziale denominato example_manifest.txt alla nostra applicazione per impostare il nostro punto di ingresso:

Main-Class: com.baeldung.jar.JarExample

Le informazioni sul manifest che forniamo verranno aggiunte a ciò che genera il comando jar, quindi è l'unica riga di cui abbiamo bisogno nel file.

È importante terminare il nostro file manifest con una nuova riga . Senza la nuova riga, il nostro file manifest verrà ignorato silenziosamente.

Con questa configurazione, creiamo di nuovo il nostro jar usando le nostre informazioni sul manifest e l' opzione m :

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

3.5. Output dettagliato

Se vogliamo più informazioni dal comando jar , possiamo semplicemente aggiungere l' opzione v per verbose.

Eseguiamo il nostro comando jar con l' opzione 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. Utilizzo di Maven

4.1. Configurazione predefinita

Possiamo anche usare Maven per creare il nostro vaso. Poiché Maven preferisce le convenzioni alla configurazione, possiamo semplicemente eseguire il pacchetto per creare il nostro file jar.

mvn package

Per impostazione predefinita, il nostro file jar verrà aggiunto alla cartella di destinazione nel nostro progetto.

4.2. Indicare la classe principale

Possiamo anche configurare Maven per specificare la classe principale e creare un file jar eseguibile.

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

5. Utilizzo di Spring Boot

5.1. Utilizzo di Maven e predefiniti

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.

Dopo aver creato i nostri file jar, siamo tornati alla riga di comando e li abbiamo eseguiti con una classe principale dedotta e specificata.

Abbiamo anche imparato come visualizzare il contenuto di un file e come visualizzare il contenuto di un singolo file all'interno di un jar.

Sia il semplice esempio Java che l'esempio Spring Boot sono disponibili su GitHub.