Gradle - 快速指南

Gradle - 概述

在本章中，我们将了解为什么需要开发 Gradle，它的功能是什么，以及为什么使用 Groovy 编程语言来开发 Gradle。

Gradle 的历史

Ant 和 Maven 在 JAVA 市场取得了相当大的成功。Ant 是 2000 年发布的第一个构建工具，它是基于过程式编程思想开发的。后来，在 Apache-IVY 的帮助下，它通过网络接受插件和依赖管理的能力得到了改进。

Ant 的主要缺点包括：

使用 XML 作为格式编写构建脚本。
对于过程式编程来说，分层结构并不好，并且
XML 相对难以管理。

Maven 于 2004 年推出。它比 ANT 有了很多改进。它能够改变其结构，并且 XML 可以用于编写构建规范。Maven 依赖于约定，并且能够通过网络下载依赖项。

Maven 的主要优点包括：

Maven 的生命周期，在连续多个项目中遵循相同生命周期。

Maven 在依赖管理方面遇到的一些问题包括：

它不处理同一库的不同版本之间的冲突。
与在ANT中编写构建脚本相比，在 Maven 中编写复杂的自定义构建脚本比较困难。

最后，Gradle 于 2012 年出现，它融合了这两个工具的一些有效功能。

Gradle 的特性

Gradle 提供的功能列表。

声明式构建和约定式构建

Gradle 提供了基于 Groovy 语言的独立领域特定语言 (DSL)。
它提供了声明式语言元素。这些元素还为 Java、Groovy、OSGI、Web 和 Scala 提供了约定式构建支持。

基于依赖的编程语言

声明式语言位于通用任务图的顶部，构建中可以完全支持该任务图。

构建结构

Gradle 允许您将通用设计原则应用于您的构建。它将为您提供完美的构建结构，以便您可以设计结构良好且易于维护、易于理解的构建。

深度 API

通过使用此 API，您可以监控并自定义其配置和执行行为的核心。

Gradle 可扩展

Gradle 可以轻松提高生产力，从简单和单个项目构建到庞大的企业多项目构建。

多项目构建

Gradle 支持多项目构建和部分构建。如果您构建一个子项目，Gradle 会负责构建该子项目所依赖的所有子项目。

管理构建的不同方法

Gradle 支持不同的策略来管理您的依赖项。

Gradle 是第一个构建集成工具

Gradle 完全支持您的 ANT 任务、Maven 和 lvy 存储库基础设施以发布和检索依赖项。它还提供了一个转换器，用于将 Maven pom.xml 转换为 Gradle 脚本。

易于迁移

Gradle 可以轻松适应任何结构。因此，您始终可以在同一个分支中开发 Gradle 构建，您可以在其中构建实时脚本。

Gradle 包装器

Gradle 包装器允许您在未安装 Gradle 的机器上执行 Gradle 构建。这对于持续集成服务器很有用。

免费开源

Gradle 是一个开源项目，并根据 Apache 软件许可证 (ASL) 许可。

Groovy

Gradle 的构建脚本是用 Groovy 编程语言编写的。Gradle 的整个设计都面向用作语言而不是用作刚性框架。Groovy 允许您使用一些抽象编写自己的脚本。整个 Gradle API 完全用 Groovy 语言设计。

为什么 Gradle 使用 Groovy？

完整的 Gradle API 是使用 Groovy 语言设计的。这是内部 DSL 相对于 XML 的优势。Gradle 是一个通用的构建工具，其主要关注点是 Java 项目。

在这些项目中，团队成员将非常熟悉 Java，并且最好使构建对所有团队成员尽可能透明。

像 Python、Groovy 或 Ruby 这样的语言更适合构建框架。选择 Groovy 的原因是，因为它为使用 Java 的人员提供了迄今为止最大的透明度。Groovy 的基本语法与 Java 相同，并且 Groovy 为其用户提供了更多好处。

Gradle - 安装

Gradle 是一个基于 Java 的构建工具。在安装 Gradle 框架之前，需要安装一些先决条件。

安装 Gradle 的先决条件

JDK 和 Groovy 是 Gradle 安装的先决条件。

Gradle 需要在系统中安装 JDK 版本 6 或更高版本。它使用已安装的 JDK 库，并将其设置为 JAVA_HOME 环境变量。

Gradle 自带 Groovy 库，因此，我们无需显式安装 Groovy。如果已安装，Gradle 会忽略它。

下面说明了在您的系统中安装 Gradle 的步骤。

步骤 1 - 验证 JAVA 安装

首先，您需要在系统上安装 Java 软件开发工具包 (SDK)。要验证这一点，请在您正在使用的任何平台上执行Java –version命令。

在 Windows 中

执行以下命令以验证 Java 安装。我在我的系统中安装了 JDK 1.8。

C:\> java - version

输出

输出如下：

java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b18)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b18, mixed mode)

在 Linux 中

执行以下命令以验证 Java 安装。我们在系统中安装了 JDK 1.8。

$ java - version

输出

java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b18)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b18, mixed mode)

我们假设本教程的读者在其系统上安装了 Java SDK 版本 1.8.0_66。

步骤 2 - 下载 Gradle 构建文件

从https://gradle.org.cn/install/提供的链接下载最新版本的 Gradle。在参考页面中，单击完整分发版链接。此步骤对任何平台都适用。为此，您将获得完整的分发文件到您的下载文件夹中。

步骤 3 - 设置 Gradle 的环境

设置环境意味着，我们必须提取分发文件并将库文件复制到正确的位置。设置GRADLE_HOME和PATH环境变量。此步骤依赖于平台。

在 Windows 中

提取名为gradle-2.11-all.zip的已下载 zip 文件，并将分发文件从Downloads\gradle-2.11\复制到C:\gradle\位置。

之后，将C:\gradle 和 C:\gradle\bin 目录添加到 GRADLE_HOME 和 PATH 系统变量中。

按照给定的说明操作：右键单击我的电脑 -> 单击属性 -> 高级系统设置 -> 单击环境变量。

您将在那里找到一个用于创建和编辑系统变量的对话框。

单击新建按钮以创建GRADLE_HOME变量（请参考左侧截图）。

单击编辑以编辑现有的 Path 系统变量（请参考右侧截图）。

请参考以下截图。

在 Linux 中

提取名为gradle-2.11-all.zip的已下载 zip 文件，然后您将找到一个名为gradle-2.11的提取文件。

您可以使用以下命令将分发文件从Downloads/gradle-2.11/移动到/opt/gradle/位置。从 Downloads 目录执行此操作。

$ sudo mv gradle-2.11 /opt/gradle

编辑~/.bashrc 文件并将以下内容粘贴到其中并保存。

export ORIENT_HOME = /opt/gradle
export PATH = $PATH:

执行以下命令以执行~/.bashrc文件。

$ source ~/.bashrc

步骤 4 - 验证 Gradle 安装

在 Windows 中

您可以在命令提示符中执行以下命令。

C:\> gradle –v

输出

在这里您将找到 Gradle 版本。

------------------------------------------------------------
Gradle 2.11
------------------------------------------------------------

