彻底理解Gradle的任务

发表于 5年以前 | 总阅读数：1139 次

在Gradle的build文件中，任务是构建活动最基本的单元，它是许多构建指令的集合，下面我将仔细介绍Gradle任务的细节。

声明一个任务

声明任务很简单，你只需要一个任务名：

task hello

你可以在命令行中使用gradle tasks来查看所有的任务：

------------------------------------------------------------
    Root Project
    ------------------------------------------------------------
    Help tasks
    ----------
    dependencies - Displays the dependencies of root project &apos;task-lab&apos;.
    help - Displays a help message
    projects - Displays the subprojects of root project &apos;task-lab&apos;.
    properties - Displays the properties of root project &apos;task-lab&apos;.
    13
    tasks - Displays the tasks in root project &apos;task-lab&apos;.
    Other tasks
    -----------
    hello

任务的动作

很显然执行gradle hello不会有任何结果，因为你没有给这个任务添加动作，我们可以通过左移操作符给任务添加一个动作(在Groovy语言中左移操作符可以重载成在任务的最后添加一个动作)：

task hello <<{  
        println 'hello,world'  
    }

我们可以在任务的后面引用前面声明的任务:


    task hello  

    hello << {  
        print 'hello,'  
    }  

    hello << {  
        println 'world'  
    }

接下来在命令行中运行gradle hello,输出如下：

$ gradle hello
    hello, world
    $

任务的配置

Gradle新手可能会很容易混淆任务的动作和配置，看下面这个例子：


    task initializeDatabase  
    initializeDatabase << { println 'connect to database' }  
    initializeDatabase << { println 'update database schema' }  
    initializeDatabase { println 'configuring database connection' }//这里没有左移操作符

运行这个构建脚本，猜猜输出是什么：

//－b 选项用于指定gradle构建脚本文件名
    $ gradle -b scratch.gradle initializeDatabase
    configuring database connection
    :initializeDatabase
    connect to database
    update database schema
    $

如果第三个代码块我们用的是<<操作浮，这个消息就是在最后而不是最先打印出来了，我把用{}扩起来的部分统称为一个闭包，上面第三个闭包并不是任务的动作，他直接使用了任务名+闭包，在这里它是一个配置块。在Gradle的构建生命周期里配置阶段是在执行阶段前运行的，所以这个块里的代码最先执行了。

Gradle的构建生命周期分为三部分，初始化、配置和执行阶段。在执行阶段，任务按照他们的依赖顺序按序执行，在配置阶段所有的任务都转换成Gradle的内部对象模型，通常叫做有向无环图(DAG)。图的节点就是构建脚本里的任务，任务与任务之间可以定义依赖关系。初始化阶段是Gradle用来找出哪些项目会参与到项目构建中，这在多项目构建中很重要。

和动作闭包一样，配置闭包也具有可加性，你可以像下面这样编写构建脚本：


    task initializeDatabase  
    initializeDatabase << { println 'connect to database' }  
    initializeDatabase << { println 'update database schema' }  
    initializeDatabase { print 'configuring ' }  
    initializeDatabase { println 'database connection' }

配置块是用来放置变量和数据结构的地方，这些可能会在任务的执行过程中用到。

一切任务都是对象

前面讲过Gradle会在任务执行之前把他们创建成内部的对象模型，每一个你声明的任务都是一个任务对象，这个对象有自己的属性和方法，就和Java语言里的对象一样，我们可以控制每个任务对象的类型。默认情况每一个新创建的任务都是DefaultTask类型，就像Java语言里的java.lang.Object一样，每一个Gradle任务都继承自DefaultTask类型，你也可以定义自己的类型。DefaultTask事实上没有做任务事情，不过它具有基本的属性和方法用来和Gradle项目模型交互。接下来我会一一介绍每个任务都有的方法和属性。

DefaultTask的方法

dependsOn(task)

