Gradle构建之Gradle构建基础

前言

Gradle是一个专注于构建自动化和支持多语言开发的构建工具。如果你在任何平台上构建、测试、发布和部署软件，Gradle提供了一个灵活的模型，可以支持从编译和打包代码到发布web站点的整个开发周期。Gradle被设计成支持跨多种语言和平台的构建自动化，包括Java、Scala、Android、C/C++和Groovy，并与开发工具和持续集成服务紧密地集成，包括Eclipse、IntelliJ和Jenkins。使用Gradle构建工具，我们可以方便又快速地实现自己的构建目标。

下载和安装

Gradle可以运行在所有主流的操作系统上，只需要安装一个版本为7或者更高版本的Java JDK或者JRE。我们可以通过 “java -version” 命令来检查。如下所示：

$ java -versionjava 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)

下面介绍一下如何手动安装Gradle：

1. 下载Gradle发行版。下载地址：https://gradle.org/releases/
2. 解压Gradle发行版。
3. 添加 GRADLE_HOME 环境变量，并设置它的值为解压后Gradle发行版的根目录。
4. 添加 GRADLE_HOME/bin 路径到 PATH 环境变量中。

安装完成之后，我们可以通过 “gradle –version” 命令来验证。如下所示：

$ gradle --version------------------------------------------------------------Gradle 4.1------------------------------------------------------------Build time:   2017-08-07 14:38:48 UTCRevision:     941559e020f6c357ebb08d5c67acdb858a3defc2Groovy:       2.4.11Ant:          Apache Ant(TM) version 1.9.6 compiled on June 29 2015JVM:          1.8.0_66 (Oracle Corporation 25.66-b18)OS:           Windows 7 6.1 amd64

可以看到，Gradle包含了自己的Groovy库，因此不需要安装Groovy。任何安装的Groovy都将被Gradle所忽略。

Gradle命令行

Gradle安装成功之后，我们就可以在命令行中使用 gradle 命令来执行构建了。

执行任务

一个Gradle构建最终是由一个或者多个任务组成的。在Gradle中，执行一个任务的方法是，在项目的根目录下执行如下命令：

$ gradle <task>

其中，代表具体的任务名。另外，当你在命令行中指定任务时，你可以不提供完整的任务名。你只需要提供足够的任务名来唯一地标识一个任务。

你也可以通过在命令行中列出每个任务，在单个构建中执行多个任务。例如：

$ gradle <task1> <task2>

Gradle将按照在命令行中列出的顺序来执行这些任务，并且还将执行每个任务的依赖任务。每个任务只执行一次，不管它是如何被包含在构建中：它是在命令行中指定的，还是作为另一个任务的依赖任务，或者两者都是。

获取构建信息

Gradle提供了几个内置的任务，这些任务可以显示构建的特定细节。这对于理解构建的结构和依赖关系，以及调试问题非常有用。

列出项目

在项目的根目录下执行 “gradle projects” 命令，它将在一个层次结构中显示所选项目的子项目列表。例如：

$ gradle projects:projects------------------------------------------------------------Root project------------------------------------------------------------Root project 'Learning'+--- Project ':projectA' - The project A\--- Project ':projectB' - The project BTo see a list of the tasks of a project, run gradle <project-path>:tasksFor example, try running gradle :projectA:tasksBUILD SUCCESSFUL in 1s1 actionable task: 1 executed

列出任务

在项目的根目录下执行 “gradle tasks” 命令，它将列出所选项目的主要任务。例如：

