Gradle学习之闭包

Gradle中的闭包其实就等同于Groovy中闭包，Groovy是一种jvm语言，语法兼容于java，曾几何时，也在脚本语言中独树一帜，初学Gradle的时候，大家很容易被其语法所迷惑，由于Gradle基本上是基于闭包以及委托实现的，所以要学Gradle必须先学Groovy闭包

一.Groovy中的闭包(Closures)

1.闭包是一种匿名的代码块，这个代码块可以有参数及返回值，同时也可以被定义成变量，在Groovy中闭包是一个对象，我们可以简单的把它理解成将方法赋值给一个变量

2.定义闭包的语法结构：{ [闭包参数 ->] 语句 }，闭包参数可以是一个或者多个，可以定义参数类型也可以不定义其类型, 例子：

{ item++ }
{ -> item++ }
{ println it }
{ it -> println it }
{ name -> println name }
{ String x, int y ->
　　println "hey ${x} the value is ${y}"
}
{ reader ->
　　def line = reader.readLine()
　　line.trim()
}

3.当闭包参数唯一时，我们可以用it来代替该参数，注意在闭包内不要再次定义it类型变量避免引起冲突
4.闭包也可以作为一个返回值付给一个变量，比如：

def listener = { e -> println "Clicked on $e.source" } 

如果我们不用def来定义，那么使用Groovy中groovy.lang.Closure来代表闭包类型

Closure callback = { println 'Done!' } 

5.调用闭包方法： 闭包名([参数 ...]) 或者 闭包名.call([参数 ...])

def test = { num -> println(num * 2) }
test(2)

6.可以使用闭包来实现接口：

def x ={Object [] args ->} as 接口名

二。闭包中的委托策略

1.在闭包中我们有三个引用对象的关键字：this,owner,delegete，委托策略是指：在闭包中写的属性或者方法，默认绑定到哪个对象上

2.三种关键字说明：

　　this:代表闭包的外部类

　　owner:默认情况与this相似，但是ownner可以代表类，也可以代表闭包对象

　　delegete:默认情况等同于owner,但是我们可以动态改变这个值让闭包内的属性和方法代表不同的意义

3.我们可以用闭包对象的resolveStrategy 来改变代理策略，常见的值
　　Closure.OWNER_FIRST：默认策略，如果闭包里的属性或者方法优先调用owner中的，如果owner不存在则调用delegete中的
　　Closure.DELEGATE_FIRST 属性或方法优先使用delegete中，如果不存在，则使用owner中的
　　Closure.OWNER_ONLY 属性或方法仅仅在owner里寻找，delegete中存在的将被忽略
　　Closure.DELEGATE_ONLY 属性或方法仅仅在delegete里寻找，delegete中存在的将被忽略

新建Groovy脚本，代码如下：

package com.bdqn.gradle.study

/**
 * Groovy委托策略演示
* @author chen.nie
* @date 2018/1/16
**/
class GroovyTest {
    def name
    def age

    def getName() {
        return name
    }

    void setName(name) {
        this.name = name
    }

    def getAge() {

        return age
    }

    void setAge(age) {
        this.age = age
    }
    /**
     * 闭包 this owner delegate 的相同情况下演示
     * @return
     */
    def testClosure1() {
        def closure1 = {
            //  test = "20"
            println owner
            println this
            println delegate
        }

        closure1.call()
    }
    /**
     * 嵌套闭包时 this owner delegate区别演示
     * 注意：此时this代表了类
     * 而owner代表了闭包对象
     */
    def testClosure2() {
        def closure2 = {
            def test = {
                println this
                println owner
                println delegate
            }
            test()
        }
        closure2()
    }

    /**
     * 代理对象演示，注意在闭包内定义的date属性如果不指定其代理一定会报错，因为owner中没有date属性
     * @return
     */
    def testClosure3() {
        def closure3 = {
            def test = {
                date = "2018-01-16"
                println(date)
            }
            test()
        }
        GroovyTest1 groovyTest1 = new GroovyTest1()
        closure3.delegate = groovyTest1
        closure3()
    }
}

class GroovyTest1 {
    def name
    def date

    def getName() {
        return name
    }

    void setName(name) {
        this.name = name
    }

    def getDate() {
        return date
    }

    void setDate(date) {
        this.date = date
    }
}

def test = new GroovyTest()
test.testClosure1()
println()
test.testClosure2()
println()
test.testClosure3()

输出结果：

com.bdqn.gradle.study.GroovyTest@23f7d05d
com.bdqn.gradle.study.GroovyTest@23f7d05d
com.bdqn.gradle.study.GroovyTest@23f7d05d

com.bdqn.gradle.study.GroovyTest@23f7d05d
com.bdqn.gradle.study.GroovyTest$_testClosure2_closure2@2a32de6c
com.bdqn.gradle.study.GroovyTest$_testClosure2_closure2@2a32de6c

2018-01-16

三 groovy常用特有语法总结：

1. groovy本身就支持java语法，groovy文件最终将会被翻译成.class文件

2. 定义变量或者方法

def name
def test(args){

}//方法可以省略返回值,参数可以省略类型

3.定义多行字符串

def ab="""
         字符串
        """    

4).对象安全操作 对象名?.属性名 当对象为null时直接返回Null

5.定义集合

def items=[4,5]
def list=[1,2,3,*items]

6) 定义map:

def m1 = [c:3,d:4]
def map= [a:1,*:m1]

7) 定义范围：

def range= 0..5 （包含5）
def range1= 0..<5 (不包含5)
def list = [0,1,2,3,4]
assert list[2] == 2
list[2] = 4
assert list[0..2] == [0,1,4]
list[0..2] = [6,6,6]
assert list == [6,6,6,3,4] 

8） 定义方法参数的默认值

def test(a=10){
  //....
}

9) 创建对象指定参数

def person = new Person(age:10,name:"张三")