Build time: 2016-02-08 07:59:16 UTC
Build number: none
Revision: 584db1c7c90bdd1de1d1c4c51271c665bfcba978
Groovy: 2.4.4

Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_60 (Oracle Corporation 24.60-b09)
OS: Windows 8.1 6.3 amd64

在 Linux 中

您可以在终端中执行以下命令。

$ gradle –v

输出

在这里您将找到 Gradle 版本。

------------------------------------------------------------
Gradle 2.11
------------------------------------------------------------

Build time: 2016-02-08 07:59:16 UTC
Build number: none
Revision: 584db1c7c90bdd1de1d1c4c51271c665bfcba978

Groovy: 2.4.4
Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_60 (Oracle Corporation 24.60-b09)
OS: Windows 8.1 6.3 amd64

在 Linux 中

您可以在终端中执行以下命令。

$ gradle –v

输出

您将找到 Gradle 版本。

------------------------------------------------------------
Gradle 2.11
------------------------------------------------------------
Build time: 2016-02-08 07:59:16 UTC
Build number: none
Revision: 584db1c7c90bdd1de1d1c4c51271c665bfcba978
Groovy: 2.4.4
Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_60 (Oracle Corporation 24.60-b09)
OS: Linux 3.13.0-74-generic amd64

Gradle - 构建脚本

Gradle 构建一个脚本文件来处理两件事；一个是项目，另一个是任务。每个 Gradle 构建都代表一个或多个项目。

一个项目代表一个库 JAR 或一个 Web 应用程序，或者它可能代表一个从其他项目生成的 JAR 组装而成的 ZIP。简单来说，一个项目是由不同的任务组成的。

任务是指构建执行的一段工作。任务可能是编译一些类、创建 JAR、生成 Javadoc 或将一些存档发布到存储库。

Gradle 使用 Groovy 语言编写脚本。

编写构建脚本

Gradle 提供了一种领域特定语言 (DSL)，用于描述构建。它使用 Groovy 语言来简化构建的描述。Gradle 的每个构建脚本都使用 UTF-8 编码，脱机保存，并命名为 build.gradle。

build.gradle

我们通过使用 Groovy 脚本描述任务和项目。您可以使用 Gradle 命令运行 Gradle 构建。此命令查找名为build.gradle的文件。

请查看以下示例，它表示一个打印tutorialspoint的小脚本。

将以下脚本复制并保存到名为build.gradle的文件中。此构建脚本定义了一个名为 hello 的任务，用于打印 tutorialspoint 字符串。

task hello {
  doLast {
   println 'tutorialspoint'
  }
}

在存储 build.gradle 文件的命令提示符中执行以下命令。

C:\> gradle –q hello

输出

您将看到以下输出 -

tutorialspoint

如果您认为任务的工作方式类似于ANT 的目标，那么就是正确的。Gradle 任务等效于 ANT 目标。

您可以通过为doLast语句指定一个快捷方式（表示符号<<）来简化此 hello 任务。如果您将此快捷方式添加到上面的任务hello中，它将如下所示 -

task hello << {
   println 'tutorialspoint'
}

现在，您可以使用gradle –q hello命令执行上述脚本。

Gradle 脚本主要使用两个真实的 Object，一个是 Project Object，另一个是 Script Object。

Project Object - 每个脚本描述一个或多个项目。在执行过程中，此脚本配置 Project Object。您可以在构建脚本中执行某些方法并使用属性，这些方法和属性被委托给 Project Object。
Script Object - Gradle 将脚本代码转换为类，这些类实现 Script 接口，然后执行。这意味着脚本接口声明的所有属性和方法都可以在您的脚本中使用。

下表定义了标准项目属性列表。所有这些属性都可以在您的构建脚本中使用。

序号	名称	类型	默认值
1	project	Project	Project 实例
2	name	String	项目目录的名称。
3	path	String	项目的绝对路径。
4	description	String	项目的描述。
5	projectDir	File	包含构建脚本的目录。
6	buildDir	File	projectDir/build
7	group	Object	未指定
8	version	Object	未指定
9	ant	AntBuilder	AntBuilder 实例

Groovy 基础

Gradle 构建脚本使用完整的 Groovy API。

作为入门，请查看以下示例。

示例 1

此示例说明如何将字符串转换为大写。

复制并保存下面给出的代码，到build.gradle文件中。

task upper << {
   String expString = 'TUTORIALS point'
   println "Original: " + expString
   println "Upper case: " + expString.toUpperCase()
}

在命令提示符中执行以下命令。它执行上面给出的脚本。您应该在存储 build.gradle 文件的位置执行此操作。

C:\> gradle –q upper

输出

Original: TUTORIALS point
Upper case: TUTORIALS POINT

示例 2

以下示例说明打印隐式参数（$it）的值 4 次

复制并保存以下代码到build.gradle文件中。

task count << {
   4.times { 
    print "$it " 
   }
}

在命令提示符中执行以下命令。它执行上面提到的脚本。您应该在存储 build.gradle 文件的位置执行此操作。

$ gradle –q count

输出

这将产生以下输出 -

0 1 2 3

Groovy 的特性

Groovy 语言提供了大量特性。下面讨论了一些重要的特性 -

Groovy JDK 方法

Groovy 为标准 Java 类添加了许多有用的方法。例如，来自 JDK 的 Iterable API 实现了一个each()方法，该方法迭代 Iterable 接口的元素。

复制并保存以下代码到build.gradle文件中。

task groovyJDK << {
   String myName = "Marc";
   myName.each() { 
    println "${it}" 
   };
}

在命令提示符中执行以下命令。它执行上面给出的脚本。您应该在存储 build.gradle 文件的位置执行此操作。

C:\> gradle –q groovyJDK

输出

执行上述代码时，您应该看到以下输出 -

M
a
r
c

属性访问器

您可以通过指定属性的引用来自动访问特定属性的 getter 和 setter 方法。

以下代码段定义了属性buildDir的 getter 和 setter 方法的语法。

// Using a getter method
println project.buildDir
println getProject().getBuildDir()

// Using a setter method
project.buildDir = 'target'
getProject().setBuildDir('target')

方法调用中的可选括号

Groovy 在方法调用中包含一个特殊功能，即方法调用中的括号是可选的。此功能也适用于 Gradle 脚本。

请查看以下语法。它定义了test对象的systemProperty方法调用。

test.systemProperty 'some.prop', 'value'
test.systemProperty('some.prop', 'value')

闭包作为最后一个参数

Gradle DSL 在许多地方使用闭包，其中方法的最后一个参数是闭包。您可以在方法调用之后放置闭包。

以下代码段定义了闭包用作 repositories() 方法参数的语法。

repositories {
   println "in a closure"
}
repositories() { 
   println "in a closure" 
}
repositories({ println "in a closure" })

默认导入

Gradle 会自动向 Gradle 脚本添加一组 import 语句。以下列表显示了 Gradle 脚本的默认导入包。

Gradle 脚本的默认导入包如下所示 -

