Exécuter une méthode principale Java à l'aide de Gradle

1. Introduction

Dans ce didacticiel, nous explorerons les différentes méthodes d'exécution d'une méthode principale Java à l' aide de Gradle.

2. Méthode principale Java

Il existe plusieurs façons d'exécuter une méthode principale Java avec Gradle. Examinons-les de près en utilisant un programme simple qui imprime un message sur la sortie standard:

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

3. Exécution avec le plug-in d'application

Le plugin Application est un plugin Gradle de base qui définit une collection de tâches prêtes à l'emploi qui nous aident à empaqueter et à distribuer notre application.

Commençons par insérer ce qui suit dans notre fichier build.gradle :

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

Le plugin génère automatiquement une tâche appelée run qui ne nécessite que de la pointer vers la classe principale . La fermeture à la ligne 9 fait exactement cela, ce qui nous permet de déclencher la tâche:

~/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. Exécution avec la tâche JavaExec

Ensuite, implémentons une tâche personnalisée pour exécuter la méthode main à l'aide du type de tâche JavaExec :

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

Nous devons définir la classe principale à la ligne 5 et, en plus, spécifier le chemin de classe. Le chemin de classe est calculé à partir des propriétés par défaut de la sortie de construction et contient le chemin correct où la classe compilée est réellement placée.

Notez que dans chaque scénario, nous utilisons le nom complet, package compris, de la classe principale .

Exécutons notre exemple en utilisant JavaExec :

~/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. Exécution avec la tâche Exec

Enfin, nous pouvons exécuter notre classe principale en utilisant le type de tâche de base Exec . Puisque cette option nous offre la possibilité de configurer l'exécution de plusieurs façons, implémentons trois tâches personnalisées et discutons-en individuellement.

5.1. Exécution à partir de la sortie de compilation compilée

Tout d'abord, nous créons une tâche Exec personnalisée qui se comporte de la même manière que JavaExec :

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

Nous pouvons exécuter n'importe quel exécutable (dans ce cas java) et lui transmettre les arguments nécessaires à son exécution.

Nous configurons le classpath et pointons vers notre classe principale sur la ligne 5, et nous ajoutons également une dépendance à la tâche de construction sur la ligne 2. Ceci est nécessaire, car nous ne pouvons exécuter notre classe principale qu'après sa compilation:

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

5.2. Exécution à partir d'un pot de sortie

La deuxième approche repose sur le conditionnement en pot de notre petite application:

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 } 

Notez la dépendance à la tâche jar à la ligne 2 et le deuxième argument à l'exécutable java à la ligne 5. Nous utilisons un jar normal, nous devons donc spécifier le point d'entrée avec le quatrième paramètre:

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

5.3. Exécution à partir d'un pot de sortie exécutable

La troisième méthode repose également sur l'emballage du pot, mais nous définissons le point d'entrée à l'aide d'une propriété manifest :

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() } 

Ici, nous n'avons plus besoin de spécifier le classpath , et nous pouvons simplement exécuter le fichier jar:

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

6. Conclusion

Dans cet article, nous avons exploré les différentes façons d'exécuter une méthode principale Java à l' aide de Gradle.

Prêt à l'emploi, le plugin Application fournit une tâche minimalement configurable pour exécuter notre méthode. Le type de tâche JavaExec nous permet d'exécuter la méthode principale sans spécifier de plugins.

Enfin, le type de tâche générique Exec peut être utilisé dans diverses combinaisons avec l'exécutable java pour obtenir les mêmes résultats mais nécessite une dépendance vis-à-vis d'autres tâches.

Comme d'habitude, le code source de ce tutoriel est disponible à l'adresse over sur GitHub.