Veiledning for å lage og kjøre en Jar-fil i Java

1. Oversikt

Vanligvis er det praktisk å pakke mange Java-klassefiler i en enkelt arkivfil.

I denne opplæringen skal vi dekke innsiden og utgangen av å jobbe med krukke - eller Java ARgressløk - filer i Java.

Spesielt vil vi ta en enkel applikasjon og utforske forskjellige måter å pakke og kjøre den som en krukke. Vi vil også svare på noen nysgjerrigheter som hvordan du enkelt leser en jar-manifestfil langs veien.

2. Java-programoppsett

Før vi kan lage en kjørbar jar-fil, må søknaden vår ha en klasse med en hoved- metode. Denne klassen gir vårt inngangspunkt i applikasjonen:

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

3. Jar-kommando

Nå som vi er klar, la oss kompilere koden vår og lage jar-filen vår.

Vi kan gjøre dette med javac fra kommandolinjen:

javac com / baeldung / jar / *. java

De javac kommandoen oppretter JarExample.klasse i com / baeldung / jar katalog. Vi kan nå pakke det inn i en jar-fil.

3.1. Bruke standardinnstillingene

For å lage jar-filen skal vi bruke krukke kommando.

For å bruke krukke kommandoen for å lage en jar-fil, må vi bruke c alternativet for å indikere at vi oppretter en fil og f muligheten til å spesifisere filen:

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

3.2. Sette hovedklassen

Det er nyttig for jar-filmanifestet å inkludere hovedklassen.

Manifestet er en spesiell fil i en krukke som ligger META-INF katalog og navngitt MANIFEST.MF. Manifestfilen inneholder spesiell metainformasjon om filer i jar-filen.

Noen eksempler på hva vi kan bruke en manifestfil til inkluderer å angi inngangspunktet, sette versjonsinformasjon og konfigurere klassestien.

Ved å bruke e alternativet, kan vi spesifisere inngangspunktet vårt og krukke kommandoen vil legge den til den genererte manifestfilen.

La oss løpe krukke med et angitt inngangspunkt:

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

3.3. Oppdatering av innholdet

La oss si at vi har gjort en endring i en av klassene våre og kompilert den på nytt. Nå må vi oppdatere jar-filen vår.

La oss bruke krukke kommando med u mulighet til å oppdatere innholdet:

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

3.4. Angi en manifestfil

I noen tilfeller kan det hende vi må ha mer kontroll over hva som står i manifestfilen vår. De krukke kommando gir funksjonalitet for å gi vår egen manifestinformasjon.

La oss legge til en delvis manifestfil med navnet eksempel_manifest.txt til vår søknad om å angi inngangspunkt:

Hovedklasse: com.baeldung.jar.JarExample

Manifestinformasjonen vi gir, blir lagt til det jar-kommandoen genererer, så det er den eneste linjen vi trenger i filen.

Det er viktig at vi avslutter manifestfilen vår med any linje. Uten den nye linjen blir manifestfilen vår ignorert.

Med det oppsettet, la oss lage glasset vårt igjen ved hjelp av vår manifestinformasjon og m alternativ:

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

3.5. Omfattende produksjon

Hvis vi vil ha mer informasjon ut av krukke kommando, kan vi ganske enkelt legge til v alternativ for verbose.

La oss kjøre vår krukke kommando med v alternativ:

jar cvfm JarExample.jar com / baeldung / jar / example_manifest.txt com / baeldung / jar / *. klasse lagt til manifest og legger til: com / baeldung / jar / JarExample.class (in = 453) (out = 312) (deflated 31% )

4. Bruke Maven

4.1. Standardkonfigurasjon

Vi kan også bruke Maven til å lage glasset vårt. Siden Maven favoriserer konvensjon fremfor konfigurasjon, kan vi bare kjøre pakken for å lage jar-filen vår.

mvn-pakke

Som standard blir jar-filen vår lagt til mål mappen i prosjektet vårt.

4.2. Angir hovedklassen

Vi kan også konfigurere Maven til å spesifisere hovedklassen og opprette en kjørbar jar-fil.

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

5. Bruke vårstøvel

5.1. Bruke Maven og standardinnstillinger

Hvis vi bruker Spring Boot med Maven, bør vi først bekrefte at innpakningsinnstillingen vår er satt til krukke heller enn krig i vår pom.xml fil.

4.0.0 spring-boot jar spring-boot

Når vi vet at det er konfigurert, kan vi kjøre pakke mål:

mvn-pakke

5.2. Stille inn inngangspunktet

Å sette hovedklassen vår er der vi finner forskjeller mellom å lage en krukke med en vanlig Java-applikasjon og en fettkrukke for en Spring Boot-applikasjon. I en Spring Boot-applikasjon er hovedklassen faktisk org.springframework.boot.loader.JarLauncher.

Selv om eksemplet vårt ikke er et Spring Boot-program, kan vi enkelt sette det opp til å være et Spring Boot-konsollprogram.

Hovedklassen vår bør spesifiseres som startklassen:

 com.baeldung.jar.JarExample 

Vi kan også bruke Gradle til å lage en Spring Boot fettkrukke.

6. Kjører krukken

Nå som vi har fått jar-filen vår, kan vi kjøre den. Vi kjører jar-filer ved hjelp av java kommando.

6.1. Utleder hovedklassen

Siden vi har gått foran og sørget for at hovedklassen er spesifisert i manifestet, vi kan bruke -krukke alternativet til java kommando for å kjøre applikasjonen vår uten å spesifisere hovedklassen:

java -jar JarExample.jar

6.2. Spesifisering av hovedklasse

Vi kan også spesifisere hovedklassen når vi kjører applikasjonen vår. Vi kan bruke -cp alternativet for å sikre at jar-filen vår er i klassestien og deretter gi vår hovedklasse i package.className format:

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

Å bruke baneseparatorer i stedet for pakkeformat fungerer også:

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

6.3. Oppføring av innholdet i en krukke

Vi kan bruke krukke kommando for å liste innholdet i jar-filen vår:

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

6.4. Vise manifestfilen

Siden det kan være viktig å vite hva som ligger i vårt MANIFEST.MF fil, la oss se på en rask og enkel måte vi kan se på innholdet uten å forlate kommandolinjen.

La oss bruke pakke ut kommando med alternativet -p:

unzip -p JarExample.jar META-INF / MANIFEST.MF Manifest-versjon: 1.0 Laget av: 1.8.0_31 (Oracle Corporation) Hovedklasse: com.baeldung.jar.JarExample

7. Konklusjon

I denne opplæringen setter vi opp en enkel Java-applikasjon med en hoved- klasse.

Så så vi på tre måter å lage jar-filer på: ved hjelp av krukke kommando, med Maven og med en Maven Spring Boot-applikasjon.

Etter at vi opprettet jar-filene våre, kom vi tilbake til kommandolinjen og kjørte dem med en avledet og en spesifisert hovedklasse.

Vi lærte også hvordan du viser innholdet i en fil og hvordan du viser innholdet i en enkelt fil i en krukke.

Både det vanlige Java-eksemplet og Spring Boot-eksemplet er tilgjengelig på GitHub.