streamalism.org

1. Introduksjon

I denne veiledningen vil vi utforske de forskjellige metodene for å utføre en Java hoved- metode ved hjelp av Gradle.

2. Java hoved- Metode

Det er flere måter vi kan kjøre en Java på hoved- metode med Gradle. La oss se nøye på dem ved hjelp av et enkelt program som skriver ut en melding til standardutgangen:

public class MainClass {public static void main (String [] args) {System.out.println ("Farvel grusom verden ..."); }}

3. Kjører med programtillegget

Programtillegget er et kjerne Gradle-programtillegg som definerer en samling ferdige oppgaver som hjelper oss med å pakke og distribuere applikasjonen vår.

La oss starte med å sette inn følgende i vår build.gradle fil:

plugins {id "application"} gjelder plugin: "java" ext {javaMain} applikasjon {mainClassName = javaMainClass}

Plugin genererer automatisk en oppgave som heter løpe som bare krever at vi peker det på hoved- klasse. Avslutningen på linje 9 gjør akkurat det, som lar oss utløse oppgaven:

~ / work / baeldung / tutorials / gradle-java-exec> ./gradlew run> Oppgave: run Goodbye cruel world ... BUILD SUCCESSFUL in 531ms 2 handlingsoppgaver: 1 utført, 1 oppdatert

4. Kjører med JavaExec Oppgave

La oss deretter implementere en tilpasset oppgave for å kjøre hoved- metoden ved hjelp av JavaExec oppgavetype:

task runWithJavaExec (type: JavaExec) {group = "Execution" description = "Kjør hovedklassen med JavaExecTask" classpath = sourceSets.main.runtimeClasspath main = javaMainClass}

Vi må definere hoved- klasse på linje 5 og i tillegg spesifisere klassestien. Klassestien beregnes fra standardegenskapene til byggeutgangen og inneholder riktig bane der den kompilerte klassen faktisk er plassert.

Legg merke til at vi i hvert scenario Bruk det fullstendige navnet, inkludert pakken, på hoved- klasse.

La oss kjøre eksemplet vårt med JavaExec:

~ / work / baeldung / tutorials / gradle-java-exec> ./gradlew runWithJavaExec> Oppgave: runWithJavaExec Farvel grusom verden ... BYGG LYKTIG på 526 ms 2 handlingsoppgaver: 1 utført, 1 oppdatert

5. Kjører med Utfør Oppgave

Endelig kan vi utføre vår hoved- klasse ved hjelp av basen Utfør oppgavetype. Siden dette alternativet gir oss muligheten til å konfigurere kjøringen på flere måter, la oss implementere tre tilpassede oppgaver og diskutere dem individuelt.

5.1. Kjører fra Compiled Build Output

Først lager vi en tilpasset Utfør oppgave som oppfører seg på samme måte som JavaExec:

task runWithExec (type: Exec) {dependsOn build group = "Execution" description = "Kjør hovedklassen med ExecTask" commandLine "java", "-classpath", sourceSets.main.runtimeClasspath.getAsPath (), javaMainClass}

Vi kan kjøre hvilken som helst kjørbar (i dette tilfellet java) og sende de nødvendige argumentene for at den skal kjøre.

Vi konfigurerer klassestien og peker på vår hoved- klasse på linje 5, og vi legger også til en avhengighet til bygge oppgave på linje 2. Dette er nødvendig, ettersom vi bare kan kjøre vår hoved- klasse etter at den er samlet:

~ / work / baeldung / tutorials / gradle-java-exec> ./gradlew runWithExec> Task: runWithExec Goodbye cruel world ... BUILD SUCCESSFUL in 666ms 6 handlingsbare oppgaver: 6 utført 

5.2. Kjører fra en utgangskrukke

Den andre tilnærmingen er avhengig av glassemballasjen til den lille applikasjonen vår:

task runWithExecJarOnClassPath (type: Exec) {dependsOn jar group = "Execution" description = "Kjør mainClass fra output jar i classpath med ExecTask" commandLine "java", "-classpath", jar.archiveFile.get (), javaMainClass} 

Legg merke til avhengigheten av jar-oppgaven på linje 2 og det andre argumentet til Java-kjørbar på linje 5. Vi bruker en vanlig krukke, så vi må spesifisere inngangspunktet med den fjerde parameteren:

~ / work / baeldung / tutorials / gradle-java-exec> ./gradlew runWithExecJarOnClassPath> Task: runWithExecJarOnClassPath Goodbye cruel world ... BUILD SUCCESSFUL in 555ms 3 handlingsoppgaver: 3 utført

5.3. Kjører fra en kjørbar utgangskrukke

Den tredje måten er også avhengig av glassemballasjen, men vi definerer inngangspunktet ved hjelp av a manifestere eiendom:

jar {manifest {attributter ("Main-Class": javaMainClass)}} oppgave runWithExecJarExecutable (type: Exec) {dependsOn jar group = "Execution" description = "Kjør den utførbare kjørbare jar med ExecTask" commandLine "java", "-jar ", jar.archiveFile.get ()} 

Her, vi trenger ikke lenger å spesifisere klassestien, og vi kan bare kjøre glasset:

~ / work / baeldung / tutorials / gradle-java-exec> ./gradlew runWithExecJarExecutable> Oppgave: runWithExecJarExecutable Farvel grusom verden ... BYGG LYKTIG i 572 ms 3 handlingsoppgaver: 3 utført

6. Konklusjon

I denne artikkelen undersøkte vi de forskjellige måtene å kjøre en Java på hoved- metode ved hjelp av Gradle.

Ut av boksen gir applikasjonspluginet en minimalt konfigurerbar oppgave for å kjøre metoden vår. De JavaExec oppgavetype lar oss kjøre hoved- metode uten å spesifisere noen plugins.

Til slutt generiske Utfør oppgavetype kan brukes i forskjellige kombinasjoner med kjørbar Java for å oppnå de samme resultatene, men krever avhengighet av andre oppgaver.

Som vanlig er kildekoden for denne opplæringen tilgjengelig på GitHub.