$ gradle tasks:tasks------------------------------------------------------------All tasks runnable from root project------------------------------------------------------------Build Setup tasks-----------------init - Initializes a new Gradle build.wrapper - Generates Gradle wrapper files.Help tasks----------buildEnvironment - Displays all buildscript dependencies declared in root project 'Learning'.components - Displays the components produced by root project 'Learning'. [incubating]dependencies - Displays all dependencies declared in root project 'Learning'.dependencyInsight - Displays the insight into a specific dependency in root project 'Learning'.dependentComponents - Displays the dependent components of components in root project 'Learning'. [incubating]help - Displays a help message.model - Displays the configuration model of root project 'Learning'. [incubating]projects - Displays the sub-projects of root project 'Learning'.properties - Displays the properties of root project 'Learning'.tasks - Displays the tasks runnable from root project 'Learning' (some of the displayed tasks may belong to subprojects).To see all tasks and more detail, run gradle tasks --allTo see more detail about a task, run gradle help --task <task>BUILD SUCCESSFUL in 1s1 actionable task: 1 executed

默认情况下，该报告只显示那些被分配给任务组的任务，即所谓的可见任务。你可以通过为任务设置 group 属性来实现这一点。你还可以使用 –all 参数来获得更多信息。有了这个参数，任务报告将列出项目中的所有任务，包括未分配给任务组的任务，也就是所谓的隐藏任务。

显示任务的细节

在项目的根目录下执行 “gradle help –task ” 命令，它将提供给定任务或者在多项目构建中匹配给定任务名的多个任务的详细信息。例如，内置的wrapper任务的详细信息：

$ gradle help --task wrapper:helpDetailed task information for wrapperPath     :wrapperType     Wrapper (org.gradle.api.tasks.wrapper.Wrapper)Options     --distribution-type     The type of the Gradle distribution to be used by the wrapper.                             Available values are:                                  ALL                                  BIN     --gradle-distribution-url     The URL to download the Gradle distribution from.     --gradle-version     The version of the Gradle distribution required by the wrapper.Description     Generates Gradle wrapper files.Group     Build SetupBUILD SUCCESSFUL in 1s1 actionable task: 1 executed

Hello World

新建一个名为build.gradle的文件，输入如下代码：

task hello {    doLast {        println 'Hello world!'    }}

在当前目录下，输入”gradle hello”命令执行构建。如下所示：

$ gradle hello:helloHello world!BUILD SUCCESSFUL in 2s1 actionable task: 1 executed

可以看到，Gradle执行了hello任务，输出了”Hello world!”字符串。

基础知识

构建脚本

我们使用 gradle 命令执行一个Gradle构建。gradle命令会在当前目录下查找一个名为 build.gradle 的文件。我们称这个build.gradle文件为一个构建脚本。严格地说，它是一个构建配置脚本。一个构建脚本定义了一个项目及其任务。

每个构建脚本编译后的脚本类都实现了 Script 接口，所以我们可以直接在构建脚本中使用该接口声明的属性和方法。通常，脚本对象会有一个代理对象。例如，一个构建脚本将会有一个 Project 代理对象，一个初始化脚本将会有一个 Gradle 代理对象。在这个脚本对象中没有找到的任何属性引用或者方法调用都被转发到代理对象上。也就是说，我们可以直接在构建脚本中使用代理对象的属性和方法。

项目和任务

Gradle中的所有东西都位于两个基本概念之上：项目（Project）和任务（Task）。

每个Gradle构建都是由一个或者多个 项目 组成的。一个项目代表什么，取决于你和Gradle做了什么。例如，一个项目可能代表一个JAR库或者一个web应用程序。一个项目并不一定代表要构建的东西，它可能表示要做的事情。

每个项目都是由一个或者多个 任务 组成的。一个任务表示一个构建执行的原子部分。一个任务可能是编译一些类，创建一个JAR，生成Javadoc，或者将一些存档发布到一个仓库中。任务之间可以有依赖关系。Gradle将保证这些任务按照其依赖的顺序执行，并且每个任务只执行一次。这些任务形成了一个有向无环图。在执行任何任务之前，Gradle将建立完整的依赖关系图。我们的构建脚本配置了这个依赖关系图。因此，严格地说，它们是构建配置脚本。

多项目构建

Gradle支持多项目的构建。多项目构建的结构包括：

• 项目的根目录下包含一个 settings.gradle 文件
• 项目的根目录下包含一个 build.gradle 文件
• 项目的子目录下包含自己的 build.gradle 文件

