使用 Gradle 构建 Java 项目

本指南将引导您使用 Gradle 构建一个简单的 Java 项目。

您将构建什么

您将创建一个简单的应用程序，然后使用 Gradle 构建它。

你需要什么

• 约15分钟
• 最喜欢的文本编辑器或 IDE
• JDK 6或更高版本

如何完成本指南

像大多数 Spring入门指南一样，您可以从头开始并完成每个步骤，也可以绕过您已经熟悉的基本设置步骤。无论哪种方式，您最终都会得到工作代码。

要从头开始，请继续设置项目。

要跳过基础知识，请执行以下操作：

• 下载并解压缩本指南的源存储库，或使用Git克隆它：git clone https://github.com/spring-guides/gs-gradle.git
• 光盘进入gs-gradle/initial
• 继续安装 Gradle。

完成后，您可以对照中的代码检查结果​​gs-gradle/complete​​。

设置项目

首先，您设置一个 Java 项目供 Gradle 构建。为了保持对 Gradle 的关注，现在让项目尽可能简单。

创建目录结构

在您选择的项目目录中，创建以下子目录结构；例如，​​mkdir -p src/main/java/hello​​在 *nix 系统上：

└── 源
    └── 主要
        └── java
            └── 你好

在该​​src/main/java/hello​​目录中，您可以创建所需的任何 Java 类。为简单起见并与本指南的其余部分保持一致，Spring 建议您创建两个类：​​HelloWorld.java​​和​​Greeter.java​​.

​​src/main/java/hello/HelloWorld.java​​

package hello;

public class HelloWorld {
  public static void main(String[] args) {
  Greeter greeter = new Greeter();
  System.out.println(greeter.sayHello());
  }
}复制

​​src/main/java/hello/Greeter.java​​

package hello;

public class Greeter {
  public String sayHello() {
  return "Hello world!";
  }
}复制

安装 Gradle

现在您有了一个可以使用 Gradle 构建的项目，您可以安装 Gradle。

强烈建议使用安装程序：

• SDKMAN
• 自制软件（brew install gradle）

作为最后的手段，如果这些工具都不适合您的需求，您可以从https://www.gradle.org/downloads下载二进制文件。只需要二进制文件，因此请查找指向 gradle-version-bin.zip 的链接。（您也可以选择 gradle-version-all.zip来获取源代码和文档以及二进制文件。）

将文件解压缩到您的计算机，并将 bin 文件夹添加到您的路径。

要测试 Gradle 安装，请从命令行运行 Gradle：

毕业典礼

如果一切顺利，您会看到一条欢迎消息：

：帮助

欢迎使用 Gradle 6.0.1。

要运行构建，请运行 gradle  ...

要查看可用任务列表，请运行 gradle tasks

要查看命令行选项列表，请运行 gradle --help

要查看有关任务的更多详细信息，请运行 gradle help --task 

如需疑难解答，请访问 https://help.gradle.org

此版本中使用了已弃用的 Gradle 功能，使其与 Gradle 7.0 不兼容。
使用“--warning-mode all”显示各个弃用警告。
请参阅 https://docs.gradle.org/6.0.1/userguide/command_line_interface.html#sec:command_line_warnings

在 455 毫秒内构建成功
1 个可操作的任务：1 个已执行

您现在已经安装了 Gradle。

了解 Gradle 可以做什么

现在安装了 Gradle，看看它可以做什么。在为项目创建 build.gradle 文件之前，您可以询问它有哪些任务可用：

毕业任务

您应该会看到可用任务的列表。假设您在没有build.gradle文件的文件夹中运行 Gradle，您将看到一些非常基本的任务，例如：

：任务

-------------------------------------------------- ----------
可从根项目运行的任务
-------------------------------------------------- ----------

构建设置任务
-----------------
init - 初始化一个新的 Gradle 构建。
wrapper - 生成 Gradle 包装文件。

帮助任务
----------
buildEnvironment - 显示在根项目“gs-gradle”中声明的所有 buildscript 依赖项。
components - 显示由根项目“gs-gradle”生成的组件。[孵化]
依赖项 - 显示在根项目“gs-gradle”中声明的所有依赖项。
dependencyInsight - 显示对根项目“gs-gradle”中特定依赖项的洞察。
dependentComponents - 显示根项目“gs-gradle”中组件的依赖组件。[孵化]
help - 显示帮助消息。
model - 显示根项目“gs-gradle”的配置模型。[孵化]
传出变量 - 显示根项目“gs-gradle”的传出变体。
projects - 显示根项目“gs-gradle”的子项目。
properties - 显示根项目“gs-gradle”的属性。
任务 - 显示可从根项目“gs-gradle”运行的任务。

要查看所有任务和更多详细信息，请运行 gradle tasks --all

