Gradle系列第（二）篇---Gradle编程主要对象

最新推荐文章于 2023-07-24 14:20:01 发布

Looper景

最新推荐文章于 2023-07-24 14:20:01 发布

阅读量1.7k

点赞数

分类专栏： Gradle 文章标签： gradle groovy Android

本文链接：https://blog.csdn.net/u013263323/article/details/53641720

版权

Gradle 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

学习Gradle前，需要有一个Groovy语言的基础，以免被Groovy的语法困扰，反而忽略了Gradle的知识，可以大致看下上篇文章Gradle系列第（一）篇—Groovy语法初探1。作为一个菜鸟，很想知道 Gradle 的脚本怎么去写，也看了很多网上的文章，大多都是从脚本的角度来介绍Gradle，给我的感觉就是，只记住参数怎么配置，却不知道它们都是函数调用，有相关API对应的。比如我们很常见的一行代码 apply plugin: ‘com.android.application’ 是什么意思呢？原来一个 build.gradle 对应一个 Project , apply 是一个Project 的一个函数，这段代码其实就是调用了project对象的apply方法，传入了一个以plugin为key的map。完整写出来就是这样的：project.apply([plugin: ‘com.android.application’])。这样就明白了。所以我们先要学习Gradle的API，然后才能熟练用Gradle构建项目。

1、Project、Task、Action的关系

创建Android项目的时候，每一个项目中都有一个build.gradle文件，我们称build.gradle文件为构建脚本,后面你会了解到这个构建脚本定义了一个project和一些默认的task，在解析 Gradle 的编译过程之前我们需要理解在 Gradle 中非常重要的两个对象。Project和Task。每个项目的编译至少有一个 Project,一个 build.gradle就代表一个project,每个project里面包含了多个task,每个task代表了构建过程当中的一个原子性操作，比如编译，打包，生成javadoc，发布等这些操作。task 里面又包含很多action，action是一个代码块，里面包含了需要被执行的代码。

2、Gradle对象

Gradle基于Groovy，Groovy又基于Java。所以，Gradle执行的时候和Groovy一样，会把脚本转换成Java对象。Gradle主要有三种对象，这三种对象和三种不同的脚本文件对应，在gradle执行的时候，会将脚本转换成对应的对象：
Gradle对象：当我们执行gradle xxx或者什么的时候，gradle会从默认的配置脚本中构造出一个Gradle对象。在整个执行过程中，只有这么一个对象。Gradle对象的数据类型就是Gradle。我们一般很少去定制这个默认的配置脚本。
Project对象：每一个build.gradle会转换成一个Project对象。
Settings对象：每一个settings.gradle都会转换成一个Settings对象。

既然当我们执行gradle xxx或者什么的时候，gradle会从默认的配置脚本中构造出一个Gradle对象，那么看一看Gradle对象的信息有哪些。在build.gradle文件中定义一个Task,如下：

task printGradleInfo{
    println "----------------------------------------------- "
    println "In posdevice, gradle id is " +gradle.hashCode()
    println "Home Dir:" + gradle.gradleHomeDir
    println "User Home Dir:" + gradle.gradleUserHomeDir
    println "Parent: " + gradle.parent
}

执行gradlew -q printGradleInfo
输出

F:\StudyProject\GradleTest2>gradlew -q printGradleInfo
In posdevice, gradle id is 635573988
Home Dir:C:\Users\wangjing\.gradle\wrapper\dists\gradle-2.14.1-all\8bnwg5hd3w55i
User Home Dir:C:\Users\wangjing\.gradle
Parent: null

如果你在打印gradle的hashCode，得到的輸出也是635573988，也验证了在整个执行过程中，只有这么一个对象。

3、Gradle的生命周期

项目结构.png
如上图,执行gradlew -q project
输出

Root project 'GradleTest'
+--- Project ':app'
+--- Project ':library'
\--- Project ':library2'

每一个Library和每一个App都是单独的Project。根据Gradle的要求，每一个Project在其根目录下都需要有一个build.gradle。build.gradle文件就是该Project的编译脚本。因为包含了多个项目，所以还要有一个setting.gradle用于多项目的构建。Gradle的生命周期总共分成三个阶段，初始化阶段，配置阶段，执行任务阶段。首先是初始化阶段，这个时候settings.gradle会执行。初始化的下一个阶段是配置阶段。配置阶段的目标是解析每个project中的build.gradle，其内部的任务也会被添加到一个有向图里，用于解决执行过程中的依赖关系。在上图中，gradle的解析顺序是：rootproject 的setting.gradle,然后是rootproject的build.gradle,然后是各个subproject。最后一个阶段就是执行任务了，你在gradle xxx中指定什么任务，gradle就会将这个xxx任务链上的所有任务全部按依赖顺序执行一遍！
gradle整个编译过程都是可控的，通过实现TaskExecutionListener和BuildListener可以对整个编译过程进行监听。下面的代码打印了一下task的名字。

gradle.addListener(new LifecycleListener())
class LifecycleListener implements  TaskExecutionListener,BuildListener{
    @Override
    void buildStarted(Gradle gradle) {

    }

    @Override
    void settingsEvaluated(Settings settings) {

    }

    @Override
    void projectsLoaded(Gradle gradle) {

    }

    @Override
    void projectsEvaluated(Gradle gradle) {

    }

    @Override
    void buildFinished(BuildResult result) {

    }

    @Override
    void beforeExecute(Task task) {

        println("beforeExecute "+task.name)
    }

