streamalism.org

1. Introduktion

Det er ret almindeligt at køre applikationer fra kommandolinjen ved hjælp af argumenter. Især på serversiden. Normalt ønsker vi ikke, at applikationen skal gøre det samme ved hver kørsel: vi vil konfigurere dens adfærd på en eller anden måde.

I denne korte vejledning undersøger vi, hvordan vi kan håndtere kommandolinjeargumenter i Java.

2. Adgang til kommandolinjeargumenter i Java

Siden den vigtigste metode er indgangspunktet for en Java-applikation, JVM sender kommandolinjeargumenterne gennem sine argumenter.

Den traditionelle måde er at bruge en Snor matrix:

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

Men Java 5 introducerede varargs, som er arrays i fåretøj. Derfor kan vi definere vores vigtigste med en Snor vararg:

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

De er identiske, og det er derfor helt op til personlig smag og præference at vælge mellem dem.

Metodeparameteren for vigtigste metode indeholder kommandolinjeargumenterne i samme rækkefølge, som vi sendte ved udførelsen. Hvis vi ønsker at få adgang til, hvor mange argumenter vi fik, behøver vi kun kontrollere længde af arrayet.

For eksempel kan vi udskrive antallet af argumenter og deres værdi på standardoutputtet:

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]); }}

Bemærk, at på nogle sprog vil det første argument være navnet på applikationen. På den anden side, i Java, indeholder denne matrix kun argumenterne.

3. Sådan overføres kommandolinjeargumenter

Nu hvor vi har et program, der håndterer kommandolinjeargumenter, er vi ivrige efter at prøve det. Lad os se, hvilke muligheder vi har.

3.1. Kommandolinje

Den mest oplagte måde er kommandolinjen. Lad os antage, at vi allerede har samlet klassen com.baeldung.commandlinearguments.CliExample med vores vigtigste metode i det.

Derefter kan vi køre det med følgende kommando:

java com.baeldung.commandlinearguments.CliExample

Det producerer følgende output:

Argumentantal: 0

Nu kan vi sende argumenter efter klassens navn:

java com.baeldung.commandlinearguments.CliExample Hello World!

Og output er:

Argumentantal: 2 Argument 0: Hej Argument 1: Verden!

Normalt offentliggør vi vores ansøgning som en jar-fil, ikke som en flok .klasse filer. Lad os sige, vi pakket det i cli-eksempel.jar, og vi satte os com.baeldung.commandlinearguments.CliExample som hovedklasse.

Nu kan vi køre det uden argumenter på følgende måde:

java -jar cli-eksempel.jar

Eller med argumenter:

java -jar cli-example.jar Hej Verden! Argumentantal: 2 Argument 0: Hej Argument 1: Verden!

Noter det Java behandler hvert argument, vi sender efter klassens navn eller jar-filnavnet, som argumenterne for vores applikation. Derfor er alt, hvad vi sender før, argumenter for selve JVM.

3.2. Formørkelse

Mens vi arbejder på vores ansøgning, vil vi kontrollere, om det fungerer, som vi ønsker.

I Eclipse kan vi køre applikationer ved hjælp af kørekonfigurationer. For eksempel definerer en kørselskonfiguration, hvilken JVM der skal bruges, hvad der er indgangspunktet, klassestien osv. Og selvfølgelig kan vi specificere kommandolinjeargumenter.

Den nemmeste måde at oprette en passende kørselskonfiguration på er at højreklikke på vores vigtigste metode, og vælg derefter Kør som> Java-applikation fra genvejsmenuen:

Med dette kører vi øjeblikkeligt vores applikation med indstillinger, der respekterer vores projektindstillinger.

For at give argumenter skal vi derefter redigere den kørende konfiguration. Vi kan gøre det gennem Kør> Kør konfigurationer ... menupunkt. Her skal vi klikke på Argumenter fanen og udfyld Programargumenter tekstboks:

At ramme Løb kører applikationen og videregiver de argumenter, vi lige har indtastet.

3.3. IntelliJ

IntelliJ bruger en lignende proces til at køre applikationer. Det kalder disse muligheder simpelthen som konfigurationer.

Først skal vi højreklikke på vigtigste metode, og vælg derefter Kør 'CliExample.main ()':

Dette vil køre vores program, men det vil også føje det til Løb liste til yderligere konfiguration.

Så for at konfigurere argumenter skal vi vælge Kør> Rediger konfigurationer ... og rediger Programargumenter tekstboks:

Derefter skal vi trykke OK og køre vores applikation igen, for eksempel med køreknappen i værktøjslinjen.

3.4. NetBeans

NetBeans falder også i tråd med sine kørsels- og konfigurationsprocesser.

Vi skal køre vores ansøgning først ved at højreklikke på vigtigste metode og valg Kør fil:

Som før skaber dette en kørselskonfiguration og kører programmet.

Dernæst skal vi konfigurere argumenterne i den kørende konfiguration. Vi kan gøre det ved at vælge Kør> Indstil projektkonfiguration> Tilpas ... Så skulle vi Løb til venstre og udfyld Argumenter tekstfelt:

Derefter skal vi trykke OK og starte applikationen.

4. Tredjepartsbiblioteker

Manuel håndtering af kommandolinjeargumenterne er ligetil i enkle scenarier. Men da vores krav bliver mere og mere komplekse, gør vores kode det også. Derfor, hvis vi vil oprette en applikation med flere kommandolinjemuligheder, ville det være lettere at bruge et tredjepartsbibliotek.

Heldigvis er der en overflod af de biblioteker, der understøtter de fleste brugssager. To populære eksempler er Picocli og Spring Shell.

5. Konklusion

Det er altid en god ide at gøre din applikations opførsel konfigurerbar. I denne artikel så vi, hvordan man gør det ved hjælp af kommandolinjeargumenter. Derudover dækkede vi forskellige måder at føre disse argumenter på.

Som sædvanligt er eksemplerne tilgængelige på GitHub.