tags: [android,gradle,CI/CD]
categories: gradle
top: false
toc: true
cover: false
img: /featureImg/gradle.png
summary: 开始自定义task的旅程
—-

什么是task

task是gradle中一个至关重要的概念，gradle的构建过程就是由一个个task组成。task之间有依赖关系，会形成一个有向无环图（Direceted Acyclic Graph，DAG）,构建过程中每个task只会执行一次，不会出现循环的情况
image.png

gradle构建的三个阶段

初始化阶段

gradle根据setting.gradle来组织多项目构建，如果当前目录没有setting.gradle会去上级目录寻找，如果找不到会将当前目录作为一个单一的项目进行构建

配置阶段

在这个阶段gradle会确定task的依赖关系，形成执行task需要的DAG

执行阶段

这个阶段是执行task的阶段，task执行会遵循配置阶段确定的依赖关系
但是没有依赖关系的task的执行顺序是不确定的，这样可以充分利用多核cpu加速构建过程

生命周期

image.png
gradle提供了几个生命周期方法来hook

Gradle对象中的生命周期方法

  1. //setting.gradle文件中
  2. println "[hook] - setting.gradle配置中..."
  3. gradle.settingsEvaluated {
  4.     println "[hook] - settingsEvaluated"
  5. }
  7. gradle.projectsLoaded {
  8.     //此时可以访问project对象
  9.     println "[hook] - projectsLoaded"
  10. }
  12. gradle.buildStarted {
  13.     println "[hook] - buildStarted"
  14. }
  16. //第二阶段
  17. //========== 每个project配置开始和结束的回调 ==================
  18. gradle.beforeProject {
  19.     println "[hook] - beforeProject ${it.name}"
  20. }
  22. gradle.afterProject {
  23.     println "[hook] - afterProject ${it.name}"
  24. }
  26. //========== 每个project配置开始和结束的回调  和上面应该是等价的==================
  27. gradle.addProjectEvaluationListener(new ProjectEvaluationListener() {
  28.     @Override
  29.     void beforeEvaluate(Project project) {
  30.         println "[hook] - ${project.name} 配置阶段开始前"
  31.     }
  33.     @Override
  34.     void afterEvaluate(Project project, ProjectState state) {
  35.         println "[hook] - ${project.name} 配置阶段完成后"
  36.     }
  37. })
  39. //========== 所有project的配置完成 ==================
  40. gradle.projectsEvaluated {
  41.     println "[hook] - projectsEvaluated"
  42. }
  44. //========== 所有DAG构建完成 ==============
  45. gradle.taskGraph.whenReady { graph ->
  46.     println "[hook] - 所有DAG已确认,执行阶段开始前"
  47. }
  49. gradle.taskGraph.addTaskExecutionGraphListener(new TaskExecutionGraphListener() {
  50.     @Override
  51.     void graphPopulated(TaskExecutionGraph taskExecutionGraph) {
  52.         println "[hook] - 所有DAG已确认,执行阶段开始前"
  53.     }
  54. })
  57. //============= 第三阶段 ===================
  58. //============= task执行前后的监听 ==========
  59. gradle.taskGraph.addTaskExecutionListener(new TaskExecutionListener() {
  60.     @Override
  61.     void beforeExecute(Task task) {
  62.         println "[hook] ======beforeExecute ${task.name} ======="
  63.     }
  65.     @Override
  66.     void afterExecute(Task task, TaskState taskState) {
  67.         println "[hook] ======afterExecute ${task.name}  ${taskState.didWork}======="
  69.     }
  70. })
  72. gradle.buildFinished { result ->
  73.     println "[hook] - 构建完成后"
  74. }

Project对象中的生命周期方法 

  1. //这个是后面经常要用到的方法
  2. //在project evaluate之后执行一些操作，例如指定task的依赖关系或者创建新的task等
  3. project.afterEvaluate {
  4.     println "[hook] - afterEvaluate"
  5. }
  7. //在project evaluate之前执行一些操作，注意这个方法的调用时间
  8. //在当前build.gradle中写这个没有作用，因为配置当前build.gradle时beforeEvaluate时机已经过了
  9. //需要在rootProject的build.gradle或者setting.gradle中获取需要监听的project对象添加beforeEvaluate
  10. project.beforeEvaluate {
  11.     println "[hook] - beforeEvaluate"
  12. }

