Gids voor het maken en uitvoeren van een jar-bestand in Java

1. Overzicht

Meestal is het handig om veel Java-klassebestanden in één archiefbestand te bundelen.

In deze tutorial gaan we het hebben over de ins en outs van het werken met jar - of Java ARbieslook - bestanden in Java.

In het bijzonder zullen we een eenvoudige applicatie nemen en verschillende manieren verkennen om het in een pot te verpakken en uit te voeren. We zullen ook enkele curiosa beantwoorden, zoals hoe je het manifestbestand van een jar gemakkelijk kunt lezen onderweg.

2. Java-programma instellen

Voordat we een uitvoerbaar jar-bestand kunnen maken, moet onze applicatie een klasse hebben met een hoofd methode. Deze klasse biedt ons toegangspunt tot de applicatie:

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

3. Jar-opdracht

Nu we helemaal klaar zijn, gaan we onze code compileren en ons jar-bestand maken.

We kunnen dit met javac vanaf de opdrachtregel:

javac com / baeldung / jar / *. java

De Javac commando creëert JarExample.class in de com / baeldung / jar directory. We kunnen dat nu verpakken in een jar-bestand.

3.1. Met behulp van de standaardinstellingen

Om het jar-bestand te maken, gaan we de pot opdracht.

Om de pot commando om een ​​jar-bestand te maken, moeten we de c optie om aan te geven dat we een bestand maken en het f optie om het bestand te specificeren:

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

3.2. De hoofdklasse instellen

Het is handig als het jar-bestandsmanifest de hoofdklasse bevat.

Het manifest is een speciaal bestand in een pot in het META-INF directory en met de naam MANIFEST.MF. Het manifestbestand bevat speciale meta-informatie over bestanden in het jar-bestand.

Enkele voorbeelden van waar we een manifestbestand voor kunnen gebruiken, zijn het instellen van het toegangspunt, het instellen van versie-informatie en het configureren van het klassenpad.

Door de e optie, kunnen we ons toegangspunt specificeren, en de pot commando zal het toevoegen aan het gegenereerde manifestbestand.

Laten we rennen pot met een opgegeven ingangspunt:

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

3.3. De inhoud bijwerken

Laten we zeggen dat we een wijziging hebben aangebracht in een van onze lessen en deze opnieuw hebben gecompileerd. Nu moeten we ons jar-bestand bijwerken.

Laten we de pot commando met de u optie om de inhoud bij te werken:

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

3.4. Een manifestbestand instellen

In sommige gevallen hebben we wellicht meer controle nodig over wat er in ons manifestbestand staat. De pot commando biedt functionaliteit voor het verstrekken van onze eigen manifestinformatie.

Laten we een gedeeltelijk manifestbestand toevoegen met de naam voorbeeld_manifest.txt naar onze applicatie om ons toegangspunt in te stellen:

Hoofdklasse: com.baeldung.jar.JarExample

De manifestinformatie die we verstrekken, wordt toegevoegd aan wat de jar-opdracht genereert, dus het is de enige regel die we nodig hebben in het bestand.

Het is belangrijk dat we ons manifestbestand eindigen met eennieuwe lijn. Zonder de nieuwe regel wordt ons manifestbestand stilzwijgend genegeerd.

Laten we met die instelling onze jar opnieuw maken met behulp van onze manifestinformatie en het m keuze:

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

3.5. Uitgebreide uitvoer

Als we meer informatie willen uit de pot commando, kunnen we eenvoudig de v optie voor uitgebreid.

Laten we onze pot commando met de v keuze:

jar cvfm JarExample.jar com / baeldung / jar / example_manifest.txt com / baeldung / jar / *. class toegevoegd manifest toevoegen: com / baeldung / jar / JarExample.class (in = 453) (out = 312) (leeggelopen 31% )

4. Maven gebruiken

4.1. Standaardconfiguratie