settings.gradle文件的作用是告诉Gradle，项目和子项目是如何组织的。它是在Gradle构建的初始化阶段被执行的。

构建语言

Gradle为描述构建提供了一种领域特定语言（DSL）。这种构建语言是基于Groovy语言的，其中添加了一些内容，以便更容易地描述构建。构建脚本可以包含任何Groovy语言元素。具体Groovy语言的基础知识可以看 Gradle构建之Groovy语言基础 这篇文章。

Gradle的DSL在许多地方使用了 闭包。这里额外提两点闭包的知识点。第一点是闭包作为方法的最后一个参数。当方法的最后一个参数是闭包时，你可以在方法调用之后放置闭包。例如，任务的定义。第二点是闭包的代理。每个闭包都有一个代理对象，当闭包内的变量和方法引用不是本地变量或者闭包的参数时，Groovy使用代理对象来查找这些变量和方法引用。Gradle在配置闭包上使用了代理对象，它将配置闭包的代理对象设置为将要配置的对象。例如，任务的配置闭包的代理对象是任务对象。

构建的生命周期

一个Gradle构建会经历三个不同的阶段：

1. 初始化阶段 Gradle支持单一和多项目的构建。在初始化阶段，Gradle决定哪些项目将参与到构建中，并为每个项目创建一个 Project 实例。
2. 配置阶段 在此阶段，Project 对象被配置。参与构建的所有项目的构建脚本都被执行。
3. 执行阶段 Gradle确定了在配置阶段中创建和配置的、即将执行的任务的子集。子集是由传递给Gradle命令和当前目录的任务名参数决定的。然后，Gradle执行每一个被选择的任务。

下面是一个构建的生命周期的例子：

settings.gradle文件：

println 'This is executed during the initialization phase.'

build.gradle文件：

println 'This is executed during the configuration phase.'task test {    doLast {        println 'This is executed during the execution phase.'    }}task testBoth {    doFirst {        println 'This is executed first during the execution phase.'    }    doLast {        println 'This is executed last during the execution phase.'    }    println 'This is also executed during the configuration phase.'}

输入”gradle test testBoth”命令执行构建。如下所示：

$ gradle test testBothThis is executed during the initialization phase.This is executed during the configuration phase.This is also executed during the configuration phase.:testThis is executed during the execution phase.:testBothThis is executed first during the execution phase.This is executed last during the execution phase.BUILD SUCCESSFUL in 1s2 actionable tasks: 2 executed

编写构建脚本

对于构建中的每个项目，Gradle创建了一个 Project 类型的对象，并将这个对象与构建脚本关联起来。当构建脚本执行时，它会配置这个Project对象：

• 在构建脚本中调用的任何未在构建脚本中定义的方法被代理给Project对象。
• 在构建脚本中访问的任何未在构建脚本中定义的属性被代理给Project对象。

定义任务

正如前面的Hello World程序，定义一个任务很简单。新建一个build.gradle文件，使用 task 来定义一个任务。如下所示：

task hello {    doLast {        println 'hello'    }}

这段代码实际上是调用了构建脚本的代理对象 Project 的 task(String name, Closure configureClosure) 方法。这个task()方法的完整声明是：

Task task(String name,        @DelegatesTo(value=Task.class,strategy=1)        Closure configureClosure)

这个方法创建了一个给定名称的任务，并将该任务添加到这个Project中。在task()方法返回之前，会执行给定的配置闭包来配置这个任务。将任务添加到项目之后，它就成为项目的一个属性，这样我们就可以在构建脚本中引用该任务了。

从task()方法的声明中，我们知道配置闭包的代理对象为Task。所以构建脚本中配置闭包中的代码实际上是调用了配置闭包的代理对象 Task 的 doLast(Closure action) 方法。这个方法将给定的闭包添加到该任务的 Action 列表的末尾。

一个任务是由一系列的 Action 对象组成的。当执行任务时，每一个Action依次执行。所以当我们输入”gradle hello”命令来执行hello任务时，上面的代码将输出”hello”字符串。