import org.gradle.*
import org.gradle.api.*
import org.gradle.api.artifacts.*
import org.gradle.api.artifacts.cache.*
import org.gradle.api.artifacts.component.*
import org.gradle.api.artifacts.dsl.*
import org.gradle.api.artifacts.ivy.*
import org.gradle.api.artifacts.maven.*
import org.gradle.api.artifacts.query.*
import org.gradle.api.artifacts.repositories.*
import org.gradle.api.artifacts.result.*
import org.gradle.api.component.*
import org.gradle.api.credentials.*
import org.gradle.api.distribution.*
import org.gradle.api.distribution.plugins.*
import org.gradle.api.dsl.*
import org.gradle.api.execution.*
import org.gradle.api.file.*
import org.gradle.api.initialization.*
import org.gradle.api.initialization.dsl.*
import org.gradle.api.invocation.*
import org.gradle.api.java.archives.*
import org.gradle.api.logging.*
import org.gradle.api.plugins.*
import org.gradle.api.plugins.announce.*
import org.gradle.api.plugins.antlr.*
import org.gradle.api.plugins.buildcomparison.gradle.*
import org.gradle.api.plugins.jetty.*
import org.gradle.api.plugins.osgi.*
import org.gradle.api.plugins.quality.*
import org.gradle.api.plugins.scala.*
import org.gradle.api.plugins.sonar.*
import org.gradle.api.plugins.sonar.model.*
import org.gradle.api.publish.*
import org.gradle.api.publish.ivy.*
import org.gradle.api.publish.ivy.plugins.*
import org.gradle.api.publish.ivy.tasks.*
import org.gradle.api.publish.maven.*
import org.gradle.api.publish.maven.plugins.*
import org.gradle.api.publish.maven.tasks.*
import org.gradle.api.publish.plugins.*
import org.gradle.api.reporting.*
import org.gradle.api.reporting.components.*
import org.gradle.api.reporting.dependencies.*
import org.gradle.api.reporting.model.*
import org.gradle.api.reporting.plugins.*
import org.gradle.api.resources.*
import org.gradle.api.specs.*
import org.gradle.api.tasks.*
import org.gradle.api.tasks.ant.*
import org.gradle.api.tasks.application.*
import org.gradle.api.tasks.bundling.*
import org.gradle.api.tasks.compile.*
import org.gradle.api.tasks.diagnostics.*
import org.gradle.api.tasks.incremental.*
import org.gradle.api.tasks.javadoc.*
import org.gradle.api.tasks.scala.*
import org.gradle.api.tasks.testing.*
import org.gradle.api.tasks.testing.junit.*
import org.gradle.api.tasks.testing.testng.*
import org.gradle.api.tasks.util.*
import org.gradle.api.tasks.wrapper.*
import org.gradle.authentication.*
import org.gradle.authentication.http.*
import org.gradle.buildinit.plugins.*
import org.gradle.buildinit.tasks.*
import org.gradle.external.javadoc.*
import org.gradle.ide.cdt.*
import org.gradle.ide.cdt.tasks.*
import org.gradle.ide.visualstudio.*
import org.gradle.ide.visualstudio.plugins.*
import org.gradle.ide.visualstudio.tasks.*
import org.gradle.ivy.*
import org.gradle.jvm.*
import org.gradle.jvm.application.scripts.*
import org.gradle.jvm.application.tasks.*
import org.gradle.jvm.platform.*
import org.gradle.jvm.plugins.*
import org.gradle.jvm.tasks.*
import org.gradle.jvm.tasks.api.*
import org.gradle.jvm.test.*
import org.gradle.jvm.toolchain.*
import org.gradle.language.assembler.*
import org.gradle.language.assembler.plugins.*
import org.gradle.language.assembler.tasks.*
import org.gradle.language.base.*
import org.gradle.language.base.artifact.*
import org.gradle.language.base.plugins.*
import org.gradle.language.base.sources.*
import org.gradle.language.c.*
import org.gradle.language.c.plugins.*
import org.gradle.language.c.tasks.*
import org.gradle.language.coffeescript.*
import org.gradle.language.cpp.*
import org.gradle.language.cpp.plugins.*
import org.gradle.language.cpp.tasks.*
import org.gradle.language.java.*
import org.gradle.language.java.artifact.*
import org.gradle.language.java.plugins.*
import org.gradle.language.java.tasks.*
import org.gradle.language.javascript.*
import org.gradle.language.jvm.*
import org.gradle.language.jvm.plugins.*
import org.gradle.language.jvm.tasks.*
import org.gradle.language.nativeplatform.*
import org.gradle.language.nativeplatform.tasks.*
import org.gradle.language.objectivec.*
import org.gradle.language.objectivec.plugins.*
import org.gradle.language.objectivec.tasks.*
import org.gradle.language.objectivecpp.*
import org.gradle.language.objectivecpp.plugins.*
import org.gradle.language.objectivecpp.tasks.*
import org.gradle.language.rc.*
import org.gradle.language.rc.plugins.*
import org.gradle.language.rc.tasks.*
import org.gradle.language.routes.*
import org.gradle.language.scala.*
import org.gradle.language.scala.plugins.*
import org.gradle.language.scala.tasks.*
import org.gradle.language.scala.toolchain.*
import org.gradle.language.twirl.*
import org.gradle.maven.*
import org.gradle.model.*
import org.gradle.nativeplatform.*
import org.gradle.nativeplatform.platform.*
import org.gradle.nativeplatform.plugins.*
import org.gradle.nativeplatform.tasks.*
import org.gradle.nativeplatform.test.*
import org.gradle.nativeplatform.test.cunit.*
import org.gradle.nativeplatform.test.cunit.plugins.*
import org.gradle.nativeplatform.test.cunit.tasks.*
import org.gradle.nativeplatform.test.googletest.*
import org.gradle.nativeplatform.test.googletest.plugins.*
import org.gradle.nativeplatform.test.plugins.*
import org.gradle.nativeplatform.test.tasks.*
import org.gradle.nativeplatform.toolchain.*
import org.gradle.nativeplatform.toolchain.plugins.*
import org.gradle.platform.base.*
import org.gradle.platform.base.binary
import org.gradle.platform.base.component.*
import org.gradle.platform.base.plugins.*
import org.gradle.platform.base.test.*
import org.gradle.play.*
import org.gradle.play.distribution.*
import org.gradle.play.platform.*
import org.gradle.play.plugins.*
import org.gradle.play.tasks.*
import org.gradle.play.toolchain.*
import org.gradle.plugin.use.*
import org.gradle.plugins.ear.*
import org.gradle.plugins.ear.descriptor.*
import org.gradle.plugins.ide.api.*
import org.gradle.plugins.ide.eclipse.*
import org.gradle.plugins.ide.idea.*
import org.gradle.plugins.javascript.base.*
import org.gradle.plugins.javascript.coffeescript.*
import org.gradle.plugins.javascript.envjs.*
import org.gradle.plugins.javascript.envjs.browser.*
import org.gradle.plugins.javascript.envjs.http.*
import org.gradle.plugins.javascript.envjs.http.simple.*
import org.gradle.plugins.javascript.jshint.*
import org.gradle.plugins.javascript.rhino.*
import org.gradle.plugins.javascript.rhino.worker.*
import org.gradle.plugins.signing.*
import org.gradle.plugins.signing.signatory.*
import org.gradle.plugins.signing.signatory.pgp.*
import org.gradle.plugins.signing.type.*
import org.gradle.plugins.signing.type.pgp.*
import org.gradle.process.*
import org.gradle.sonar.runner.*
import org.gradle.sonar.runner.plugins.*
import org.gradle.sonar.runner.tasks.*
import org.gradle.testing.jacoco.plugins.*
import org.gradle.testing.jacoco.tasks.*
import org.gradle.testkit.runner.*
import org.gradle.util.*

