Opdrachtregelargumenten doorgeven in Gradle

1. Overzicht

Soms willen we verschillende programma's van Gradle uitvoeren waarvoor invoerparameters nodig zijn.

In deze korte tutorial gaan we zien hoe we opdrachtregelargumenten van Gradle kunnen doorgeven.

2. Soorten invoerargumenten

Als we invoerargumenten van de Gradle CLI willen doorgeven, hebben we twee keuzes:

  • systeemeigenschappen instellen met de -D vlag
  • projecteigenschappen instellen met de -P vlag

Over het algemeen, we zouden projecteigenschappen moeten gebruiken, tenzij we instellingen in de JVM willen aanpassen.

Hoewel het mogelijk is om systeemeigenschappen te kapen om onze invoer door te geven, moeten we dit vermijden.

Laten we deze eigenschappen in actie zien. Eerst configureren we onze build.gradle:

apply plugin: "java" description = "Gradle Command Line Arguments voorbeelden" task propertyTypes () {doLast {if (project.hasProperty ("args")) {println "Ons invoerargument met projecteigenschap [" + project.getProperty (" args ") +"] "} println" Ons invoerargument met systeemeigenschap ["+ System.getProperty (" args ") +"] "}} 

Merk op dat we ze in onze taak anders lezen.

We doen dit omdat project.getProperty () gooit een MissingPropertyException voor het geval ons eigendom niet is gedefinieerd.

In tegenstelling tot projecteigenschappen, System.getProperty () geeft een terug nul waarde voor het geval de eigenschap niet is gedefinieerd.

Laten we vervolgens de taak uitvoeren en de uitvoer bekijken:

$ ./gradlew propertyTypes -Dargs = lorem -Pargs = ipsum> Taak: cmd-line-args: propertyTypes Ons invoerargument met projecteigenschap [ipsum] Ons invoerargument met systeemeigenschap [lorem] 

3. Opdrachtregelargumenten doorgeven

Tot nu toe hebben we gezien hoe we de eigendommen moesten lezen. In de praktijk moeten we deze eigenschappen als argumenten naar ons programma naar keuze sturen.

3.1. Argumenten doorgeven aan Java-applicaties

In een eerdere zelfstudie hebben we uitgelegd hoe u Java-hoofdklassen vanuit Gradle kunt uitvoeren. Laten we daarop voortbouwen en kijken hoe we ook argumenten kunnen aanvoeren.

Laten we eerst gebruik de applicatie-plug-in in onze build.gradle:

pas plug-in toe: "java" pas plug-in toe: "application" description = "Gradle Command Line Arguments-voorbeelden" // eerdere verklaringen ext.javaMain-applicatie {mainClassName = javaMainClass} 

Laten we nu eens kijken naar onze hoofdklasse:

openbare klasse MainClass {openbare statische leegte hoofd (String [] args) {System.out.println ("Gradle-voorbeeld van opdrachtregelargumenten"); for (String arg: args) {System.out.println ("Got argument [" + arg + "]"); }}} 

Laten we het vervolgens uitvoeren met enkele argumenten:

$ ./gradlew: cmd-line-args: run --args = "lorem ipsum dolor"> Taak: cmd-line-args: run Gradle opdrachtregel argumenten voorbeeld Kreeg argument [lorem] Kreeg argument [ipsum] Kreeg argument [dolor ]

Hier gebruiken we geen eigenschappen om argumenten door te geven. In plaats daarvan, we passeren de -Args vlag en de bijbehorende ingangen daar.

Dit is een mooie verpakking die wordt geleverd door de applicatie-plug-in. Echter, dit is alleen beschikbaar vanaf Gradle 4.9 en hoger.

Laten we eens kijken hoe dit eruit zou zien gebruik maken van een JavaExec taak.

Ten eerste moeten we het definiëren in onze build.gradle:

ext.javaMain if (project.hasProperty ("args")) {ext.cmdargs = project.getProperty ("args")} anders {ext.cmdargs = ""} taak cmdLineJavaExec (type: JavaExec) {group = "Uitvoering" description = "Voer de hoofdklasse uit met JavaExecTask" classpath = sourceSets.main.runtimeClasspath main = javaMainClass args cmdargs.split ()} 

Laten we eens nader bekijken wat we hebben gedaan. Wij eerst lees de argumenten van een projecteigenschap.

Aangezien dit alle argumenten als één string bevat, kunnen we dus gebruik de splitsen methode om een ​​reeks argumenten te verkrijgen.

Vervolgens we geef deze array door aan de args eigendom van onze JavaExec taak.

Laten we eens kijken wat er gebeurt als we deze taak uitvoeren en projecteigenschappen doorgeven met de -P keuze:

$ ./gradlew cmdLineJavaExec -Pargs = "lorem ipsum dolor"> Taak: cmd-line-args: cmdLineJavaExec Voorbeeld van opdrachtregelargumenten voor Gradle Gekregen argument [lorem] Gekregen argument [ipsum] Gekregen argument [dolor] 

3.2. Argumenten doorgeven aan andere toepassingen

In sommige gevallen willen we misschien wat argumenten doorgeven aan een applicatie van derden van Gradle.

Gelukkig kunnen we dat gebruik de meer algemene Exec taak om dit te doen:

if (project.hasProperty ("args")) {ext.cmdargs = project.getProperty ("args")} else {ext.cmdargs = "ls"} taak cmdLineExec (type: Exec) {group = "Execution" description = "Draai een extern programma met ExecTask" commandLine cmdargs.split ()} 

Hier Wij gebruik de opdrachtregel eigenschap van de taak om het uitvoerbare bestand samen met eventuele argumenten door te geven. Nogmaals, we splitsen de invoer op basis van spaties.

Laten we eens kijken hoe we dit kunnen uitvoeren voor de ls opdracht:

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

Dit kan erg handig zijn als we het uitvoerbare bestand in de taak niet hard willen coderen.

4. Conclusie

In deze korte tutorial hebben we gezien hoe we invoerargumenten van Gradle kunnen doorgeven.

Eerst hebben we de soorten eigenschappen uitgelegd die we kunnen gebruiken. Hoewel we systeemeigenschappen kunnen gebruiken om invoerargumenten door te geven, zouden we in plaats daarvan de voorkeur moeten geven aan projecteigenschappen.

Vervolgens hebben we verschillende benaderingen onderzocht voor het doorgeven van opdrachtregelargumenten aan Java of externe applicaties.

Zoals gewoonlijk is de volledige code te vinden op GitHub.