Arguments de ligne de commande en Java

1. Introduction

Il est assez courant d'exécuter des applications à partir de la ligne de commande en utilisant des arguments. Surtout côté serveur. Habituellement, nous ne voulons pas que l'application fasse la même chose à chaque exécution: nous voulons configurer son comportement d'une manière ou d'une autre.

Dans ce court didacticiel, nous allons explorer comment gérer les arguments de ligne de commande en Java.

2. Accès aux arguments de ligne de commande en Java

La méthode principale étant le point d'entrée d'une application Java, la JVM transmet les arguments de ligne de commande via ses arguments.

La méthode traditionnelle consiste à utiliser un tableau String :

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

Cependant, Java 5 a introduit les varargs, qui sont des tableaux en vêtements de mouton. Par conséquent, nous pouvons définir notre main avec un vararg String :

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

Ils sont identiques, donc le choix entre eux dépend entièrement des goûts et des préférences personnels.

Le paramètre method de la méthode main contient les arguments de ligne de commande dans le même ordre que nous avons passé lors de l'exécution. Si nous voulons accéder à la quantité d'arguments que nous avons obtenue, nous n'avons qu'à vérifier la longueur du tableau.

Par exemple, nous pouvons imprimer le nombre d'arguments et leur valeur sur la sortie standard:

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

Notez que dans certaines langues, le premier argument sera le nom de l'application. En revanche, en Java, ce tableau ne contient que les arguments.

3. Comment transmettre des arguments de ligne de commande

Maintenant que nous avons une application qui gère les arguments de ligne de commande, nous sommes impatients de l'essayer. Voyons quelles options nous avons.

3.1. Ligne de commande

Le moyen le plus évident est la ligne de commande. Supposons que nous ayons déjà compilé la classe com.baeldung.commandlinearguments.CliExample avec notre méthode main .

Ensuite, nous pouvons l'exécuter avec la commande suivante:

java com.baeldung.commandlinearguments.CliExample

Il produit la sortie suivante:

Argument count: 0

Maintenant, nous pouvons passer des arguments après le nom de la classe:

java com.baeldung.commandlinearguments.CliExample Hello World!

Et le résultat est:

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

Habituellement, nous publions notre application sous forme de fichier jar, et non sous forme de fichiers .class . Disons que nous l'avons empaqueté dans cli-example.jar et que nous avons défini com.baeldung.commandlinearguments.CliExample comme classe principale.

Maintenant, nous pouvons l'exécuter sans arguments de la manière suivante:

java -jar cli-example.jar

Ou avec des arguments:

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

Notez que Java traitera chaque argument que nous passons après le nom de la classe ou le nom du fichier jar comme les arguments de notre application . Par conséquent, tout ce que nous passons avant ce sont des arguments pour la JVM elle-même.

3.2. Éclipse

Pendant que nous travaillons sur notre application, nous voudrons vérifier si cela fonctionne comme nous le souhaitons.

Dans Eclipse, nous pouvons exécuter des applications à l'aide de configurations d'exécution. Par exemple, une configuration d'exécution définit la JVM à utiliser, quel est le point d'entrée, le chemin d'accès aux classes, etc. Et bien sûr, nous pouvons spécifier des arguments de ligne de commande.

Le moyen le plus simple de créer une configuration d'exécution appropriée est de cliquer avec le bouton droit sur notre méthode principale , puis de choisir Exécuter en tant que> Application Java dans le menu contextuel:

Avec cela, nous exécutons instantanément notre application avec des paramètres qui respectent les paramètres de notre projet.

Pour fournir des arguments, nous devons ensuite éditer cette configuration d'exécution. Nous pouvons le faire via l' option de menu Exécuter> Exécuter les configurations… . Ici, nous devons cliquer sur l' onglet Arguments et remplir la zone de texte Arguments du programme :

Appuyer sur Exécuter exécutera l'application et transmettra les arguments que nous venons d'entrer.

3.3. IntelliJ

IntelliJ utilise un processus similaire pour exécuter des applications. Il appelle ces options simplement comme des configurations.

Tout d'abord, nous devons faire un clic droit sur la méthode principale , puis choisir Exécuter 'CliExample.main ()':

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

C'est toujours une bonne idée de rendre le comportement de votre application configurable. Dans cet article, nous avons vu comment faire cela en utilisant des arguments de ligne de commande. De plus, nous avons abordé différentes manières de transmettre ces arguments.

Comme d'habitude, les exemples sont disponibles à l'adresse over sur GitHub.