Gradle - 任务

Gradle 构建脚本描述了一个或多个项目。每个项目都由不同的任务组成，而任务是构建执行的一项工作。

任务可能是编译一些类，将类文件存储到单独的目标文件夹中，创建 JAR，生成 Javadoc 或将一些存档发布到存储库中。

本章说明什么是任务以及如何生成和执行任务。

定义任务

Task 是一个关键字，用于在构建脚本中定义任务。

请查看以下示例，该示例表示一个名为hello的任务，该任务打印tutorialspoint。将以下脚本复制并保存到名为build.gradle的文件中。

此构建脚本定义了一个名为hello的任务，用于打印 tutorialspoint 字符串。

task hello {
   doLast {
    println 'tutorialspoint'
   }
}

在命令提示符中执行以下命令。它执行上述脚本。您应该在存储 build.gradle 文件的位置执行此操作。

C:\> gradle –q hello

输出

以下是代码的输出 -

tutorialspoint

您可以通过为doLast语句指定一个快捷方式（表示符号<<）来简化此hello 任务。如果您将此快捷方式添加到上面的任务hello中，它将如下所示 -

task hello << {
   println 'tutorialspoint'
}

您可以使用gradle –q hello命令执行上述脚本。

以下示例定义了一个任务hello。

复制并保存以下代码到build.gradle文件中。

task (hello) << {
   println "tutorialspoint"
}

在命令提示符中执行以下命令。它执行上面给出的脚本。您应该在存储 build.gradle 文件的位置执行此操作。

C:\> gradle –q hello

输出

输出如下所示 -

tutorialspoint

您还可以使用字符串作为任务名称。请查看相同的hello 示例。在这里，我们将使用String作为任务。

复制并保存以下代码到build.gradle文件中。

task('hello') << {
   println "tutorialspoint"
}

在命令提示符中执行以下命令。它执行上面提到的脚本。您应该在存储 build.gradle 文件的位置执行此操作。

C:\> gradle –q hello

输出

执行上述代码时，您应该看到以下输出 -

tutorialspoint

您还可以使用另一种语法来定义任务。即，使用 create() 方法来定义任务。请查看下面给出的相同 hello 示例。

复制并保存下面给出的代码到build.gradle文件中。

tasks.create(name: 'hello') << {
   println "tutorialspoint"
}

在命令提示符中执行以下命令。它执行上面提到的脚本。您应该在存储 build.gradle 文件的位置执行此操作。

C:\> gradle –q hello

输出

执行后，您将收到以下输出 -

tutorialspoint

查找任务

如果您想找到在构建文件中定义的任务，那么您必须使用相应的标准项目属性。这意味着每个任务都作为项目的属性可用，其中任务名称用作属性名称。

请查看以下访问任务作为属性的代码。

复制并保存下面给出的代码到build.gradle文件中。

task hello

println hello.name
println project.hello.name

在命令提示符中执行以下命令。它执行上面给出的脚本。您应该在存储 build.gradle 文件的位置执行此操作。

C:\> gradle –q hello

输出

输出如下所示 -

hello
hello

您还可以通过 tasks 集合使用所有属性。

复制并保存以下代码到build.gradle文件中。

task hello

println tasks.hello.name
println tasks['hello'].name

在命令提示符中执行以下命令。它执行上面提到的脚本。您应该在存储 build.gradle 文件的位置执行此操作。

C:\> gradle –q hello

输出

这将产生以下输出 -

hello
hello

您还可以使用 tasks 访问任务的路径。为此，您可以使用任务名称、相对路径或绝对路径调用getByPath() 方法。

复制并保存下面给出的代码到build.gradle文件中。

project(':projectA') {
   task hello
}
task hello

println tasks.getByPath('hello').path
println tasks.getByPath(':hello').path
println tasks.getByPath('projectA:hello').path
println tasks.getByPath(':projectA:hello').path

在命令提示符中执行以下命令。它执行上面给出的脚本。您应该在存储 build.gradle 文件的位置执行此操作。

C:\> gradle –q hello

输出

输出如下所示 -

:hello
:hello
:projectA:hello
:projectA:hello

向任务添加依赖项

您可以使一个任务依赖于另一个任务，这意味着当一个任务完成后，另一个任务才会开始。

每个任务都使用任务名称进行区分。任务名称的集合由其 tasks 集合引用。要引用另一个项目中的任务，您应该使用项目的路径作为相应任务名称的前缀。

以下示例向 taskX 添加对 taskY 的依赖项。

复制并保存下面给出的代码到build.gradle文件中。请查看以下代码。

task taskX << {
   println 'taskX'
}
task taskY(dependsOn: 'taskX') << {
   println "taskY"
}

在命令提示符中执行以下命令。它执行上面提到的脚本。您应该在存储build.gradle文件的位置执行此操作。

C:\> gradle –q taskY

输出

输出如下所示 -

taskX
taskY

以上示例是使用任务名称添加任务依赖项。还有另一种方法可以实现任务依赖项，即使用 Task 对象定义依赖项。

让我们以taskY依赖于 taskX 为例，但是在这里，我们使用的是 Task 对象而不是任务引用名称。

复制并保存以下代码到build.gradle文件中。

task taskY << {
   println 'taskY'
}
task taskX << {
   println 'taskX'
}
taskY.dependsOn taskX

在命令提示符中执行以下命令。您应该在存储 build.gradle 文件的位置执行此操作。

C:\> gradle –q taskY

输出

输出如下所示 -

taskX
taskY

以上示例是使用任务名称添加任务依赖项。

还有另一种方法可以实现任务依赖项，即使用 Task 对象定义依赖项。

在这里，我们使用相同的示例，taskY依赖于taskX，但是我们使用的是 Task 对象而不是任务引用名称。

复制并保存下面给出的代码到build.gradle文件中。请查看以下代码。

task taskX << {
   println 'taskX'
}
taskX.dependsOn {
   tasks.findAll { 
    task → task.name.startsWith('lib') 
   }
}
task lib1 << {
   println 'lib1'
}
task lib2 << {
   println 'lib2'
}
task notALib << {
   println 'notALib'
}

在命令提示符中执行以下命令。它执行上面给出的脚本。您应该在存储build.gradle文件的位置执行此操作。

C:\> gradle –q taskX

输出

输出如下所示 -

lib1
lib2
taskX

添加描述

您可以向任务添加描述。当您执行Gradle tasks时，将显示此描述，这可以通过使用 description 关键字来实现。

复制并保存以下代码到build.gradle文件中。请查看以下代码。

