Voer een Java-hoofdmethode uit met Gradle

1. Inleiding

In deze tutorial onderzoeken we de verschillende methoden voor het uitvoeren van een Java hoofd methode met behulp van Gradle.

2. Java hoofd Methode

Er zijn verschillende manieren waarop we een Java kunnen draaien hoofd methode met Gradle. Laten we ze eens nader bekijken met behulp van een eenvoudig programma dat een bericht afdrukt naar de standaarduitvoer:

openbare klasse MainClass {openbare statische leegte main (String [] args) {System.out.println ("Vaarwel wrede wereld ..."); }}

3. Uitvoeren met de applicatie-plug-in

De applicatie-plug-in is een kern-Gradle-plug-in die een verzameling kant-en-klare taken definieert die ons helpen bij het verpakken en distribueren van onze applicatie.

Laten we beginnen met het invoegen van het volgende in ons build.gradle het dossier:

plug-ins {id "application"} pas plug-in toe: "java" ext {javaMain} applicatie {mainClassName = javaMainClass}

De plug-in genereert automatisch een taak met de naam rennen dat vereist alleen dat we het naar de hoofd klasse. De sluiting op regel 9 doet precies dat, waardoor we de taak kunnen activeren:

~ / work / baeldung / tutorials / gradle-java-exec> ./gradlew run> Taak: run Vaarwel wrede wereld ... BOUW SUCCESVOL in 531 ms 2 uitvoerbare taken: 1 uitgevoerd, 1 up-to-date

4. Hardlopen met de JavaExec Taak

Laten we vervolgens een aangepaste taak implementeren voor het uitvoeren van het hoofd methode met behulp van de JavaExec taaktype:

task runWithJavaExec (type: JavaExec) {group = "Execution" description = "Voer de hoofdklasse uit met JavaExecTask" classpath = sourceSets.main.runtimeClasspath main = javaMainClass}

We moeten de hoofd class op regel 5 en geef daarnaast het classpath op. Het klassepad wordt berekend op basis van de standaardeigenschappen van de build-uitvoer en bevat het juiste pad waar de gecompileerde klasse feitelijk is geplaatst.

Merk op dat we in elk scenario gebruik de volledig gekwalificeerde naam, inclusief pakket, van het hoofd klasse.

Laten we ons voorbeeld uitvoeren met JavaExec:

~ / work / baeldung / tutorials / gradle-java-exec> ./gradlew runWithJavaExec> Taak: runWithJavaExec Vaarwel wrede wereld ... BOUW SUCCESVOL in 526 ms 2 uitvoerbare taken: 1 uitgevoerd, 1 up-to-date

5. Hardlopen met de Exec Taak

Eindelijk kunnen we onze hoofd klasse met behulp van de basis Exec taaktype. Aangezien deze optie ons de mogelijkheid biedt om de uitvoering op meerdere manieren te configureren, kunnen we drie aangepaste taken implementeren en deze afzonderlijk bespreken.

5.1. Uitgevoerd vanaf de gecompileerde build-uitvoer

Eerst maken we een custom Exec taak die zich op dezelfde manier gedraagt ​​als JavaExec:

task runWithExec (type: Exec) {dependOn build group = "Execution" description = "Voer de hoofdklasse uit met ExecTask" commandLine "java", "-classpath", sourceSets.main.runtimeClasspath.getAsPath (), javaMainClass}

We kunnen elk uitvoerbaar bestand uitvoeren (in dit geval java) en de nodige argumenten doorgeven om het uit te voeren.

We configureren het klassenpad en wijzen naar onze hoofd class op regel 5, en we voegen ook een afhankelijkheid toe aan de bouwen taak op regel 2. Dit is nodig, omdat we alleen onze hoofd klasse nadat het is gecompileerd:

~ / work / baeldung / tutorials / gradle-java-exec> ./gradlew runWithExec> Taak: runWithExec Vaarwel wrede wereld ... BOUW SUCCESVOL in 666ms 6 uitvoerbare taken: 6 uitgevoerd 

5.2. Rennen vanuit een Output Jar

De tweede benadering is gebaseerd op de potverpakking van onze kleine applicatie:

task runWithExecJarOnClassPath (type: Exec) {dependOn jar group = "Execution" description = "Start mainClass vanuit de output jar in classpath met ExecTask" commandLine "java", "-classpath", jar.archiveFile.get (), javaMainClass} 

Let op de afhankelijkheid van de jar-taak op regel 2 en het tweede argument voor het java-uitvoerbare bestand op regel 5. We gebruiken een normale jar, dus we moeten het beginpunt specificeren met de vierde parameter:

~ / work / baeldung / tutorials / gradle-java-exec> ./gradlew runWithExecJarOnClassPath> Taak: runWithExecJarOnClassPath Vaarwel wrede wereld ... BOUW SUCCESVOL in 555 ms 3 uitvoerbare taken: 3 uitgevoerd

5.3. Uitgevoerd vanuit een uitvoerbare uitvoerpot

De derde manier is ook afhankelijk van de verpakking van de pot, maar we definiëren het toegangspunt met behulp van een manifesteren eigendom:

jar {manifest {attributes ("Main-Class": javaMainClass)}} taak runWithExecJarExecutable (type: Exec) {afhankelijk jar group = "Execution" description = "Voer de uitvoerbare jar uit met ExecTask" commandLine "java", "-jar ", jar.archiveFile.get ()} 

Hier, we hoeven niet langer het klassenpad op te geven, en we kunnen gewoon de pot draaien:

~ / work / baeldung / tutorials / gradle-java-exec> ./gradlew runWithExecJarExecutable> Taak: runWithExecJarExecutable Vaarwel wrede wereld ... BOUW SUCCESVOL in 572 ms 3 uitvoerbare taken: 3 uitgevoerd

6. Conclusie

In dit artikel hebben we de verschillende manieren onderzocht om Java uit te voeren hoofd methode met behulp van Gradle.

Out of the box biedt de applicatie-plug-in een minimaal configureerbare taak om onze methode uit te voeren. De JavaExec taaktype stelt ons in staat om het hoofd methode zonder plug-ins op te geven.

Eindelijk, de generieke Exec het taaktype kan in verschillende combinaties met het uitvoerbare Java-bestand worden gebruikt om dezelfde resultaten te bereiken, maar vereist een afhankelijkheid van andere taken.

Zoals gewoonlijk is de broncode voor deze tutorial beschikbaar op GitHub.