Befehlszeilenargumente in Java

1. Einleitung

Es ist durchaus üblich, Anwendungen über die Befehlszeile mit Argumenten auszuführen. Besonders auf der Serverseite. Normalerweise möchten wir nicht, dass die Anwendung bei jedem Lauf dasselbe tut: Wir möchten ihr Verhalten auf irgendeine Weise konfigurieren.

In diesem kurzen Tutorial werden wir untersuchen, wie wir mit Befehlszeilenargumenten in Java umgehen können.

2. Zugriff auf Befehlszeilenargumente in Java

Da die Hauptmethode der Einstiegspunkt einer Java-Anwendung ist, übergibt die JVM die Befehlszeilenargumente über ihre Argumente.

Der traditionelle Weg ist die Verwendung eines String- Arrays:

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

In Java 5 wurden jedoch Varargs eingeführt, die Arrays im Schafspelz sind. Daher können wir unser Haupt mit einem String vararg definieren:

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

Sie sind identisch, daher hängt die Wahl zwischen ihnen ganz vom persönlichen Geschmack und den Vorlieben ab.

Die Verfahrensparameter des Hauptverfahrens enthält die Befehlszeilenargumente in der gleichen Reihenfolge wir bei Ausführung übergeben. Wenn wir darauf zugreifen möchten, wie viele Argumente wir erhalten haben, müssen wir nur die Länge des Arrays überprüfen .

Zum Beispiel können wir die Anzahl der Argumente und ihren Wert in der Standardausgabe drucken:

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

Beachten Sie, dass in einigen Sprachen das erste Argument der Name der Anwendung ist. In Java hingegen enthält dieses Array nur die Argumente.

3. Übergeben von Befehlszeilenargumenten

Jetzt, da wir eine Anwendung haben, die Befehlszeilenargumente verarbeitet, möchten wir sie unbedingt ausprobieren. Mal sehen, welche Möglichkeiten wir haben.

3.1. Befehlszeile

Der naheliegendste Weg ist die Kommandozeile. Nehmen wir an, wir haben die Klasse com.baeldung.commandlinearguments.CliExample bereits mit unserer Hauptmethode kompiliert .

Dann können wir es mit dem folgenden Befehl ausführen:

java com.baeldung.commandlinearguments.CliExample

Es wird die folgende Ausgabe erzeugt:

Argument count: 0

Jetzt können wir Argumente nach dem Klassennamen übergeben:

java com.baeldung.commandlinearguments.CliExample Hello World!

Und die Ausgabe ist:

Argument count: 2 Argument 0: Hello Argument 1: World!

Normalerweise veröffentlichen wir unsere Anwendung als JAR-Datei, nicht als Bündel von .class- Dateien. Nehmen wir an, wir haben es in die Datei cli-example.jar gepackt und com.baeldung.commandlinearguments.CliExample als Hauptklasse festgelegt.

Jetzt können wir es ohne Argumente folgendermaßen ausführen:

java -jar cli-example.jar

Oder mit Argumenten:

java -jar cli-example.jar Hello World! Argument count: 2 Argument 0: Hello Argument 1: World!

Beachten Sie, dass Java jedes Argument, das wir nach dem Klassennamen oder dem Namen der JAR-Datei übergeben, als Argumente unserer Anwendung behandelt . Daher sind alles, was wir vorher übergeben, Argumente für die JVM selbst.

3.2. Finsternis

Während wir an unserer Anwendung arbeiten, möchten wir überprüfen, ob sie wie gewünscht funktioniert.

In Eclipse können wir Anwendungen mithilfe von Ausführungskonfigurationen ausführen. Beispielsweise definiert eine Ausführungskonfiguration, welche JVM verwendet werden soll, was der Einstiegspunkt, der Klassenpfad usw. ist. Und natürlich können wir Befehlszeilenargumente angeben.

Der einfachste Weg, eine geeignete Ausführungskonfiguration zu erstellen, besteht darin, mit der rechten Maustaste auf unsere Hauptmethode zu klicken und dann im Kontextmenü Ausführen als> Java-Anwendung zu wählen :

Damit führen wir unsere Anwendung sofort mit Einstellungen aus, die unseren Projekteinstellungen entsprechen.

Um Argumente bereitzustellen, sollten wir dann diese Ausführungskonfiguration bearbeiten. Wir können dies über die Menüoption Ausführen> Konfigurationen ausführen… tun . Hier sollten wir auf die Registerkarte Argumente klicken und das Textfeld Programmargumente ausfüllen :

Wenn Sie auf Ausführen klicken, wird die Anwendung ausgeführt und die gerade eingegebenen Argumente übergeben.

3.3. IntelliJ

IntelliJ verwendet einen ähnlichen Prozess zum Ausführen von Anwendungen. Diese Optionen werden einfach als Konfigurationen aufgerufen.

Zuerst müssen wir mit der rechten Maustaste auf die Hauptmethode klicken und dann 'CliExample.main ()' ausführen wählen :

This will run our program, but it will also add it to the Run list for further configuration.

So, then to configure arguments, we should choose Run > Edit Configurations… and edit the Program arguments textbox:

After that, we should hit OK and rerun our application, for example with the run button in the toolbar.

3.4. NetBeans

NetBeans also falls into line with its running and configuration processes.

We should run our application first by right-clicking on the main method and choosing Run File:

Like before, this creates a run configuration and runs the program.

Next, we have to configure the arguments in that run configuration. We can do that by choosing Run > Set Project Configuration > Customize… Then we should Run on the left and fill the Arguments text field:

After that, we should hit OK and start the application.

4. Third-Party Libraries

Manual handling of the command-line arguments is straightforward in simple scenarios. However, as our requirements become more and more complex, so does our code. Therefore, if we want to create an application with multiple command-line options, it would be easier to use a third-party library.

Fortunately, there're a plethora of those libraries which support most use cases. Two popular examples are Picocli and Spring Shell.

5. Conclusion

Es ist immer eine gute Idee, das Verhalten Ihrer Anwendung konfigurierbar zu machen. In diesem Artikel haben wir gesehen, wie das mit Befehlszeilenargumenten gemacht wird. Darüber hinaus haben wir verschiedene Möglichkeiten zur Übergabe dieser Argumente behandelt.

Wie üblich sind die Beispiele auf GitHub verfügbar.