使用Gradle运行Java main方法


Run a Java main Method Using Gradle

1.简介

在本教程中，我们将探讨使用Gradle执行Java main方法的不同方法。

2. Java主要方法

我们可以通过多种方式使用Gradle运行Java main方法。让我们使用一个简单的程序仔细查看它们，该程序将消息打印到标准输出：

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

3.使用应用程序插件运行

Application插件是Gradle的核心插件，它定义了一系列现成的任务，可帮助我们打包和分发我们的应用程序。

让我们从在build.gradle文件中插入以下内容开始：

1
2
3
4
5
6
7
8
9
10
11
plugins {
    id"application"
}
apply plugin :"java"
ext {
   javaMainClass ="com.baeldung.gradle.exec.MainClass"
}

application {
    mainClassName = javaMainClass
}

该插件会自动生成一个名为run的任务，只需要我们将其指向主类即可。第9行的闭包正是这样做的，这使我们能够触发任务：

1
2
3
4
5
6
7
~/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.使用JavaExec任务运行

接下来，让我们实现一个自定义任务，以借助JavaExec任务类型来运行main方法：

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

我们需要在第5行上定义主类，并另外指定classpath。从构建输出的默认属性计算类路径，并包含实际放置已编译类的正确路径。

请注意，在每种情况下，我们都使用主类的完全限定名称，包括程序包。

让我们使用JavaExec运行示例：

1
2
3
4
5
6
7
~/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.使用Exec任务运行

最后，我们可以使用基本的Exec任务类型执行主类。由于此选项为我们提供了以多种方式配置执行的可能性，因此让我们实现三个自定义任务并分别进行讨论。

5.1。从编译的构建输出运行

首先，我们创建一个自定义Exec任务，其行为类似于JavaExec：

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

我们可以运行任何可执行文件(在本例中为java)并传递必要的参数以使其运行。

我们在第5行上配置类路径并指向我们的主类，并在第2行上向构建任务添加依赖项。这是必需的，因为我们只能在编译主类后运行它：

1
2
3
4
5
6
7
~/work/baeldung/tutorials/gradle-java-exec> ./gradlew runWithExec

> Task :runWithExec
Goodbye cruel world ...

BUILD SUCCESSFUL in 666ms
6 actionable tasks: 6 executed

5.2。从输出罐运行

第二种方法依赖于我们的小型应用程序的jar包装：

1
2
3
4
5
6
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
}

注意第2行对jar任务的依赖性以及第5行对java可执行文件的第二个参数。我们使用普通的jar，因此我们需要使用第四个参数指定入口点：

1
2
3
4
5
6
7
~/work/baeldung/tutorials/gradle-java-exec> ./gradlew runWithExecJarOnClassPath

> Task :runWithExecJarOnClassPath
Goodbye cruel world ...

BUILD SUCCESSFUL in 555ms
3 actionable tasks: 3 executed

5.3。从可执行输出jar运行

第三种方式也依赖于jar包装，但是我们借助manifest属性定义入口点：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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()
}

在这里，我们不再需要指定类路径，我们可以简单地运行jar：

1
2
3
4
5
6
7
~/work/baeldung/tutorials/gradle-java-exec> ./gradlew runWithExecJarExecutable

> Task :runWithExecJarExecutable
Goodbye cruel world ...

BUILD SUCCESSFUL in 572ms
3 actionable tasks: 3 executed

六，结论

在本文中，我们探讨了使用Gradle运行Java main方法的各种方法。

开箱即用的Application插件提供了一个最低配置的任务来运行我们的方法。 JavaExec任务类型使我们无需指定任何插件即可运行main方法。

最后，通用Exec任务类型可以与java可执行文件结合使用，以达到相同的结果，但需要依赖其他任务。

像往常一样，可以在GitHub上获得本教程的源代码。