Android-Gradle-生命周期、Task

3,013 阅读4分钟

Gradle简介

Gradle 是一个开源的自动化构建工具,其核心是基于 Java 实现,可以把它看成一个轻量级的 Java 应用,可以使用 Groovy 或 Kotlin 来编写脚本,简化了开发时对项目构建要做的配置,使用更加灵活和强大。 在 Android 工程中,Gradle 主要涉及于:构建 Android 应用、组件化、插件化、热修复等方面,所以学习 Gradle 是很有必要的。

Gradle文件

1. build.gradle

  • build.gradle是项目构建文件,每个工程都有一个build.gradle文件。
  • build.gradle在配置阶段执行,并创建相应工程的Project对象,执行的代码可以直接调用该对象提供的方法或属性。

2. settings.gradle

settings 文件在初始化阶段执行,创建 Setting 对象,在执行脚本时可调用此对象方法,它决定哪些模块参与构建。 使用方法:

Settings.include(String... projectPaths)
include ':app'
  • 将给定的目录添加到项目构建中,':app' 表示文件相对路径,相当于 './app' 文件夹。
  • 多项目架构进行分层,把同层次的子工程放在同一文件夹下便于管理,使用 ':xxx:yyy' 表示

项目和任务

  • 项目:每个 build.gradle 都是一个项目对象,每一次 gradle 构建都至少包含一个项目,每个项目中都有各自的任务。
  • 任务:任务定义在构建脚本中,包含一系列的动作,类似于一个方法,比如 clean 任务:
task clean(type: Delete) {
    delete rootProject.buildDir
}

基本命令

可以直接通过命令调用任务,常用的命令如下:

1.依赖命令

androidDependencies 查找app工程依赖树
--refresh-dependencies assemble 强制刷新依赖

2.构建命令

assemble 全渠道打包
assembleDebug 全渠道打debug包
build 检查依赖并编译打包
clean 清除build文件夹

3.帮助命令

help 使用帮助
tasks 查看所有可执行Task

4.安装命令

installDebug 编译并安装debug包
installRelease
uninstallDebug 卸载debug包

5.验证命令

check 运行全部checks
lint 运行lint
test 运行单元测试

gradle生命周期

分为三个阶段:

1. 初始化

Gradle支持单项目和多项目构建。在初始化阶段,Gradle 确定哪些项目将参与构建,并为每个项目创建 Project 实例,一般我们不会接触到它。(比如解析settings.gradle)

2. 配置

配置阶段,解析每个工程的 build.gradle 文件,创建要执行的任务子集和确定各种任务之间的关系,以供执行阶段按照顺序执行,并对任务的做一些初始化配置。

3. 执行

运行阶段,Gradle 根据配置阶段创建和配置的要执行的任务子集,执行任务。

Task

1.task定义

任务属于某一个 Project 对象,是在 Gradle 执行阶段可以执行的代码块。 定义方式:

直接使用Project对象的task函数创建
task <任务名称>{代码块}
task test{
    println "test task"
}
//通过TaskContainer对象创建
tasks.create(name:"test2"){
    println "test task2"
}

但上述两个例子只是设置了任务的配置,在配置阶段就是打印出信息,那么想要在执行阶段添加动作,需要像下面一样表示:

task test{
    println "test task"
    //添加一个动作到task的最前面,表示task开始时调用
    doFirst {
        println "test doFirst"
    }
    //添加一个动作到task的最后面,表示任务结束时调用
    doLast {
        println "test doLast"
    }
}

输出:
> Configure project :app
test task

> Task :app:test
test doFirst
test doLast

2.task依赖

task A(dependsOn:[B]){ .. } 表示任务 A 依赖于任务 B,那么 B 执行在 A 之前。

task A{
    println "test A"
    doLast{
        println "test A-doLast"
    }
}
//这里表示任务B依赖任务A,在A执行后才会执行B
task B(dependsOn:[A]){
    println "test B"
    doLast{
        println "test B-doLast"
    }
}

