gradle7 从上手到实践之执行流程

1 gradle 构建的三个阶段

gradle 构建过程有三个阶段

• 初始化阶段
• 配置阶段
• 执行阶段

1.1 初始化阶段

• 与初始化阶段相关的脚本文件是 settings.gradle（包括<USER_HOME>/.gradle/init.d目录下的所有.gradle脚本文件，这些文件作用于本机的所有构建过程）。
• 一个 settings.gradle 脚本对应一个 Settings 对象，用来声明项目的层次结构的 include 对应于 Settings 的 include 方法，该方法用于指定当前项目的子项目。
• 初始化阶段的任务是创建项目的层次结构，并且为每一个项目创建一个 Project 实例。包括了 RootProject 和其子 Project。此时的 Project 对象的内部属性均未赋值。

1.2 配置阶段

• 与初始化阶段相关的脚本文件是根目录下的 build.gradle 以及子项目根目录下的 build.gradle
• 一个 build.gradle 脚本对应一个 Project 对象，Project 对象在初始化阶段生成，在配置阶段完成配置即对内部属性赋值
• 配置阶段的任务是执行各项目下的 build.gradle 脚本，完成 Project 的配置，并且构造 Task 任务依赖关系图以便在执行阶段按照依赖关系执行 Task
• 配置阶段不仅执行 build.gradle 中的语句，还包括了 Task 中的配置语句
• 无论执行Gradle的任何命令，初始化阶段和配置阶段的代码都会被执行。

1.3 执行阶段

在配置阶段结束后，Gradle 会根据 Task 的依赖关系创建一个有向无环图，通过这个图来确定当前 Task 的依赖并执行依赖的 Task 与当前 Task。

2 gradle 流程与 Hook

Gradle提供了非常多的 Hook 供开发人员修改构建过程中的行为，为了方便说明，看下面这张图：

2.1 Hook 位置

Hook 位置

2.2 gradle.addBuildListener

除了上图中的 hook 点，gradle 还提供 gradle.addBuildListener 方法

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 '构建结束 '
  }
})

2.3 监听器一定要在回调的生命周期之前添加

在根目录的 build.gradle 添加：

//不会执行
gradle.settingsEvaluated { setting ->
  // do something with setting
}

////不会执行
gradle.projectsLoaded { 
  gradle.rootProject.afterEvaluate {
    println 'rootProject evaluated'
  }
}

Hook 的代码一般是放在 Settings.gradle 中，以避免上述情况

2.4 gradle.afterProject 与 project.afterEvaluate 的区别

在根 build.gradle 中添加:

gradle.afterProject {
    //每一个 Project 都会执行
    println "afterProject: ${it.name}"
}

this.afterEvaluate {
    //只有调用的 Project 会执行
    println "afterEvaluate: ${it.name}"
}

gradle.beforeProject 与 project.beforeEvaluate,与上述情况类似

2.5 一些 hook 的实例

计算每个阶段的用时：

在 settings.gradle 添加如下代码：

//初始化阶段开始时间
long beginOfSetting = System.currentTimeMillis()
//配置阶段开始时间
def beginOfConfig
//配置阶段是否开始了，只执行一次
def configHasBegin = false
//存放每个 build.gradle 执行之前的时间
def beginOfProjectConfig = new HashMap()
//执行阶段开始时间
def beginOfTaskExecute
//初始化阶段执行完毕
gradle.projectsLoaded {
    println "初始化总耗时 ${System.currentTimeMillis() - beginOfSetting} ms"
}

//build.gradle 执行前
gradle.beforeProject {Project project ->
    if(!configHasBegin){
        configHasBegin = true
        beginOfConfig = System.currentTimeMillis()
    }
    beginOfProjectConfig.put(project,System.currentTimeMillis())
}

//build.gradle 执行后
gradle.afterProject {Project project ->
    def begin = beginOfProjectConfig.get(project)
    println "配置阶段，$project 耗时：${System.currentTimeMillis() - begin} ms"
}

//配置阶段完毕
gradle.taskGraph.whenReady {
    println "配置阶段总耗时：${System.currentTimeMillis() - beginOfConfig} ms"
    beginOfTaskExecute = System.currentTimeMillis()
}

//执行阶段
gradle.taskGraph.beforeTask {Task task ->
    task.doFirst {
        task.ext.beginOfTask = System.currentTimeMillis()
    }

    task.doLast {
        println "执行阶段，$task 耗时：${System.currentTimeMillis() - task.ext.beginOfTask} ms"
    }
}

//执行阶段完毕
gradle.buildFinished {
    println "执行阶段总耗时：${System.currentTimeMillis() - beginOfTaskExecute}"
}

单独计算 build task 用时：

在根 build.gradle 中添加

gradle.afterProject { Project project ->

    if (project == rootProject) return

    def preBuildTask = project.tasks.getByName('preBuild')
    preBuildTask.doFirst {
        startBuildTime = System.currentTimeMillis()
        println "the ${ project.name } start time is:" + startBuildTime
    }

    def buildTask = project.tasks.getByName('build')
    buildTask.doLast {
        endBuildTime = System.currentTimeMillis()
        println "the ${ project.name } build time is ${endBuildTime - startBuildTime}"
    }
}