gradle task

1. Task定义及配置

1.1. 定义

直接使用task函数进行定义：

task helloTask {
    println 'I am helloTask'
}

通过TaskContainer创建Task

this.tasks.create(name: 'helloTask2') {
    println 'I am helloTask2'
}

gradle是通过TaskContainer管理当前Project中所有的Task。

1.2. 配置

为task设置组名和描述信息：

task helloTask (group: 'imooc', description: 'task study') {
    println 'I am helloTask'
}

this.tasks.create(name: 'helloTask2') {
    setGroup('imooc')
    setDescription('task study')
    println 'I am helloTask2'
}

上述2中创建task的方法效果都是一样的，最终都会把创建的task添加到task TaskContainer中。
group分组后，gradle会把相同group的task放一起，方便管理，如果不添加分组，就会被gradle放到other分组。
description是普通描述信息，说明该task的作用

2. Task的执行详解

定义中的例子输出都是在task的配置阶段进行输出的，所以上述例子会输出task中的2个task中的打印语句。任何task的执行整个project中所有的配置代码都会被这行。使用task的doFirst和doLast会运行在gradle的执行周期，下面看看如何让task里面的代码在执行阶段运行。

task helloTask (group: 'imooc', description: 'task study') {
    println 'I am helloTask'
    doFirst {
        println 'the task group is: ' + group
    }
    // 可以多次调用
    doFirst {}
}

helloTask.doFirst {
    println 'the task description is: '+ description
}

在task内部可以多次调用doFirst，也可以在task外部进行调用doFirst，执行时先执行外部的doFirst，再执行task内部定义的。

E:\studio\gradletest>gradlew helloTask
Starting a Gradle Daemon, 1 incompatible Daemon could not be reused, use --status for details

> Configure project :app
I am helloTask

> Task :app:helloTask
the task description is: task study
the task group is: imooc

doFirst和doLast的区别，gradle已经为我们默认实现了许多task，可以通过doFirst可以为已经有的task之前添加相应的逻辑，通过doLast可以为已经有的task之后添加相应的逻辑。
下面实现一个计算build执行时长的功能：

// 在这个方法执行的时候，project所有的task都已经被有序地创建好了
// 如果直接在脚本找，有些task没有被创建完毕，会出现task找不到报错
this.afterEvaluate {
    def preBuildTask = project.tasks.getByName('preBuild')
    preBuildTask.doFirst {
        startBuildTime = System.currentTimeMillis()
        println 'the start time is: ' + startBuildTime
    }
    def buildTask = project.tasks.getByName('build')
    buildTask.doLast {
        endBuildTime = System.currentTimeMillis()
        println "the build time is: ${endBuildTime - startBuildTime}"
    }
}

3. Task的依赖和执行顺序

决定task执行顺序主要有3中方式： 
1.    dependsOn强依赖方式
2.    通过Task输入输出指定
3.    通过API指定实行顺序
其中方式1和方式2是等效的。
task依赖示例：

/**
 * task 依赖
 */
task taskX {
    doLast {
        println 'taskX'
    }
}

task taskY {
    doLast {
        println 'taskY'
    }
}
task taskZ(dependsOn : [taskX, taskY]) {
    doLast {
        println 'taskZ'
    }
}

使用dependsOn指定依赖，如果多个依赖，使用列表进行定义，输出

E:\studio\gradletest>gradlew taskZ

> Task :app:taskX
taskX

> Task :app:taskY
taskY

> Task :app:taskZ
taskZ

也可以使用下面方式指定依赖：

taskZ.dependsOn(taskX, taskY)

被依赖的task如果没有依赖关系，他们的执行的时机是随机的。
使用<<的作用完全等于doLast方法。
task动态依赖：

task lib1 << {
    println 'lib1'
}

task lib2 << {
    println 'lib2'
}

task noLib << {
    println 'noLib'
}

task taskZ {
    dependsOn this.tasks.findAll { task ->
        println 'dependsOn: ' + task.name
        task.name.startsWith('lib')
    }
    doLast {
        println 'taskZ'
    }
}

taskZ需要放到依赖task的后面，如果放在前面，在执行dependsOn会发现tasks中没有在taskZ后面task，导致依赖失败。
实际运用，解析xml并输出到对应的文件：
xml的内容：

<releases>
  <release>
    <versionCode>100</versionCode>
    <versionName>1.0.0</versionName>
    <versionInfo>App的第1个版本，上线了一些最基础核心的功能.</versionInfo>
  </release>
  
  
  <release>
    <versionCode>110</versionCode>
    <versionName>1.1.0</versionName>
    <versionInfo>App的第2个版本，上线了一些最基础核心的功能.</versionInfo>
  </release>
  
  
  <release>
    <versionCode>1</versionCode>
    <versionName>1.2.0</versionName>
    <versionInfo>第8个版本。。。</versionInfo>
  </release>
</releases>

build.gradle

task handleReleaseFile {
    def srcFile = file('releases.xml')
    def destDir = new File(this.buildDir, 'generated/release/')
    doLast {
        println '开始解析对应的xml文件...'
        destDir.mkdir()
        def releases = new XmlParser().parse(srcFile)
        releases.release.each{releaseNode ->
            // 解析每个release节点的内容
            def name = releaseNode.versionName.text()
            def versionCode = releaseNode.versionCode.text()
            def versionInfo = releaseNode.versionInfo.text()
            // 创建文件，并写入节点数据
            def destFile = new File(destDir, "release-${name}.txt")
            destFile.withWriter { writer ->
                writer.write("${name} -> ${versionCode} -> ${versionInfo}")

            }
        }
    }
}