在Gradle中，还有其它的方式来定义任务。例如：

task(hello1) {    doLast {        println "hello1"    }}task('hello2') {    doLast {        println "hello2"    }}tasks.create(name: 'hello3') {    doLast {        println "hello3"    }}

默认任务

Gradle允许你定义一个或者多个默认任务。当你使用gradle命令却没有指定任务时，默认任务将被执行。例如：

defaultTasks 'clean', 'run'task clean {    doLast {        println 'Default Cleaning!'    }}task run {    doLast {        println 'Default Running!'    }}task other {    doLast {        println "I'm not a default task!"    }}

输入”gradle”命令执行构建。如下所示：

$ gradle:cleanDefault Cleaning!:runDefault Running!BUILD SUCCESSFUL in 1s2 actionable tasks: 2 executed

定位任务

我们通常需要定位在构建脚本中定义的任务，例如，配置它们或者使用它们作为依赖任务。有很多方法可以定位任务。

首先，每个任务都可以作为项目的属性使用，使用任务名作为属性名。例如：

task helloprintln hello.nameprintln project.hello.name

你也可以通过任务集合来定位一个任务。例如：

task helloprintln tasks.hello.nameprintln tasks['hello'].name

你还可以通过tasks.getByPath()方法，使用任务的路径来访问任何项目中的任务。你可以使用任务名、相对路径或者绝对路径来调用getByPath()方法。例如：

task helloprintln tasks.getByPath('hello').pathprintln tasks.getByPath(':hello').path

配置任务

为了创建一个 Copy 任务，我们可以在构建脚本中声明任务的类型。例如：

task myCopy(type: Copy)

这将创建一个没有默认行为的复制任务。我们可以使用Copy API来配置这个任务。

你可以在定义任务时使用配置闭包来配置任务。例如：

task myCopy(type: Copy) {   from 'resources'   into 'target'   include('**/*.txt', '**/*.xml', '**/*.properties')}

你也可以在定义任务之后再使用配置闭包来配置任务。例如：

task myCopy(type: Copy)myCopy {   from 'resources'   into 'target'   include('**/*.txt', '**/*.xml', '**/*.properties')}

你还可以像在Java中配置对象那样来配置任务。例如：

Copy myCopy = task(myCopy, type: Copy)myCopy.from 'resources'myCopy.into 'target'myCopy.include('**/*.txt', '**/*.xml', '**/*.properties')

任务依赖

你可以定义依赖于其它任务的任务。例如：

task hello {    doLast {        println 'Hello world!'    }}task intro(dependsOn: hello) {    doLast {        println "I'm Gradle"    }}

输入”gradle intro”命令执行构建。如下所示：

$ gradle intro:helloHello world!:introI'm GradleBUILD SUCCESSFUL in 1s2 actionable tasks: 2 executed

可以看到，在执行intro任务之前先执行了被依赖的hello任务。

你也可以使用Task对象来定义任务依赖。例如：

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

你还可以使用闭包来定义任务依赖。例如：

task lib1 {    doLast {        println 'lib1'    }}task lib2 {    doLast {        println 'lib2'    }}task notALib {    doLast {        println 'notALib'    }}task taskX {    doLast {        println 'taskX'    }}taskX.dependsOn {    tasks.findAll { task ->         task.name.startsWith('lib')     }}

添加任务依赖时，被依赖的任务可以先不定义。例如：

task taskX(dependsOn: 'taskY') {    doLast {        println 'taskX'    }}task taskY {    doLast {        println 'taskY'    }}

taskX对taskY的依赖在taskY定义之前就已经声明了。这对于多项目构建非常重要。

任务排序

任务排序是一个还在完善的功能。这个功能可能会在以后的版本中发生变化。

在某些情况下，控制两个任务执行的顺序是很有用的，而不需要在这两个任务之间引入显式的依赖关系。任务排序和任务依赖之间的主要区别是， 排序规则不会影响执行哪些任务，只会影响它们将要执行的顺序。

