Kommandolinjeargumenter i Java

1. Introduksjon

Det er ganske vanlig å kjøre applikasjoner fra kommandolinjen ved hjelp av argumenter. Spesielt på serversiden. Vanligvis vil vi ikke at applikasjonen skal gjøre det samme ved hver løp: vi vil konfigurere atferden på en eller annen måte.

I denne korte opplæringen vil vi utforske hvordan vi kan håndtere kommandolinjeargumenter i Java.

2. Få tilgang til kommandolinjeargumenter i Java

Siden hoved- metoden er inngangspunktet til et Java-program, sender JVM kommandolinjeargumentene gjennom argumentene.

Den tradisjonelle måten er å bruke en String matrise:

public static void main (String [] args) {// håndter argumenter}

Imidlertid introduserte Java 5 varargs, som er arrays i saueklær. Derfor kan vi definere vår hoved- med en String vararg:

public static void main (String ... args) {// håndter argumenter}

De er identiske, og valget mellom dem er helt opp til personlig smak og preferanse.

Metodeparameteren til hoved- metoden inneholder kommandolinjeargumentene i samme rekkefølge som vi sendte ved utførelsen. Hvis vi ønsker å få tilgang til hvor mange argumenter vi fikk, trenger vi bare å sjekke lengde av matrisen.

For eksempel kan vi skrive ut antall argumenter og deres verdi på standardutdata:

public static void main (String [] args) {System.out.println ("Argument count:" + args.length); for (int i = 0; i <args.length; i ++) {System.out.println ("Argument" + i + ":" + args [i]); }}

Merk at på noen språk vil det første argumentet være navnet på applikasjonen. På den annen side, i Java, inneholder denne matrisen bare argumentene.

3. Hvordan passere kommandolinjeargumenter

Nå som vi har et program som håndterer kommandolinjeargumenter, er vi ivrige etter å prøve det. La oss se hvilke alternativer vi har.

3.1. Kommandolinje

Den mest åpenbare måten er kommandolinjen. La oss anta at vi allerede har laget timen com.baeldung.commandlinearguments.CliExample med vår hoved- metode i den.

Deretter kan vi kjøre den med følgende kommando:

java com.baeldung.commandlinearguments.CliExample

Den gir følgende utgang:

Argumentantall: 0

Nå kan vi sende argumenter etter kursnavnet:

java com.baeldung.commandlinearguments.CliExample Hello World!

Og produksjonen er:

Argumentantall: 2 Argument 0: Hei Argument 1: Verden!

Vanligvis publiserer vi søknaden vår som en jar-fil, ikke som en haug med .klasse filer. La oss si, vi pakket den i cli-eksempel.jar, og vi satt com.baeldung.commandlinearguments.CliExample som hovedklasse.

Nå kan vi kjøre det uten argumenter på følgende måte:

java -jar cli-example.jar

Eller med argumenter:

java -jar cli-example.jar Hello World! Argumentantall: 2 Argument 0: Hei Argument 1: Verden!

Noter det Java vil behandle hvert argument vi passerer etter klassenavnet eller jar-filnavnet som argumentene for søknaden vår. Derfor er alt vi passerer før, argumenter for selve JVM.

3.2. Formørkelse

Mens vi jobber med søknaden vår, vil vi sjekke om den fungerer slik vi vil.

I Eclipse kan vi kjøre applikasjoner ved hjelp av løpekonfigurasjoner. For eksempel definerer en kjøringskonfigurasjon hvilken JVM som skal brukes, hva er inngangspunktet, klassestien og så videre. Og selvfølgelig kan vi spesifisere kommandolinjeargumenter.

Den enkleste måten å lage en passende kjøringskonfigurasjon er å høyreklikke på vår hoved- metode, og velg deretter Kjør som> Java-applikasjon fra hurtigmenyen:

Med dette kjører vi applikasjonen vår med innstillinger som respekterer prosjektinnstillingene våre.

For å gi argumenter, bør vi deretter redigere den kjørende konfigurasjonen. Vi kan gjøre det gjennom Kjør> Kjør konfigurasjoner ... menyvalg. Her bør vi klikke på Argumenter kategorien og fyll ut Programargumenter tekstboks:

Treffer Løpe kjører applikasjonen og sender argumentene vi nettopp skrev inn.

3.3. IntelliJ

IntelliJ bruker en lignende prosess for å kjøre applikasjoner. Det kaller disse alternativene bare som konfigurasjoner.

Først må vi høyreklikke på hoved- metode, og velg deretter Kjør ‘CliExample.main ()’:

Dette vil kjøre programmet vårt, men det vil også legge det til Løpe liste for videre konfigurasjon.

Så for å konfigurere argumenter, bør vi velge Kjør> Rediger konfigurasjoner ... og rediger Programargumenter tekstboks:

Etter det bør vi trykke OK og kjøre applikasjonen på nytt, for eksempel med kjør-knappen i verktøylinjen.

3.4. NetBeans

NetBeans faller også i tråd med sine kjøre- og konfigurasjonsprosesser.

Vi bør kjøre søknaden vår først ved å høyreklikke på hoved- metode og valg Kjør fil:

Som før skaper dette en konfigurasjon og kjører programmet.

Deretter må vi konfigurere argumentene i den kjørte konfigurasjonen. Vi kan gjøre det ved å velge Kjør> Angi prosjektkonfigurasjon> Tilpass ... Da burde vi Løpe til venstre og fyll Argumenter tekstfelt:

Etter det skal vi trykke OK og starte applikasjonen.

4. Tredjepartsbiblioteker

Manuell håndtering av kommandolinjeargumentene er grei i enkle scenarier. Når kravene våre blir mer og mer komplekse, blir koden vår også. Derfor, hvis vi ønsker å lage et program med flere kommandolinjealternativer, ville det være lettere å bruke et tredjepartsbibliotek.

Heldigvis er det en mengde av de bibliotekene som støtter de fleste brukssaker. To populære eksempler er Picocli og Spring Shell.

5. Konklusjon

Det er alltid en god ide å gjøre applikasjonens atferd konfigurerbar. I denne artikkelen så vi hvordan du gjør det ved hjelp av kommandolinjeargumenter. I tillegg dekket vi forskjellige måter å formidle disse argumentene på.

Som vanlig er eksemplene tilgjengelige på GitHub.


$config[zx-auto] not found$config[zx-overlay] not found