streamalism.org

1. Oversikt

Vanligvis inneholder alle meningsfylte applikasjoner en eller flere JAR-filer som avhengigheter. Imidlertid er det noen ganger en JAR-fil i seg selv representerer et frittstående program eller en webapplikasjon.

Vi vil fokusere på det frittstående applikasjonsscenariet i denne artikkelen. Heretter vil vi referere til det som en JAR-applikasjon.

I denne opplæringen vil vi først lære hvordan du lager en JAR-applikasjon. Senere lærer vi hvordan kjør et JAR-program med eller uten kommandolinjeargumenter.

2. Opprett en KRUKKE applikasjon

En JAR-fil kan inneholde en eller flere hovedklasser. Hver hovedklasse er inngangspunktet for en applikasjon. Så teoretisk sett kan en JAR-fil inneholde mer enn ett program, men det må inneholde minst én hovedklasse for å kunne kjøre.

En JAR-fil kan ha ett inngangspunkt angitt i manifestfilen. I dette tilfellet er JAR-filen en kjørbar JAR. Hovedklassen må inkluderes i den JAR-filen.

Først av alt, la oss se et raskt eksempel på hvordan vi kan kompilere klassene våre og lage en kjørbar JAR med en manifestfil:

$ javac com / baeldung / jarArguments / *. java $ jar cfm JarExample.jar ../resources/example_manifest.txt com / baeldung / jarArguments / *. class

En ikke-kjørbar JAR er ganske enkelt en JAR-fil som ikke har en Hovedklasse definert i manifestfilen. Som vi får se senere, kan vi fremdeles kjøre en hovedklasse som finnes i selve JAR-filen.

Slik oppretter vi en ikke-kjørbar JAR uten en manifestfil:

$ jar cf JarExample2.jar com / baeldung / jarArguments / *. class

3. Java-kommandolinjeargumenter

Akkurat som alle applikasjoner, godtar et JAR-program et hvilket som helst antall argumenter, inkludert null argumenter. Alt avhenger av applikasjonens behov.

Dette lar brukeren spesifiser konfigurasjonsinformasjon når applikasjonen startes.

Som et resultat kan applikasjonen unngå hardkodede verdier, og den kan fortsatt håndtere mange forskjellige bruksområder.

Et argument kan inneholde hvilke som helst alfanumeriske tegn, unicode-tegn og muligens noen spesialtegn som er tillatt av skallet, for eksempel ‘@’.

Argumenter er atskilt med ett eller flere mellomrom. Hvis et argument må inneholde mellomrom, må mellomrommene være lukket mellom anførselstegn. Enten enkle sitater eller doble anførselstegn fungerer fint.

Vanligvis, for et typisk Java-program, når brukeren påkaller applikasjonen, skriver brukeren kommandolinjeargumenter etter navnet på klassen.

Imidlertid er det ikke alltid tilfelle for JAR-applikasjoner.

Som vi allerede har diskutert, er inngangspunktet til en Java-hovedklasse hovedmetoden. De argumenter er alt Strings og blir overført til hovedmetoden som en String array.

Når det er sagt, i applikasjonen kan vi konvertere alle elementer i String array til andre datatyper, for eksempel røye, int, dobbelt, deres innpakningsklasser, eller andre passende typer.

4. Kjør en kjørbar KRUKKE med argumenter

La oss se den grunnleggende syntaksen for å kjøre en kjørbar JAR-fil med argumenter:

java -jar jar-file-name [args ...]

Den kjørbare JAR opprettet tidligere er et enkelt program som bare skriver ut argumentene som er sendt inn. Vi kan kjøre det med et hvilket som helst antall argumenter. Nedenfor er et eksempel med to argumenter:

$ java -jar JarExample.jar "arg 1" [e-postbeskyttet] 

Vi ser følgende utdata i konsollen:

Hei Baeldung Reader i JarExample! Det er 2 argument (er)! Argument (1): arg 1 Argument (2): [e-postbeskyttet] 

Så, når vi påkaller en kjørbar JAR, trenger vi ikke å spesifisere hovedklassenavnet på kommandolinjen. Vi legger ganske enkelt til argumentene våre etter JAR-filnavnet. Hvis vi gir et klassenavn etter det kjørbare JAR-filnavnet, blir det ganske enkelt det første argumentet til den faktiske hovedklassen.

De fleste ganger er en JAR-applikasjon en kjørbar JAR. En kjørbar JAR kan ha maksimalt én hovedklasse definert i manifestfilen.

Følgelig kan andre applikasjoner i den samme kjørbare JAR-filen ikke settes i manifestfilen, men vi kan fortsatt kjøre dem fra kommandolinjen akkurat som for en JAR som ikke kan kjøres. Vi får se nøyaktig hvordan i neste avsnitt.

5. Kjør en ikke-kjørbar KRUKKE med argumenter

For å kjøre et program i en ikke-kjørbar JAR-fil, må vi bruke -cp alternativet i stedet for -krukke. Vi bruker -cp alternativ (forkortelse for classpath) for å spesifisere JAR-filen som inneholder klassefilen vi vil utføre:

java -cp jar-file-name main-class-name [args…]

Som du kan se, i dette tilfellet må vi inkludere hovedklassenavnet i kommandolinjen, etterfulgt av argumenter.

Den ikke-kjørbare JARen som ble opprettet tidligere, inneholder den samme enkle applikasjonen. Vi kan kjøre den med alle (inkludert null) argumenter. Her er et eksempel med to argumenter:

$ java -cp JarExample2.jar com.baeldung.jarArguments.JarExample "arg 1" [e-postbeskyttet]

Og akkurat som vi så ovenfor, ser vi følgende utdata:

Hei Baeldung Reader i JarExample! Det er 2 argument (er)! Argument (1): arg 1 Argument (2): [e-postbeskyttet]

6. Konklusjon

I denne opplæringen lærte vi to måter å kjøre et JAR-program på kommandolinjen med eller uten argumenter.

Vi demonstrerte også at et argument kan inneholde mellomrom og spesialtegn (når skallet tillater det).

Som alltid er koden for eksemplene tilgjengelig på GitHub.