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)。

简单的来讲 DSL 是一个面向特定小领域的语言,如常见的 HTML、CSS 都是 DSL,它通常是以配置的方式进行编程,与之相对的是通用语言(General Purpose Language),如 Java 等。

0x02 groovy 基本知识

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

2)groovy与java

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

name = "lzy"
def say(){
    "my name is $name"
}
println say()

在命令行输入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 ", ""});
    }
}

到这里我们可以发现,其实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");

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

import groovy.transform.Field

@Field name = "lzy"
def say(){
    "my name is $name"
}
println say()

加上这行注解后,生成的字节码如下:
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 ", ""});
    }
}

0x03 Groovy 语法

这里只讲一些比较重要的特性,其余比较基本的语法比较简单,可以参考这里过一遍:
工匠若水的博客:Groovy脚本基础全攻略

1)方法的输入参数优化

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

def func(String a){
    println(a)
}

func 'hello'

在android项目中,比如build.gradle

android {
    compileSdkVersion 25
    buildToolsVersion "25.0.0"
}

比如这里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"
}

闭包有三个很重要的属性分别是: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()

运行后得到如下结果:

--------------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

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()

运行后得到如下结果:

ABC
TTT
my name is ppp
my name is abc

这里重点强调一下,成员变量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"

然后对这个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;
    }

    ···
}

5)操作符重载

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

task hello << {
    println "hello world"
}

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

task("hello").leftShift(closure)

因为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") }

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
}

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

0x04 Gradle 基本概念

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

├── app
│   └── build.gradle
├── lib
│   └── build.gradle
├── build.gradle
└── settings.gradle

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

Gradle中,每一个待编译的工程,或者叫每一个Library和App都是单独的Project。根据Gradle的要求,每一个Project在其根目录下都需要有一个build.gradle。build.gradle文件就是该Project的编译脚本,类似于Makefile。每一个Project在构建的时候都包含一系列的Task。比如一个Android APK的编译可能包含:Java源码编译Task、资源编译Task、JNI编译Task、lint检查Task、打包生成APK的Task、签名Task等。具体一个Project到底包含多少个Task,其实是由编译脚本指定的插件决定。插件是什么呢?插件就是用来定义Task,并具体执行这些Task的东西。

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

android{
    ...
}  
dependencies{
  ....
}

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

这些task都是android application插件生成的。我们能使用Gradle构建Android 工程,一切都基于这个插件。这个插件从android这个扩展中读取了我们的配置,生成了一些列构建android 所需要的任务。

我们执行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。

gradle具有以下几个常用的命令:
gradle tasks //列出所有的任务
gradle projects //列出所有的项目
gradle properties //列出所有的属性

2)Setting对象

先看文档,方法文档都在文档中:Settings
其中有这么句话比较重要:

In addition to the properties of this interface, the Settings object makes some additional read-only properties available to the settings script. This includes properties from the following sources:

  • Defined in the gradle.properties file located in the settings directory of the build.
  • Defined the gradle.properties file located in the user’s .gradle directory.
  • Provided on the command-line using the -P option.

翻译后就是,除了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);

在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
  • 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

A Task is made up of a sequence of Action objects. When the task is executed, each of the actions is executed in turn, by calling Action.execute(T). You can add actions to a task by calling Task.doFirst(org.gradle.api.Action) or Task.doLast(org.gradle.api.Action).

Groovy closures can also be used to provide a task action. When the action is executed, the closure is called with the task as parameter. You can add action closures to a task by calling Task.doFirst(groovy.lang.Closure) or Task.doLast(groovy.lang.Closure).

There are 2 special exceptions which a task action can throw to abort execution and continue without failing the build. A task action can abort execution of the action and continue to the next action of the task by throwing a StopActionException. A task action can abort execution of the task and continue to the next task by throwing a StopExecutionException. Using these exceptions allows you to have precondition actions which skip execution of the task, or part of the task, if not true.

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

task <taskName> << {
}

这句话应该这么理解:

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

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

task <taskName> {
}

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

//Project类
Task task(String name, Closure configureClosure);

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

//指定Copy类型task的属性
task copyDocs(type: Copy) {
   from 'src/main/doc'
   into 'build/target/doc'
}

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

task exampleTask {
    doLast{

    }
}

task exampleTask doLast{

}

task exampleTask << {

}

还可以指定task的类型

task name(type: Type){
    doLast{

     }
}

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

root/settings.gradle

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

include ':app', ':lib', ':helloPlugin', ':simplePlugin'

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"
    }
}

app/build.gradle

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

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

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

lib/build.gradle

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

在根目录下执行 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. 如果一个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

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

apply plugin: 'helloPlugin'

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

implementation-class=com.lzy.plugin.HelloPlugin

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. 在我们构建项目的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')
    }
}

有时我们更想开源出去给其他人用,像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'
}

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'
    }
}

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

apply plugin: 'helloPlugin'

最后,在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")
    }
}

接着修改
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
            }
        }
    }
}

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

person {
    name = "abc"
    age = 18
    boy = true
}

这里使用=号进行复制,实际上可加可不加,本质是利用了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

到这里说明我们定义的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"
    }
}

修改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
            }
        }
    }
}

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

hobbies {
    basketball {
        level = 4
        school = "beijing"
    }
    football {
        level = 6
        school = "qinghua"
    }
}

执行 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]

到这里说明我们定义的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"
    }
}

这里的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
            }
        }
    }
}

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

team {
    name = "android"
    count = 10
    hobbies {
        basketball {
            level = 4
            school = "beijing"
        }
        football {
            level = 6
            school = "qinghua"
        }
    }
}

执行 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]

到这里说明我们定义的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

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

- 对于项目根目录下的gradle.properties文件需要做修改,一定要将org.gradle.jvmargs这个参数给注释掉,原因是上述在配置remote调试参数的时候已经配置了jvmargs,如果此时配置文件中仍然配置,会导致remote失效,从而不能监听端口
- 在执行./gradlew someTask -Dorg.gradle.daemon=false这行命令时,为了方便可以省略后面的-D参数,改为在配置文件中增加上述配置。这是-D参数的描述

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

阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/jeasonlzy/article/details/74273953
文章标签: groovy java
个人分类: android
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