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 提供基于 Groovy 语言的单独领域特定语言 (DSL)。

• 它提供声明性语言元素。这些元素还为 Java、Groovy、OSGI、Web 和 Scala 提供按约定构建支持。

基于依赖的编程语言

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

构建您的构建

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

深度API

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

等级量表

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

多项目构建

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

管理构建的不同方式

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

Gradle 是第一个构建集成工具

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

易于迁移

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

Gradle 包装器

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

免费开源

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

格罗维

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/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/位置。从下载目录执行此操作。

$ sudo mv gradle-2.11 /opt/gradle

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

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

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

$ source ~/.bashrc

步骤 4 - 验证 Gradle 安装

在窗口中

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

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。

构建.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命令执行上述脚本。

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

• 项目对象- 每个脚本描述一个或多个项目。在执行过程中，该脚本会配置项目对象。您可以在构建脚本中执行一些方法并使用属性，这些方法被委托给项目对象。

• 脚本对象- Gradle 将脚本代码放入类中，该类实现脚本接口，然后执行它。这意味着脚本接口声明的所有属性和方法在您的脚本中都可用。

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

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 脚本。

看看下面的语法。它定义了一个调用测试对象的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 脚本添加一组导入语句。以下列表显示了 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 或将一些成果发布到存储库。

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

定义任务

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

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

此构建脚本定义了一个任务名称hello，用于打印教程点字符串。

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

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

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

task hello

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

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

C:\> gradle –q hello

输出

这会产生以下输出 -

hello
hello

您还可以通过使用任务来访问任务的路径。为此，您可以使用任务名称、相对路径或绝对路径调用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

向任务添加依赖关系

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

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

以下示例添加从taskX 到taskY 的依赖关系。

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

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

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

C:\> gradle –q taskY

输出

输出如下：

taskX
taskY

上面的示例是通过使用任务名称来添加对任务的依赖关系。还有另一种实现任务依赖关系的方法，即使用 Task 对象定义依赖关系。

让我们以任务 Y依赖于任务 X 的相同示例为例，但在这里，我们使用任务对象而不是任务引用名称。

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

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

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

C:\> gradle –q taskY

输出

输出如下 -

taskX
taskY

上面的示例是通过使用任务名称来添加对任务的依赖关系。

还有另一种实现任务依赖关系的方法，即使用 Task 对象定义依赖关系。

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

将下面给出的代码复制并保存到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 任务时，会显示此描述，这可以通过使用描述关键字来实现。

将以下代码复制并保存到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 或 lvy 存储库，或者您可能会使用同一多项目构建中另一个项目的文件。我们可以将发布任务的过程称为发布。

声明你的依赖关系

依赖关系配置定​​义了一组依赖关系。您可以使用此功能来声明要从网络下载的外部依赖项。这定义了不同的标准，如下所示。

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.+'
}

依赖配置

依赖关系配置定​​义了一组依赖关系。您可以使用此功能来声明要从网络下载的外部依赖项。这定义了以下不同的标准配置。

• 编译- 编译项目的生产源所需的依赖项。

• 运行时- 生产类在运行时所需的依赖项。默认情况下，它还包括编译时依赖项。

• 测试编译- 编译项目的测试源所需的依赖项。默认情况下，它包括已编译的生产类和编译时依赖项。

• 测试运行时- 运行测试所需的依赖项。默认情况下，它包括运行时和测试编译依赖项。

外部依赖

外部依赖是依赖类型之一。这是对当前构建外部构建的某些文件的依赖，这些文件存储在某种类型的存储库中，例如 Maven 中心、企业 Maven 或 lvy 存储库，或者是本地文件系统的目录 I。

以下代码片段是定义外部依赖项。在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 在哪里发布工件。

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

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

apply plugin: 'maven'

uploadArchives {
   repositories {
      mavenDeployer {
         repository(url: "file://localhost/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.gradle build.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 中编译和执行的各种语言的支持。

孵化语言插件

这些插件添加了对各种语言的支持。

Gradle - 运行构建

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

执行多个任务

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

例子

有四个任务 - task1、task2、task3和task4。任务 3 和任务 4 依赖于任务 1 和任务 2。看一下下图。

上述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 选项来选择特定的构建文件以及绝对路径。

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

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 提供了几个内置任务，用于检索有关任务和项目的详细信息。这对于理解构建的结构、依赖关系以及调试问题很有用。

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

上市项目

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

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'.

下面给出了命令列表以及说明。

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'
      }
   }
}

初始化任务执行

Gradle 尚不支持多个项目模板。但它提供了一个初始化任务来创建新 Gradle 项目的结构。如果没有其他参数，此任务将创建一个 Gradle 项目，其中包含 gradle 包装文件、build.gradle和settings.gradle文件。

添加--type参数并以java-library作为值时，java 项目结构