一个简单的例子

关于task的理论知识简单介绍了下，现在开始自定义一个task
在build.gradle中加入以下代码，我们就完成了一个自定义task，当然它没啥作用，只是打印hello world

  1. task helloWorld {
  2.     println "hello world"
  3. }

直接点下AndroidStudio中的GradleSync按钮，就可以在输出中看到hello world了
当然这里其实并不是在执行阶段打印的，而是在在配置阶段就已经打印了，这个和单独的 println "hello world" 没什么区别

我们要真正在执行阶段来执行我们自定义的逻辑还需要稍作修改，为task添加action

  1. task helloWorld {
  2.     doLast{
  3.         println "hello world"
  4.     }
  5. }
  7. //或者使用doFirst
  8. task helloWorld {
  9.     doFirst{
  10.         println "hello world"
  11.     }
  12. }

每个task可以有多个action，使用一个list维护，doFirst会在list头部添加一个action，doLast会在list尾部添加一个action

这样在终端中执行 ./gradlew helloWorld 会看到在执行阶段打印出了hello world
ps:在gradle 5.0之后 `Task.leftShift(Closure) 被废弃了

  1. //这种用法不行了
  2. task helloWorld << {
  3.         println "hello world"
  4. }

为什么可以这样定义一个task

在gradle中 task 是一个关键字，可以用来定义一个task

Each task belongs to a Project. You can use the various methods on TaskContainer to create and lookup task instances. For example, TaskContainer.create(java.lang.String)) creates an empty task with the given name. You can also use the taskkeyword in your build file

  1. task myTask
  2. task myTask { configure closure }
  3. task myTask(type: SomeType)
  4. task myTask(type: SomeType) { configure closure }

上面的用法和groovy的语法稍有不同
相当于下面的方法调用

  1. task("myTask")
  2. task("myTask") { configure closure }
  3. task(type: SomeType, "myTask")
  4. task(type: SomeType, "myTask") { configure closure }

task的简单复用

在build.gradle中直接定义task是最简单的方式，这样定义的task是依赖于project的，如果一个工程有多个project，每个project都需要相同的自定task怎么办呢

  • 一种方案是在root project中为所有子project添加task

    1. allprojects {
    2.   task helloAll {
    3.       doLast {
    4.           println "hello"
    5.       }
    6.   }
    7. }

  • 一种方案是在一个gradle文件中定义task，在需要使用的地方apply这个文件

    1. //在hello.gradle中定义helloWorld task
    2. apply from: file("hello.gradle")

Gradle Plugin

直接在gradle文件中定义task只适合一些简单的脚本，复杂一些的构建逻辑如果跟项目的业务逻辑放在一起混乱且不好管理，这时我们就需要自己写一个项目专门实现这些构建逻辑了，也就是gradle插件
apply plugin: 'com.android.application' apply plugin: 'com.android.library' 这种就是google为我们提供的构建android app和库的 gradle 插件
实现 gradle 插件的方式有两种：

  • buildSrc
  • 单独的gradle插件工程

两者的目录结构其实是一样的
区别是buildSrc在项目中可以直接被其他子项目使用
而单独的gradle插件工程需要发布到maven仓库，添加到classPath才能使用其中的gradle插件

目录结构

一个典型的gradle 插件工程的目录结构如下

  1. |-GradleProjectName
  2.     |-src   
  3.     |    |-main   
  4.     |        |-java
  5.     |        |-groovy
  6.     |        |-kotlin
  7.     |        |-resources   
  8.     |            |-META-INF
  9.     |                |-gradle-plugins
  10.     |                    |-${pluginId}.properties
  11.     |-build.gradle

build.gradle

  1. //编译buildSrc需要用到 groovy 插件
  2. apply plugin: 'groovy'
  3. //依赖
  4. dependencies {
  5.     //gradleApi() localGroovy()都是gradle的内部依赖
  6.     implementation gradleApi()
  7.     implementation localGroovy()
  8.     //依赖其他库，如Gson
  9.     implementation 'com.google.code.gson:gson:2.8.5'
  10. }
  12. //中央仓库
  13. repositories {
  14.     google()
  15.     jcenter()
  16. }

源码

java/groovy/kotlin是三种可以用来实现gradle plugin的语言，对应的源代码放到对应的文件夹,一般来说只需要groovy一个文件夹放置源码

插件命名

默认情况下插件名和项目名称是一样的，要修改插件名可以通过.properties文件实现
.properties文件的文件名表示pluginId，使用 apply plugin:pluginId 使用该插件 

  1. # 指定class路径
  2. implementation-class=me.sunhapper.gradleplugin.GradlePlugin

定义第一个插件

  1. import org.gradle.api.Plugin
  2. import org.gradle.api.Project
  4. class GradlePlugin implements Plugin<Project> {
  5.     @Override
  6.     void apply(Project project) {
  7.         //配置阶段打印出projectName
  8.         println(project.name)
  9.     }
  10. }

自定义Task

之前出现的task都是在.gradle文件中使用task关键字直接创建的，现在我们需要用另一种方式实现Task来完成Task功能的复用

实现一个自定义Task

这里使用@TaskAction标记一个方法，这个方法会在

  1. class GreetingTask extends DefaultTask {
  2.     String greeting = 'hello from GreetingTask'
  4.     @TaskAction
  5.     def greet() {
  6.         println greeting
  7.     }
  8. }

添加到project中

对于已经加入classpath中的gradle库或者buildSrc中定义的类，在build.gradle文件中可以直接使用 

  1. import 包名.GreetingTask
  3. // Use the default greeting
  4. task hello(type: GreetingTask)
  6. // Customize the greeting
  7. task greeting(type: GreetingTask) {
  8.     greeting = 'greetings from GreetingTask'
  9. }

或者通过Plugin作为桥梁，来为project创建一个task 

  1. class GradlePlugin implements Plugin<Project> {
  3.     @Override
  4.     void apply(Project target) {
  5.         target.task("greeting", type: GreetingTask)
  6.     }
  7. }

使用kotlin-dsl

因为groovy是一种动态语言，带来了出色的灵活性的同时也带来了代码难以理解以及错误定位比较困难的问题，同时ide的支持也无法像静态语言一样那么完善
而kotlin作为一门静态语言，而且作为JetBrain的亲儿子，在IDE的支持上比groovy好了不少，而损失的动态特性也要求gradle插件的作者使用更工程化的方式提供功能
所以使用kotlin编写gradle是一个趋势，现在gradle的官方文档中代码示例也基本有kotlin和groovy两个版本

先来看看如何将kotlin-dsl引入工程
将buildSrc中的build.gradle改为build.gradle.kts

  1. plugins {
  2.     //使用kotlin-dsl插件
  3.     `kotlin-dsl`
  4.     //保留groovy插件
  5.     groovy
  6. }
  8. dependencies {
  9.     gradleApi()
  10.     localGroovy()
  11. }
  13. repositories {
  14.     jcenter()
  15. }

最初我是想在build.gradle中直接加上kotlin-dsl的支持，不过因为kotlin-dsl和gradle的版本有一定得关联性，所以被坑了一把，最后虽然搞定了，但还是建议build.gradle.kts作为项目的配置文件

  1. apply plugin: 'groovy'
  2. apply plugin: "org.gradle.kotlin.kotlin-dsl"
  4. dependencies {
  5.     implementation gradleApi()
  6.     implementation localGroovy()
  7. }
  9. repositories {
  10.     google()
  11.     jcenter()
  12. }
  14. //buildSrc是配置阶段第一个加载的，所以root project下配置的classpath对buildSrc不起作用
  15. //需要在buildSrc的build.gradle下配置
  16. buildscript {
  17.     repositories {
  18.         google()
  19.         jcenter()
  20.         maven {
  21.             url "https://plugins.gradle.org/m2/"
  22.         }
  23.     }
  24.     dependencies {
  25.         //1.2.9对应gradle5.6,不同的gradle版本有对应的kotlin-dsl
  26.         classpath "org.gradle.kotlin:plugins:1.2.9"
  27.         // NOTE: Do not place your application dependencies here; they belong
  28.         // in the individual module build.gradle files
  29.     }
  30. }

Plugin的代码没啥区别，也是实现Plugin接口

总结

  • gradle构建有初始化、配置、执行三个阶段
  • 可以直接在build.gradle中自定义task，也可以写在一个文件里在build.gradle中apply
  • 复杂的构建逻辑可以写成一个单独的项目，buildSrc对整个项目有效
  • kotlin也可以用来写gradle脚本

参考文章

Developing Custom Gradle Task Types