读书笔记《gradle-effective-implementations-guide-second-edition》进军企业

Chapter 11. Gradle in the Enterprise

在软件项目中使用持续集成工具是一种很好的做法。使用持续集成工具，我们可以在受控环境中自动构建我们的软件。在本章中，我们将了解几个持续集成工具对 Gradle 的支持。

首先，我们将创建一个示例 Java 项目并使用 Git 作为版本控制存储库。然后，我们将看看持续集成服务器，例如 Jenkins、JetBrains TeamCity ，和 Atlassian Bamboo，支持 Gradle。

我们将在本章中介绍以下主题：

创建示例 Java 项目
将 Gradle 与 Jenkins 一起使用
使用 JetBrains TeamCity 运行 Gradle 任务
学习如何为 Gradle 设置 Atlassian Bamboo

Creating a sample project

在我们看到几个持续集成服务器对 Gradle 的支持之前，我们需要有一个示例项目。在本节中，我们将创建一个非常简单的带有测试类的 Java 项目并将其添加到 Git 存储库中。

我们之前已经创建了一个 Java 项目。我们将在示例项目中重用本章中的代码。我们希望在我们的项目中进行测试，以便我们可以看到持续集成工具如何处理测试结果。最后，我们的项目需要不止一个工件；我们还需要一个 JAR 文件，其中包含已编译的类、源代码和 Javadoc 生成的文档。

我们将首先在目录中创建一个 build.gradle 文件，其内容如下：

        // We create a Java project so we need the Java plugin 
        apply plugin: 'java' 
 
        // Set base name for archives. 
        archivesBaseName = 'gradle-sample' 
 
        // Version of the project. 
        version = '1.1' 
 
        // Definine JCenter as repository for downloading 
        // dependencies. 
        repositories { 
            jcenter() 
        } 
 
        // We have a single dependency on JUnit 
        // for the testCompile configuration 
        dependencies { 
            testCompile 'junit:junit:4.11' 
        } 
 
        // Extra task to create a JAR file with the sources. 
        task sourcesJar(type: Jar) { 
            classifier = 'sources' 
            from sourceSets.main.allSource 
        } 
 
        // Extra task to create a JAR file with Javadoc 
        // generated documentation. 
        task docJar(type: Jar, dependsOn: javadoc) { 
            classifier = 'docs' 
            from javadoc.destinationDir 
        } 
 
        // Add extra JAR file to the list of artifacts 
        // for this project. 
        artifacts { 
            archives sourcesJar 
            archives docJar 
        }

接下来，我们将在 src/main/java/gradle/sample 目录下创建三个 Java 源文件。我们已经有了一个单一方法返回欢迎消息的接口：

        package gradle.sample; 
 
        /** 
        * Read welcome message from source and return value. 
        */ 
        public interface ReadWelcomeMessage { 
 
            /** 
            * @return Welcome message 
            */ 
            String getWelcomeMessage(); 
        }

然后，我们将创建此接口的实现并返回 String 值：

        package gradle.sample; 
 
        import java.util.ResourceBundle; 
 
        /** 
        * Simple implementation to return welcome message. 
        */ 
        public class ReadWelcomeMessageImpl implements
            ReadWelcomeMessage { 
 
             public ReadWelcomeMessageImpl() { 
             } 
 
             /** 
             * Return "Welcome to Gradle." String value. 
             * 
             * @return Welcome to Gradle. 
             */ 
             public String getWelcomeMessage() { 
                  return "Welcome to Gradle."; 
             } 
         }

最后，我们有一个 Java 应用程序类，它使用我们已经添加的接口和实现类：

        package gradle.sample; 
 
        import java.util.ResourceBundle; 
 
        public class SampleApp { 
 
            public SampleApp() { 
            } 
 
            public static void main(final String[] arguments) { 
                final SampleApp app = new SampleApp(); 
                app.welcomeMessage(); 
            } 
 
            public void welcomeMessage() { 
                final String welcomeMessage = readMessage(); 
                showMessage(welcomeMessage); 
            } 
 
            private String readMessage() { 
                final ReadWelcomeMessage reader = 
                  new ReadWelcomeMessageImpl(); 
                final String message = reader.getWelcomeMessage(); 
                return message; 
            } 
 
            private void showMessage(final String message) { 
                System.out.println(message); 
            } 
        }

