EZLippi-浮生志

彻底理解Gradle的任务

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

声明一个任务

声明任务很简单,你只需要一个任务名:

1
task hello

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

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

任务的动作

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

1
2
3
task hello <<{
println 'hello,world'
}

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

1
2
3
4
5
6
7
8
9
10

task hello

hello << {
print 'hello,'
}

hello << {
println 'world'
}

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

$ gradle hello
hello, world
$

##任务的配置

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

1
2
3
4
5

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用来找出哪些项目会参与到项目构建中,这在多项目构建中很重要。

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

1
2
3
4
5
6

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)

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

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

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

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

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

任务可以依赖多个任务,如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

//每次声明一个任务
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方法,传递一个闭包给这个方法,如下所示:

1
2
3
4
5
6
7
8
9

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

setupDatabaseTests.doFirst {
println 'create schema'
}

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

$ gradle setupDatabaseTests
:setupDatabaseTests
create schema
load test data
$

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

1
2
3
4
5
6
7
8
9

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

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

1
2
3
4
5
6
7
8
9
10
11
12

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语句,看一个例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

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不让它运行,但是它依赖的任务依然会运行。

1
2
3
4
5
6
7
8
9
10

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

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

1
2
3
4

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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任务用于把文件从一个地方复制到另一个地方,你可以设置源目录、目标目录和要复制的文件类型,如下所示:

1
2
3
4
5
6

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目录下,文件名默认是用项目的名称。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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()方法。举例说明:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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数据库执行一些随机的查询,下面我们来编写一个任务执行数据库查询:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

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中,如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

//任务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,然后添加下面的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

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

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

🐶 您的支持将鼓励我继续创作 🐶