Gradle 进行构建，都要经过3个生命周期阶段：
- 初始化阶段settings.gradle
- 配置阶段
- 执行阶段
初始化阶段
初始化阶段的任务是创建项目的层次结构，并且为每一个项目创建一个Project实例。
与初始化阶段相关的脚本文件是settings.gradle（包括<USER_HOME>/.gradle/init.d目录下的所有.gradle脚本文件，这些文件作用于本机的所有构建过程）。一个settings.gradle脚本对应一个Settings对象，我们最常用来声明项目的层次结构的include就是Settings类下的一个方法，在Gradle初始化的时候会构造一个Settings实例对象，它包含了下图中的方法，这些方法都可以直接在settings.gradle中直接访问。
比如可以通过如下代码向Gradle的构建过程添加监听：
gradle.addBuildListener(new BuildListener() {
void buildStarted(Gradle var1) {
println '开始构建'
}
void settingsEvaluated(Settings var1) {
println 'settings评估完成（settins.gradle中代码执行完毕）'
// var1.gradle.rootProject 这里访问Project对象时会报错，还未完成Project的初始化
}
void projectsLoaded(Gradle var1) {
println '项目结构加载完成（初始化阶段结束）'
println '初始化结束，可访问根项目：' + var1.gradle.rootProject
}
void projectsEvaluated(Gradle var1) {
println '所有项目评估完成（配置阶段结束）'
}
void buildFinished(BuildResult var1) {
println '构建结束 '
}
})
执行gradle build，打印结果如下：
settings评估完成（settins.gradle中代码执行完毕）
项目结构加载完成（初始化阶段结束）
初始化结束，可访问根项目：root project 'GradleTest'
所有项目评估完成（配置阶段结束）
:buildEnvironment
------------------------------------------------------------
Root project
------------------------------------------------------------
classpath
No dependencies
BUILD SUCCESSFUL
Total time: 0.959 secs
构建结束
配置阶段
配置阶段的任务是执行各项目下的build.gradle脚本，完成Project的配置，并且构造Task任务依赖关系图以便在执行阶段按照依赖关系执行Task。
该阶段也是我们最常接触到的构建阶段，比如应用外部构建插件apply plugin: 'com.android.application'，配置插件的属性android{ compileSdkVersion 25 ...}等。每个build.gralde脚本文件对应一个Project对象，在初始化阶段创建，Project的接口文档。
配置阶段执行的代码包括build.gralde中的各种语句、闭包以及Task中的配置段语句，在根目录的build.gradle中添加如下代码：
println 'build.gradle的配置阶段'
// 调用Project的dependencies(Closure c)声明项目依赖
dependencies {
// 闭包中执行的代码
println 'dependencies中执行的代码'
}
// 创建一个Task
task test() {
println 'Task中的配置代码'
// 定义一个闭包
def a = {
println 'Task中的配置代码2'
}
// 执行闭包
a()
doFirst {
println '这段代码配置阶段不执行'
}
}
println '我是顺序执行的'
调用gradle build，得到如下结果：
build.gradle的配置阶段
dependencies中执行的代码
Task中的配置代码
Task中的配置代码2
我是顺序执行的
:buildEnvironment
------------------------------------------------------------
Root project
------------------------------------------------------------
classpath
No dependencies
BUILD SUCCESSFUL
Total time: 1.144 secs
一定要注意，配置阶段不仅执行build.gradle中的语句，还包括了Task中的配置语句。从上面执行结果中可以看到，在执行了dependencies的闭包后，直接执行的是任务test中的配置段代码（Task中除了Action外的代码段都在配置阶段执行）。
另外一点，无论执行Gradle的任何命令，初始化阶段和配置阶段的代码都会被执行。
同样是上面那段Gradle脚本，我们执行帮助任务gradle help，任然会打印出上面的执行结果。我们在排查构建速度问题的时候可以留意，是否部分代码可以写成任务Task，从而减少配置阶段消耗的时间。
执行阶段
在配置阶段结束后，Gradle会根据任务Task的依赖关系创建一个有向无环图，可以通过Gradle对象的getTaskGraph方法访问，对应的类为TaskExecutionGraph，然后通过调用gradle <任务名>执行对应任务。
下面我们展示如何调用子项目中的任务。
- 在根目录下创建目录subproject，并添加文件build.gradle
- 在settings.gradle中添加
include ':subproject' - 在subproject的build.gradle中添加如下代码
task grandpa {
doFirst {
println 'task grandpa：doFirst 先于 doLast 执行'
}
doLast {
println 'task grandpa：doLast'
}
}
task father(dependsOn: grandpa) {
doLast {
println 'task father：doLast'
}
}
task mother << {
println 'task mother 先于 task father 执行'
}
task child(dependsOn: [father, mother]){
doLast {
println 'task child 最后执行'
}
}
task nobody {
doLast {
println '我不执行'
}
}
// 指定任务father必须在任务mother之后执行
father.mustRunAfter mother
它们的依赖关系如下：
:subproject:child
+--- :subproject:father
| \--- :subproject:grandpa
\--- :subproject:mother
执行gradle :subproject:child，得到如下打印结果：
:subproject:mother
task mother 先于 task father 执行
:subproject:grandpa
task grandpa：doFirst 先于 doLast 执行
task grandpa：doLast
:subproject:father
task father：doLast
:subproject:child
task child 最后执行
BUILD SUCCESSFUL
Total time: 1.005 secs
因为在配置阶段，我们声明了任务mother的优先级高于任务father，所以mother先于father执行，而任务father依赖于任务grandpa，所以grandpa先于father执行。任务nobody不存在于child的依赖关系中，所以不执行。
Hook点
Gradle提供了非常多的钩子供开发人员修改构建过程中的行为，为了方便说明，先看下面这张图。
Gradle在构建的各个阶段都提供了很多回调，我们在添加对应监听时要注意，监听器一定要在回调的生命周期之前添加，比如我们在根项目的build.gradle中添加下面的代码就是错误的：
gradle.settingsEvaluated { setting ->
// do something with setting
}
gradle.projectsLoaded {
gradle.rootProject.afterEvaluate {
println 'rootProject evaluated'
}
}
当构建走到build.gradle时说明初始化过程已经结束了，所以上面的回调都不会执行，把上述代码移动到settings.gradle中就正确了。
1. Project
Project 提供的生命周期回调方法有：
//在 Project 进行配置前调用
void beforeEvaluate(Closure closure)
//在 Project 配置结束后调用
void afterEvaluate(Closure closure)
beforeEvaluate 必须在父模块的 build.gradle 对子模块进行配置才能生效，因为在当前模块的 build.gradle 中配置，它自己本身都没配置好，所以不会监听到。
每一个 build.gradle 脚本文件被 Gradle 加载解析后，都会对应生成一个 Project 对象，在脚本中的配置方法其实都对应着 Project 中的API，如果想详细了解这些脚本的配置含义，有必要对 Project 类做些深入的剖析。
Project类图
当构建进程启动后，Gradle基于build.gradle中的配置实例化org.gradle.api.Project类，先来看看 Project 类的主要结构(节选部分常用)：
接下来我们通过一些实际的例子，由浅入深的来体会这些 API 的含义。
File bd = getBuildDir()
println "buildDir = ${bd.getAbsolutePath()}"
//获取Project的名字
String name = getName()
println "project name = $name"
//设置Project的描述信息
setDescription "这是一个测试案例"
String desc = getDescription()
println "project description = $desc"
//获取Project的路径
String path = getPath();
println "project path = $path"
class VersionInfo {
String version
boolean release
VersionInfo(String v, boolean release) {
version = v
this.release = release
}
String toString() {
return "V-${version}-${release ? 'release' : 'debug'}"
}
}
//设置Project的版本号，参数可以是任何对象，gradle内部会使用 toString() 方法返回的值
setVersion(new VersionInfo("1.0.0", true))
println("project version = ${getVersion()}")
//设置Project的分组
setGroup "TestGroup"
println("project group = ${getGroup()}")
直接执行 gradle 命令，可以看到在配置阶段输出以下结果：
> Configure project :
rootDir = /Users/hjy/Desktop/gradle
buildDir = /Users/hjy/Desktop/testgradle/build
project name = gradle
project description = 这是一个测试案例
project path = :
project version = V-1.0.0-release
project group = TestGroup
我们用个例子来验证下结果，工程结构如下图所示：
settings.gradle 代码：
include ":app"
build.gradle 代码：
//对子模块进行配置
subprojects { sub ->
sub.beforeEvaluate { proj ->
println "子项目beforeEvaluate回调..."
}
}
println "根项目配置开始---"
task rootTest {
println "根项目里任务配置---"
doLast {
println "执行根项目任务..."
}
}
println "根项目配置结束---"
app/build.gradle 代码：
println "APP子项目配置开始---"
afterEvaluate {
println "APP子项目afterEvaluate回调..."
}
task appTest {
println "APP子项目里任务配置---"
doLast {
println "执行子项目任务..."
}
}
println "APP子项目配置结束---"
在根目录执行：gradle -q，结果如下：
根项目配置开始---
根项目里任务配置---
根项目配置结束---
子项目beforeEvaluate回调...
APP子项目配置开始---
APP子项目里任务配置---
APP子项目配置结束---
APP子项目afterEvaluate回调...
2. Gradle
Gradle 提供的生命周期回调方法很多，部分与 Project 里的功能雷同：
//在project进行配置前调用，child project必须在root project中设置才会生效，root project必须在settings.gradle中设置才会生效
void beforeProject(Closure closure)
//在project配置后调用
afterProject(Closure closure)
//构建开始前调用
void buildStarted(Closure closure)
//构建结束后调用
void buildFinished(Closure closure)
//所有project配置完成后调用
void projectsEvaluated(Closure closure)
//当settings.gradle中引入的所有project都被创建好后调用，只在该文件设置才会生效
void projectsLoaded(Closure closure)
//settings.gradle配置完后调用，只对settings.gradle设置生效
void settingsEvaluated(Closure closure)
我们修改 setting.gradle 的代码如下：
gradle.settingsEvaluated {
println "settings：执行settingsEvaluated..."
}
gradle.projectsLoaded {
println "settings：执行projectsLoaded..."
}
gradle.projectsEvaluated {
println "settings: 执行projectsEvaluated..."
}
gradle.beforeProject { proj ->
println "settings：执行${proj.name} beforeProject"
}
gradle.afterProject { proj ->
println "settings：执行${proj.name} afterProject"
}
gradle.buildStarted {
println "构建开始..."
}
gradle.buildFinished {
println "构建结束..."
}
include ":app"
这个时候的执行结果如下：
settings：执行settingsEvaluated...
settings：执行projectsLoaded...
settings：执行test beforeProject
根项目配置开始---
根项目里任务配置---
根项目配置结束---
settings：执行test afterProject
settings：执行app beforeProject
子项目beforeEvaluate回调...
APP子项目配置开始---
APP子项目里任务配置---
APP子项目配置结束---
settings：执行app afterProject
APP子项目afterEvaluate回调...
settings: 执行projectsEvaluated...
构建结束...
可以看到 gradle.beforeProject 与 project.beforeEvaluate 是类似的，同样 afterProject 与 afterEvaluate 也是类似的。
除此之外，Gradle 还有一个通用的设置生命周期监听器的方法：addListener
上面的 BuildListener、ProjectEvaluationListener 等与前面的部分 API 功能是一致的，这里不再赘述了。
3. TaskExecutionGraph（Task执行图）
Gradle 在配置完成后，会对所有的 task 生成一个有向无环图，这里叫做 task 执行图，他们决定了 task 的执行顺序等。同样，Gradle 可以对 task 的执行生命周期进行监听。
//任务执行前掉用
void afterTask(Closure closure)
//任务执行后调用
void beforeTask(Closure closure)
//任务准备好后调用
void whenReady(Closure closure)
通过 gradle.getTaskGraph() 方法来获取 task 执行图：
TaskExecutionGraph taskGraph = gradle.getTaskGraph()
taskGraph.whenReady {
println "task whenReady"
}
taskGraph.beforeTask { Task task ->
println "任务名称：${task.name} beforeTask"
}
taskGraph.afterTask { Task task ->
println "任务名称：${task.name} afterTask"
}
小结
生命周期回调的执行顺序：
gradle.settingsEvaluated->
gradle.projectsLoaded->
gradle.beforeProject->
project.beforeEvaluate->
gradle.afterProject->
project.afterEvaluate->
gradle.projectsEvaluated->
gradle.taskGraph.graphPopulated->
gradle.taskGraph.whenReady->
gradle.buildFinished