task copy(type: Copy) {
   description 'Copies the resource directory to the target directory.'
   from 'resources'
   into 'target'
   include('**/*.txt', '**/*.xml', '**/*.properties')
   println("description applied")
}

在命令提示符中执行以下命令。您应该在存储 build.gradle 文件的位置执行此操作。

C:\> gradle –q copy

如果命令成功执行，您将获得以下输出

description applied

跳过任务

跳过任务可以通过传递一个谓词闭包来完成。只有当任务的方法或闭包在执行任务的实际工作之前抛出StopExecutionException时，这才是可能的。

复制并保存以下代码到build.gradle文件中。

task eclipse << {
   println 'Hello Eclipse'
}

// #1st approach - closure returning true, if the task should be executed, false if not.
eclipse.onlyIf {
   project.hasProperty('usingEclipse')
}

// #2nd approach - alternatively throw an StopExecutionException() like this
eclipse.doFirst {
   if(!usingEclipse) {
      throw new StopExecutionException()
   }
}

在命令提示符中执行以下命令。您应该在存储 build.gradle 文件的位置执行此操作。

C:\> gradle –q eclipse

任务结构

在处理任务时，Gradle 具有不同的阶段。首先，有一个配置阶段，其中直接在任务的闭包中指定的代码将被执行。配置块将为每个可用的任务执行，而不仅仅是为稍后实际执行的任务执行。

在配置阶段之后，执行阶段将运行那些实际执行的任务的doFirst或doLast闭包内的代码。

Gradle - 依赖管理

Gradle 构建脚本定义了一个构建项目的流程；每个项目包含一些依赖项和一些发布项。依赖项指的是构建项目所需的支撑内容，例如来自其他项目的必需 JAR 文件以及类路径中的外部 JAR 文件，例如 JDBC JAR 或 Eh-cache JAR。

发布项指的是项目的输出结果，例如测试类文件、构建文件和 war 文件。

并非所有项目都是自包含的。它们需要由其他项目构建的文件来编译和测试源文件。例如，为了在项目中使用 Hibernate，您需要在类路径中包含一些 Hibernate JAR 文件。Gradle 使用一些特殊的脚本定义依赖项，这些依赖项需要下载。

Gradle 处理构建和发布输出结果。发布基于您定义的任务。它可能希望将文件复制到本地目录，或将它们上传到远程 Maven 或 Ivy 存储库，或者您可能在同一个多项目构建中使用来自另一个项目的文件。我们可以将发布过程中的任务称为发布项。

声明您的依赖项

依赖项配置定义了一组依赖项。您可以使用此功能声明外部依赖项，您希望从 Web 下载这些依赖项。这定义了如下不同的标准。

apply plugin: 'java'

repositories {
   mavenCentral()
}

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
   testCompile group: 'junit', name: 'junit', version: '4.+'
}

依赖项配置

依赖项配置定义了一组依赖项。您可以使用此功能声明外部依赖项，您希望从 Web 下载这些依赖项。这定义了以下不同的标准配置。

Compile − 编译项目生产源代码所需的依赖项。
Runtime − 生产类在运行时所需的依赖项。默认情况下，它还包括编译时依赖项。
Test Compile − 编译项目测试源代码所需的依赖项。默认情况下，它包括已编译的生产类和编译时依赖项。
Test Runtime − 运行测试所需的依赖项。默认情况下，它包括运行时和测试编译依赖项。

外部依赖项

外部依赖项是依赖项的一种类型。这依赖于当前构建外部构建的一些文件，并存储在某种类型的存储库中，例如 Maven 中央存储库、公司 Maven 或 Ivy 存储库，或者本地文件系统中的目录。

以下代码片段用于定义外部依赖项。在build.gradle文件中使用此代码。

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
}

外部依赖项声明了外部依赖项，快捷形式如下所示："group: name: version"。

存储库

添加外部依赖项时，Gradle 会在存储库中查找它们。按组、名称和版本组织的文件集合称为存储库。默认情况下，Gradle 没有定义任何存储库。我们必须显式定义至少一个存储库。以下代码片段定义了如何定义 Maven 存储库。在build.gradle文件中使用此代码。

在build.gradle文件中使用以下代码 −

repositories {
   mavenCentral()
}

以下代码用于定义远程 Maven。在build.gradle文件中使用此代码。

repositories {
   maven {
    url "http://repo.mycompany.com/maven2"
   }
}

发布构件

依赖项配置也用于发布文件。这些已发布的文件称为构件。通常，我们使用插件来定义构件。但是，您确实需要告诉 Gradle 在哪里发布构件。

您可以通过将存储库附加到 uploadArchives 任务来实现此目的。查看发布 Maven 存储库的以下语法。在执行时，Gradle 会根据项目要求生成并上传Pom.xml。

在build.gradle文件中使用此代码。

apply plugin: 'maven'

uploadArchives {
   repositories {
      mavenDeployer {
         repository(url: "file://127.0.0.1/tmp/myRepo/")
      }
   }
}

Gradle - 插件

插件只不过是一组所有有用的任务，例如编译任务、设置域对象、设置源文件等，都由插件处理。将插件应用于项目意味着它允许插件扩展项目的功能。

插件可以执行以下操作 −

扩展基本的 Gradle 模型（例如，添加可以配置的新 DSL 元素）。
根据约定配置项目（例如，添加新任务或配置合理的默认值）。
应用特定配置（例如，添加组织存储库或强制执行标准）。

插件类型

Gradle 中有两种类型的插件，如下所示 −

脚本插件 − 脚本插件是一个额外的构建脚本，它提供了一种声明式方法来操作构建。这通常在构建内部使用。
二进制插件 − 二进制插件是实现插件接口并采用编程方法来操作构建的类。二进制插件可以驻留在构建脚本中，在项目层次结构中，或者外部在插件 JAR 中。

应用插件

Project.apply() API 方法用于应用特定的插件。您可以多次使用同一个插件。插件有两种类型，一种是脚本插件，另一种是二进制插件。

脚本插件

脚本插件可以从本地文件系统上的脚本或远程位置应用。文件系统位置相对于项目目录，而远程脚本位置指定 HTTP URL。

查看以下代码片段。它用于将other.gradle插件应用于构建脚本。在build.gradle文件中使用此代码。

apply from: 'other.gradle'

二进制插件

每个插件都由插件 ID 标识。一些核心插件使用简短名称来应用插件 ID，而一些社区插件使用完全限定名称作为插件 ID。有时，它允许指定插件的类。

查看以下代码片段。它展示了如何使用其类型应用 Java 插件。在下面的build.gradle文件中使用代码。

apply plugin: JavaPlugin

查看以下代码，了解如何使用简短名称应用核心插件。在build.gradle文件中使用此代码。

plugins {
   id 'java'
}

查看以下代码，了解如何使用简短名称应用社区插件。在build.gradle文件中使用此代码。

plugins {
   id "com.jfrog.bintray" version "0.4.1"
}

编写自定义插件

创建自定义插件时，您需要编写插件的实现。Gradle 实例化插件并使用 Plugin.apply() 方法调用插件实例。

以下示例包含一个问候插件，它向项目添加了一个 hello 任务。查看以下代码，并在build.gradlebuild.gradle 文件中使用此代码。

