Two Methods to Execute Java Classes in Gradle: Solutions Without Modifying build.gradle

Comparison Between Gradle and Maven for Executing Java Classes

In Java project build tools, Maven offers the mvn compile exec:java -Dexec.mainClass=example.Example command to directly compile and run a specified main class, without modifying the project's pom.xml file. However, Gradle lacks a direct equivalent by default, posing challenges for developers migrating to or using Gradle. This article addresses this issue by presenting two solutions that require no changes to the build.gradle file.

Using the Application Plugin

The application plugin in Gradle is a standard approach for creating executable Java applications. To use it, first activate the plugin in build.gradle:

plugins {
    id 'application'
    // other plugins...
}

Next, configure the mainClassName property to dynamically accept command-line arguments:

application {
    mainClassName = project.hasProperty("mainClass") ? project.getProperty("mainClass") : "NULL"
}

On the command line, use the -P parameter to pass the main class name:

$ gradle -PmainClass=runclass.RunClass run

This triggers Gradle to compile the project and run the specified main class. If the mainClass property is not provided, the task fails with a message indicating no main class is specified, ensuring execution clarity.

Using JavaExec Tasks

Another more flexible method is to define a custom JavaExec task. Add the following task definition to build.gradle:

task execute(type:JavaExec) {
   main = project.hasProperty("mainClass") ? getProperty("mainClass") : "NULL"
   classpath = sourceSets.main.runtimeClasspath
}

To execute, use the command:

$ gradle -PmainClass=runclass.RunClass execute

This outputs results similar to:

:compileJava
:compileGroovy UP--TO-DATE
:processResources UP-TO-DATE
:classes
:execute
app is running!

The classpath is set to sourceSets.main.runtimeClasspath, ensuring the use of the latest compiled classes. Similar to the application plugin, missing the mainClass property causes build failure.

Error Handling and Considerations

Both methods rely on dynamic property passing; if mainClass is not specified in the command line, Gradle throws an error. For example, with the JavaExec task:

$ gradle execute

FAILURE: Build failed with an exception.

* Where:
Build file 'xxxx/build.gradle' line: 4

* What went wrong:
A problem occurred evaluating root project 'Foo'.
> Could not find property 'mainClass' on task ':execute'.

This highlights the importance of ensuring property passing in automated scripts or CI/CD pipelines. Additionally, these methods avoid modifying each project's build.gradle, enhancing portability and maintainability.

Supplementary References and Other Approaches

Beyond these methods, a simplified alternative is to directly apply the application plugin and statically set mainClass:

apply plugin:'application'
mainClass = "org.gradle.sample.Main"

Then run gradle run. However, this requires modifying build.gradle and is less flexible than dynamic approaches. Based on Stack Overflow discussions, best practices involve combining command-line arguments to adapt to different environmental needs.

Conclusion

Through the application plugin or JavaExec tasks, developers can efficiently execute Java classes in Gradle without invasive changes to build files. These methods offer functionality similar to Maven's exec:java while maintaining Gradle's flexibility and scalability. In practical projects, it is advisable to choose the appropriate method based on team preferences and deployment requirements, ensuring robust error handling mechanisms are in place.