Führen Sie eine Java-Hauptmethode mit Gradle aus

1. Einleitung

In diesem Tutorial werden die verschiedenen Methoden zum Ausführen einer Java - Hauptmethode mit Gradle erläutert.

2. Java Haupt Methode

Es gibt verschiedene Möglichkeiten, wie wir eine Java - Hauptmethode mit Gradle ausführen können . Schauen wir sie uns mit einem einfachen Programm genauer an, das eine Nachricht an die Standardausgabe druckt:

public class MainClass { public static void main(String[] args) { System.out.println("Goodbye cruel world ..."); } }

3. Ausführen mit dem Anwendungs-Plugin

Das Anwendungs-Plugin ist ein zentrales Gradle-Plugin, das eine Sammlung gebrauchsfertiger Aufgaben definiert, mit denen wir unsere Anwendung verpacken und verteilen können.

Beginnen wir mit dem Einfügen von Folgendem in unsere build.gradle- Datei:

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

Das Plugin generiert automatisch eine Aufgabe namens run , bei der wir nur auf die Hauptklasse verweisen müssen . Die Schließung in Zeile 9 bewirkt genau das, wodurch wir die Aufgabe auslösen können:

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

4. Ausführen mit der JavaExec- Task

Als Nächstes implementieren wir eine benutzerdefinierte Aufgabe zum Ausführen der Hauptmethode mithilfe des JavaExec- Aufgabentyps:

task runWithJavaExec(type: JavaExec) { group = "Execution" description = "Run the main class with JavaExecTask" classpath = sourceSets.main.runtimeClasspath main = javaMainClass }

Wir müssen die Hauptklasse in Zeile 5 definieren und zusätzlich den Klassenpfad angeben. Der Klassenpfad wird aus den Standardeigenschaften der Build-Ausgabe berechnet und enthält den richtigen Pfad, in dem die kompilierte Klasse tatsächlich platziert ist.

Beachten Sie, dass in jedem Szenario, wir verwenden den vollständig qualifizierten Namen, einschließlich Paket, der Hauptklasse .

Lassen Sie uns unser Beispiel mit JavaExec ausführen :

~/work/baeldung/tutorials/gradle-java-exec> ./gradlew runWithJavaExec > Task :runWithJavaExec Goodbye cruel world ... BUILD SUCCESSFUL in 526ms 2 actionable tasks: 1 executed, 1 up-to-date

5. Ausführen mit der Exec- Task

Schließlich können wir unsere Hauptklasse mit dem Basis- Exec- Aufgabentyp ausführen . Da diese Option die Möglichkeit bietet, die Ausführung auf verschiedene Arten zu konfigurieren, implementieren wir drei benutzerdefinierte Aufgaben und diskutieren sie einzeln.

5.1. Ausführen von der kompilierten Build-Ausgabe

Zunächst erstellen wir eine benutzerdefinierte Exec- Aufgabe, die sich ähnlich wie JavaExec verhält :

task runWithExec(type: Exec) { dependsOn build group = "Execution" description = "Run the main class with ExecTask" commandLine "java", "-classpath", sourceSets.main.runtimeClasspath.getAsPath(), javaMainClass }

Wir können jede ausführbare Datei (in diesem Fall Java) ausführen und die erforderlichen Argumente übergeben, damit sie ausgeführt werden kann.

Wir konfigurieren den Klassenpfad und zeigen auf unsere Hauptklasse in Zeile 5 und fügen der Build- Task in Zeile 2 eine Abhängigkeit hinzu. Dies ist erforderlich, da wir unsere Hauptklasse erst ausführen können , nachdem sie kompiliert wurde:

~/work/baeldung/tutorials/gradle-java-exec> ./gradlew runWithExec > Task :runWithExec Goodbye cruel world ... BUILD SUCCESSFUL in 666ms 6 actionable tasks: 6 executed 

5.2. Aus einem Ausgangsglas laufen

Der zweite Ansatz basiert auf der Glasverpackung unserer kleinen Anwendung:

task runWithExecJarOnClassPath(type: Exec) { dependsOn jar group = "Execution" description = "Run the mainClass from the output jar in classpath with ExecTask" commandLine "java", "-classpath", jar.archiveFile.get(), javaMainClass } 

Beachten Sie die Abhängigkeit von der JAR-Task in Zeile 2 und das zweite Argument von der ausführbaren Java-Datei in Zeile 5. Wir verwenden ein normales JAR, daher müssen wir den Einstiegspunkt mit dem vierten Parameter angeben:

~/work/baeldung/tutorials/gradle-java-exec> ./gradlew runWithExecJarOnClassPath > Task :runWithExecJarOnClassPath Goodbye cruel world ... BUILD SUCCESSFUL in 555ms 3 actionable tasks: 3 executed

5.3. Ausführen von einem ausführbaren Ausgabe-Jar

Der dritte Weg beruht ebenfalls auf der Glasverpackung, aber wir definieren den Einstiegspunkt mithilfe einer Manifest- Eigenschaft:

jar { manifest { attributes( "Main-Class": javaMainClass ) } } task runWithExecJarExecutable(type: Exec) { dependsOn jar group = "Execution" description = "Run the output executable jar with ExecTask" commandLine "java", "-jar", jar.archiveFile.get() } 

Hier müssen wir den Klassenpfad nicht mehr angeben , und wir können einfach das jar ausführen:

~/work/baeldung/tutorials/gradle-java-exec> ./gradlew runWithExecJarExecutable > Task :runWithExecJarExecutable Goodbye cruel world ... BUILD SUCCESSFUL in 572ms 3 actionable tasks: 3 executed

6. Fazit

In diesem Artikel haben wir die verschiedenen Möglichkeiten zum Ausführen einer Java - Hauptmethode mit Gradle untersucht.

Das Anwendungs-Plugin bietet standardmäßig eine minimal konfigurierbare Aufgabe zum Ausführen unserer Methode. Mit dem JavaExec- Aufgabentyp können wir die Hauptmethode ausführen , ohne Plugins anzugeben.

Schließlich kann der generische Exec- Aufgabentyp in verschiedenen Kombinationen mit der ausführbaren Java-Datei verwendet werden, um dieselben Ergebnisse zu erzielen, erfordert jedoch eine Abhängigkeit von anderen Aufgaben.

Wie üblich ist der Quellcode für dieses Tutorial auf GitHub verfügbar.