    @Override
    void afterExecute(Task task, TaskState state) {
        println("afterExecute  name="+task.name+" state="+state.toString() )
    }
}

输出结果：

beforeExecute printGradleInfo
afterExecute  name=printGradleInfo state=org.gradle.api.internal.tasks.TaskState

4、Project

一般app.build文件的第一行是apply plugin: ‘com.android.application’，这句话是什么意思，刚刚解释过，我们之前说在 Gradle 中构建脚本定义了一个项目（project）。在构建的每一个项目中，Gradle 创建了一个Project类型的实例，并在构建脚本中关联此Project对象。并且Project接口是你在 Gradle API 中访问一切的入点，当构建脚本执行时，它会配置此Project对象。调用project的api来获取和项目有关的信息。

task queryInfo<<{
    println name
    println project.name
}

执行命令gradlew -q queryInfo
输出

queryInfo
app

第一个获取的是任务名称，第二个获取的是Project名称，如果把queryInfo中的 println name放在外面，他会打印项目名称。

println name
task check<<{
 println project.name
}

app
app

查询项目的项目信息：

task queryProjectInfo<<{
    //项目名
    println project.name
    //项目相对路径
    println project.path
    //项目描述
    println project.description
    //项目的绝对路径
    println project.projectDir
    //项目的build文件绝对路径
    println project.buildDir
    //项目所在的group
    println project.group
    //项目的版本号
    println project.version
    //项目的ant对象
    println project.ant
}

执行命令gradlew -q queryInfo
输出

app
:app
null
E:\Programs\android_studio\GradleTest\app
E:\Programs\android_studio\GradleTest\app\build
GradleTest
unspecified
org.gradle.api.internal.project.DefaultAntBuilder@3f1ae6ad

还有若干方法的使用

比如，在解析setting.gradle之后，开始解析build.gradle之前，这里如果要干些事情可以写在beforeEvaluate。

在所有build.gradle解析完成后，开始执行task之前，此时所有的脚本已经解析完成，task，plugins等所有信息可以获取，task的依赖关系也已经生成，如果此时需要做一些事情，可以写在afterEvaluate。文档对afterEvaluate(closure)的解释是：

Adds a closure to be called immediately after this project has been evaluated. The project is passed to the closure as a parameter. Such a listener gets notified when the build file belonging to this project has been executed. A parent project may for example add such a listener to its child project. Such a listener can further configure those child projects based on the state of the child projects after their build files have been run.

举个列子：过滤掉一些我不想执行的task.

def disableDebugBuild(){
    //project.tasks包含了所有的tasks，下面的findAll是寻找那些名字中带debug的Task。
    //返回值保存到targetTasks容器中
    def targetTasks = project.tasks.findAll{task ->
        task.name.contains("Debug")
    }
    //对满足条件的task，设置它为disable。如此这般，这个Task就不会被执行
    targetTasks.each{
        println"disable debug task  :${it.name}"
        it.setEnabled false
    }
}

project.afterEvaluate{
    disableDebugBuild()
}

又比如

apply plugin: 'com.android.application'  的原形是
project.apply([plugin: 'com.android.application'])

dependencies {
       compile 'com.google.code.gson:gson:2.3'
}

原形:

project.dependencies({
       add('compile', 'com.google.code.gson:gson:2.3', {
           // Configuration statements
       })
})

看看下面的图，Project的方法和属性很多

这是Project官方文档：https://docs.gradle.org/current/dsl/org.gradle.api.Project.html

project的方法.png

5、Task

如果你想知道你多少tasks可以用，直接运行gradlew tasks，其会为你展示所有可用的tasks。当你创建了一个Android工程，那么将包含Android tasks，build tasks，build setup tasks，help tasks，install tasks，verification tasks等。

项目构建过程中那么多任务，有些test相关的任务可能根本不需要，可以直接关掉，在build.gradle中加入如下脚本：

tasks.whenTaskAdded { task ->
    if (task.name.contains('AndroidTest')) {
        task.enabled = false
    }
}

tasks会获取当前project中所有的task，enabled属性控制任务开关，whenTaskAdded后面的闭包会在gradle配置阶段完成。

一般我们定义任务的时候采用的是task ＋任务名的方式。例如

task hello << {
        println "hello"
}

现在再介绍另外两种方式，和上面的定义是等价的。

task(hello)<<{
        println "hello"
}
task('hello')<<{
        println "hello"
}

gradle还提供了一个tasks容器来创建任务，通过调用create方法：

tasks.create(name:'hello')<<{
        println "hello"
}

如何获取一个任务呢？

将任务看成项目的属性的方式
println tasks.hello.name
println tasks['hello'].name

使用tasks容器来定位
println hello.name
println project.hello.name

tasks.getByPath()方式来获得
println tasks.getByPath('hello').path
println tasks.getByPath(':hello').path

每个Task包含了Action对象的集合。当Task被执行的时候，其内部的Action集合会按次序逐个执行，所以借助doFirst(),doLast()等方法来控制Action在队列中的顺序，同时也是执行的顺序。

task testAction {
    doFirst {
        println("first")
    }
    doLast {
        println("last")
    }
}

输出

first
last

其中对于doLast这个Action还有一个简便的写法

task testAction <<{
    println("last")
}

<<就代表doLast操作

task与task之间是有关联的，关联可以使用dependsOn和finalizedBy。

task A <<{
    println("i am task A")
}
task B <<{
    println("i am task B")
}

A.dependsOn B

执行gradlew -q A
输出：

i am task B
i am task A

如果是 A.finalizedBy B

i am task A
i am task B