Übergeben von Befehlszeilenargumenten in Gradle

1. Übersicht

Manchmal möchten wir verschiedene Programme von Gradle ausführen, die Eingabeparameter erfordern.

In diesem kurzen Tutorial erfahren Sie, wie Sie Befehlszeilenargumente von Gradle übergeben.

2. Arten von Eingabeargumenten

Wenn wir Eingabeargumente von der Gradle-CLI übergeben möchten, haben wir zwei Möglichkeiten:

  • Festlegen der Systemeigenschaften mit dem Flag -D
  • Festlegen der Projekteigenschaften mit dem Flag -P

Im Allgemeinen sollten wir Projekteigenschaften verwenden, es sei denn, wir möchten die Einstellungen in der JVM anpassen .

Obwohl es möglich ist, Systemeigenschaften zu entführen, um unsere Eingaben zu übergeben, sollten wir dies vermeiden.

Lassen Sie uns diese Eigenschaften in Aktion sehen. Zuerst konfigurieren wir unser 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")+"]" } } 

Beachten Sie, dass wir sie in unserer Aufgabe anders lesen.

Wir machen das wegen Projekt. getProperty () löst eine MissingPropertyException aus, falls unsere Eigenschaft nicht definiert ist .

Im Gegensatz zu Projekteigenschaften gibt System.getProperty () einen Nullwert zurück, falls die Eigenschaft nicht definiert ist.

Lassen Sie uns als Nächstes die Aufgabe ausführen und ihre Ausgabe sehen:

$ ./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. Übergeben von Befehlszeilenargumenten

Bisher haben wir gesehen, wie man die Eigenschaften liest. In der Praxis müssen wir diese Eigenschaften als Argumente an das Programm unserer Wahl senden.

3.1. Übergeben von Argumenten an Java-Anwendungen

In einem früheren Tutorial haben wir erklärt, wie Java-Hauptklassen von Gradle ausgeführt werden. Lassen Sie uns darauf aufbauen und sehen, wie wir auch Argumente übergeben können.

Verwenden wir zunächst das Anwendungs-Plugin in unserem build.gradle :

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

Schauen wir uns jetzt unsere Hauptklasse an:

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

Als nächstes führen wir es mit einigen Argumenten aus:

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

Hier verwenden wir keine Eigenschaften, um Argumente zu übergeben. Stattdessen übergeben wir dort das Flag –args und die entsprechenden Eingaben .

Dies ist ein netter Wrapper, der vom Anwendungs-Plugin bereitgestellt wird. Dies ist jedoch nur ab Gradle 4.9 verfügbar .

Mal sehen, wie dies mit einer JavaExec- Aufgabe aussehen würde .

Zuerst müssen wir es in unserem build.gradle definieren :

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

Schauen wir uns genauer an, was wir getan haben. Wir lesen zuerst die Argumente aus einer Projekteigenschaft .

Da dies alle Argumente als eine Zeichenfolge enthält, verwenden wir die Split- Methode, um ein Array von Argumenten zu erhalten .

Als Nächstes übergeben wir dieses Array an die Eigenschaft args unserer JavaExec- Task .

Mal sehen, was passiert, wenn wir diese Aufgabe ausführen und Projekteigenschaften mit der Option -P übergeben :

$ ./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. Übergeben von Argumenten an andere Anwendungen

In einigen Fällen möchten wir möglicherweise einige Argumente an eine Drittanbieteranwendung von Gradle übergeben.

Glücklicherweise können wir dazu die allgemeinere Exec- Aufgabe verwenden:

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

Hier verwenden wir die commandLine- Eigenschaft der Task, um die ausführbare Datei zusammen mit allen Argumenten zu übergeben . Wieder teilen wir die Eingabe basierend auf Leerzeichen.

Mal sehen, wie dies für den Befehl ls ausgeführt wird:

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

Dies kann sehr nützlich sein, wenn wir die ausführbare Datei in der Aufgabe nicht fest codieren möchten.

4. Fazit

In diesem kurzen Tutorial haben wir gesehen, wie Eingabeargumente von Gradle übergeben werden.

Zuerst haben wir die Arten von Eigenschaften erklärt, die wir verwenden können. Obwohl wir Systemeigenschaften verwenden können, um Eingabeargumente zu übergeben, sollten wir stattdessen Projekteigenschaften bevorzugen.

Anschließend untersuchten wir verschiedene Ansätze zum Übergeben von Befehlszeilenargumenten an Java oder externe Anwendungen.

Den vollständigen Code finden Sie wie gewohnt auf GitHub.