要查看有关任务的更多详细信息，请运行 gradle help --task 

此版本中使用了已弃用的 Gradle 功能，使其与 Gradle 7.0 不兼容。
使用“--warning-mode all”显示各个弃用警告。
请参阅 https://docs.gradle.org/6.0.1/userguide/command_line_interface.html#sec:command_line_warnings

在 477 毫秒内构建成功
1 个可操作的任务：1 个已执行

即使这些任务可用，但如果没有项目构建配置，它们也不会提供太多价值。当你充实​​build.gradle​​文件时，一些任务会更有用。任务列表会随着您向 中添加插件而增加​​build.gradle​​，因此您有时会希望再次运行任务以查看可用的任务。

说到添加插件，接下来您将添加一个启用基本 Java 构建功能的插件。

构建 Java 代码

​​build.gradle​​从简单开始，在您在本指南开头创建的 <项目文件夹> 中创建一个非常基本的文件。只给它一行：

apply plugin: 'java'复制

构建配置中的这一单行带来了巨大的力量。再次运行gradle 任务，您会看到列表中添加了新任务，包括构建项目、创建 JavaDoc 和运行测试的任务。

你会经常使用gradle build任务。此任务编译、测试代码并将其组装到 JAR 文件中。你可以像这样运行它：

梯度构建

几秒钟后，“BUILD SUCCESSFUL”表示构建已完成。

要查看构建工作的结果，请查看构建文件夹。在其中你会发现几个目录，包括这三个值得注意的文件夹：

• 类。项目的已编译 .class 文件。
• 报告。构建生成的报告（例如测试报告）。
• 库。组装的项目库（通常是 JAR 和/或 WAR 文件）。

classes 文件夹包含通过编译 Java 代码生成的 .class 文件。具体来说，您应该找到 HelloWorld.class 和 Greeter.class。

此时，该项目没有任何库依赖项，因此dependency_cache文件夹中没有任何内容。

报告文件夹应包含在项目上运行单元测试的报告。因为该项目还没有任何单元测试，所以该报告将是无趣的。

libs 文件夹应该包含一个以项目文件夹命名的 JAR 文件。再往下，您将看到如何指定 JAR 的名称及其版本。

声明依赖

简单的 Hello World 示例是完全独立的，不依赖于任何其他库。然而，大多数应用程序依赖于外部库来处理常见和/或复杂的功能。

例如，假设除了说“Hello World！”之外，您还希望应用程序打印当前日期和时间。您可以使用本地 Java 库中的日期和时间工具，但您可以使用 Joda Time 库使事情变得更有趣。

首先，将 HelloWorld.java 更改为如下所示：

package hello;

import org.joda.time.LocalTime;

public class HelloWorld {
  public static void main(String[] args) {
    LocalTime currentTime = new LocalTime();
    System.out.println("The current local time is: " + currentTime);

    Greeter greeter = new Greeter();
    System.out.println(greeter.sayHello());
  }
}复制

这里​​HelloWorld​​使用 Joda Time 的​​LocalTime​​类来获取和打印当前时间。

如果您​​gradle build​​现在运行构建项目，构建将失败，因为您尚未在构建中将 Joda Time 声明为编译依赖项。

对于初学者，您需要为 3rd 方库添加源。

repositories { 
    mavenCentral() 
}复制

该​​repositories​​块指示构建应该从 Maven 中央存储库解决其依赖关系。Gradle 非常依赖 Maven 构建工具建立的许多约定和工具，包括使用 Maven Central 作为库依赖源的选项。

现在我们已经为 3rd 方库做好了准备，让我们声明一些。

sourceCompatibility = 1.8
targetCompatibility = 1.8

dependencies {
    implementation "joda-time:joda-time:2.2"
    testImplementation "junit:junit:4.12"
}复制

使用该​​dependencies​​块，您可以为 Joda Time 声明一个依赖项。具体来说，您在 joda-time 组中要求（从右到左阅读）joda-time 库的 2.2 版。

关于此依赖项的另一件需要注意的是，它是一个​​compile​​依赖项，表明它应该在编译时可用（如果您正在构建一个 WAR 文件，包含在 WAR 的 /WEB-INF/libs 文件夹中）。其他值得注意的依赖类型包括：

• ​​implementation​​. 编译项目代码所需的依赖项，但将在运行时由运行代码的容器提供（例如，Java Servlet API）。
• ​​testImplementation​​. 用于编译和运行测试的依赖项，但不是构建或运行项目运行时代码所必需的。

最后，让我们指定 JAR 工件的名称。

jar {
    archiveBaseName = 'gs-gradle'
    archiveVersion =  '0.1.0'
}复制