让我们创建一个测试来验证我们的 ReadWelcomeMessageImpl 类是否返回了预期的 String 值。我们将在 src/test/java/gradle/sample目录下添加 ReadWelcomeMessageTest.java文件：

        package gradle.sample; 
 
        import org.junit.Assert; 
        import org.junit.Test; 
 
        public class ReadWelcomeMessageTest { 
 
           @Test 
            public void readWelcomeMessage() { 
                final ReadWelcomeMessage reader = new
                ReadWelcomeMessageImpl(); 
                final String realMessage =                         reader.getWelcomeMessage(); 
 
                final String expectedMessage = "Welcome to
                Gradle."; 
 
                Assert.assertEquals("Get text from                    implementation",expected Message, realMessage); 
          } 
        }

为了检查一切是否正常，我们将使用 build 任务运行 Gradle。我们应该看到以下输出：

$ gradle build
:compileJava
:processResources UP-TO-DATE
:classes
:javadoc
:docJar
:jar
:sourcesJar
:assemble
:compileTestJava
:processTestResources UP-TO-DATE
:testClasses
:test
:check
:build
BUILD SUCCESSFUL
Total time: 3.337 secs

我们有所有的源代码，所以让我们把它放在版本控制存储库中。我们可以使用任何我们想要的版本控制系统，只要持续集成服务器支持版本控制系统。我们将为我们的示例创建一个 Git 存储库，因为它很容易设置一个本地存储库，然后在持续集成工具中使用它。为了使用 Git，我们必须首先将它安装在我们的计算机上。我们将使用 Git 中的 init 命令在当前项目目录中创建一个新的 Git 存储库：
```
$ git init
Initialized empty Git repository 
      in  /Users/mrhaki/Projects/sample-project
```
接下来，我们将使用 add 命令将文件添加到 Git 暂存区：
```
$ git add .
```

我们将使用 Git 中的 commit 命令将代码提交到存储库：

$ git commit -m "First commit."
create mode 100644 build.gradle
create mode 100644 build.output.txt
create mode 100644 src/main/java/gradle/sample/
    ReadWelcomeMessage.java
create mode 100644 src/main/java/gradle/sample/
    ReadWelcomeMessageImpl.java
create mode 100644 src/main/java/gradle/sample/SampleApp.java
create mode 100644 src/test/java/gradle/sample/
    ReadWelcomeMessageTest.java

我们的项目现在可以在持续集成工具中使用了。

Using Jenkins

最流行的开源持续集成工具之一是 Jenkins。好消息是 Jenkins 通过 Gradle 插件支持 Gradle。让我们看看如何使用插件将我们的 Java 小项目添加到 Jenkins。

要在我们的计算机上安装 Jenkins，我们必须首先从 Jenkins 网站下载安装文件。本机安装程序可用于 Mac OS X、Windows 和 Linux。我们可以简单地运行安装程序软件在我们的计算机上安装 Jenkins。我们还可以下载 WAR 文件并将其部署到 Java Web 容器以安装 Jenkins。 WAR 文件也是一个 Java 可执行档案。这意味着我们可以简单地使用 java -jar 命令运行 WAR 文件来执行 Jenkins。

Adding the Gradle plugin

首先，我们必须在 Jenkins 中安装 Gradle 插件。
我们将启动一个网络浏览器并访问 http://localhost:8080 。在 Jenkins 主页中，我们将选择 Manage Jenkins 链接，这会将我们带到相应的页面，如下图所示：

管理 Jenkins 的选项概述
在这里，我们将选择 Manage Plugins。
在插件管理器页面，我们可以使用过滤器右上角的框以搜索 Gradle Plugin：

Gradle 插件的搜索结果
我们选择插件并点击Install without resta rt按钮。安装插件后，我们看到以下屏幕：

成功安装 Gradle 插件后的结果
我们需要重新启动 Jenkins 以使插件激活并可用于我们的 Jenkins 项目。

Configuring a Jenkins job

Jenkins 现在已经设置好了 Gradle 插件，是时候创建一个作业了：

在主页上，我们选择新工作链接。
我们得到一个屏幕，我们可以在其中填写作业名称并选择自由式项目单选按钮：

在 Jenkins 中创建新工作
如果我们已经填写了名称并选择了单选按钮，我们可以点击确定按钮。我们将进入我们工作的配置页面。作业名称已填充上一个屏幕中的值：

配置 Jenkins 作业
我们至少必须在 Source Code Management 部分定义我们的 Git 存储库。
此外，我们必须在 Build 部分添加一个构建步骤。
我们选择 Git 单选按钮来定义我们的 Git 存储库在存储库字段的 URL 中的位置。请注意，默认情况下不支持 Git。我们必须在 Jenkins 中安装 Git 客户端插件才能获得 Git 支持。
如果我们选择构建添加构建步骤按钮> 部分，我们可以看到 Invoke Gradle script选项。感谢 Gradle 插件，我们现在在以下屏幕截图中突出显示了此选项：