任务排序在许多场景中都是有用的：

• 强制任务的顺序排序。例如，构建任务永远不会在清除任务之前运行。
• 在构建的前期执行构建验证。例如，在开始构建发布版本之前，验证是否有正确的凭证。
• 通过在长时间验证任务之前运行快速验证任务来更快地获得反馈。例如，单元测试应该在集成测试之前运行。
• 一个任务集合了一个特定类型的所有任务的结果。例如：测试报告任务组合了所有被执行的测试任务的输出。

在Gradle中，有两种排序规则：mustRunAfter 和 shouldRunAfter。对于”taskB.mustRunAfter(taskA)”，当taskA和taskB都将执行时，taskB一定在taskA之后执行。而shouldRunAfter用在不是那么严格要求排序的地方。

mustRunAfter的例子如下：

task taskX {    doLast {        println 'taskX'    }}task taskY {    doLast {        println 'taskY'    }}taskY.mustRunAfter taskX

输入”gradle taskY taskX”命令执行构建。如下所示：

$ gradle taskY taskX:taskXtaskX:taskYtaskYBUILD SUCCESSFUL in 1s2 actionable tasks: 2 executed

输入”gradle taskY”命令执行构建。如下所示：

$ gradle taskY:taskYtaskYBUILD SUCCESSFUL in 1s1 actionable task: 1 executed

shouldRunAfter的例子如下：

task taskX {    doLast {        println 'taskX'    }}task taskY {    doLast {        println 'taskY'    }}taskY.shouldRunAfter taskX

输入”gradle taskY taskX”命令执行构建。如下所示：

$ gradle taskY taskX:taskXtaskX:taskYtaskYBUILD SUCCESSFUL in 1s2 actionable tasks: 2 executed

输入”gradle taskY”命令执行构建。如下所示：

$ gradle taskY:taskYtaskYBUILD SUCCESSFUL in 1s1 actionable task: 1 executed

从上面的两个例子可以知道，”B.mustRunAfter(A)”或者”B.shouldRunAfter(A)”并不意味着任务之间有任何执行依赖关系。任务A和B可以独立地被执行。只有当两个任务都被执行时，排序规则才会生效。

描述任务

你可以向任务添加一个描述。这个描述在执行”gradle tasks”命令时显示。例如：

task hello {    description 'This is a Hello World task.'    doLast {        println 'Hello World!'    }}

替换任务

有时我们想要替换一个任务。比如，你想要将Java插件中添加的任务替换为另一种类型的定制任务。例如：

task copy(type: Copy)task copy(overwrite: true) {    doLast {        println('I am the new one.')    }}

输入”gradle copy”命令执行构建。如下所示：

$ gradle copy:copyI am the new one.BUILD SUCCESSFUL in 1s1 actionable task: 1 executed

声明变量

在构建脚本中，有两种类型的变量可以声明：局部变量 和 额外的属性。

局部变量使用 def 关键字声明。它们只在已声明的范围内可见。例如：

def greeting = 'Hello cyc!'task hello {    doLast {        println greeting    }}

输入”gradle hello”命令执行构建。如下所示：

$ gradle hello:helloHello cyc!BUILD SUCCESSFUL in 1s1 actionable task: 1 executed

在Gradle的域模型中所有增强的对象都可以拥有额外的用户自定义属性。这包括，但不限于，项目、任务和源码集。我们可以通过增强对象的 ext 属性来添加、读取和设置额外的属性。另外，可以使用一个 ext {} 块来同时添加多个属性。例如：

apply plugin: "java"ext {    springVersion = "3.1.0.RELEASE"    emailNotification = "[e-mail]"}sourceSets.all {     ext.purpose = null }sourceSets {    main {        purpose = "production"    }    test {        purpose = "test"    }    plugin {        purpose = "production"    }}task printProperties {    doLast {        println springVersion        println emailNotification        sourceSets.matching {             it.purpose == "production"         }.each {             println it.name         }    }}