apply plugin: GreetingPlugin

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.task('hello') << {
         println "Hello from the GreetingPlugin"
      }
   }
}

使用以下代码执行上述脚本。

C:\> gradle -q hello

输出

这将产生以下输出 -

Hello from the GreetingPlugin

从构建中获取输入

大多数插件需要构建脚本的配置支持。Gradle 项目具有一个关联的 ExtensionContainer 对象，该对象有助于跟踪传递给插件的所有设置和属性。

让我们向项目添加一个简单的扩展对象。在这里，我们向项目添加了一个问候扩展对象，它允许您配置问候语。在build.gradle文件中使用此代码。

apply plugin: GreetingPlugin

greeting.message = 'Hi from Gradle'

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      // Add the 'greeting' extension object
      project.extensions.create("greeting", GreetingPluginExtension)
		
      // Add a task that uses the configuration
      project.task('hello') << {
         println project.greeting.message
      }
   }
}

class GreetingPluginExtension {
   def String message = 'Hello from GreetingPlugin'
}

使用以下代码执行上述脚本 −

C:\> gradle -q hello

输出

运行代码时，您将看到以下输出 −

Hi from Gradle

在此示例中，GreetingPlugin 是一个简单的旧 Groovy 对象，带有一个名为 message 的字段。扩展对象以名称 greeting 添加到插件列表中。然后，此对象作为具有与扩展对象相同名称的项目属性可用。

Gradle 为每个扩展对象添加了一个配置闭包，因此您可以将设置组合在一起。查看以下代码。在build.gradle文件中使用此代码。

apply plugin: GreetingPlugin

greeting {
   message = 'Hi'
   greeter = 'Gradle'
}

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.extensions.create("greeting", GreetingPluginExtension)
		
      project.task('hello') << {
         println "${project.greeting.message} from ${project.greeting.greeter}"
      }
   }
}

class GreetingPluginExtension {
   String message
   String greeter
}

使用以下代码执行上述脚本。

C:\> gradle -q hello

输出

输出如下所示 -

Hello from Gradle

标准 Gradle 插件

Gradle 发行版中包含不同的插件。

语言插件

这些插件为可以在 JVM 中编译和执行的各种语言添加支持。

插件 ID	自动应用	描述
java	java-base	向项目添加 Java 编译、测试和打包功能。它是许多其他 Gradle 插件的基础。
groovy	java,groovy-base	添加对构建 Groovy 项目的支持。
scala	java,scala-base	添加对构建 Scala 项目的支持。
antlr	Java	添加对使用 Antlr 生成解析器的支持。

孵化语言插件

这些插件为各种语言添加支持。

插件 ID	自动应用	描述
assembler	-	向项目添加本机汇编语言功能。
c	-	向项目添加 C 源代码编译功能。
cpp	-	向项目添加 C++ 源代码编译功能。
objective-c	-	向项目添加 Objective-C 源代码编译功能。
objective-cpp	-	向项目添加 Objective-C++ 源代码编译功能。
windows-resources	-	添加对在原生二进制文件中包含 Windows 资源的支持。

Gradle - 运行构建

Gradle 提供了一个命令行来执行构建脚本。它可以一次执行多个任务。本章介绍了如何使用不同的选项执行多个任务。

执行多个任务

您可以从单个构建文件中执行多个任务。Gradle 可以使用gradle 命令处理构建文件。此命令将按列出的顺序编译每个任务，并使用不同的选项执行每个任务及其依赖项。

示例

有四个任务 − task1、task2、task3 和 task4。Task3 和 task4 依赖于 task1 和 task2。查看下图。

在上图中，4 个任务相互依赖，用箭头符号表示。查看以下代码。可以复制粘贴到build.gradle文件中。

task task1 << {
   println 'compiling source'
}

task task2(dependsOn: task1) << {
   println 'compiling unit tests'
}

task task3(dependsOn: [task1, task2]) << {
   println 'running unit tests'
}

task task4(dependsOn: [task1, task3]) << {
   println 'building the distribution'
}

您可以使用以下代码编译和执行上述任务。

C:\> gradle task4 test

输出

输出如下所示 -

:task1
compiling source
:task2
compiling unit tests
:task3
running unit tests
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

排除任务

在从执行中排除任务时，您可以将 –x 选项与 Gradle 命令一起使用，并提及要排除的任务的名称。

使用以下命令从上述脚本中排除 task4。

C:\> gradle task4 -x test

输出

下面引用的是代码的输出 −

:task1
compiling source
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

继续构建

只要任何任务失败，Gradle 就会中止执行并使构建失败。即使发生故障，您也可以继续执行。为此，您必须将 –continue 选项与 gradle 命令一起使用。它分别处理每个任务及其依赖项。

要点是它会捕获遇到的每个错误，并在构建执行结束时报告。假设如果某个任务失败，则后续依赖任务也不会执行。

选择要执行的构建

运行 gradle 命令时，它会在当前目录中查找构建文件。您可以使用 –b 选项选择特定的构建文件以及绝对路径。

以下示例从位于subdir/中的myproject.gradle文件中选择项目 hello。

task hello << {
   println "using build file '$buildFile.name' in '$buildFile.parentFile.name'."
}

您可以使用以下命令执行上述脚本。

C:\> gradle -q -b subdir/myproject.gradle hello

输出

这将产生以下输出 -

using build file 'myproject.gradle' in 'subdir'.

获取构建信息

Gradle 提供了几个内置任务来检索有关任务和项目的信息详细信息。这对于理解构建的结构、构建的依赖项以及调试问题很有用。

您可以使用 project report 插件向您的项目添加任务，这些任务将生成这些报告。

列出项目

您可以使用gradle –q projects命令列出所选项目及其子项目的项目层次结构。使用以下命令列出构建文件中的所有项目。这是一个示例，

C:\> gradle -q projects

输出

输出如下所示 -

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'projectReports'
+--- Project ':api' - The shared API for the application
\--- Project ':webapp' - The Web application implementation

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :api:tasks

如果指定了项目描述，则报告将显示每个项目的描述。您可以使用以下命令指定描述。将其粘贴到build.gradle文件中。

description = 'The shared API for the application'

列出任务

您可以使用以下命令列出属于多个项目的所有任务。

C:\> gradle -q tasks

输出

输出如下所示 -

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Default tasks: dists

Build tasks
-----------
clean - Deletes the build directory (build)
dists - Builds the distribution
libs - Builds the JAR

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'projectReports'.
components - Displays the components produced by root project 'projectReports'. [incubating]
dependencies - Displays all dependencies declared in root project 'projectReports'.
dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'.
help - Displays a help message.
model - Displays the configuration model of root project 'projectReports'. [incubating]
projects - Displays the sub-projects of root project 'projectReports'.
properties - Displays the properties of root project 'projectReports'.
tasks - Displays the tasks runnable from root project 'projectReports' 
   (some of the displayed tasks may belong to subprojects).

To see all tasks and more detail, run gradle tasks --all

To see more detail about a task, run gradle help --task <task>

您可以使用以下命令显示所有任务的信息。

C:\> gradle -q tasks --all