添加构建步骤以调用 Gradle
我们将选择 Invoke Gradle script选项和Jenkins添加新字段来配置我们的 Gradle 构建：

Gradle 构建步骤的详细信息
首先，我们可以选择是否要为这个项目使用 Gradle Wrapper。我们的项目不需要它，所以我们不选中它。
接下来，我们可以选择Gradle Version。我们可以为 Jenkins 安装多个 Gradle 版本，我们可以选择我们想要使用的版本。默认版本是系统路径上可用的版本。稍后我们将讨论如何向 Jenkins 添加更多 Gradle 版本。
我们可以在构建步骤描述 字段。
Switches 字段可以包含我们想要使用的 Gradle 命令行选项。例如，要排除任务，我们可以将 Switches 字段的值设置为 -x <taskName> ; 。
Tasks 字段必须包含我们要执行的任务。如果我们的项目设置了默认任务并且我们想要运行这些任务，我们可以将 Tasks 字段留空。对于我们的项目，我们要调用 clean 和 build 任务，因此我们将值设置为 干净构建。
Root Build script 字段用于多项目构建，其中 root 脚本不在默认位置。我们可以在这里定义自定义位置。
如果 Gradle 项目的构建文件名不是默认的 build.gradle，我们可以在 Build文件字段。

Running the job

我们有运行 Gradle 项目的基本设置：

我们将点击保存按钮并关闭配置。
我们将返回工作页面。在左侧，我们可以看到一个带有立即构建链接的菜单。我们将点击链接，Jenkins 将开始工作：

我们配置的 Gradle 作业概览

我们的代码将从 Git 存储库中检查，并运行 clean 和 build Gradle 任务。
如果工作完成，我们可以看到构建结果。在构建结果页面中，当我们点击 Console Output链接时，我们可以看到控制台输出：

在 Jenkins 中运行 Gradle 作业的控制台输出

在左侧，我们还可以看到所有已执行的 Gradle 任务。我们可以单击链接并直接跳转到任务的任何输出。

Configuring artifacts and test results

要查看生成的工件和测试结果，我们必须将以下两个构建后操作添加到作业配置中：

首先，我们将选择配置作业链接。在构建后操作部分，我们将点击添加构建后操作按钮。在这里，我们将首先选择 Archive the artifacts：

添加用于归档工件的构建步骤
接下来，我们将选择 Publish JUnit test result report：

添加构建步骤以发布测试结果
工件保存在我们项目的 build/libs 目录中。因此，在要归档的文件字段中，我们将输入 build/libs/.jar。我们还将设置 Test report XMLs 字段到 build/test-results/.xml：

构建步骤的配置
配置完成，所以我们点击保存按钮。我们可以再次运行该作业，这一次，我们将在作业页面上以可下载链接的形式看到项目的工件。测试结果也显示出来了，点击测试 <可以看到更多细节strong>结果链接：

包含已发布测试结果和存档工件的作业概览页面

Adding Gradle versions

我们可以向 Jenkins 添加额外的 Gradle 版本。例如，如果一些项目依赖 Gradle 2.10 而其他项目依赖 Gradle 2.11，我们可以将其他 Gradle 版本添加到 Jenkins。让我们看看如何向 Jenkins 添加另一个 Gradle 版本：

在 Manage Jenkins页面中，我们将选择 Configure System。该页面有一个 Gradle 部分，我们可以在其中添加新的 Gradle 安装：

在 Jenkins 中添加新 Gradle 版本的选项
如果我们点击 Add Gradle按钮，我们可以在 Gradle 名称字段。
我们还将看到一个自动安装复选框。如果选中此项，Jenkins 将从 Internet 为我们下载 Gradle 版本。我们可以从版本下拉框中选择版本：

配置自动安装 Gradle 版本
如果我们想使用本地安装的 Gradle 实例，我们必须取消选中 Install 自动复选框。现在，我们可以在 GRADLE_HOME 字段中设置 Gradle 位置：

现有 Gradle 安装的配置
我们必须点击保存按钮来保存更改。现在，我们可以在作业中选择正确的 Gradle 版本。

Using JetBrains TeamCity