该​​jar​​块指定如何命名 JAR 文件。在这种情况下，它将呈现​​gs-gradle-0.1.0.jar​​.

现在，如果您运行​​gradle build​​，Gradle 应该从 Maven 中央存储库中解析 Joda Time 依赖项，并且构建将成功。

使用 Gradle Wrapper 构建您的项目

Gradle Wrapper 是启动 Gradle 构建的首选方式。它由一个适用于 Windows 的批处理脚本和一个适用于 OS X 和 Linux 的 shell 脚本组成。这些脚本允许您运行 Gradle 构建，而无需在系统上安装 Gradle。这曾经是添加到您的构建文件中的东西，但它已被折叠到 Gradle 中，因此不再需要。相反，您只需使用以下命令。

$ gradle wrapper --gradle-version 6.0.1

此任务完成后，您会注意到一些新文件。这两个脚本位于文件夹的根目录中，而包装器 jar 和属性文件已添加到新​​gradle/wrapper​​文件夹中。

└── <项目文件夹>
    └── 毕业
    └── gradlew.bat
    └── 毕业
        └── 包装
            └── gradle-wrapper.jar
            └── gradle-wrapper.properties

Gradle Wrapper 现在可用于构建您的项目。将它添加到您的版本控制系统中，克隆您的项目的每个人都可以构建它。它的使用方式与安装的 Gradle 版本完全相同。运行包装器脚本以执行构建任务，就像您之前所做的那样：

./gradlew 构建

第一次为指定版本的 Gradle 运行包装器时，它会下载并缓存该版本的 Gradle 二进制文件。Gradle Wrapper 文件旨在致力于源代码控制，因此任何人都可以构建项目，而无需先安装和配置特定版本的 Gradle。

在这个阶段，您将构建您的代码。你可以在这里看到结果：

建造
├── 班级
│ └── 主要
│ └── 你好
│ ├── Greeter.class
│ └── HelloWorld.class
├── 依赖缓存
├── 库
│ └── gs-gradle-0.1.0.jar
└── 时间
    └── 罐子
        └── 清单.MF

包括两个预期的 和 类文件​​Greeter​​，​​HelloWorld​​以及一个 JAR 文件。快速浏览一下：

$ jar tvf build/libs/gs-gradle-0.1.0.jar
  0 5 月 30 日星期五 16:02:32 CDT 2014 META-INF/
 2014 年 5 月 30 日星期五 16:02:32 CDT 25 META-INF/MANIFEST.MF
  0 5 月 30 日星期五 16:02:32 CDT 2014 你好/
369 2014 年 5 月 30 日星期五 16:02:32 CDT hello/Greeter.class
988 2014 年 5 月 30 日星期五 16:02:32 CDT hello/HelloWorld.class

类文件捆绑在一起。需要注意的是，即使您将 joda-time 声明为依赖项，该库也不包含在此处。JAR 文件也不能运行。

为了使这段代码可以运行，我们可以使用 gradle 的​​application​​插件。将此添加到您的​​build.gradle​​文件中。

应用插件：'应用程序'

mainClassName = '你好.HelloWorld'

然后你就可以运行应用程序了！

$ ./gradlew 运行
:compileJava UP-TO-DATE
:processResources 最新
:classes UP-TO-DATE
：跑
当前当地时间为：16:16:20.544
你好世界！

构建成功

总时间：3.798 秒

捆绑依赖项需要更多的思考。例如，如果我们正在构建一个 WAR 文件，一种通常与打包 3rd 方依赖项相关的格式，我们可以使用 gradle 的WAR 插件。如果您正在使用 Spring Boot 并想要一个可运行的 JAR 文件，那么spring-boot-gradle-plugin非常方便。在这个阶段，gradle 对你的系统的了解还不够多，无法做出选择。但就目前而言，这应该足以开始使用 gradle。

为了总结本指南，这里是完整的​​build.gradle​​文件：

​​build.gradle​​

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'application'

mainClassName = 'hello.HelloWorld'

// tag::repositories[]
repositories { 
    mavenCentral() 
}
// end::repositories[]

// tag::jar[]
jar {
    archiveBaseName = 'gs-gradle'
    archiveVersion =  '0.1.0'
}
// end::jar[]

// tag::dependencies[]
sourceCompatibility = 1.8
targetCompatibility = 1.8

dependencies {
    implementation "joda-time:joda-time:2.2"
    testImplementation "junit:junit:4.12"
}
// end::dependencies[]

// tag::wrapper[]
// end::wrapper[]

这里嵌入了许多开始/结束注释。这使得可以将构建文件的部分内容提取到本指南中以获取上述详细说明。您的生产构建文件中不需要它们。

概括

恭喜！您现在已经创建了一个简单而有效的 Gradle 构建文件，用于构建 Java 项目。