输出

执行上述代码时，您应该看到以下输出 -

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Default tasks: dists

Build tasks
-----------
clean - Deletes the build directory (build)
api:clean - Deletes the build directory (build)
webapp:clean - Deletes the build directory (build)
dists - Builds the distribution [api:libs, webapp:libs]
docs - Builds the documentation
api:libs - Builds the JAR
api:compile - Compiles the source files
webapp:libs - Builds the JAR [api:libs]
webapp:compile - Compiles the source files

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'projectReports'.
api:buildEnvironment - Displays all buildscript dependencies declared in project ':api'.
webapp:buildEnvironment - Displays all buildscript dependencies declared in project ':webapp'.
components - Displays the components produced by root project 'projectReports'. [incubating]
api:components - Displays the components produced by project ':api'. [incubating]
webapp:components - Displays the components produced by project ':webapp'. [incubating]
dependencies - Displays all dependencies declared in root project 'projectReports'.
api:dependencies - Displays all dependencies declared in project ':api'.
webapp:dependencies - Displays all dependencies declared in project ':webapp'.
dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'.
api:dependencyInsight - Displays the insight into a specific dependency in project ':api'.
webapp:dependencyInsight - Displays the insight into a specific dependency in project ':webapp'.
help - Displays a help message.
api:help - Displays a help message.
webapp:help - Displays a help message.
model - Displays the configuration model of root project 'projectReports'. [incubating]
api:model - Displays the configuration model of project ':api'. [incubating]
webapp:model - Displays the configuration model of project ':webapp'. [incubating]
projects - Displays the sub-projects of root project 'projectReports'.
api:projects - Displays the sub-projects of project ':api'.
webapp:projects - Displays the sub-projects of project ':webapp'.
properties - Displays the properties of root project 'projectReports'.
api:properties - Displays the properties of project ':api'.
webapp:properties - Displays the properties of project ':webapp'.
tasks - Displays the tasks runnable from root project 'projectReports'
(some of the displayed tasks may belong to subprojects).
api:tasks - Displays the tasks runnable from project ':api'.
webapp:tasks - Displays the tasks runnable from project ':webapp'.

命令列表如下所示，以及描述。

序号	命令	描述
1	gradle –q help –task <task name>	提供有关特定任务或多个任务的用法信息（例如路径、类型、描述、组）。
2	gradle –q dependencies	提供所选项目的依赖项列表。
3	gradle -q api:dependencies --configuration <task name>	提供与配置相关的有限依赖项列表。
4	gradle –q buildEnvironment	提供构建脚本依赖项的列表。
5	gradle –q dependencyInsight	深入了解特定依赖项。
6	Gradle –q properties	提供所选项目的属性列表。

Gradle - 构建 JAVA 项目

本章介绍如何使用 Gradle 构建文件构建 Java 项目。

首先，我们必须将 Java 插件添加到构建脚本中，因为它提供了编译 Java 源代码、运行单元测试、创建 Javadoc 和创建 JAR 文件的任务。

在build.gradle文件中使用以下行。

apply plugin: 'java'

Java 默认项目布局

每当你向构建中添加插件时，它都会假设你的 Java 项目的特定设置（类似于 Maven）。请查看以下目录结构。

src/main/java 包含 Java 源代码。
src/test/java 包含 Java 测试。

如果你遵循此设置，则以下构建文件足以编译、测试和捆绑 Java 项目。

要启动构建，请在命令行上键入以下命令。

C:\> gradle build

SourceSets 可用于指定不同的项目结构。例如，源代码存储在src文件夹中，而不是src/main/java中。请查看以下目录结构。

apply plugin: 'java'
sourceSets {
   main {
      java {
         srcDir 'src'
      }
   }
	
   test {
      java {
         srcDir 'test'
      }
   }
}

init 任务执行

Gradle 还不支持多个项目模板。但它提供了一个init任务来创建新 Gradle 项目的结构。在没有其他参数的情况下，此任务会创建一个 Gradle 项目，其中包含 Gradle 包装器文件、build.gradle和settings.gradle文件。

当添加--type参数并将java-library作为值时，将创建 Java 项目结构，并且build.gradle文件包含带有 Junit 的特定 Java 模板。请查看build.gradle文件的以下代码。

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

在 repositories 部分，它定义了在哪里查找依赖项。Jcenter 用于解析你的依赖项。Dependencies 部分用于提供有关外部依赖项的信息。

指定 Java 版本

通常，Java 项目具有一个版本和一个编译的目标 JRE。version和sourceCompatibility属性可以在build.gradle文件中设置。

version = 0.1.0
sourceCompatibility = 1.8

如果工件是可执行的 Java 应用程序，则MANIFEST.MF文件必须知道具有 main 方法的类。

apply plugin: 'java'

jar {
   manifest {
      attributes 'Main-Class': 'com.example.main.Application'
   }
}

示例

创建如下所示的目录结构。

将下面给出的 Java 代码复制到 App.java 文件中，并存储到consumerbanking\src\main\java\com\bank目录中。

package com.bank;

/**
* Hello world!
*
*/

public class App {
   public static void main( String[] args ){
      System.out.println( "Hello World!" );
   }
}

将下面给出的 Java 代码复制到 AppTset.java 文件中，并存储到consumerbanking\src\test\java\com\bank目录中。

package com.bank;

/**
* Hello world!
*
*/

public class App{
   public static void main( String[] args ){
      System.out.println( "Hello World!" );
   }
}

将下面给出的代码复制到 build.gradle 文件中，并放置到consumerbanking\目录中。

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

jar {
   manifest {
      attributes 'Main-Class': 'com.example.main.Application'
   }
}

要编译并执行上述脚本，请使用下面给出的命令。

consumerbanking\> gradle tasks
consumerbanking\> gradle assemble
consumerbanking\> gradle build

检查各个目录中的所有类文件，并检查consumerbanking\build\lib文件夹中的consumerbanking.jar文件。

Gradle - 构建 Groovy 项目

本章介绍如何使用build.gradle文件编译和执行 Groovy 项目。

Groovy 插件

Gradle 的 Groovy 插件扩展了 Java 插件，并为 Groovy 程序提供了任务。你可以使用以下行应用 Groovy 插件。

apply plugin: 'groovy'

将以下代码复制到build.gradle文件中。完整的构建脚本文件如下所示：

apply plugin: 'groovy'

repositories {
   mavenCentral()
}

dependencies {
   compile 'org.codehaus.groovy:groovy-all:2.4.5'
   testCompile 'junit:junit:4.12'
}

你可以使用以下命令执行构建脚本：

gradle build

默认项目布局

Groovy 插件假设你的 Groovy 项目的特定设置。

src/main/groovy 包含 Groovy 源代码
src/test/groovy 包含 Groovy 测试
src/main/java 包含 Java 源代码
src/test/java 包含 Java 测试

检查build.gradle文件所在目录的构建文件夹。

Gradle - 测试

test 任务会自动检测并在测试源集中执行所有单元测试。测试执行完成后，它还会生成报告。JUnit 和 TestNG 是受支持的 API。

