Gradle入门系列(四)——初识Gradle Task

Gradle中的Task

1、Task定义及配置

TaskContainer:管理全部的Task，如：增长、查找。

定义（建立）Task

// 直接经过task函数去建立
task helloTask {
  println 'i am helloTask.'
}

// 经过TaskContainer去建立
this.tasks.create(name: 'helloTask2') {
  println 'i am helloTask 2.'
}
复制代码

配置Task

// 给Task指定分组与描述
task helloTask(group: 'study', description: 'task study'){ // 语法糖
  ...
}
task helloTask {
  group 'study' // setGroup('study')
  description 'task study' // setDescription('task study')
  ...
}
复制代码

Task除了能够配置group、description外，还能够配置name、type、dependsOn、overwrite、action。

结论：

• 给Task分组以后，该task会被放到指定组中，方便归类查找。（默认被分组到other中）
• 给Task添加描述，至关于给方法添加注释。

2、Task的执行详情

Task中doFirst与doLast的使用：

task helloTask {
  println 'i am helloTask.'
  doFirst {
    println 'the task group is: ' + group
  }
  // doFirst、doLast能够定义多个
  doFirst {}
}
// 外部指定doFirst（会比在闭包内部指定的doFirst先执行）
helloTask.doFirst {
  println 'the task description is: ' + description
}

// 统计build执行时长
def startBuildTime, endBuildTime
this.afterEvaluate { Project project ->
  // 保证要找的task已经配置完毕
  def preBuildTask = project.tasks.getByName('preBuild') // 执行build任务时，第一个被执行的Task
  preBuildTask.doFirst {
    startBuildTime = System.currentTimeMillis()
  }
  def buildTask = project.tasks.getByName('build') // 执行build任务时，最后一个被执行的Task
  buildTask.doLast {
    endBuildTime = System.currentTimeMillis()
    println "the build time is: ${endBuildTime - startBuildTime}"
  }
}
复制代码

结论：

• Task闭包中直接编写的代码，会在配置阶段执行。能够经过doFirst、doLast块将代码逻辑放到执行阶段中执行。
• doFirst、doLast能够指定多个。
• 外部指定的doFirst、doLast会比内部指定的先执行。
• doFirst、doLast能够对gradle中提供的已有的task进行扩展。

3、Task的执行顺序

task执行顺序指定的三种方式：

1. dependsOn强依赖方式
2. 经过Task输入输出指定（与第1种等效）
3. 经过API指定执行顺序

一、Task的依赖

// ============= dependsOn强依赖方式 =============
task taskX {
  doLast {
      println 'taskX'
  }
}
task taskY {
  doLast {
      println 'taskY'
  }
}
// 方式一：静态依赖
// task taskZ(dependsOn: taskY) // 依赖一个task
task taskZ(dependsOn: [taskX, taskY]) { // 依赖多个task，须要用数组[]表示
  doLast {
      println 'taskZ'
  }
}
// 方式二：静态依赖
taskZ.dependsOn(taskX, taskY)
// 方式三：动态依赖
task taskZ() {
  dependsOn this.tasks.findAll {    // 依赖全部以lib开头的task
    task -> return task.name.startsWith('lib')
  }
  doLast {
      println 'taskZ'
  }
}
复制代码

其余：

• taskZ依赖了taskX与taskY，因此在执行taskZ时，会先执行taskX、taskY。
• taskZ依赖了taskX与taskY，但taskX与taskY没有关系，它们的执行顺序是随机的。

二、Task的输入输出

inputs和outputs是Task的属性。 inputs能够是任意数据类型对象，而outputs只能是文件（或文件夹）。 TaskA的outputs能够做为TaskB的inputs。

例子：writeTask输入扩展属性，输出文件，readTask输入writeTask的输出文件

ext {
    versionCode = '1.0.0'
    versionName = '100'
    versionInfo = 'App的第1个版本，完成聊天功能'
    destFile = file('release.xml')
    if (destFile != null && !destFile.exists()) {
        destFile.createNewFile()
    }
}

task writeTask {
    inputs.property('versionCode', this.versionCode)
    inputs.property('versionName', this.versionName)
    inputs.property('versionInfo', this.versionInfo)
    outputs.file this.destFile
    doLast {
        def data = inputs.getProperties() // 返回一个map
        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将xml数据写入到sw中
            xmlBuilder.releases { // <releases>
                release { // <releases>的子节点<release>
                    versionCode(versionMsg.versionCode)
                    // <release>的子节点<versionCode>1.0.0<versionCode>
                    versionName(versionMsg.versionName)
                    versionInfo(versionMsg.versionInfo)
                }
            }
            // 将sw里的内容写到文件中
            file.withWriter { writer ->
                writer.append(sw.toString())
            }
        } else { // 已经有其它版本信息了
            xmlBuilder.release {
                versionCode(versionMsg.versionCode)
                versionName(versionMsg.versionName)
                versionInfo(versionMsg.versionInfo)
            }
            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(sw.toString() + '\r\n')
                        writer.append(line + '\r\n')
                    }
                }
            }
        }
    }
}

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

task taskTest(dependsOn: [writeTask, readTask]) {
    doLast {
        println '任务执行完毕'
    }
}

class VersionMsg {
    String versionCode
    String versionName
    String versionInfo
}
复制代码

经过执行 gradle taskTask 以后，就能够在工程目录下看到release.xml文件了。

结论：

• 由于writeTask与readTask经过inputs、outputs产生了关联关系，因此，readTask必定会在writeTask执行以后才执行。

三、Task API指定顺序

task指定执行顺序的api有：

• mustRunAfter : 强行指定在某个或某些task执行以后才执行。
• shouldRunAfter : 与mustRunAfter同样，但不强制。

task taskX {
    doLast {
        println 'taskX'
    }
}
task taskY {
    // shouldRunAfter taskX
    mustRunAfter taskX
    doLast {
        println 'taskY'
    }
}
task taskZ {
    mustRunAfter taskY
    doLast {
        println 'taskZ'
    }
}
复制代码

经过执行 gradle taskY taskZ taskX 以后，能够看到终端仍是按taskX、taskY、taskZ顺序执行的。

4、挂接到构建生命周期

例子：build任务执行完成后，执行一个自定义task

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

例子：Tinker将自定义的manifestTask插入到了gradle脚本中processManifest与processResources这两个任务之间

TinkerManifestTask manifestTask = project.tasks.create("tinkerProcess${variantName}Manifest", TinkerManifestTask)
...
manifestTask.mustRunAfter variantOutput.processManifest
variantOutput.processResources.dependsOn manifestTask
复制代码

5、Task类型

Gradle DSL Version 5.1

Copy - Gradle DSL Version 5.1