JetBrains TeamCity 是一个商业持续集成服务器。 TeamCity 具有专业服务器许可证。这意味着我们可以创建 20 个构建配置和一个构建代理。如果我们需要更多配置或构建代理，我们可以购买其他许可证。在本节中，我们将了解如何使用 Gradle 创建构建计划。

我们可以从 JetBrains TeamCity 网站下载适用于 Mac OS X、Windows 和 Linux 的安装程序软件。我们运行安装程序软件在我们的计算机上安装 TeamCity。 TeamCity 也可用作所有平台的存档。要安装存档，我们只需将内容解压缩到我们计算机上的目录中。 TeamCity 也可用作 WAR 文件，可部署到 Java Web 容器。

Creating a project

在 TeamCity 中，我们必须使用我们想要执行的构建配置创建一个项目。让我们看看如何添加项目：

安装 TeamCity 后，我们将打开 Web 浏览器并转到 http://localhost:8111/ 。我们可以从管理页面创建一个新项目。我们还可以定义项目名称并提供简短描述：

在 TeamCity 中创建新项目
然后我们将点击创建按钮来创建项目并进入我们项目的概览页面：

项目概览页面
是时候添加新的构建配置了。我们将点击构建配置<中的创建构建配置按钮/span> 部分添加构建配置：

创建新的构建配置
我们将点击创建按钮创建项目并进入我们项目的版本控制设置页面。在这里，我们填写本地 Git 存储库的属性：

版本控制管理配置
我们将点击创建按钮进行创建项目并转到我们项目的概述页面：

