Groovy&Gradle总结

欢迎大家加入QQ群一起讨论： 489873144（android格调小窝）

我的github地址：https://github.com/jeasonlzy

0x01 Groovy 概述

Groovy 是一个基于 JVM 的语言，代码最终编译成字节码（bytecode）,并在 JVM 上运行。它具有类似于 Java 的语法风格，但是语法又比 Java 要灵活和方便，同时具有动态语言（如 ruby 和 Python）的一些特性。

正因为如此，所以Groovy适合用来定义DSL（Domain Specific Language）。

0x02 groovy 基本知识

1）首先需要安装groovy环境，具体的环境安装就不说了，网上很多，安装完成后配置环境变量，出现以下结果，即安装成功

2）groovy与java

因为Groovy是基于JVM的语言，所以我们来看看最后生成的字节码文件。我们写一个类：

hello.groovy

name = "lzy"

def say(){

    "my name is $name"

}

println say()
1
2
3
4
5

在命令行输入groovy hello.groovy，运行脚本，输出以下结果：



上面的操作做完后，有什么感觉和体会？

最大的感觉可能就是groovy和shell脚本，或者python好类似。

另外，除了可以直接使用JDK之外，Groovy还有自己的一套GDK。

我们看一下编译成jvm字节码后的结果

我们输入groovyc -d classes hello.groovy命令将当前文件生成字节码文件，-d参数表示在classes文件夹下，最终结果如下：

hello.class

import groovy.lang.Binding;

import groovy.lang.Script;

import org.codehaus.groovy.runtime.BytecodeInterface8;

import org.codehaus.groovy.runtime.GStringImpl;

import org.codehaus.groovy.runtime.InvokerHelper;

import org.codehaus.groovy.runtime.ScriptBytecodeAdapter;

import org.codehaus.groovy.runtime.callsite.CallSite;

public class hello extends Script {

    public hello() {

        CallSite[] var1 = $getCallSiteArray();

    }

    public hello(Binding context) {

        CallSite[] var2 = $getCallSiteArray();

        super(context);

    }

    public static void main(String... args) {

        CallSite[] var1 = $getCallSiteArray();

        var1[0].call(InvokerHelper.class, hello.class, args);

    }

    public Object run() {

        CallSite[] var1 = $getCallSiteArray();

        String var2 = "lzy";

        ScriptBytecodeAdapter.setGroovyObjectProperty(var2, hello.class, this, (String)"name");

        return !__$stMC && !BytecodeInterface8.disabledStandardMetaClass()?var1[3].callCurrent(this, this.say()):var1[1].callCurrent(this, var1[2].callCurrent(this));

    }