ext {} 块为项目对象添加了两个额外的属性。另外，通过设置ext.purpose为null为每个源码集添加了一个名为purpose的属性。一旦添加了属性，就可以像预定义的属性那样读取和设置它们。

输入”gradle printProperties”命令执行构建。如下所示：

$ gradle printProperties:[e-mail] SUCCESSFUL in 1s1 actionable task: 1 executed

Gradle插件

Gradle所有有用的特性，比如编译Java代码的能力，都是由 插件 提供的。插件添加了新的任务（例如，JavaCompile）、域对象（例如，SourceSet）、约定（例如，Java源代码位于src/main/java），以及扩展的核心对象和来自其它插件的对象。

插件的作用

应用一个插件到一个项目中可以使插件扩展项目的功能。比如：

• 扩展Gradle的模型（例如，添加可以配置的新DSL元素）。
• 根据约定配置项目（例如，添加新的任务或者配置合理的缺省值）。
• 应用特定的配置（例如，添加组织仓库或者执行标准）。

通过使用插件，而不是将逻辑添加到项目的构建脚本中，我们可以获得许多好处。比如：

• 促进重用并减少在多个项目中维护相似逻辑的开销。
• 允许更高程度的模块化，增强可理解性和组织性。
• 封装了命令式的逻辑，并允许构建脚本尽可能的声明。

插件的类型

在Gradle中，有两种类型的插件：脚本插件 和 二进制插件。脚本插件是额外的构建脚本，它可以进一步地配置构建，并且通常实现了一种声明式的方法来操作构建。脚本插件通常在一个构建中使用，尽管它们可以被外部化并从一个远程位置访问。二进制插件是实现了 Plugin 接口的类，它采用一种编程的方法来操作构建。二进制插件可以驻留在一个构建脚本中或者项目层次结构中，或者在外部的插件jar包中。

一个插件通常是作为一个脚本插件开始的（因为它们容易编写），然后随着代码变得更有价值，它被移植到一个二进制插件中，这种插件可以在多个项目或者组织之间容易地进行测试和共享。

使用插件

脚本插件

在build.gradle文件中，使用 apply 来应用一个脚本插件。例如：

apply from: 'other.gradle'

脚本插件可以自动解析。我们可以应用本地文件系统或者远程位置上的脚本插件。文件系统位置相对于项目目录，而远程脚本位置由一个HTTP URL来指定。一个构建脚本可以应用多个脚本插件。

二进制插件

你可以使用插件ID来应用插件，插件ID是一个用于插件的全局唯一的标识符或者名称。核心Gradle插件是特别的，它们提供简短的名称，比如核心JavaPlugin的名称是”java”。所有其它的二进制插件必须使用插件ID的完全限定形式（例如，com.github.foo.bar），尽管一些遗留的插件仍然使用一个简短的、非限定的形式。

插件DSL方式。应用一个核心插件，例如：

plugins {    id 'java'}

应用一个社区插件，例如：

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

除了新的插件DSL方式，还有遗留方法来应用插件。应用一个核心插件，例如：

apply plugin: 'java'

以外部jar文件发布的二进制插件可以通过将插件添加到构建脚本类路径中，然后应用该插件。我们可以使用 buildscript {} 块将外部jar添加到构建脚本类路径中。例如：