版本控制配置概述
我们将在常规设置页面上定义我们项目的工件。我们可以在 Artifact paths 字段中定义项目中工件的路径。在这里，我们在 Artifact paths 字段中定义了值 build/libs/*.jar。：

项目工件的配置
在项目概览屏幕上，我们将点击添加构建步骤按钮。我们被带到一个新屏幕，在这里我们可以选择 Runner 类型的构建。在这里，我们将选择 Gradle运行器并点击保存 按钮：

使用 Gradle 定义新的构建步骤
我们现在在构建步骤的配置页面上，如以下屏幕截图所示：

Gradle 构建步骤的配置
我们可以在 Step name 字段中为此构建步骤填写描述性名称。在 Gradle Parameters部分，我们可以设置 Gradle tasks 字段中的任务。对于我们的项目，我们要调用 build 任务，所以我们将填写 build。请注意，我们可以启用增量 building项目构建。 TeamCity 将使用 buildDependents 任务。
要设置 Gradle 版本，我们将填写 Gradle home path 字段。额外的命令行参数可以填写在 Additional Gradle command line parameters字段。
如果我们的项目有 Gradle Wrapper，我们可以选中 Gradle Wrapper 复选框。然后，TeamCity 将使用 gradlew 或 gradlew.bat 脚本而不是 Gradle 主路径位置来运行 Gradle。

Running the project

我们可以保存构建配置，现在我们准备运行它，如下所示：

在右上角，我们可以看到带有省略号的 Run 按钮。当我们单击省略号时，我们将获得一个对话框窗口，其中包含我们可以在运行构建之前设置的选项，如以下屏幕截图所示：

使用 Gradle 构建步骤运行项目

我们将保留所有选项不变，然后单击 Run Build 按钮。
TeamCity 指示构建代理运行我们的构建配置。从存储库中检查代码，并调用 build Gradle 任务。在 Projects 页面上，我们将看到构建的摘要：

项目运行后的结果
我们可以单击该项目以获取更多详细信息。以下项目概述页面显示了项目构建的日期、使用的构建代理和测试结果摘要：

已运行项目的更多详细信息
如果我们点击 Tests 选项卡，我们将看到已运行的测试以及执行它们所花费的时间：

测试结果概述
Build Log 标签页显示了构建过程的输出。我们将在这里看到详细信息：

用于运行项目的 TeamCity 日志记录
最后，在 Artifacts 页面上，我们将看到生成的 JAR 文件。我们可以点击文件名，查看文件内容：

项目的工件概述

Using Atlassian Bamboo

我们要配置的最后一个持续集成工具是 Atlassian Bamboo。 Bamboo 是一个商业持续集成服务器。 Atlassian 网站提供 30 天的评估许可证。我们将讨论如何配置 Bamboo 以使用 Gradle 作为我们 Java 项目的构建工具。

我们可以在本地计算机上安装 Bamboo。我们首先需要从 Bamboo 网站下载安装包。我们可以为 Mac OS X、Windows 和 Linux 选择本机安装程序。或者，我们可以简单地下载一个打包版本并将其解压缩到我们计算机上的一个目录中。最后，我们可以下载 WAR 文件并将其部署到 Web 容器中。

Defining a plan

Bamboo 没有 Gradle runner 或插件，但我们可以定义一个构建计划并添加所谓的脚本任务。脚本任务可以运行任何脚本作为构建计划的一部分。为了确保 Bamboo 可以构建我们的 Java 项目，我们必须将 Gradle Wrapper 脚本添加到项目中。

我们将在本地 Java 项目目录中运行 wrapper 任务。我们现在有了 gradlew 和 gradlew.bat 脚本文件。此外，gradle 目录是使用 Gradle Wrapper 的配置创建的。我们将目录和文件添加到我们的 Git 存储库中，如下所示：

$ git add .
$ git commit -m "Add Gradle wrapper output."

我们现在准备在 Bamboo 中创建一个新的构建计划：

我们将启动一个网络浏览器并打开 http://localhost:8085/。登录 Bamboo 后，我们将选择创建计划链接。我们将进入一个新页面，我们可以在其中设置构建计划的属性：

在 Bamboo 中创建新计划
我们必须在项目名称字段中定义项目名称。 Bamboo 还希望在 Project Key 字段中使用大写字符的短标识符作为项目键。作为项目一部分的计划也有名称和密钥；我们填写计划名称和计划k ey 个字段。我们可以在计划说明字段中设置简短说明。
在 Source Repositories部分，我们可以为我们的项目定义 Git 存储库位置。
最后，在构建策略部分，我们将设置构建策略 下拉框改为手动。这意味着我们必须通过 Bamboo 用户界面中的运行操作手动启动构建。
我们将点击配置任务按钮将任务添加到我们的计划中。一个任务包含一些我们想要作为计划的一部分执行的逻辑：

将新任务添加到计划中
第一个任务是自动添加的，它负责检查 Git 存储库的源代码。我们将点击添加任务按钮来创建一个新任务：

搜索脚本任务
将出现一个对话框窗口，我们将从 Builder Script任务强> 部分。通过这个任务，我们可以配置要执行的 Gradle Wrapper 脚本。
我们将返回任务窗口并填写脚本配置下的字段：

配置脚本任务
我们在任务描述字段中填写描述。脚本位置必须设置为文件而不是内联 . Script 文件字段具有 gradlew 或 gradlew.bat 我们想要调用的脚本。
在 Argument字段中，我们将把参数传递给 gradlew脚本。我们要调用 build 任务，所以我们将值设置为 build。
我们准备好点击保存按钮来保存我们的脚本任务配置。该任务被添加到任务列表中，如以下屏幕截图所示：

用于运行 Gradle 的脚本任务的配置
我们可以在 Enable this Plan?部分启用该计划，方法是选中是 请！复选框。接下来，我们将点击创建按钮完成配置并将计划保存在Bamboo中。

计划概述

Running the build plan

我们现在准备好运行构建：

点击页面右上角的运行按钮。在构建运行时，我们可以看到一些日志输出。构建完成后，我们可以看到结果。
我们还希望将项目工件以及测试结果添加到我们的计划中。因此，我们将选择 Actions中的配置计划选项跨度>菜单：

运行计划后构建结果
然后我们将转到 Artifacts标签页并点击创建定义按钮添加新的工件定义：

为计划定义工件
我们将看到一个对话框窗口，我们可以定义 Name、Location 和 Copy Pattern 的工件在这里：

工件的配置
我们将 artifacts 填入 Name 字段和 构建/libs 在位置字段中。 Copy pattern字段用 < code class="literal">*.jar 值以包含所有 JAR 文件。然后我们点击创建按钮来完成工件的配置。
接下来，我们将选择 Tasks标签页并点击添加t 询问按钮来创建一个新任务。

搜索任务发布测试结果
在具有 Tasks 类型的对话框窗口中，我们将选择 JUnit Parser 来自测试部分。 Bamboo 显示了此任务的配置字段：

测试结果任务的配置
然后我们将 Task description设置为 Test results值。在指定自定义结果目录字段中，我们将设置 build/test-results/*.xml 模式。
我们现在准备再次运行我们的计划；但这一次，我们得到了测试结果：

构建结果摘要
我们将点击 Artifacts 选项卡，并查看计划已生成工件：

计划的工件概述
如果我们点击 artifacts 链接，我们会被带到一个页面，我们可以在其中下载每个 artifact JAR 文件，如以下屏幕截图所示：

下载工件的链接