task handleReleaseFileTest (dependsOn : handleReleaseFile){
    def dir = fileTree( 'build/generated/release/')
    doLast {
        dir.each {
            println 'the file name is: ' + it
        }
        println '输出完成...'
    }
}

在控制台输入命令运行task：

gradlew handleReleaseFileTest

输出结果：

> Task :app:handleReleaseFile
开始解析对应的xml文件...

> Task :app:handleReleaseFileTest
the file name is: E:\studio\gradletest\app\build\generated\release\release-1.0.0.txt
the file name is: E:\studio\gradletest\app\build\generated\release\release-1.1.0.txt
the file name is: E:\studio\gradletest\app\build\generated\release\release-1.2.0.txt
输出完成...

4.    Task输入输出
先看一张图：
 
上图Task One和Task Two分别代表2个Task，inputs和outputs是Task的2个属性，Task One的输出是Task Two的输入。
TaskInputs代表Task的输入类，TaskInputs接收的输入参数类型包括：files，file，dir和key-value类型的属性，value可以是任何对象类型。也就是说Task输入可以是任意对象，文件，多个文件和文件夹。
TaskOutputs表示Task的输出类，输出类型包括：files，file，dir，也就是说TaskOutputs的输出是文件类型。
gradle规定，如果一个task同时依赖于另外两个task，并且另外两个task的其中一个task输出作为另外一个task的输入，那么会先执行生产者的task。
下面的代码功能：根据版本信息生成release.xml文件

/**
 * task的输入输出详解
 */
import groovy.xml.MarkupBuilder

ext {
    versionName = '1.1.0'
    versionCode = '110'
    versionInfo = 'App的第2个版本，上线了一些基础的核心功能'
    destFile = file('releases.xml')
    if(destFile != null && !destFile.exists()) {
        destFile.createNewFile()
    }
}

task readTask {
    inputs.file destFile
    doLast {
        def file = inputs.files.singleFile
        println file.text
    }
}

task writeTask {
    // 为Task指定输入
    inputs.property('versionCode', this.versionCode)
    inputs.property('versionName', this.versionName)
    inputs.property('versionInfo', this.versionInfo)

    outputs.file destFile

    doLast {
        def data = inputs.getProperties()
        File file = outputs.getFiles().getSingleFile()

        // 将Map转化为实体对象
        def versionMsg = new VersionMsg(data)
        def sw = new StringWriter()
        def xmlBuilder = new MarkupBuilder(sw)
        if(file.text != null && file.text.size() <= 0) {
            // 文件中没有内容
            xmlBuilder.releases {
                release {
                    versionCode(versionMsg.versionCode)
                    versionName(versionMsg.versionName)
                    versionInfo(versionMsg.versionInfo)
                }
            }
            file.withWriter{writer -> writer.append(sw.toString())}
        } else {
            // 已有版本信息
            xmlBuilder.release {
                versionCode(versionMsg.versionCode)
                versionName(versionMsg.versionName)
                versionInfo(versionMsg.versionInfo)
            }
            // 将生成的xml数据插入到根节点之前
            def lines = file.readLines()
            def lengths = lines.size() - 1
            file.withWriter { writer ->
                lines.eachWithIndex { String line, int index ->
                    if(index != lengths) {
                        writer.append(line + '\r\n')
                    } else if(index == lengths) {
                        writer.append('\r\r\n' + sw.toString() + '\r\n')
                        writer.append(lines.get(lengths))
                    }

                }

            }

        }
    }
}

class VersionMsg {
    String versionCode
    String versionName
    String versionInfo
}

task taskTest {
    dependsOn readTask, writeTask
    doLast {
        println '输入输出任务结束'
    }
}

5. 挂接到构建生命周期

5.1. task执行顺序

task执行顺序的指定除了使用dependsOn强依赖方式和通过Task输入输出指定，还可以通过API指定实行顺序。
mustRunAfter它可以指定一个，也可以指定多个，用法完全一样。

/**
 * 执行顺序的指定
 */
task taskX {
    doLast {
        println 'taskX'
    }
}

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

task taskZ {
    mustRunAfter taskY
    doLast {
        println 'taskZ'
    }
}

控制台输入顺序错乱的task：

gradlew taskY taskZ taskX

输出：

E:\studio\gradletest>gradlew taskY taskZ taskX

> Task :app:taskX
taskX

> Task :app:taskY
taskY

> Task :app:taskZ
taskZ

shouldRunAfter和mustRunAfter用法完全一样，唯一区别是mustRunAfter是强制task必须在另外的task之后执行，而shouldRunAfter是非强制性的。

5.2. 挂接到构建生命周期

this.project.afterEvaluate { project ->
    def buildTask = project.tasks.getByName('build')
    if(buildTask == null) {
        throw GradleException('the build task is not found')
    }
    buildTask.doLast {
        writeTask.execute()
    }
}

5.3. 挂接到构建生命周期的中间

指定运行在某些task之后，某个task之前。

6. task类型

参考官方文档：https://docs.gradle.org/current/dsl/