buildscript {    repositories {        jcenter()    }    dependencies {        classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:0.4.1"    }}apply plugin: "com.jfrog.bintray"

Gradle插件

当我们在构建脚本中应用一个插件，我们就可以使用这个插件提供的各种功能。例如，java插件：

plugins {    id 'java'}

输入”gradle tasks”命令查看java插件提供的功能。如下所示：

$ gradle tasks:tasks------------------------------------------------------------All tasks runnable from root project------------------------------------------------------------Build tasks-----------assemble - Assembles the outputs of this project.build - Assembles and tests this project.buildDependents - Assembles and tests this project and all projects that depend on it.buildNeeded - Assembles and tests this project and all projects it depends on.classes - Assembles main classes.clean - Deletes the build directory.jar - Assembles a jar archive containing the main classes.testClasses - Assembles test classes.Build Setup tasks-----------------init - Initializes a new Gradle build.wrapper - Generates Gradle wrapper files.Documentation tasks-------------------javadoc - Generates Javadoc API documentation for the main source code.Help tasks----------buildEnvironment - Displays all buildscript dependencies declared in root project 'Learning'.components - Displays the components produced by root project 'Learning'. [incubating]dependencies - Displays all dependencies declared in root project 'Learning'.dependencyInsight - Displays the insight into a specific dependency in root project 'Learning'.dependentComponents - Displays the dependent components of components in root project 'Learning'. [incubating]help - Displays a help message.model - Displays the configuration model of root project 'Learning'. [incubating]projects - Displays the sub-projects of root project 'Learning'.properties - Displays the properties of root project 'Learning'.tasks - Displays the tasks runnable from root project 'Learning' (some of the displayed tasks may belong to subprojects).Verification tasks------------------check - Runs all checks.test - Runs the unit tests.Rules-----Pattern: clean<TaskName>: Cleans the output files of a task.Pattern: build<ConfigurationName>: Assembles the artifacts of a configuration.Pattern: upload<ConfigurationName>: Assembles and uploads the artifacts belonging to a configuration.To see all tasks and more detail, run gradle tasks --allTo see more detail about a task, run gradle help --task <task>BUILD SUCCESSFUL in 1s1 actionable task: 1 executed

可以看到，通过应用一个java插件，我们就可以很方便的构建、测试、打包java程序。

Gradle发行版中提供了很多标准插件，再加上大量的第三方插件，我们可以快速地实现自己的构建目标。

Gradle Wrapper

如果一个Gradle项目使用了Gradle Wrapper，那么我们可以直接在项目的根目录下使用 gradlew 命令来执行构建。如下所示：

$ ./gradlew <task>

每个Wrapper都绑定到一个特定版本的Gradle，因此，当你第一次运行给定Gradle版本的gradlew命令时，它将自动下载对应版本的Gradle发行版，并使用它来执行构建。

Gradle Wrapper是你应该加入到 版本控制 的内容。通过将Wrapper与你的项目一起发布，任何人无需预先安装Gradle就可以构建你的项目。同时，这样确保了构建用户使用的Gradle版本与项目发布的Gradle版本一致。这对于持续集成服务来说也很好，因为它不需要配置服务器。

通过执行 wrapper 任务，我们可以将Wrapper安装到项目中。wrapper任务是Gradle内置的任务。我们可以使用 –gradle-version 参数来指定一个Gradle版本。默认情况下，Wrapper将使用Gradle的二进制发行版，这是最小的Gradle发行版。我们可以使用 –distribution-type 参数来选择不同的Gradle发行版类型。我们还可以直接使用 –gradle-distribution-url 参数来设置下载Gradle的URL。如果没有指定版本或者下载URL，那么Wrapper将被配置为使用执行wrapper任务时的Gradle版本。

在项目的根目录下，输入 “gradle wrapper” 命令执行wrapper任务。如下所示：

$ gradle wrapper:wrapperBUILD SUCCESSFUL in 1s1 actionable task: 1 executed

执行wrapper任务之后，你可以在项目的根目录下找到以下文件：

• gradlew (Unix Shell script)
• gradlew.bat (Windows batch file)
• gradle/wrapper/gradle-wrapper.jar (Wrapper JAR)
• gradle/wrapper/gradle-wrapper.properties (Wrapper properties)

所有这些文件都应该提交到你的版本控制系统。将这些文件添加到项目之后，就应该使用gradlew命令来构建项目了。gradlew命令与gradle命令的使用方法是一致的。

总结

Gradle是一个专注于构建自动化的、强大的构建工具。使用Gradle构建工具，我们可以方便又快速地实现自己的构建目标。

参考

• https://gradle.org/
• https://gradle.org/docs/
• https://docs.gradle.org/4.1/userguide/userguide.html