简介

在之前的文章中，咱们讲到了如何应用gradle创立一个简略的task，以及task之间怎么依赖，甚至应用了程序来创立task。在本文中，咱们会更加深刻的去理解一下gradle中的task。

定义task

定义一个task能够有很多种形式，比方上面的应用string作为task的名字：

task('hello') {    doLast {        println "hello"    }}task('copy', type: Copy) {    from(file('srcDir'))    into(buildDir)}

还能够应用tasks容器来创立：

tasks.create('hello') {    doLast {        println "hello"    }}tasks.create('copy', Copy) {    from(file('srcDir'))    into(buildDir)}

下面的例子中，咱们应用tasks.create办法，将新创建的task加到tasks汇合中。

咱们还能够应用groovy特有的语法来定义一个task：

task(hello) {    doLast {        println "hello"    }}task(copy, type: Copy) {    from(file('srcDir'))    into(buildDir)}

tasks 汇合类

下面咱们在创立task的时候，应用了tasks汇合类来创立task。

实际上，tasks汇合类是一个十分有用的工具类，咱们能够应用它来做很多事件。

间接在build文件中应用tasks，实际上是援用了TaskContainer的一个实例对象。咱们还能够应用 Project.getTasks() 来获取这个实例对象。

咱们看下TaskContainer的定义：

public interface TaskContainer extends TaskCollection<Task>, PolymorphicDomainObjectContainer<Task> 

从定义上，咱们能够看出TaskContainer是一个task的汇合和域对象的汇合。

taskContainer中有四类十分重要的办法：

第一类是定位task的办法，有个别离是findByPath和getByPath。两个办法的区别就是findByPath如果没找到会返回null，而getByPath没找到的话会抛出UnknownTaskException。

看下怎么应用：

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

输入：

:hello:hello

第二类是创立task的办法create，create办法有多种实现，你能够间接通过名字来创立一个task：

task('hello') {    doLast {        println "hello"    }}

也能够创立特定类型的task：

task('copy', type: Copy) {    from(file('srcDir'))    into(buildDir)}

还能够创立带参数的构造函数的task：

class CustomTask extends DefaultTask {    final String message    final int number    @Inject    CustomTask(String message, int number) {        this.message = message        this.number = number    }}

下面咱们为CustomTask创立了一个带参数的构造函数，留神，这里须要带上@javax.inject.Inject注解，示意咱们前面能够传递参数给这个构造函数。

咱们能够这样应用：

tasks.create('myTask', CustomTask, 'hello', 42)

也能够这样应用：

task myTask(type: CustomTask, constructorArgs: ['hello', 42])

第三类是register，register也是用来创立新的task的，不过register执行的是提早创立。也就是说只有当task被须要应用的时候才会被创立。

咱们先看一个register办法的定义：

TaskProvider<Task> register(String name,                            Action<? super Task> configurationAction)                     throws InvalidUserDataException 

能够看到register返回了一个TaskProvider，有点像java多线程中的callable,当咱们调用Provider.get()获取task值的时候，才会去创立这个task。

或者咱们调用TaskCollection.getByName(java.lang.String)的时候也会创立对应的task。

最初一类是replace办法：

Task replace(String name)<T extends Task> T replace(String name,                           Class<T> type)

replace的作用就是创立一个新的task，并且替换掉同样名字的老的task。

Task 之间的依赖

task之间的依赖关系是通过task name来决定的。咱们能够在同一个我的项目中做task之间的依赖：

task hello {    doLast {        println 'Hello www.flydean.com!'    }}task intro {    dependsOn hello    doLast {        println "I'm flydean"    }}

也能够跨我的项目进行task的依赖，如果是跨我的项目的task依赖的话，须要制订task的门路：

project('project-a') {    task taskX {        dependsOn ':project-b:taskY'        doLast {            println 'taskX'        }    }}project('project-b') {    task taskY {        doLast {            println 'taskY'        }    }}

或者咱们能够在定义好task之后，再解决task之间的依赖关系：

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

还能够动静增加依赖关系：

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

定义task之间的程序

有时候咱们的task之间是有执行程序的，咱们称之为对task的排序ordering。

先看一下ordering和dependency有什么区别。dependency示意的是一种强依赖关系，如果taskA依赖于taskB，那么执行taskA的时候肯定要先执行taskB。

而ordering则是一种并不太强列的程序关系。示意taskA须要在taskB之后执行，然而taskB不执行也能够。

在gradle中有两种order：别离是must run after和should run after。

taskA.mustRunAfter(taskB)示意必须恪守的程序关系，而taskA.shouldRunAfter(taskB)则不是必须的，在上面两种状况下能够疏忽这样的程序关系：
第一种状况是如果shouldRunAfter引入了order循环的时候。

第二种状况是如果在并行执行的状况下，task所有的依赖关系都曾经满足了，那么也会疏忽这个程序。

咱们看下怎么应用：

task taskX {    doLast {        println 'flydean.com'    }}task taskY {    doLast {        println 'hello'    }}taskY.mustRunAfter taskX//taskY.shouldRunAfter taskX

给task一些形容

咱们能够给task一些形容信息，这样咱们在执行gradle tasks的时候，就能够查看到：

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

task的条件执行

有时候咱们须要依据build文件中的某些属性来判断是否执行特定的task，咱们能够应用onlyIf ：

task hello {    doLast {        println 'www.flydean.com'    }}hello.onlyIf { !project.hasProperty('skipHello') }

或者咱们能够抛出StopExecutionException异样，如果遇到这个异样，那么task前面的工作将不会被执行：

task compile {    doLast {        println 'We are doing the compile.'    }}compile.doFirst {    if (true) { throw new StopExecutionException() }}task myTask {    dependsOn('compile')    doLast {        println 'I am not affected'    }}

咱们还能够启动和禁用task：

myTask.enabled = false

最初咱们还能够让task超时，当超时的时候，执行task的线程将会被中断，并且task将会被标记为failed。

如果咱们想继续执行，那么能够应用 --continue。

留神， 只有可能响应中断的task，timeout才有用。

task hangingTask() {    doLast {        Thread.sleep(100000)    }    timeout = Duration.ofMillis(500)}

task rule

如果咱们想要给某些task定义一些规定，那么能够应用tasks.addRule：

tasks.addRule("Pattern: ping<ID>") { String taskName ->    if (taskName.startsWith("ping")) {        task(taskName) {            doLast {                println "Pinging: " + (taskName - 'ping')            }        }    }}

上咱们定义了一个rule，如果taskName是以ping结尾的话，那么将会输入对应的内容。

看下运行后果：

> gradle -q pingServer1Pinging: Server1

我还能够将这些rules作为依赖项引入：

task groupPing {    dependsOn pingServer1, pingServer2}

Finalizer tasks

和java中的finally一样，task也能够指定对应的finalize task：

task taskX {    doLast {        println 'taskX'    }}task taskY {    doLast {        println 'taskY'    }}taskX.finalizedBy taskY> gradle -q taskXtaskXtaskY

finalize task是肯定会被执行的，即便下面的taskX中抛出了异样。

总结

以上就是gradle中task的详解，心愿大家可能喜爱。

本文已收录于 http://www.flydean.com/gradle-task-in-depth/

最艰深的解读，最粗浅的干货，最简洁的教程，泛滥你不晓得的小技巧等你来发现！

欢送关注我的公众号:「程序那些事」,懂技术，更懂你！