test 任务提供了一个Test.getDebug()方法，可以将其设置为启动以使 JVM 等待调试器。在继续执行之前，它将调试器端口设置为5005。

测试检测

Test Task 通过检查已编译的测试类来检测哪些类是测试类。默认情况下，它会扫描所有 .class 文件。你可以设置自定义的包含/排除项，并且只会扫描这些类。

根据使用的测试框架（JUnit/TestNG），测试类检测使用不同的标准。使用 JUnit 时，我们会扫描 JUnit 3 和 4 测试类。

如果以下任何标准匹配，则该类被视为 JUnit 测试类：

类或超类扩展 TestCase 或 GroovyTestCase
类或超类用 @RunWith 注解
类或超类包含用 @Test 注解的方法
使用 TestNG 时，我们会扫描用 @Test 注解的方法

注意 - 抽象类不会执行。Gradle 还扫描测试类路径上 jar 文件中的继承树。

如果你不想使用测试类检测，可以通过将scanForTestClasses设置为false来禁用它。

测试分组

JUnit 和 TestNG 允许对测试方法进行复杂的分组。对于分组，JUnit 测试类和方法 JUnit 4.8 引入了类别的概念。test 任务允许指定要包含和排除的 JUnit 类别。

你可以在 build.gradle 文件中使用以下代码片段对测试方法进行分组：

test {
   useJUnit {
      includeCategories 'org.gradle.junit.CategoryA'
      excludeCategories 'org.gradle.junit.CategoryB'
   }
}

包含和排除测试

Test 类具有include和exclude方法。这些方法可用于指定应实际运行哪些测试。

使用下面提到的代码仅运行包含的测试：

test {
   include '**my.package.name/*'
}

使用下面给出的代码跳过排除的测试：

test {
   exclude '**my.package.name/*'
}

下面显示的示例build.gradle文件显示了不同的配置选项。

apply plugin: 'java' // adds 'test' task

test {
   // enable TestNG support (default is JUnit)
   useTestNG()

   // set a system property for the test JVM(s)
   systemProperty 'some.prop', 'value'

   // explicitly include or exclude tests
   include 'org/foo/**'
   exclude 'org/boo/**'

   // show standard out and standard error of the test JVM(s) on the console
   testLogging.showStandardStreams = true

   // set heap size for the test JVM(s)
   minHeapSize = "128m"
   maxHeapSize = "512m"

   // set JVM arguments for the test JVM(s)
   jvmArgs '-XX:MaxPermSize=256m'
   
   // listen to events in the test execution lifecycle
   beforeTest { 
      descriptor → logger.lifecycle("Running test: " + descriptor)
   }

   // listen to standard out and standard error of the test JVM(s)
   onOutput { 
      descriptor, event → logger.lifecycle
         ("Test: " + descriptor + " produced standard out/err: " 
         + event.message )
   }
}

你可以使用以下命令语法执行某些测试任务。

gradle <someTestTask> --debug-jvm

Gradle - 多项目构建

Gradle 可以轻松处理最小和最大的项目。小型项目只有一个构建文件和一个源树。一个已被拆分为更小、相互依赖的模块的项目非常容易理解和理解。Gradle 完全支持这种多项目构建的场景。

多项目构建的结构

此类构建具有各种形状和大小，但它们确实有一些共同的特点，如下所示：

项目根目录或主目录中的settings.gradle文件。
根目录或主目录中的build.gradle文件。
具有其自身*.gradle构建文件的子目录（某些多项目构建可能会省略子项目构建脚本）。

要列出构建文件中的所有项目，可以使用以下命令。

C:\> gradle -q projects

输出

你将收到以下输出：

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'projectReports'
+--- Project ':api' - The shared API for the application
\--- Project ':webapp' - The Web application implementation

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :api:tasks

该报告显示每个项目的描述（如果已指定）。你可以使用以下命令指定描述。将其粘贴到build.gradle文件中。

description = 'The shared API for the application'

常规构建配置

在root_project中的build.gradle文件中，可以将常规配置应用于所有项目或仅应用于子项目。

allprojects {
   group = 'com.example.gradle'
   version = '0.1.0'
}

subprojects {
   apply plugin: 'java'
   apply plugin: 'eclipse'
}

这将com.example.gradle组和0.1.0版本指定给所有项目。subprojects闭包为所有子项目应用通用配置，但不应用于根项目，就像allprojects闭包一样。

配置和依赖项

核心ui和util子项目也可以有自己的build.gradle文件，如果它们有特定的需求，而这些需求尚未由根项目的通用配置应用。

例如，ui 项目通常依赖于核心项目。因此，ui 项目需要自己的build.gradle文件来指定此依赖项。

dependencies {
   compile project(':core')
   compile 'log4j:log4j:1.2.17'
}

项目依赖项使用 project 方法指定。

Gradle - 部署

Gradle 提供了几种将构建工件部署到存储库的方法。将工件的签名部署到 Maven 存储库时，你还需要对已发布的 POM 文件进行签名。

Maven-publish 插件

默认情况下，Gradle 提供了maven-publish插件。它用于发布 Gradle 脚本。请查看以下代码。

apply plugin: 'java'
apply plugin: 'maven-publish'

publishing {
   publications {
      mavenJava(MavenPublication) {
         from components.java
      }
   }

   repositories {
      maven {
         url "$buildDir/repo"
      }
   }
}

应用Java和maven-publish插件时，有多个发布选项。请查看以下代码，它会将项目部署到远程存储库。

apply plugin: 'groovy'
apply plugin: 'maven-publish'

group 'workshop'
version = '1.0.0'

publishing {
   publications {
      mavenJava(MavenPublication) { 
         from components.java 
      }
   }
	
   repositories {
      maven {
          default credentials for a nexus repository manager
         credentials {
            username 'admin'
            password 'admin123'
         }
         // url to the releases maven repository
            url "https://127.0.0.1:8081/nexus/content/repositories/releases/"
      }
   }
}

从 Maven 转换为 Gradle

如果所有使用的 Maven 插件都为此任务所知，则有一个特殊的命令用于将 Apache Mavenpom.xml文件转换为 Gradle 构建文件。

在本节中，以下pom.xml Maven 配置将转换为 Gradle 项目。

<project xmlns = "http://maven.apache.org/POM/4.0.0" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
	
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.example.app</groupId>
   <artifactId>example-app</artifactId>
   <packaging>jar</packaging>
   
   <version>1.0.0-SNAPSHOT</version>
	
   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>

         <version>4.11</version>
         <scope>test</scope>
      </dependency>
   </dependencies>
	
</project>

你可以在命令行上使用以下命令，这将导致以下 Gradle 配置。

C:\> gradle init --type pom

init任务依赖于 wrapper 任务，以便创建 Gradle 包装器。

生成的build.gradle文件与此类似：

apply plugin: 'java'
apply plugin: 'maven'

group = 'com.example.app'
version = '1.0.0-SNAPSHOT'

description = """"""

sourceCompatibility = 1.5
targetCompatibility = 1.5

repositories {
   maven { url "http://repo.maven.apache.org/maven2" }
}

dependencies {
   testCompile group: 'junit', name: 'junit', version:'4.11'
}