Opdrachtregelargumenten in Java

1. Inleiding

Het is vrij gebruikelijk om applicaties vanaf de opdrachtregel uit te voeren met argumenten. Vooral aan de serverkant. Meestal willen we niet dat de applicatie bij elke run hetzelfde doet: we willen zijn gedrag op een of andere manier configureren.

In deze korte tutorial zullen we onderzoeken hoe we met opdrachtregelargumenten in Java kunnen omgaan.

2. Toegang tot opdrachtregelargumenten in Java

Sinds de hoofd methode is het startpunt van een Java-applicatie, de JVM geeft de opdrachtregelargumenten door zijn argumenten.

De traditionele manier is om een Draad matrix:

public static void main (String [] args) {// handle arguments}

Java 5 introduceerde echter varargs, dit zijn arrays in schaapskleren. Daarom kunnen we onze definiëren hoofd met een Draad vararg:

public static void main (String ... args) {// handle arguments}

Ze zijn identiek, daarom is de keuze tussen hen geheel aan uw persoonlijke smaak en voorkeur.

De method parameter van het hoofd methode bevat de opdrachtregelargumenten in dezelfde volgorde die we bij de uitvoering hebben doorgegeven. Als we willen zien hoeveel argumenten we hebben gekregen, hoeven we alleen de lengte van de array.

We kunnen bijvoorbeeld het aantal argumenten en hun waarde afdrukken op de standaarduitvoer:

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 op dat in sommige talen het eerste argument de naam van de toepassing is. Aan de andere kant bevat deze array in Java alleen de argumenten.

3. Hoe u opdrachtregelargumenten kunt doorgeven

Nu we een applicatie hebben die opdrachtregelargumenten afhandelt, willen we het graag proberen. Laten we eens kijken welke opties we hebben.

3.1. Opdrachtregel

De meest voor de hand liggende manier is de opdrachtregel. Laten we aannemen dat we de klas al hebben samengesteld com.baeldung.commandlinearguments.CliExample met onze hoofd methode erin.

Dan kunnen we het uitvoeren met het volgende commando:

java com.baeldung.commandlinearguments.CliExample

Het produceert de volgende output:

Aantal argumenten: 0

Nu kunnen we argumenten doorgeven achter de klassenaam:

java com.baeldung.commandlinearguments.CliExample Hallo wereld!

En de output is:

Aantal argumenten: 2 Argument 0: Hallo Argument 1: Wereld!

Meestal publiceren we onze applicatie als een jar-bestand, niet als een hoop .klasse bestanden. Laten we zeggen dat we het hebben verpakt in de cli-voorbeeld.jar, en we gaan com.baeldung.commandlinearguments.CliExample als de hoofdklasse.

Nu kunnen we het zonder argumenten op de volgende manier uitvoeren:

java -jar cli-example.jar

Of met argumenten:

java -jar cli-example.jar Hallo wereld! Aantal argumenten: 2 Argument 0: Hallo Argument 1: Wereld!

Let daar op Java behandelt elk argument dat we doorgeven na de klassenaam of de jar-bestandsnaam als de argumenten van onze applicatie. Daarom zijn alles wat we eerder passeren argumenten voor de JVM zelf.

3.2. Verduistering

Terwijl we aan onze applicatie werken, willen we controleren of deze werkt zoals we willen.

In Eclipse kunnen we applicaties draaien met behulp van run-configuraties. Een uitvoeringsconfiguratie bepaalt bijvoorbeeld welke JVM moet worden gebruikt, wat het toegangspunt is, het klassenpad, enzovoort. En natuurlijk kunnen we opdrachtregelargumenten specificeren.

De eenvoudigste manier om een ​​geschikte uitvoeringsconfiguratie te maken, is door met de rechtermuisknop op onze te klikken hoofd methode en kies vervolgens Uitvoeren als> Java-applicatie vanuit het contextmenu:

Hiermee voeren we onze applicatie onmiddellijk uit met instellingen die voldoen aan onze projectinstellingen.

Om argumenten te geven, moeten we die run-configuratie bewerken. We kunnen het doen via de Uitvoeren> Configuraties uitvoeren ... menuoptie. Hier moeten we op het Argumenten tabblad en vul het Programma-argumenten tekstvak:

Slaan Rennen zal de applicatie uitvoeren en de argumenten doorgeven die we zojuist hebben ingevoerd.

3.3. IntelliJ

IntelliJ gebruikt een soortgelijk proces om applicaties uit te voeren. Het noemt deze opties eenvoudigweg als configuraties.

Eerst moeten we met de rechtermuisknop op het hoofd methode en kies vervolgens Voer ‘CliExample.main () 'uit:

Dit zal ons programma uitvoeren, maar het zal het ook toevoegen aan het Rennen lijst voor verdere configuratie.

Dus om argumenten te configureren, moeten we kiezen Uitvoeren> Configuraties bewerken ... en bewerk het Programma-argumenten tekstvak:

Daarna moeten we op OK drukken en onze applicatie opnieuw starten, bijvoorbeeld met de knop Uitvoeren in de werkbalk.

3.4. NetBeans

NetBeans past ook in de lopende en configuratieprocessen.

We moeten onze applicatie eerst starten door met de rechtermuisknop op het hoofd methode en kiezen Bestand uitvoeren:

Net als voorheen creëert dit een run-configuratie en wordt het programma uitgevoerd.

Vervolgens moeten we de argumenten in die run-configuratie configureren. Dat kunnen we doen door te kiezen Uitvoeren> Projectconfiguratie instellen> Aanpassen ... Dan zouden we moeten Rennen aan de linkerkant en vul het Argumenten tekstveld:

Daarna zouden we op OK moeten drukken en de applicatie moeten starten.

4. Bibliotheken van derden

Handmatige afhandeling van de opdrachtregelargumenten is eenvoudig in eenvoudige scenario's. Naarmate onze vereisten echter steeds complexer worden, geldt dat ook voor onze code. Daarom, als we een applicatie met meerdere opdrachtregelopties willen maken, is het gemakkelijker om een ​​bibliotheek van derden te gebruiken.

Gelukkig is er een overvloed aan bibliotheken die de meeste gebruiksscenario's ondersteunen. Twee populaire voorbeelden zijn Picocli en Spring Shell.

5. Conclusie

Het is altijd een goed idee om het gedrag van uw toepassing configureerbaar te maken. In dit artikel hebben we gezien hoe je dat doet met opdrachtregelargumenten. Bovendien hebben we verschillende manieren besproken om die argumenten door te geven.

Zoals gewoonlijk zijn de voorbeelden beschikbaar op GitHub.