Groovy 是一个基于 JVM 的语言，代码最终编译成字节码（bytecode）,并在 JVM 上运行。它具有类似于 Java 的语法风格，但是语法又比 Java 要灵活和方便，同时具有动态语言（如 ruby 和 Python）的一些特性。
正因为如此，所以Groovy适合用来定义DSL（Domain Specific Language）。
简单的来讲 DSL 是一个面向特定小领域的语言，如常见的 HTML、CSS 都是 DSL，它通常是以配置的方式进行编程，与之相对的是通用语言（General Purpose Language），如 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 ", ""}); } }
这里只讲一些比较重要的特性，其余比较基本的语法比较简单，可以参考这里过一遍：
工匠若水的博客：Groovy脚本基础全攻略
groovy中定义的函数，如果至少有一个参数，在调用的时候可以省略括号。如果某个函数没有参数，那就不能省略括号，否则会当成一个变量使用。
def func(String a){
println(a)
}
func 'hello'
在android项目中，比如build.gradle
android {
compileSdkVersion 25 buildToolsVersion "25.0.0" }
比如这里compileSdkVersion 和 buildToolsVersion 其实就是调用了同样名字的两个函数，在AndroidStudio里面可以点进去查看函数实现
闭包的概念也许我们稍微陌生一点，但是实际上，我们可以简单把它当做一个匿名类，只是编译器提供了更加简单的语法来实现它的功能。
闭包(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，分别代表以下概念：
我们编写如下代码：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
如果在闭包内，没有明确指定属性或者方法的调用是发生在this, 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属性将不会是成员变量
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; } ··· }
我们经常在gradle中看见以下代码：
task hello << { println "hello world" }
实际上他的原始调用含义是：
task("hello").leftShift(closure)
因为task重载了leftShift，所以可以使用 << 操作符，这和c++的特性是一样的
这个特性不仅可以省略函数调用中的括号，而且可以省略，连续函数调用中的. 点号, 比如
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") }
借助闭包的特性，我们可以尝试写一个简单的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 }
我们在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，但是为什么可以呢？
我们需要在根目录下也添加一个build.gradle。这个build.gradle一般干得活是：配置其他子Project的。比如为子Project添加一些属性。这个build.gradle有没有都无所谓。
继续在根目录下添加一个名为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，这个文档很重要，后面会经常使用！！！
补充一点：Init Script其实就是配置gradle运行环境。似乎从来没有使用过，但是在每一次构建开始之前，都会执行init script，我们可以对当前的build做出一些全局配置，比如全局依赖，何处寻找插件等。有多个位置可以存放init script如下：
1. 通过在命令行里指定gradle参数 -I 或者–init-script
Gradle的构建脚本生命周期具备三大步，如下：
上图告诉我们以下信息，
gradle具有以下几个常用的命令：
gradle tasks //列出所有的任务
gradle projects //列出所有的项目
gradle properties //列出所有的属性
先看文档，方法文档都在文档中：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 属性
其余的文档中比较详细。
以下内容均来自与文档：Project
每一个build.gradle文件和一个Project对象一一对应，在执行构建的时候，gradle通过以下方式为每一个工程创建一个Project对象：
其中有很多有用的方法：
//apply一个插件或者脚本 void apply(Map<String, ?> options); //配置当前project的依赖 void dependencies(Closure configureClosure); //配置当前脚本的classpath void buildscript(Closure configureClosure);
在build.gradle文件中定义的属性和方法会委托给Project对象执行，每一个project对象在寻找一个属性的时候有5个作用域作为范围，分别是：
属性可见范围
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
当获取或者设置这些属性的时候，按照上述的顺序依次寻找，如果都没找到，则抛出异常。
方法可见范围
先来文档 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> << {
}
这句话应该这么理解：
有时候，我们可能会错写成
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里面。
以下各个方法参考文档：
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
从上述例子中我们验证了以下结果：
首先看一下工程结构
├── 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完成很多复杂的工作的。
有时候我们希望在使用插件的时候，额外配置一些参数，这时候就需要额外写一个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正确设置并读取成功了。
如果我们希望设置的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正确设置并读取成功了。
我们也可以混合列表和单个属性，就像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不再陌生。
主要参考 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参数的描述
JPG