Passer des arguments de ligne de commande dans Gradle

1. Vue d'ensemble

Parfois, nous voulons exécuter divers programmes à partir de Gradle qui nécessitent des paramètres d'entrée.

Dans ce tutoriel rapide, nous allons voir comment passer des arguments de ligne de commande à partir de Gradle.

2. Types d'arguments d'entrée

Lorsque nous voulons passer des arguments d'entrée à partir de la CLI Gradle, nous avons deux choix:

  • définition des propriétés système avec l' indicateur -D
  • définition des propriétés du projet avec l' indicateur -P

En général, nous devons utiliser les propriétés du projet, sauf si nous voulons personnaliser les paramètres dans la JVM .

Bien qu'il soit possible de détourner les propriétés du système pour transmettre nos entrées, nous devons éviter de le faire.

Voyons ces propriétés en action. Tout d'abord, nous configurons notre build.gradle :

apply plugin: "java" description = "Gradle Command Line Arguments examples" task propertyTypes(){ doLast{ if (project.hasProperty("args")) { println "Our input argument with project property ["+project.getProperty("args")+"]" } println "Our input argument with system property ["+System.getProperty("args")+"]" } } 

Notez que nous les lisons différemment dans notre tâche.

Nous faisons cela parce que projet. getProperty () lève une MissingPropertyException au cas où notre propriété ne serait pas définie .

Contrairement aux propriétés du projet, System.getProperty () renvoie une valeur nulle au cas où la propriété ne serait pas définie.

Ensuite, exécutons la tâche et voyons sa sortie:

$ ./gradlew propertyTypes -Dargs=lorem -Pargs=ipsum > Task :cmd-line-args:propertyTypes Our input argument with project property [ipsum] Our input argument with system property [lorem] 

3. Passer des arguments de ligne de commande

Jusqu'à présent, nous avons vu comment lire les propriétés. En pratique, nous devons envoyer ces propriétés comme arguments à notre programme de choix.

3.1. Passer des arguments aux applications Java

Dans un didacticiel précédent, nous avons expliqué comment exécuter les classes principales Java à partir de Gradle. Construisons sur cela et voyons comment nous pouvons également transmettre des arguments.

Tout d'abord, utilisons le plugin d'application dans notre build.gradle :

apply plugin: "java" apply plugin: "application" description = "Gradle Command Line Arguments examples" // previous declarations ext.javaMain application { mainClassName = javaMainClass } 

Maintenant, jetons un coup d'œil à notre classe principale:

public class MainClass { public static void main(String[] args) { System.out.println("Gradle command line arguments example"); for (String arg : args) { System.out.println("Got argument [" + arg + "]"); } } } 

Ensuite, exécutons-le avec quelques arguments:

$ ./gradlew :cmd-line-args:run --args="lorem ipsum dolor" > Task :cmd-line-args:run Gradle command line arguments example Got argument [lorem] Got argument [ipsum] Got argument [dolor]

Ici, nous n'utilisons pas de propriétés pour passer des arguments. À la place, nous passons l' indicateur –args et les entrées correspondantes .

C'est un joli wrapper fourni par le plugin d'application. Cependant, ceci n'est disponible qu'à partir de Gradle 4.9 .

Voyons à quoi cela ressemblerait en utilisant une tâche JavaExec .

Tout d'abord, nous devons le définir dans notre build.gradle :

ext.javaMain if (project.hasProperty("args")) { ext.cmdargs = project.getProperty("args") } else { ext.cmdargs = "" } task cmdLineJavaExec(type: JavaExec) { group = "Execution" description = "Run the main class with JavaExecTask" classpath = sourceSets.main.runtimeClasspath main = javaMainClass args cmdargs.split() } 

Regardons de plus près ce que nous avons fait. Nous lisons d' abord les arguments d'une propriété de projet .

Comme il contient tous les arguments sous la forme d'une chaîne, nous utilisons ensuite la méthode split pour obtenir un tableau d'arguments .

Ensuite, nous passons ce tableau à la propriété args de notre tâche JavaExec .

Voyons ce qui se passe lorsque nous exécutons cette tâche, en passant les propriétés du projet avec l' option -P :

$ ./gradlew cmdLineJavaExec -Pargs="lorem ipsum dolor" > Task :cmd-line-args:cmdLineJavaExec Gradle command line arguments example Got argument [lorem] Got argument [ipsum] Got argument [dolor] 

3.2. Passer des arguments à d'autres applications

Dans certains cas, nous pouvons souhaiter transmettre certains arguments à une application tierce depuis Gradle.

Heureusement, nous pouvons utiliser la tâche Exec plus générique pour ce faire:

if (project.hasProperty("args")) { ext.cmdargs = project.getProperty("args") } else { ext.cmdargs = "ls" } task cmdLineExec(type: Exec) { group = "Execution" description = "Run an external program with ExecTask" commandLine cmdargs.split() } 

Ici, nous utilisons la propriété commandLine de la tâche pour transmettre l'exécutable avec tous les arguments . Encore une fois, nous divisons l'entrée en fonction d'espaces.

Voyons comment exécuter ceci pour la commande ls :

$ ./gradlew cmdLineExec -Pargs="ls -ll" > Task :cmd-line-args:cmdLineExec total 4 drwxr-xr-x 1 user 1049089 0 Sep 1 17:59 bin drwxr-xr-x 1 user 1049089 0 Sep 1 18:30 build -rw-r--r-- 1 user 1049089 1016 Sep 3 15:32 build.gradle drwxr-xr-x 1 user 1049089 0 Sep 1 17:52 src

Cela peut être très utile si nous ne voulons pas coder en dur l'exécutable dans la tâche.

4. Conclusion

Dans ce tutoriel rapide, nous avons vu comment passer des arguments d'entrée à partir de Gradle.

Tout d'abord, nous avons expliqué les types de propriétés que nous pouvons utiliser. Bien que nous puissions utiliser les propriétés système pour passer des arguments d'entrée, nous devrions préférer les propriétés du projet à la place.

Ensuite, nous avons exploré différentes approches pour transmettre des arguments de ligne de commande à Java ou à des applications externes.

Comme d'habitude, le code complet peut être trouvé sur GitHub.