Passaggio di argomenti della riga di comando in Gradle

1. Panoramica

A volte, vogliamo eseguire vari programmi da Gradle che richiedono parametri di input.

In questo rapido tutorial, vedremo come passare gli argomenti della riga di comando da Gradle.

2. Tipi di argomenti di input

Quando vogliamo passare argomenti di input dalla CLI Gradle, abbiamo due scelte:

  • impostando le proprietà di sistema con il flag -D
  • impostando le proprietà del progetto con il flag -P

In generale, dovremmo usare le proprietà del progetto a meno che non desideriamo personalizzare le impostazioni nella JVM .

Sebbene sia possibile dirottare le proprietà di sistema per passare i nostri input, dovremmo evitare di farlo.

Vediamo queste proprietà in azione. Per prima cosa, configuriamo il nostro 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")+"]" } } 

Notare che li leggiamo in modo diverso nel nostro compito.

Lo facciamo perché project. getProperty () genera un'eccezione MissingPropertyException nel caso in cui la nostra proprietà non sia definita .

A differenza delle proprietà del progetto, System.getProperty () restituisce un valore null nel caso in cui la proprietà non sia definita.

Quindi, eseguiamo l'attività e vediamo il suo output:

$ ./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. Passaggio di argomenti della riga di comando

Finora, abbiamo visto come leggere le proprietà. In pratica, dobbiamo inviare queste proprietà come argomenti al nostro programma preferito.

3.1. Passaggio di argomenti alle applicazioni Java

In un precedente tutorial, abbiamo spiegato come eseguire le classi principali Java da Gradle. Costruiamo su questo e vediamo come possiamo anche passare argomenti.

Per prima cosa, usiamo il plugin dell'applicazione nel nostro build.gradle :

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

Ora, diamo un'occhiata alla nostra 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 + "]"); } } } 

Successivamente, eseguiamolo con alcuni argomenti:

$ ./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]

Qui, non usiamo le proprietà per passare argomenti. Invece, passiamo lì il flag –args e gli input corrispondenti .

Questo è un bel wrapper fornito dal plugin dell'applicazione. Tuttavia, questo è disponibile solo da Gradle 4.9 in poi .

Vediamo che cosa questo assomiglierebbe utilizzando un JavaExec compito .

Per prima cosa, dobbiamo definirlo nel nostro 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() } 

Diamo uno sguardo più da vicino a quello che abbiamo fatto. Prima leggiamo gli argomenti da una proprietà del progetto .

Poiché questo contiene tutti gli argomenti come una stringa, utilizziamo quindi il metodo split per ottenere un array di argomenti .

Successivamente, passiamo questo array alla proprietà args della nostra attività JavaExec .

Vediamo cosa succede quando eseguiamo questa attività, passando le proprietà del progetto con l' opzione -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. Passaggio di argomenti ad altre applicazioni

In alcuni casi, potremmo voler passare alcuni argomenti a un'applicazione di terze parti da Gradle.

Fortunatamente, possiamo usare l' attività Exec più generica per farlo:

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() } 

Qui, usiamo la proprietà commandLine dell'attività per passare l'eseguibile insieme a qualsiasi argomento . Ancora una volta, dividiamo l'input in base agli spazi.

Vediamo come eseguirlo per il comando 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

Questo può essere molto utile se non vogliamo codificare l'eseguibile nell'attività.

4. Conclusione

In questo breve tutorial, abbiamo visto come passare argomenti di input da Gradle.

Innanzitutto, abbiamo spiegato i tipi di proprietà che possiamo utilizzare. Sebbene possiamo usare le proprietà di sistema per passare gli argomenti di input, dovremmo preferire invece le proprietà del progetto.

Quindi, abbiamo esplorato diversi approcci per il passaggio di argomenti della riga di comando a Java o ad applicazioni esterne.

Come al solito, il codice completo può essere trovato su GitHub.