用于给任务添加一个依赖的任务，被依赖的任务总是在依赖它的任务之前运行，你可以有多种方式声明这种依赖关系，如下所示：


    //最简单的方法  
    task loadTestData {  
        dependsOn createSchema  
    }  

    //使用<<声明依赖  
    task loadTestData {  
        dependsOn << createSchema  
    }  

    // 使用单引号声明依赖  
    task loadTestData {  
        dependsOn 'createSchema'  
    }  

    //显式调用dependsOn方法  
    task loadTestData  
    loadTestData.dependsOn createSchema  

    // 快捷方法  
    task loadTestData(dependsOn: createSchema)

任务可以依赖多个任务，如下所示：


    //每次声明一个任务  
    task loadTestData {  
        dependsOn << compileTestClasses  
        dependsOn << createSchema  
    }  

    // 依次传递任务名  
    task world {  
        dependsOn compileTestClasses, createSchema  
    }  

    // 显式调用方法  
    task world  
    world.dependsOn compileTestClasses, createSchema  

    //快捷方式  
    task world(dependsOn: [ compileTestClasses, createSchema ])

doFirst(closure)

在任务的最开始添加一个可执行的代码块，doFirst方法允许你添加动作到现有的任务中，这个任务是在其他插件中定义的，你没有办法修改，但是你可以多次调用doFirst方法在任务执行之前添加一些代码块。
你可以使用任务对象调用doFirst方法，传递一个闭包给这个方法，如下所示：


    task setupDatabaseTests << {  
    // 任务现有的代码  
    println 'load test data'  
    }  

    setupDatabaseTests.doFirst {  
    println 'create schema'  
    }

然后运行gradle setupDatabaseTests,结果如下：

$ gradle setupDatabaseTests
    :setupDatabaseTests
    create schema
    load test data
    $

你也可以在任务的配置块里面调用doFirst方法，不过要记住配置块里的代码在任务的动作之前执行：


    task setupDatabaseTests << {  
        println 'load test data'  
    }  
    setupDatabaseTests {  
    doFirst {  
        println 'create schema'  
    }  
    }

doFirst方法也是可加的，你可以多次调用这个方法在任务的最前面添加代码块，如下所示：


    task setupDatabaseTests << {  
        println 'load test data'  
    }  

    setupDatabaseTests.doFirst {  
        println 'create database schema'  
    }  

    setupDatabaseTests.doFirst {  
        println 'drop database schema'  
    }

运行结果如下：

$ gradle world
    :setupDatabaseTests
    drop database schema
    create database schema
    load test data
    $

doLast(closure)

doLast方法和doFirst方法很类似，它用于在任务的最后面添加一段代码，这里就不重复了。

onlyIf(closure)

onlyIf方法用于决定是否执行一个任务，这里使用闭包返回的值来作为onlyIf的判断依据，在Groovy语言中，一个闭包的最后一个表达式用来作为这个闭包的返回值，即使你没有声明return语句，看一个例子：


    task createSchema << {  
        println 'create database schema'  
    }  

    task loadTestData(dependsOn: createSchema) << {  
        println 'load test data'  
    }  

    loadTestData.onlyIf {  
        System.properties['load.data'] == 'true'//当系统属性load.data为true时这个闭包返回true  
    }

看下下面的运行结果：  

    //这里没有系统属性load.data  
    $ build loadTestData  
    create database schema  
    :loadTestData SKIPPED  

    //在命令行中传递系统属性  
    $ gradle -Dload.data=true loadTestData  
    :createSchema  
    create database schema  
    :loadTestData  
    load test data  
    $  

##DefaultTask的属性  

###didWork  

一个用来标识任务是否成功完成的boolean属性，不是所有的任务都是在完成之后设置didWork变量，一些自带的任务比如Compile,Copy和Delete会根据动作是否执行成功来设置这个变量，JavaCompiler任务的实现是只要有一个文件成功编译就返回true,你可以在你自己的任务中设置didWork属性来反映构建代码的执行结果，举例如下：  