We kunnen Maven ook gebruiken om onze pot te maken. Omdat Maven de voorkeur geeft aan conventie boven configuratie, kunnen we het pakket gewoon uitvoeren om ons jar-bestand te maken.

mvn-pakket

Standaard wordt ons jar-bestand toegevoegd aan het doelwit map in ons project.

4.2. Geeft de hoofdklasse aan

We kunnen Maven ook configureren om de hoofdklasse te specificeren en een uitvoerbaar jar-bestand te maken.

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

5. Spring Boot gebruiken

5.1. Maven en standaardinstellingen gebruiken

Als we Spring Boot gebruiken met Maven, moeten we eerst bevestigen dat onze verpakkingsinstelling is ingesteld op pot liever dan oorlog in onze pom.xml het dossier.

4.0.0 spring-boot jar spring-boot

Zodra we weten dat dit is geconfigureerd, kunnen we het pakket doel:

mvn-pakket

5.2. Instellen van het beginpunt

Bij het instellen van onze hoofdklasse vinden we verschillen tussen het maken van een jar met een gewone Java-applicatie en een fat jar voor een Spring Boot-applicatie. In een Spring Boot-applicatie is de hoofdklasse eigenlijk org.springframework.boot.loader.JarLauncher.

Hoewel ons voorbeeld geen Spring Boot-applicatie is, kunnen we het gemakkelijk instellen als een Spring Boot-consoletoepassing.

Onze hoofdklasse moet worden opgegeven als de startklasse:

 com.baeldung.jar.Jar Voorbeeld 

We kunnen Gradle ook gebruiken om een ​​Spring Boot-vetpot te maken.

6. De pot laten draaien

Nu we ons jar-bestand hebben, kunnen we het uitvoeren. We voeren jar-bestanden uit met behulp van de Java opdracht.

6.1. De hoofdklasse afleiden

Aangezien we door zijn gegaan en ervoor hebben gezorgd dat onze hoofdklasse in het manifest wordt gespecificeerd, we kunnen de -pot optie van de Java opdracht om onze applicatie uit te voeren zonder de hoofdklasse op te geven:

java -jar JarExample.jar

6.2. De hoofdklasse specificeren

We kunnen ook de hoofdklasse specificeren wanneer we onze applicatie draaien. We kunnen de -cp optie om ervoor te zorgen dat ons jar-bestand zich in het klassenpad bevindt en vervolgens onze hoofdklasse in het package.className formaat:

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

Het gebruik van padscheidingstekens in plaats van het pakketformaat werkt ook:

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

6.3. De inhoud van een pot weergeven

We kunnen de pot commando om de inhoud van ons jar-bestand weer te geven:

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

6.4. Het manifestbestand bekijken

Omdat het belangrijk kan zijn om te weten wat er in ons MANIFEST.MF bestand, laten we eens kijken naar een snelle en gemakkelijke manier waarop we de inhoud kunnen bekijken zonder de opdrachtregel te verlaten.

Laten we de uitpakken commando met de -p optie:

unzip -p JarExample.jar META-INF / MANIFEST.MF Manifest-versie: 1.0 Gemaakt door: 1.8.0_31 (Oracle Corporation) Hoofdklasse: com.baeldung.jar.JarExample

7. Conclusie

In deze tutorial zetten we een eenvoudige Java-applicatie op met een hoofd klasse.

Vervolgens hebben we gekeken naar drie manieren om jar-bestanden te maken: met behulp van de pot commando, met Maven en met een Maven Spring Boot-applicatie.

Nadat we onze jar-bestanden hadden gemaakt, keerden we terug naar de opdrachtregel en voerden ze uit met een afgeleide en een opgegeven hoofdklasse.

We hebben ook geleerd hoe we de inhoud van een bestand kunnen weergeven en hoe we de inhoud van een enkel bestand in een jar kunnen weergeven.

Zowel het gewone Java-voorbeeld als het Spring Boot-voorbeeld zijn beschikbaar op GitHub.