Arguments de ligne de commande en Java

Introduction

Il est assez courant d’exécuter des applications depuis la ligne de commande en utilisant des arguments. En particulier du côté du 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 tutoriel, nous allons explorer comment pouvons-nous gérer les arguments de ligne de commande en Java.

Accéder aux arguments de ligne de commande en Java

Puisque la méthode main est le point d’entrée d’une application Java, la JVM transmet les arguments de ligne de commande par le biais de ses arguments.

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

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

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

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

Ils sont identiques, donc choisir entre les deux est entièrement une question de goût et de préférence personnels.

Le paramètre de la méthode main contient les arguments de la ligne de commande dans le même ordre que nous avons passé à l’exécution. Si nous voulons accéder au nombre d’arguments obtenus, il nous suffit de 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); }}

Notez que dans certains langages, le premier argument sera le nom de l’application. Par contre, en Java, ce tableau ne contient que les arguments.

Comment passer les arguments de la ligne de commande

Maintenant que nous avons une application qui gère les arguments de la 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 principale dedans.

Alors nous pouvons l’exécuter avec la commande suivante:

java com.baeldung.commandlinearguments.CliExample

Elle 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 la sortie est:

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

En général, nous publions notre application sous la forme d’un fichier jar, et non d’un ensemble de fichiers .class. Disons que nous l’avons empaquetée dans le fichier 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 cela sont des arguments pour la JVM elle-même.

3.2. Eclipse

Pendant que nous travaillons sur notre application, nous voudrons vérifier si elle 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 quelle JVM utiliser, quel est le point d’entrée, le classpath, et ainsi de suite. Et bien sûr, nous pouvons spécifier des arguments de ligne de commande.

La façon la plus simple de créer une configuration d’exécution appropriée est de faire un clic droit sur notre méthode principale, puis de choisir Exécuter comme > application Java dans le menu contextuel :

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

Pour fournir des arguments, nous devons ensuite modifier cette configuration d’exécution. Nous pouvons le faire à travers l’option de menu Exécuter > Configurations d’exécution…. Ici, nous devrions cliquer sur l’onglet Arguments et remplir la zone de texte Arguments du programme :

L’appui sur Run exécutera l’application et passera les arguments que nous venons de saisir.

3.3. IntelliJ

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

D’abord, nous devons faire un clic droit sur la méthode main, puis choisir Exécuter ‘CliExample.main()’:

Ceci exécutera notre programme, mais l’ajoutera également à la liste d’exécution pour une configuration ultérieure.

Alors, pour configurer les arguments, nous devrions choisir Exécuter > Modifier les configurations… et modifier la zone de texte Arguments du programme :

Après cela, nous devrions appuyer sur OK et réexécuter notre application, par exemple avec le bouton Exécuter de la barre d’outils.

3.4. NetBeans

NetBeans s’aligne également sur ses processus d’exécution et de configuration.

Nous devrions d’abord exécuter notre application en cliquant avec le bouton droit de la souris sur la méthode principale et en choisissant Run File :

Comme précédemment, cela crée une configuration d’exécution et exécute le programme.

Puis, nous devons configurer les arguments dans cette configuration d’exécution. Nous pouvons le faire en choisissant Exécuter > Définir la configuration du projet > Personnaliser… Ensuite, nous devrions Exécuter à gauche et remplir le champ de texte Arguments :

Après cela, nous devrions appuyer sur OK et démarrer l’application.

Librairies tierces

La manipulation manuelle des arguments de la ligne de commande est directe dans les scénarios simples. Cependant, à mesure que nos exigences deviennent de plus en plus complexes, notre code le devient aussi. Par conséquent, si nous voulons créer une application avec plusieurs options de ligne de commande, il serait plus facile d’utiliser une bibliothèque tierce.

Heureusement, il existe une pléthore de ces bibliothèques qui prennent en charge la plupart des cas d’utilisation. Deux exemples populaires sont Picocli et Spring Shell.

Conclusion

C’est toujours une bonne idée de rendre le comportement de votre application configurable. Dans cet article, nous avons vu comment le faire en utilisant des arguments de ligne de commande. De plus, nous avons couvert différentes façons de passer ces arguments.

Comme d’habitude, les exemples sont disponibles sur GitHub.

.