``` Groovy  

apply plugin: 'java'  

task emailMe(dependsOn: compileJava) << {  
    if(tasks.compileJava.didWork) {  
        println 'SEND EMAIL ANNOUNCING SUCCESS'  
     }  
}


运行结果如下：

$ gradle -b didWork.gradle emailMe SEND EMAIL ANNOUNCING SUCCESS $


### enabled

一个用来设置任务是否会执行的一个属性，你可以设置enabled为false不让它运行，但是它依赖的任务依然会运行。

task templates << {  
    println 'process email templates'  
}  

task sendEmails(dependsOn: templates) << {  
    println 'send emails'  
}  

sendEmails.enabled = false


运行结果如下：

$ gradle -b enabled.gradle sendEmails :templates process email templates :sendEmails SKIPPED $


### path

一个字符串属性包含任务的全限定路径名，默认是一个冒号加上任务名，如下所示：

task echoMyPath << {  
println "THIS TASK'S PATH IS ${path}"  
}


运行一下，输出如下：

$ gradle -b path.gradle echoMyPath THIS TASK'S PATH IS :echoMyPath $


最开始的冒号表示这个任务在最顶级的构建文件里面，由于Gradle支持多项目构建，一个项目里面可能有多个子项目，假如echoMyPath在子项目subProject构建文件中,那它的全限定路径名就是:subProject:echoMyPath。

### description

正如它的名字一样，这个用来给一个任务添加一段容易阅读的描述，你可以使用如下几种方法给任务添加描述。

task helloWorld(description: 'Says hello to the world') << {  
println 'hello, world'  
}  

task helloWorld << {  
println 'hello, world'  
}  

helloWorld {  
description = 'Says hello to the world'  
}  

// Another way to do it  
helloWorld.description = 'Says hello to the world'


## 任务的类型

我前面说过每个任务都有一个类型。除了DefaultTask之外，还有许多其他类型，你可以继承DefaultTask来声明新的类型，下面介绍几种比较重要的类型，以后可能经常会用到。

### Copy

Copy任务用于把文件从一个地方复制到另一个地方，你可以设置源目录、目标目录和要复制的文件类型，如下所示：

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


如果目标目录不存在,Copy任务会自动创建，上面这个任务会把resources目录下所有的xml、txt和propertied文件都复制到target目录。

### Jar

Jar任务用于打包源代码生成Jar文件，Java插件就自带这种类型，任务类型就叫做jar,这个任务把源代码文件和资源文件打包成Jar文件，并保存在build/libs目录下，文件名默认是用项目的名称。

apply plugin: 'java'  
task customJar(type: Jar) {  
manifest {  
//设置一些属性值(以键值对的形式)  
    attributes firstKey: 'firstValue', secondKey: 'secondValue'  
}  
//文件名  
archiveName = 'hello.jar'  
//目标路径  
destinationDir = file("${buildDir}/jars")//file方法用于把一个字符串变成文件对象  
//要打包的文件  
from sourceSets.main.classes  
}


### JavaExec

用于执行一个Java类的main()方法。举例说明：

apply plugin: 'java'  
//maven中央仓库  
repositories {  
    mavenCentral()  
}  
//项目依赖  
dependencies {  
    runtime 'commons-codec:commons-codec:1.5'  
}  

task encode(type: JavaExec, dependsOn: classes) {  

main = 'org.gradle.example.commandline.MetaphoneEncoder'  
    args = "The rain in Spain falls mainly in the plain".split().toList()  
    classpath sourceSets.main.classesDir  
    classpath configurations.runtime  
}


这个构建文件声明了一个外部依赖，Apache Commons Codec库。一般情况下，在命令行运行一个class文件的步骤是编译Java源文件，然后在命令行中设置class文件的路径和依赖的库文件。我们上面encode任务声明了main函数所在的类，给他传递了命令行参数，设置classpath参数。

## 编写自定义的任务类型

如果Gradle自带的任务类型不满足你的工作需求时，最简单的办法就是编写自定义的任务类型，Gradle提供了多种方法来实现，这里我介绍两种最常用的方法。

### 在Build文件中编写自定义任务类型

假设你的构建脚本需要对MySQL数据库执行一些随机的查询，下面我们来编写一个任务执行数据库查询：

task createDatabase(type: MySqlTask) {  
    sql = 'CREATE DATABASE IF NOT EXISTS example'  
}  

task createUser(type: MySqlTask, dependsOn: createDatabase) {  
    sql = "GRANT ALL PRIVILEGES ON example.*  
    TO exampleuser@localhost IDENTIFIED BY 'passw0rd'"  
}  

task createTable(type: MySqlTask, dependsOn: createUser) {  
    username = 'exampleuser'  
    password = 'passw0rd'  
    database = 'example'  
    sql = 'CREATE TABLE IF NOT EXISTS users  
    (id BIGINT PRIMARY KEY, username VARCHAR(100))'  
}  

class MySqlTask extends DefaultTask {  
    //声明任务的属性  
    def hostname = 'localhost'  
    def port = 3306  
    def sql  
    def database  
    def username = 'root'  
    def password = 'password'  

//表示这是任务的动作  
@TaskAction  
def runQuery() {  
    def cmd  
if(database) {  
    cmd = "mysql -u ${username} -p${password} -h    ${hostname}-P ${port} ${database} -e "  
}  
else {  
    cmd = "mysql -u ${username} -p${password} -h ${hostname} -P ${port} -e "  
}  
project.exec {  
    commandLine = cmd.split().toList() + sql  
}  
}  
}


上面的MySqlTask继承自DefaultTask,所有的任务都必须继承自这个类或者它的子类。任务声明了几个属性，然后声明了一个方法runQuery(),这个方法用@TaskAction注解了，表示这个方法会在任务执行的时候执行。最上面定义的三个任务都声明为MySqlTask类型，因此他们都自动继承了它的属性和方法，有些属性有默认值，你可以覆写这些默认值，来添加你的逻辑。

### 在源码树中定义自定义任务类型

前面你在build文件中定义了一个自定义的MySqlTask类型，这样的缺点就是你无法在其他构建文件中使用它，只能把它的源码复制过去。我们可以在源码树的buildSrc目录下定义自定义任务类型，这个目录下的文件会被自动编译然后添加到项目的classpath中，如下所示：

//任务MySqlTask并没有定义在构建脚本中  
task createDatabase(type: MySqlTask) {  
    sql = 'CREATE DATABASE IF NOT EXISTS example'  
}  

task createUser(type: MySqlTask, dependsOn: createDatabase) {  
    sql = "GRANT ALL PRIVILEGES ON example.*  
    TO exampleuser@localhost IDENTIFIED BY 'passw0rd'"  
}  

task createTable(type: MySqlTask, dependsOn: createUser) {  
    username = 'exampleuser'  
    password = 'passw0rd'  
    database = 'example'  
    sql = 'CREATE TABLE IF NOT EXISTS users  
    (id BIGINT PRIMARY KEY, username VARCHAR(100))'  
}


在buildSrc目录下新建一个文件MysqlTask.groovy,然后添加下面的代码：

import org.gradle.api.DefaultTask  
import org.gradle.api.tasks.TaskAction  

class MySqlTask extends DefaultTask {  
    //声明任务的属性  
    def hostname = 'localhost'  
    def port = 3306  
    def sql  
    def database  
    def username = 'root'  
    def password = 'password'  

//表示这是任务的动作  
@TaskAction  
def runQuery() {  
    def cmd  
if(database) {  
    cmd = "mysql -u ${username} -p${password} -h    ${hostname}-P ${port} ${database} -e "  
}  
else {  
    cmd = "mysql -u ${username} -p${password} -h ${hostname} -P ${port} -e "  
}  
project.exec {  
    commandLine = cmd.split().toList() + sql  
}  
}  
}



编译之后buildSrc目录树如下所示：

![/images/gradle-tasks.png](https://codingsky.oss-cn-hangzhou.aliyuncs.com/cdn/codingsky/upload/img/blog/bd5ace4dcd09329bdbbc04723abfee5b.png)

对Gradle的任务介绍就到此为止，大家如果还有不懂的地方可以去查看Gradle的官方文档<https://docs.gradle.org/current/release-notes>。