输出:
> Configure project :app
test A
test B

> Task :app:A
test A-doLast

> Task :app:B
test B-doLast

动态的依赖任务:

//构建任务依赖时动态的依赖其它任务
tasks.whenTaskAdded { theTask->
    if(theTask.name == "packageDebug"){
        theTask.dependsOn "get"
    }
}

task get{
    doFirst{
        println "get doFirst"
    }
}

3.DefaultTask

task 定义的任务其实就是 DefaultTask 的一种具体实现类的对象,Gradle 自带的有 Delete、Copy、Zip 等等。 可以使用自定义类继承 DeaflutTask:

class WriteTask extends DefaultTask {
	//在方法上使用@TaskAction注解,表示任务运行时调用的方法。
    @TaskAction
    void write() {
        println("begin write...")
    }
}

task writeTask(type: WriteTask) {
	doLast {
        println "writeTask doLast"
    }
}

输出:
> Task :app:writeTask
begin write...
writeTask doLast

4.关联生命周期

Gradle生命周期流程如网图:

Gradle执行流程.png

4.1.GradleHook

Gradle在生命周期的三个阶段都设置了相应的Hook函数供使用。 初始化阶段:gradle.settingsEvaluated和gradle.projectsLoaded。(在settings.gradle中生效)

settings.gradle
gradle.settingsEvaluated {
    println("gradle.settingsEvaluated")
}

gradle.projectsEvaluated {
    println("gradle.projectsEvaluated")
}

执行任务输出:
gradle.settingsEvaluated
> Configure project :app
writeTask
gradle.projectsEvaluated

配置阶段:project.beforeEvaluateproject.afterEvaluate
gradle.beforeProjectgradle.afterProjectgradle.taskGraph.whenReady

gradle.beforeProject {
    println("gradle.beforeProject")
}

gradle.afterProject {
    println("gradle.afterProject")
}

gradle.taskGraph.whenReady {
    println("gradle.taskGraph.whenReady")
}

project.afterEvaluate {
    println("project.taskGraph.afterEvaluate")
}

执行任务输出:
> Configure project :app
test task
gradle.afterProject
project.taskGraph.afterEvaluate
gradle.taskGraph.whenReady

执行阶段:gradle.taskGraph.beforeTaskgradle.taskGraph.afterTask

gradle.taskGraph.beforeTask {
    println("gradle.taskGraph.beforeTask")
}

gradle.taskGraph.afterTask {
    println("gradle.taskGraph.afterTask")
}

执行任务输出:
> Task :app:C
gradle.taskGraph.beforeTask
test C-doLast
gradle.taskGraph.afterTask

Gradle对各阶段都有相应的回调处理:
gradle.addProjectEvaluationListener
gradle.addBuildListener gradle.addListenerTaskExecutionGraphListener (任务执行图监听)TaskExecutionListener(任务执行监听)TaskExecutionListenerTaskActionListenerStandardOutputListener 等。

5.Task案例

5.1.写文件

class WriteTask extends DefaultTask {
    @TaskAction
    void write() {
        println("begin write...")
        //输入文件
        def inFile = inputs.files.singleFile
        println(inFile)
        //输出文件
        def outFile = outputs.files.singleFile
        println(outFile)
        outFile.createNewFile()
        //write操作
        outFile.text = inFile.text
    }
}

task writeTask(type: WriteTask) {
	//输入文件,例如build.gradle
    inputs.file(file("build.gradle"))
    //输出文件
    outputs.file(file("text.txt"))
}

5.2.压缩apk为zip文件

afterEvaluate {
    task zip(type: Zip) {
    	//输出文件名称
        archiveName("outputName.zip")
        //路径
        destinationDir file("${buildDir}/custom")
        //输入数据为:task->packageDebug的产出文件
        from(tasks.findByName("packageDebug").outputs.files)
    }
}

总结

到此,我们学习到了Gradle生命周期,Task任务,命令行执行任务