    public Object say() {

        CallSite[] var1 = $getCallSiteArray();

        return new GStringImpl(new Object[]{var1[4].callGroovyObjectGetProperty(this)}, new String[]{"my name is ", ""});

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

到这里我们可以发现，其实groovy脚本本质就是java，他与java几乎没有区别，只是在java语言在语法上的扩展，支持DSL，增强了可读性。并且我们得出以下结论：

1. hello.groovy被转换成了一个hello类，它从Script派生。

2. 每一个脚本都会生成一个static main函数。这样，当我们groovy hello.groovy去执行的时候，其实就是用java去执行了这个main函数

3. 脚本中的所有代码都会放到run函数中。比如，say()方法的调用，这句代码实际上是包含在run()方法里的。

4. 如果脚本中定义了方法，则方法会被定义在hello类中。

5. 脚本中定义的变量是有它的作用域的，name = “lzy”，这句话是在run()中创建的。所以，name看起来好像是在整个脚本中定义的，但实际

上say()方法无法直接访问它。

接着我们把上述的hello.groovy文件修改，在定义name前的加上def修饰符，其余不做任何修改，我们再次运行代码，发现以下错误：

我们将修改后的代码编译成class文件后，与之前的正常结果做对比，发现以下不同：



左边是正确的，右边是错误的，相比下来就是多调用了一个方法，这个方法看起来就是将你定义的属性保存到了某个全局的环境中，确保下面的say()方法在调用的时候，能从全局取到这个属性。

ScriptBytecodeAdapter.setGroovyObjectProperty(var2, hello.class, this, (String)"name");
1

但是这样还是与我们的想象有差距，name并没有在成员位置，那如何才能才能让我们定义的属性就生成在成员变量的位置呢？这时候需要@Field注解，如下：

import groovy.transform.Field

@Field name = "lzy"

def say(){

    "my name is $name"

}

println say()
1
2
3
4
5
6
7

加上这行注解后，生成的字节码如下：

name属性确实变成了成员变量，并且是在构造方法中被初始化了。

import groovy.lang.Binding;

import groovy.lang.Script;

import org.codehaus.groovy.runtime.BytecodeInterface8;

import org.codehaus.groovy.runtime.GStringImpl;

import org.codehaus.groovy.runtime.InvokerHelper;

import org.codehaus.groovy.runtime.callsite.CallSite;

public class hello extends Script {

    Object name;

    public hello() {

        CallSite[] var1 = $getCallSiteArray();

        String var2 = "lzy";

        this.name = var2;

    }

    public hello(Binding context) {

        CallSite[] var2 = $getCallSiteArray();

        super(context);

        String var3 = "lzy";

        this.name = var3;

    }

    public static void main(String... args) {

        CallSite[] var1 = $getCallSiteArray();

        var1[0].call(InvokerHelper.class, hello.class, args);

    }

    public Object run() {

        CallSite[] var1 = $getCallSiteArray();

        Object var10000 = null;

        return !__$stMC && !BytecodeInterface8.disabledStandardMetaClass()?var1[3].callCurrent(this, this.say()):var1[1].callCurrent(this, var1[2].callCurrent(this));

    }

    public Object say() {

        CallSite[] var1 = $getCallSiteArray();

        return new GStringImpl(new Object[]{this.name}, new String[]{"my name is ", ""});

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

0x03 Groovy 语法

这里只讲一些比较重要的特性，其余比较基本的语法比较简单，可以参考这里过一遍：

工匠若水的博客：Groovy脚本基础全攻略

1）方法的输入参数优化

groovy中定义的函数，如果至少有一个参数，在调用的时候可以省略括号。如果某个函数没有参数，那就不能省略括号，否则会当成一个变量使用。

def func(String a){

    println(a)

}

func 'hello'
1
2
3
4
5

在android项目中，比如build.gradle

android {

    compileSdkVersion 25

    buildToolsVersion "25.0.0"

}
1
2
3
4

比如这里compileSdkVersion 和 buildToolsVersion 其实就是调用了同样名字的两个函数，在AndroidStudio里面可以点进去查看函数实现

2）闭包

闭包的概念也许我们稍微陌生一点，但是实际上，我们可以简单把它当做一个匿名类，只是编译器提供了更加简单的语法来实现它的功能。

闭包(Closure)是groovy中一个很重要的概念，而且在gradle中广泛使用。简而言之，闭包就是一个可执行的代码块，类似于C语言中的函数指针。在很多动态类型语言中都有广泛的使用，java8 中也有类似的概念:lambda expression，但是groovy中的闭包和java8中的lambda表达式相比又有很多的不同之处。

我们可以把闭包当做一个匿名内部类，只是编译器提供了更加简单的语法来实现它的功能。在Groovy中闭包也是对象，可以像方法一样传递参数，并且可以在需要的地方执行。

def clos = { params ->

    println "Hello ${params}"

}

clos("World")

//Closure类型的实例，比如上面的闭包我们又可以定义为:

//参数可以声明类型，也可以不声明，还可以有缺省值

Closure clos1 = { a, def b, int c = 2 ->

    a + b + c //默认返回值就是最后一行计算的结果，return关键字可省略

}

println clos1(5, 3)

//可以制定一个可选的返回类型

//如果闭包内没有生命任何参数，没有->， 那么闭包内置会定义一个隐含参数it

Closure<String> clos2 = {

    println it

    return "clos2"

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

闭包有三个很重要的属性分别是：this,owner,delegate，分别代表以下概念：

• this: 对应于定义闭包时包含他的class，可以通过getThisObject或者直接this获取
• owner: 对应于定义闭包时包含他的对象，可以通过getOwner或者直接owner获取
• delegate: 闭包对象可以指定一个第三方对象作为其代理，用于函数调用或者属性的指定，可以通过getDelgate或者delegate属性获取

我们编写如下代码：test1.groovy

class A {

    def closure1 = {

        println "--------------closure1--------------"

        println "this:" + this.class.name

        println "owner:" + owner.class.name

        println "delegate:" + delegate.class.name

        def closure2 = {

            println "-------------closure2---------------"

            println "this:" + this.class.name

            println "owner:" + owner.class.name

            println "delegate:" + delegate.class.name

            def closure3 = {

                println "-------------closure3---------------"

                println "this:" + this.class.name

                println "owner:" + owner.class.name

                println "delegate:" + delegate.class.name

            }

            closure3()

        }

        closure2()

    }

}

def a = new A()

def closure1 = a.closure1

closure1()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

运行后得到如下结果：

--------------closure1--------------

this:com.lzy.A

owner:com.lzy.A

delegate:com.lzy.A

-------------closure2---------------

this:com.lzy.A

owner:com.lzy.A$_closure1

delegate:com.lzy.A$_closure1

-------------closure3---------------

this:com.lzy.A

owner:com.lzy.A$_closure1$_closure2

delegate:com.lzy.A$_closure1$_closure2
1
2
3
4
5
6
7
8
9
10
11
12

3）代理策略

如果在闭包内，没有明确指定属性或者方法的调用是发生在this, owner,delegate上时，就需要根据代理策略来判断到底该发生在谁身上。有如下几种代理策略:

• Closure.OWNER_FIRST 默认的策略，如果属性或者方法在owner中存在，调用就发生在owner身上，否则发生在delegate上
• Closure.DELEGATE_FIRST 跟owner_first正好相反
• Closure.OWNER_ONLY 忽略delegate
• Closure.DELEGATE_ONLY 忽略owner
• Closure.TO_SELF 调用不发生在owner或delegate上，只发生在闭包内

我们编写如下代码：test2.groovy

import groovy.transform.Field

@Field String name = "abc"

class P {

    String name

    def pretty = {

        "my name is $name"

    }

}

class T {

    String name

}

def upper = {

    name.toUpperCase()

}

println upper()

def p = new P(name: 'ppp')

def t = new T(name: 'ttt')

upper.delegate = t

upper.resolveStrategy = Closure.DELEGATE_FIRST

println upper()

p.pretty.delegate = this

println p.pretty()

p.pretty.resolveStrategy = Closure.DELEGATE_FIRST

println p.pretty()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

运行后得到如下结果：

ABC

TTT

my name is ppp

my name is abc
1
2
3
4

这里重点强调一下，成员变量name一定要加上@Field注解，否者出现的结果一定不是上述结果，原因之前已经分析过，不加这个注解，name属性将不会是成员变量

4）类的Property

Groovy中的class和java中的Class区别不大，值得我们关注的区别是，如果类的成员变量没有加任何权限访问，则称为Property, 否则是Field，filed和Java中的成员变量相同，但是Property的话，它是一个private field和getter setter的集合，也就是说groovy会自动生成getter setter方法，因此在类外面的代码，都是会透明的调用getter和setter方法

我们在上述的test1.groovy的类A中加入以下几行代码：

String name = "aaa"

public String name1 = "bbb"

private String name2 = "ccc"
1
2
3

然后对这个test1.groovy进行编译groovyc -d classes test1.groovy，生成的文件结构如下：



点开A.class发现以下代码：

public class A implements GroovyObject {

    private String name;

    public String name1;

    private String name2;

    private Object closure1;

    ···

    public String getName() {

        return this.name;

    }

    public void setName(String var1) {

        this.name = var1;

    }

    ···

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

5）操作符重载

我们经常在gradle中看见以下代码：

task hello << {

    println "hello world"

}
1
2
3

实际上他的原始调用含义是：

task("hello").leftShift(closure)
1

因为task重载了leftShift，所以可以使用 << 操作符，这和c++的特性是一样的

6）Command Chains

这个特性不仅可以省略函数调用中的括号，而且可以省略，连续函数调用中的. 点号, 比如

a(b).c(d) 这里a c是函数, b d是函数参数, 就可以缩写为a b c d。这个特性强大之处在于不仅适用于单个参数类型函数，而且适用于多个参数类型的函数，当参数类型为闭包时同样适用。

task("task1").doLast({

    println "111"

}).doLast({

    println("222")

})

//简写

task task1 doLast { println "111" } doLast { println("222") }
1
2
3
4
5
6
7

7）DSL

借助闭包的特性，我们可以尝试写一个简单的DSL。下面的代码展示了如何借助groovy的语法特性来实现一个DSL，这些特性我们稍后会在gradle的脚本中看到。

test3.groovy

class Book {

    def _name = ''

    def _price = 0.0

    def shop = []

    def static config(config){

        Book book = new Book(shop:['A','B'])

        config.delegate = book

        config()

    }

    def name(name){

        this._name = name

    }

    def price(price){

        this._price = price

    }

    def getDetail(){

        println "name : ${_name}"

        println "price : ${_price}"

        println "shop : ${shop}"

    }

}

Book.config {

    name 'test'

    price  1.2

    detail

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

上面所提到的这些groovy的语法特性，构成了Gradle中DSL的基础

0x04 Gradle 基本概念

我们在AndroidStudio中创建基于Gradle的project时，会默认生成一个多项目结构的Gradle工程，他有如下结构：

├── app

│   └── build.gradle

├── lib

│   └── build.gradle

├── build.gradle

└── settings.gradle
1
2
3
4
5
6

如果是单工程结构，这个Setting.gradle其实可以省略

apply plugin: 'com.android.application' //app插件

apply plugin: 'com.android.library'     //lib插件

android{

    ...

}

dependencies{

  ....

}
1
2
3
4
5
6
7
8
9

如果我们把以上代码在build.gradle中删掉，执行gradle tasks命令列出所有可执行的task，会发现很多task都不见了，由此我们能得出结论，

我们执行gradle projects列出所有的工程：

这个图片的最后几句话也告诉了我们，如果你在根目录下，想查看或者运行某个项目下的任务，可以用gradle :app:tasks这种语法，如果你cd到子项目的根目录下，是不需要加:app这样的前缀的。

对Android来说，gradle assemble这个Task会生成最终的产物Apk，所以如果一个工程包含5个Model，那么需要分别编译这5个，他们可能还有一些依赖关系，这样就很麻烦了，而在Gradle中，是支持多工程编译的（Multi-Projects Build），我们在根目录下直接执行gradle assemble，就能按照依赖关系把这5个Model全部编译出来生成最终的Apk，但是为什么可以呢？

1. 我们需要在根目录下也添加一个build.gradle。这个build.gradle一般干得活是：配置其他子Project的。比如为子Project添加一些属性。这个build.gradle有没有都无所谓。

2. 继续在根目录下添加一个名为settings.gradle。这个文件很重要，名字必须是settings.gradle。它里边用来告诉Gradle，这个multi-projects包含多少个子Project，内部一般就是一个include指令。根据groovy的语法，他就是在gradle生成的settings对象调用函数 include(‘app’)，include接受的参数是一个string数组，因此include后可以加很多参数，这个函数的意义就是：指明那些子project参与这次gradle构建

所以对于一个工程，我们能对构建过程做出改变的，就只能发生在这些.gradle文件中，这些文件称为Build Script构建脚本。对于Gradle中的构建脚本，一方面可以理解为配置文件，每一种类型脚本文件都是对某一种类型的构建对象进行配置。另一方面也可以把每个脚本理解为一个Groovy闭包，这样我们在执行构建脚本时，就是在执行每一个闭包函数，只不过每个闭包所设置的delegate不一样。

以下来自于文档：Gradle Build Language Reference，这个文档很重要，后面会经常使用！！！

• Project对象：每个build.gradle会转换成一个Project对象，或者说代理对象就是Project。
• Gradle对象：当我们执行gradle xxx或者什么的时候，gradle会从默认的配置脚本中构造出一个Gradle对象。在整个执行过程中，只有这么一个对象。Gradle对象的数据类型就是Gradle。我们一般很少去定制这个默认的配置脚本。
• Settings对象：每个settings.gradle会转换成一个Settings对象，或者说代理对象是Setting。

补充一点：Init Script其实就是配置gradle运行环境。似乎从来没有使用过，但是在每一次构建开始之前，都会执行init script，我们可以对当前的build做出一些全局配置，比如全局依赖，何处寻找插件等。有多个位置可以存放init script如下：

1. 通过在命令行里指定gradle参数 -I 或者–init-script

1）Build生命周期

Gradle的构建脚本生命周期具备三大步，如下：

上图告诉我们以下信息，

1. Gradle工作包含三个阶段：
2. 首先是初始化阶段。对我们前面的multi-project build而言，就是执行settings.gradle
3. Initiliazation phase的下一个阶段是Configration阶段。
4. Configration阶段的目标是解析每个project中的build.gradle。比如multi-project build例子中，
   
   解析每个子目录中的build.gradle。在这两个阶段之间，我们可以加一些定制化的Hook。这当然是通过
   
   API来添加的，需要特别注意：每个Project都会被解析。
5. Configuration阶段完了后，整个build的project以及内部的Task关系就确定了。一个
   
   Project包含很多Task，每个Task之间有依赖关系。Configuration会建立一个有向图来描述Task之间的
   
   依赖关系，是一个有向图，所以，我们可以添加一个HOOK，即当Task关系图建立好后，执行一些操作.
6. 最后一个阶段就是执行任务了。你在gradle xxx中指定什么任务，gradle就会将这个xxx任务链上的所有任务全部按依赖顺序执行一遍！当然，任务执行完后，我们还可以加Hook。

2）Setting对象

先看文档，方法文档都在文档中：Settings

其中有这么句话比较重要：

翻译后就是，除了Setting这个接口自己提供的属性方法外，你还可以在以下位置添加自己的额外属性：

- setting.gradle 平级目录下的 gradle.properties 文件

- 用户.gradle目录下的 gradle.properties 文件

- 使用命令行 -P 属性

其余的文档中比较详细。

3）Project对象

以下内容均来自与文档：Project

每一个build.gradle文件和一个Project对象一一对应，在执行构建的时候，gradle通过以下方式为每一个工程创建一个Project对象：

1. 创建一个Settings对象，
2. 根据settings.gradle文件配置它
3. 根据Settings对象中定义的工程的父子关系创建Project对象
4. 执行每一个工程的build.gradle文件配置上一步中创建的Project对像

其中有很多有用的方法：

//apply一个插件或者脚本

void apply(Map<String, ?> options);

//配置当前project的依赖

void dependencies(Closure configureClosure);

//配置当前脚本的classpath

void buildscript(Closure configureClosure);
1
2
3
4
5
6

在build.gradle文件中定义的属性和方法会委托给Project对象执行，每一个project对象在寻找一个属性的时候有5个作用域作为范围，分别是：

属性可见范围

• 1.Project 本身
• 2.Project的ext属性

project.ext.prop1 = "prop1"

ext.prop2 = "prop2"

project.ext {

    prop3 = "prop3"

    prop4 = "prop4"

}

ext {

    prop5 = "prop5"

    prop6 = "prop6"

}

println project.ext.prop1

println project.ext.prop2

println project.prop3

println project.prop4

println prop5

println prop6
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 3.通过plugin添加的extension，就是插件定义自己的特有扩展属性，每一个extension通过一个和extension同名的只读属性访问
• 4.通过plugin添加的属性。一个plugin可以通过Project的Convention对象为project添加属性和方法。
• 5.project中的task,一个task对象可以通过project中的同名属性访问，但是它是只读的
• 6.当前project的父工程的extra属性和convention属性，是只读的

当获取或者设置这些属性的时候，按照上述的顺序依次寻找，如果都没找到，则抛出异常。

方法可见范围

1. Project对象本身
2. build.gradle文件中定义的方法
3. 通过plugin添加的extension，每个extensions都可以作为一个方法访问，它接受一个闭包或Action作为参数
4. 通过plugin添加的方法。一个plugin可以通过Project的Convention对象为project添加属性和方法。
5. project中的task,每一个task 都会在当前project中存在一个接受一个闭包或者Action作为参数的方法，这个闭包会在task的configure(closure)方法中调用。
6. 当前工程的父工程中的方法
7. 当前工程的属性可见范围中所有的闭包属性都可以作为方法访问

4) Task对象

先来文档 Task

创建一个简单的task的语法为：

task <taskName> << {

}
1
2

这句话应该这么理解：

1. 首先调用project的task方法，传入一个taskName,返回一个task
2. 调用task的leftShift 方法 传入一个closure，根据leftShift的解释，我们知道这个闭包将添加到task的action list里去，在任务执行的时候运行

有时候，我们可能会错写成

task <taskName> {

}
1
2

少了这个<< 操作符，意思就完全不一样了，这个时候调用的函数为

//Project类

Task task(String name, Closure configureClosure);
1
2

这时，第二个参数closure用来配置task，在task创建的时候，也就是构建整个任务有向图的时候执行，而不是在task执行的时候运行。不过我们可以在这个闭包内配置task的一些属性。

//指定Copy类型task的属性

task copyDocs(type: Copy) {

   from 'src/main/doc'

   into 'build/target/doc'

}
1
2
3
4
5

当然我们还可以这样指定task的行为：

task exampleTask {

    doLast{

    }

}

task exampleTask doLast{

}

task exampleTask << {

}
1
2
3
4
5
6
7
8
9
10
11
12
13

还可以指定task的类型

task name(type: Type){

    doLast{

     }

}
1
2
3
4
5

gradle内置为我们生成了很多task类型，比如Copy，Delete，可以点击链接 查看gradle内置的task类型列表，如果创建task时没有指定type，则他默认是DefaultTask类型。我们还可以创建自己的task类型，我们在稍后就会讲到。

我们还可以可以指定task之间的依赖关系, 通过dependsOn, mustRunAfter, shouldRunAfter来指定。 还可以指定task的分组group， 如果不指定，将会出现在other里面。

5) 构建的生命周期测试

以下各个方法参考文档：

Gradle相关

Task相关

├── app

│   └── build.gradle

├── lib

│   └── build.gradle

├── build.gradle

└── settings.gradle


1
2
3
4
5
6
7

root/settings.gradle

println '------setting.gradle execute------'

include ':app', ':lib', ':helloPlugin', ':simplePlugin'
1
2
3

root/build.gradle

println '------root build.gradle execute------'

apply from: uri('./build_1.gradle')

apply from: uri('./build_2.gradle')

println "all project size : ${allprojects.size()}"

gradle.settingsEvaluated { settings ->

    println "settingsEvaluated"

}

gradle.projectsLoaded { gradle ->

    println "projectsLoaded"

}

gradle.beforeProject { project ->

    println "beforeProject: ${project.name} "

}

gradle.afterProject { project ->

    println "afterProject: ${project.name}"

}

gradle.projectsEvaluated { gradle ->

    println "projectsEvaluated"

}

gradle.buildFinished { buildResult ->

    println "buildFinished"

}

gradle.taskGraph.whenReady { graph ->

    println "============task graph is ready============"

    graph.getAllTasks().each {

        println "task ${it.name} will execute"

    }

    println "============task graph is over============="

}

gradle.taskGraph.beforeTask { task ->

    println "before ${task.name} execute"

}

gradle.taskGraph.afterTask { task ->

    println "after ${task.name} execute"

}

tasks.whenTaskAdded { task ->

    println "taskAdded:" + task.name

}

task subTask1 {

    group "hello"

    doLast {

        println "${name} execute"

    }

}

task subTask2(dependsOn: 'subTask1') {

    group "hello"

    doLast {

        println "${name} execute"

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

app/build.gradle

println '------app build.gradle execute------'

beforeEvaluate { project ->

    println "beforeEvaluate: ${project.name} --in--"

}

afterEvaluate { project ->

    println "beforeEvaluate: ${project.name} --in--"

}
1
2
3
4
5
6
7
8
9

lib/build.gradle

println '------lib build.gradle execute------'
1

在根目录下执行 gradle libTask2

------setting.gradle execute------

------root build.gradle execute------

all project size : 5

taskAdded:subTask1

taskAdded:subTask2

afterProject: GradlePlugin

afterEvaluate: GradlePlugin

beforeProject: app

beforeEvaluate: app

------app build.gradle execute------

afterProject: app

afterEvaluate: app

Incremental java compilation is an incubating feature.

beforeEvaluate: app --in--

beforeProject: lib

beforeEvaluate: lib

------lib build.gradle execute------

afterProject: lib

afterEvaluate: lib

projectsEvaluated

============task graph is ready============

task subTask1 will execute

task subTask2 will execute

============task graph is over=============

:subTask1

before subTask1 execute

subTask1 execute

after subTask1 execute

:subTask2

before subTask2 execute

subTask2 execute

after subTask2 execute
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

从上述例子中我们验证了以下结果：

1. 如果一个task在build.gradle中定义，但是在构建中不会执行，那么它的Task对象会创建，但是不会在任务图中出现。
2. 我们可以通过Gradle或者Project对象中定义的方法获取生命周期中每一个过程在执行中的回调。这里注意一下，我们定义的一些回调在实际执行中似乎并没有被触发，例如，settingsEvaluated,projectsLoaded。具体原因需要细看。

0x05 自定义一个插件

首先看一下工程结构

├── app                 //root工程

├── repo                //本地maven目录

├── helloPlugin         //plugin工程

│   ├── build.gradle

│   └── src

│       └── main

│           ├── groovy

│           │   └── com.lzy.plugin

│           │       ├── HelloPlugin.groovy

│           │       ├── Person.groovy

│           │       └── PersonExt.groovy

│           └── resources

│               └── META-INF

│                   └── gradle-plugins

│                       └── helloPlugin.properties  //插件名

│

├── build.gradle

└── settings.gradle
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

首先，插件工程可以用任意的jvm语言编写，例如，scala，groovy，java等，最终每一个插件都会打包成一个jar包，其中META-INF文件下中每一个.properties文件代表一个Plugin，最后使用的时候如下：

apply plugin: 'helloPlugin'
1

这个文件里面内容指明了插件类的全类名，如下：

implementation-class=com.lzy.plugin.HelloPlugin
1

HelloPlugin.groovy：很简单，就定义一个任务，打印一个字符串

package com.lzy.plugin

import org.gradle.api.Plugin

import org.gradle.api.Project

class HelloPlugin implements Plugin<Project> {

    public void apply(Project project) {

        project.task("sayHello") {

            group "hello"

            doLast {

                println "Hello Plugin"

            }

        }

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

首先我们必须说明的是，插件可以以三种形式存在:

1. 在我们构建项目的build.gradle脚本中直接编写

2. 在我们构建项目的rootProjectDir/buildSrc/src/main/groovy 目录下

3. 以单独的project存在

这里采用第三种方式：在插件目录下编写

这种编写方式只能发布到本地

build.gradle

apply plugin: 'groovy'

apply plugin: 'maven'

version = '0.1.1'

group = 'com.lzy.plugin'

repositories {

    mavenCentral()

}

dependencies {

    compile gradleApi()

    compile localGroovy()

}

uploadArchives {

    repositories.mavenDeployer {

        repository(url: 'file:../repo')

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

有时我们更想开源出去给其他人用，像Small这样，我们就可以这么写

build.gradle

apply plugin: 'maven-publish'

publishing {

    publications {

        mavenJava(MavenPublication) {

            from components.java

            //这两行是发布源码和文档的，可以不发布

            artifact sourcesJar

            artifact javadocJar

            groupId 'com.lzy.plugin'

            artifactId 'helloPlugin'

            version '0.1.1'

        }

    }

    repositories {

        maven {

            url "../repo"

        }

    }

}

//默认打包时只会包含编译过的jar包，我们可以增加以下两个task，将源代码和javadoc打包发布，并通过上述artifact指定:

task javadocJar(type: Jar, dependsOn: groovydoc) {

    classifier = 'javadoc'

    from "${buildDir}/javadoc"

}

task sourcesJar(type: Jar) {

    from sourceSets.main.allSource

    classifier = 'sources'

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

groupId、artifactId、version,这三者组成了插件使用者在声明依赖时的完整语句 groupId:artifactId:version

对于第一种方式：在helloPlugin的根目录下执行，gralde uploadArchives，编译插件工程，并发布到../repo目录。

对于第二种方式：有两种publish任务，publish 和 publishToMavenLocal，

- publish：任务依赖于所有的mavenPublication的generatePomFileFor任务和publishxxxPublicationToMavenRepository，意思是将所有的mavenPublication发布到指定的repository，

- publishToMavenLocal依赖于所有的mavenPublication的generatePomFileFor和publishxxxTomavenLocal任务，意思是将所有的mavenPublication发布到本地的m2 repository。

以上，我们就创建好了一个gradle plugin，那么如何使用它呢？

首先，在root工程下的build.gradle中，我们通过buildscript引入插件

buildscript{

    repositories{

        mavenCentral()

        maven {

            url uri('./repo')

        }

    }

    dependencies {

        classpath 'com.lzy.plugin:helloPlugin:0.1.1'

    }

}
1
2
3
4
5
6
7
8
9
10
11

然后，在app工程下，我们应用这个插件，

apply plugin: 'helloPlugin'
1

最后，在app或者根目录下执行，gradle sayHello，这样就打印出了我们插件中定义的文字。

以上就是一个自定义插件的创建和应用过程，虽然很简单，但是可以帮助我们理解gradle是如何通过plugin完成很多复杂的工作的。

Extension

1）情况一：

有时候我们希望在使用插件的时候，额外配置一些参数，这时候就需要额外写一个Ext类，如下：

PersonExt.groovy

public class PersonExt {

    String name

    int age

    boolean boy

    @Override

    public String toString() {

        return "I am $name, $age years old, " + (boy ? "I am a boy" : "I am a girl")

    }

}
1
2
3
4
5
6
7
8
9
10

接着修改

HelloPlugin.groovy

class HelloPlugin implements Plugin<Project> {

    public void apply(Project project) {

        project.extensions.add("person", PersonExt)

        project.task("sayHello") {

            group "hello"

            doLast {

                //以下两种方式都可以

                def personExt = project.person

                def personExt1 = project.extensions.getByName('person')

                println personExt

                println personExt1

            }

        }

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

最后我们再使用插件的地方添加以下属性：

person {

    name = "abc"

    age = 18

    boy = true

}
1
2
3
4
5

这里使用=号进行复制，实际上可加可不加，本质是利用了grooy特性，调用了setName方法，并且省略了方法调用的括号。

执行 gradle sayHello得到如下结果：

:sayHello

I am abc, 18 years old, I am a boy

I am abc, 18 years old, I am a boy
1
2
3

到这里说明我们定义的Extension正确设置并读取成功了。

2）情况二

如果我们希望设置的Extension是一个集合列表，并且该列表长度未知，又该怎么写呢？

我们需要使用NamedDomainObjectContainer,我们后面都简称NDOC 这是一个容纳object的容器，它的特点是它的内部使用SortedSet实现的，内部对象的name是unique的，而且是按name进行排序的。通常创建NDOC的方法就是调用Project里的方法：



这里type有一个要求：必须有一个public的构造函数，接受string作为一个参数，必须有一个叫做name 的property。

新增一个类：

HobbyExt.groovy

public class HobbyExt {

    String name

    int level

    String school

    HobbyExt(name) {

        this.name = name;

    }

    @Override

    public String toString() {

        return "My hobby is $name, level $level, School $school"

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

修改HelloPlugin.groovy代码如下：

class HelloPlugin implements Plugin<Project> {

    public void apply(Project project) {

        NamedDomainObjectContainer<HobbyExt> hobbies = project.container(HobbyExt.class)

        project.extensions.add('hobbies', hobbies)

        project.task("sayHello") {

            group "hello"

            doLast {

                def hobbiesExt = project.hobbies

                def hobbiesExt1 = project.extensions.getByName('hobbies')

                println hobbiesExt

                println hobbiesExt1

            }

        }

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在使用插件的地方添加以下代码：

hobbies {

    basketball {

        level = 4

        school = "beijing"

    }

    football {

        level = 6

        school = "qinghua"

    }

}
1
2
3
4
5
6
7
8
9
10

执行 gradle sayHello得到如下结果：

:sayHello

[My hobby is basketball, level 4, School beijing, My hobby is football, level 6, School qinghua]

[My hobby is basketball, level 4, School beijing, My hobby is football, level 6, School qinghua]
1
2
3

到这里说明我们定义的Extension正确设置并读取成功了。

3）情况三

我们也可以混合列表和单个属性，就像android{…}一样

新建一个类

Team.groovy

public class TeamExt {

    NamedDomainObjectContainer<HobbyExt> hobbies

    String name

    int count

    public TeamExt(NamedDomainObjectContainer<HobbyExt> hobbies) {

        this.hobbies = hobbies

    }

    def hobbies(Closure closure) {

        hobbies.configure(closure)

    }

    String toString() {

        "this is a team, name: $name, count $count, hobbies: $hobbies"

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这里的hobbies(closure)函数是必须的，只有实现了这个函数，Gradle在解析team的extension，遇到hobbies配置时，才能通过调用函数，调用 NamedDomainObjectContainer的configure方法，往里面添加对象。

接着我们修改

HelloPlugin.groovy

class HelloPlugin implements Plugin<Project> {

    public void apply(Project project) {

        NamedDomainObjectContainer<HobbyExt> hobbyExt = project.container(HobbyExt)

        def team = new TeamExt(hobbyExt)

        project.extensions.add("team", team)

        project.task("sayHello") {

            group "hello"

            doLast {

                def teamExt = project.team

                def teamExt1 = project.extensions.getByName('team')

                println teamExt

                println teamExt1

            }

        }

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在使用插件的地方添加以下代码：

team {

    name = "android"

    count = 10

    hobbies {

        basketball {

            level = 4

            school = "beijing"

        }

        football {

            level = 6

            school = "qinghua"

        }

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

执行 gradle sayHello得到如下结果：

:sayHello

this is a team, name: android, count 10, hobbies: [My hobby is basketball, level 4, School beijing, My hobby is football, level 6, School qinghua]

this is a team, name: android, count 10, hobbies: [My hobby is basketball, level 4, School beijing, My hobby is football, level 6, School qinghua]


1
2
3
4

到这里说明我们定义的Extension正确设置并读取成功了。

以上的写法是不是特别像build.gradle文件中的android标签，他的内部可以配置很多属性，原理都和这个一样。

到这里，我们就通过一个简单的例子就熟悉了Gradle插件的编写规则，而且通过对groovy语法的了解，让我们对gradle的DSL不再陌生。

0x06 Groovy和Gradle的调试

主要参考 Small 中 Debug gradle on android studio

核心就是下面两个命令：

export GRADLE_OPTS="-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005"

./gradlew someTask -Dorg.gradle.daemon=false
1
2
3

其中有以下几个注意事项：



- 对于项目根目录下的gradle.properties文件需要做修改，一定要将org.gradle.jvmargs这个参数给注释掉，原因是上述在配置remote调试参数的时候已经配置了jvmargs，如果此时配置文件中仍然配置，会导致remote失效，从而不能监听端口

- 在执行./gradlew someTask -Dorg.gradle.daemon=false这行命令时，为了方便可以省略后面的-D参数，改为在配置文件中增加上述配置。这是-D参数的描述

如果你觉得好，对你有过帮助，请给我一点打赏鼓励吧，一分也是爱呀！