Kør en Java-hovedmetode ved hjælp af Gradle

1. Introduktion

I denne vejledning undersøger vi de forskellige metoder til udførelse af en Java vigtigste metode ved hjælp af Gradle.

2. Java vigtigste Metode

Der er flere måder, hvorpå vi kan køre en Java vigtigste metode med Gradle. Lad os se nærmere på dem ved hjælp af et simpelt program, der udskriver en besked til standardoutputtet:

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

3. Kører med Application Plugin

Applikations-pluginet er et kernegradle-plugin, der definerer en samling klar-til-brug opgaver, der hjælper os med at pakke og distribuere vores applikation.

Lad os starte med at indsætte følgende i vores build.gradle fil:

plugins {id "application"} anvend plugin: "java" ext {javaMain} applikation {mainClassName = javaMainClass}

Pluginet genererer automatisk en kaldet opgave løb det kræver kun, at vi peger på det vigtigste klasse. Lukningen ved linje 9 gør netop det, som giver os mulighed for at udløse opgaven:

~ / work / baeldung / tutorials / gradle-java-exec> ./gradlew run> Task: run Goodbye cruel world ... BUILD SUCCESSFUL in 531ms 2 handlingsopgaver: 1 udført, 1 up-to-date

4. Kører med JavaExec Opgave

Lad os derefter implementere en brugerdefineret opgave til at køre vigtigste metode ved hjælp af JavaExec opgavetype:

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

Vi er nødt til at definere vigtigste klasse på linje 5, og angiv desuden klassestien. Klassestien beregnes ud fra standardegenskaberne for buildoutputtet og indeholder den korrekte sti, hvor den kompilerede klasse faktisk er placeret.

Bemærk, at vi i hvert scenario Brug det fuldt kvalificerede navn, inklusive pakke, på vigtigste klasse.

Lad os køre vores eksempel ved hjælp af JavaExec:

~ / work / baeldung / tutorials / gradle-java-exec> ./gradlew runWithJavaExec> Task: runWithJavaExec Farvel grusom verden ... BYG SUCCESFULD i 526ms 2 handlinger, der kan handles: 1 udført, 1 up-to-date

5. Kører med Exec Opgave

Endelig kan vi udføre vores vigtigste klasse ved hjælp af basen Exec opgavetype. Da denne mulighed giver os muligheden for at konfigurere udførelsen på flere måder, lad os implementere tre brugerdefinerede opgaver og diskutere dem individuelt.

5.1. Kører fra den kompilerede buildoutput

Først opretter vi en brugerdefineret Exec opgave, der opfører sig på samme måde som JavaExec:

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

Vi kan køre enhver eksekverbar (i dette tilfælde java) og videregive de nødvendige argumenter for, at den kan køre.

Vi konfigurerer klassestien og peger på vores vigtigste klasse på linje 5, og vi tilføjer også en afhængighed af bygge opgave på linje 2. Dette er nødvendigt, da vi kun kan køre vores vigtigste klasse efter at den er samlet:

~ / work / baeldung / tutorials / gradle-java-exec> ./gradlew runWithExec> Task: runWithExec Farvel grusom verden ... BYG SUCCESFUL i 666 ms 6 handlingsopgaver: 6 udført 

5.2. Kører fra en outputkrukke

Den anden tilgang er afhængig af krukkeemballagen i vores lille applikation:

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

Bemærk afhængigheden af ​​jar-opgaven på linje 2 og det andet argument til den eksekverbare java på linje 5. Vi bruger en normal krukke, så vi skal angive indgangspunktet med den fjerde parameter:

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

5.3. Kører fra en eksekverbar outputkrukke

Den tredje måde er også afhængig af krukkeemballagen, men vi definerer indgangspunktet ved hjælp af a manifest ejendom:

jar {manifest {attributter ("Main-Class": javaMainClass)}} task runWithExecJarExecutable (type: Exec) {dependsOn jar group = "Execution" description = "Kør output-eksekverbar jar med ExecTask" commandLine "java", "-jar ", jar.archiveFile.get ()} 

Her, vi behøver ikke længere angive klassestien, og vi kan simpelthen køre krukken:

~ / work / baeldung / tutorials / gradle-java-exec> ./gradlew runWithExecJarExecutable> Opgave: runWithExecJarExecutable Farvel grusom verden ... BYG SUCCESFULD i 572 ms 3 handlingsopgaver: 3 udført

6. Konklusion

I denne artikel undersøgte vi de forskellige måder at køre en Java på vigtigste metode ved hjælp af Gradle.

Uden for boksen giver applikations-pluginet en minimalt konfigurerbar opgave til at køre vores metode. Det JavaExec opgavetype giver os mulighed for at køre vigtigste metode uden at specificere nogen plugins.

Endelig generiske Exec Opgavetype kan bruges i forskellige kombinationer med den eksekverbare java for at opnå de samme resultater, men kræver en afhængighed af andre opgaver.

Som normalt er kildekoden til denne vejledning tilgængelig på GitHub.