streamalism.org

1. Oversikt

Noen ganger ønsker vi å utføre forskjellige programmer fra Gradle som krever inndataparametere.

I denne raske opplæringen skal vi se hvordan du overfører kommandolinjeargumenter fra Gradle.

2. Typer av inngangsargumenter

Når vi ønsker å sende inn argumenter fra Gradle CLI, har vi to valg:

• sette systemegenskaper med -D flagg
• sette prosjektegenskaper med -P flagg

Generelt, vi bør bruke prosjektegenskaper med mindre vi vil tilpasse innstillingene i JVM.

Selv om det er mulig å kapre systemegenskaper for å passere våre innganger, bør vi unngå å gjøre dette.

La oss se disse egenskapene i aksjon. Først konfigurerer vi vår build.gradle:

bruk plugin: "java" beskrivelse = "Eksempler på Gradle Command Line Arguments" oppgave propertyTypes () {doLast {if (project.hasProperty ("args")) {println "Vårt inputargument med prosjektegenskap [" + project.getProperty (" args ") +"] "} println" Vårt inputargument med systemegenskap ["+ System.getProperty (" args ") +"] "}} 

Legg merke til at vi leser dem annerledes i vår oppgave.

Vi gjør dette fordi prosjekt.getProperty () kaster en MissingPropertyException i tilfelle eiendommen vår ikke er definert.

I motsetning til prosjektegenskaper, System.getProperty () returnerer a null verdi i tilfelle eiendommen ikke er definert.

La oss deretter kjøre oppgaven og se utdataene:

$ ./gradlew propertyTypes -Dargs = lorem -Pargs = ipsum> Oppgave: cmd-line-args: propertyTypes Vårt inputargument med prosjektegenskap [ipsum] Vårt inputargument med systemegenskap [lorem] 

3. Passere kommandolinjeargumenter

Så langt har vi sett hvordan vi kan lese eiendommene. I praksis må vi sende disse egenskapene som argumenter til vårt valgte program.

3.1. Overføring av argumenter til Java-applikasjoner

I en tidligere veiledning forklarte vi hvordan du kjører Java-hovedklasser fra Gradle. La oss bygge videre på det og se hvordan vi også kan føre argumenter.

Først, la oss bruk programtillegget i vår build.gradle:

bruke plugin: "java" bruke plugin: "application" beskrivelse = "Gradle Command Line Argumenter eksempler" // tidligere erklæringer ext.javaMain-applikasjon {mainClassName = javaMainClass} 

La oss ta en titt på hovedklassen vår:

public class MainClass {public static void main (String [] args) {System.out.println ("Eksempel på Gradle kommandolinjeargumenter"); for (String arg: args) {System.out.println ("Got argument [" + arg + "]"); }}} 

La oss kjøre det med noen argumenter:

$ ./gradlew: cmd-line-args: run --args = "lorem ipsum dolor"> Oppgave: cmd-line-args: run Gradle kommandolinje argumenter eksempel Got argument [lorem] Got argument [ipsum] Got argument [dolor ]

Her bruker vi ikke egenskaper for å sende argumenter. I stedet, vi passerer –Arker flagg og tilsvarende innganger der.

Dette er en fin innpakning levert av programtillegget. Derimot, dette er bare tilgjengelig fra Gradle 4.9 og utover.

La oss se hvordan dette vil se ut bruker en JavaExec oppgave.

Først må vi definere det i vårt build.gradle:

ext.javaMain if (project.hasProperty ("args")) {ext.cmdargs = project.getProperty ("args")} annet {ext.cmdargs = ""} oppgave cmdLineJavaExec (type: JavaExec) {group = "Execution" beskrivelse = "Kjør hovedklassen med JavaExecTask" classpath = sourceSets.main.runtimeClasspath main = javaMainClass args cmdargs.split ()} 

La oss se nærmere på hva vi gjorde. Vi først lese argumentene fra en prosjekteiendom.

Siden dette inneholder alle argumentene som en streng, vi da bruke dele metode for å skaffe en rekke argumenter.

Neste, vi overfør denne matrisen til argumenterer vår eiendom JavaExec oppgave.

La oss se hva som skjer når vi kjører denne oppgaven, og sender prosjektegenskapene med -P alternativ:

$ ./gradlew cmdLineJavaExec -Pargs = "lorem ipsum dolor"> Oppgave: cmd-line-args: cmdLineJavaExec Gradle kommandolinje argumenter eksempel Fikk argument [lorem] Fikk argument [ipsum] Fikk argument [dolor] 

3.2. Formidling av argumenter til andre applikasjoner

I noen tilfeller vil vi kanskje sende noen argumenter til en tredjepartsapplikasjon fra Gradle.

Heldigvis kan vi bruk det mer generiske Utfør oppgave å gjøre slik:

hvis (project.hasProperty ("args")) {ext.cmdargs = project.getProperty ("args")} ellers {ext.cmdargs = "ls"} oppgave cmdLineExec (type: Exec) {group = "Execution" beskrivelse = "Kjør et eksternt program med ExecTask" commandLine cmdargs.split ()} 

Her vi bruke kommandolinje egenskapen til oppgaven for å sende den kjørbare filen sammen med eventuelle argumenter. Igjen, vi deler inngangen basert på mellomrom.

La oss se hvordan du kjører dette for ls kommando:

$ ./gradlew cmdLineExec -Pargs = "ls -ll"> Oppgave: cmd-line-args: cmdLineExec totalt 4 drwxr-xr-x 1 bruker 1049089 0 september 1 17:59 bin drwxr-xr-x 1 bruker 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

Dette kan være ganske nyttig hvis vi ikke vil hardkode den kjørbare filen i oppgaven.

4. Konklusjon

I denne raske opplæringen så vi hvordan vi kunne sende inputargumenter fra Gradle.

Først forklarte vi hvilke typer egenskaper vi kan bruke. Selv om vi kan bruke systemegenskaper til å sende inn inputargumenter, bør vi foretrekke prosjektegenskaper i stedet.

Deretter utforsket vi forskjellige tilnærminger for å overføre kommandolinjeargumenter til Java eller eksterne applikasjoner.

Som vanlig kan du finne den fullstendige koden på GitHub.