groovy 闭包

语法规则

{ [closureParameters -> ] statements }

下面的语句都是正确的

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

参数列表

def closureWithTwoArgsAndOptionalTypes = { a, int b -> a+b }
assert closureWithTwoArgsAndOptionalTypes(1,2) == 3

可以看到参数列表使用逗号分隔，而且 typed 和 untyped 均可，-> 符号用以分隔参数列表和语句。值得提一下，如果闭包只有一个参数，那么可以省略参数列表，直接使用 it 代替参数。

委托策略

闭包有三个概念：this、owner 和 delegate

this 定义闭包的封闭类（enclosing class）

owner 定义闭包的封闭对象（enclosing object），可能是类也可能是对象

delegate 被调用方法或者引用属性的第三方对象，这个需要具体参考代码

this

class Enclosing {
    void run() {
        def whatIsThisObject = { getThisObject() }          // 返回对象 this
        assert whatIsThisObject() == this
        def whatIsThis = { this }                           // 返回对象 this
        assert whatIsThis() == this
    }
}
class EnclosedInInnerClass {
    class Inner {
        Closure cl = { this }                               // Inner 类的对象 this
    }
    void run() {
        def inner = new Inner()
        assert inner.cl() == inner
    }
}
class NestedClosures {
    void run() {
        def nestedClosures = {
            def cl = { this }                              
            cl()                                            // 还是 this
        }
        assert nestedClosures() == this
    }
}

可以看出 groovy 闭包中的 this 和 java 是一致的。

owner

class Enclosing {
    void run() {
        def whatIsOwnerMethod = { getOwner() }                  // 对象的 this
        assert whatIsOwnerMethod() == this
        def whatIsOwner = { owner }                             // 同样是对象的 this                   
        assert whatIsOwner() == this
    }
}
class EnclosedInInnerClass {
    class Inner {
        Closure cl = { owner }                                  // 本质上还是对象的 this
    }
    void run() {
        def inner = new Inner()
        assert inner.cl() == inner                           
    }
}
class NestedClosures {
    void run() {
        def nestedClosures = {
            def cl = { owner }                               
            cl()
        }
        assert nestedClosures() == nestedClosures            // 此处就是 this 就有区别了，和 owner 的语义一致
    }
}

delegate

上面的 this 和 owner 引用的都是闭包 scope 的内容，但是 delegate 可以引用第三方对象的内容，默认 delegate 被设置为 owner，因为第三方对象不一定被设置。

class Person {
    String name
}
class Thing {
    String name
}

def p = new Person(name: 'Norman')
def t = new Thing(name: 'Teapot')

def upperCasedName = { delegate.name.toUpperCase() } // delegate 可以省略 name.toUpperCase() 也是正确的

upperCasedName.delegate = p
assert upperCasedName() == 'NORMAN'
upperCasedName.delegate = t
assert upperCasedName() == 'TEAPOT'

// 和引用外部变量有本质区别，下面的 target 不可能被省略
def target = p
def upperCasedNameUsingVar = { target.name.toUpperCase() }
assert upperCasedNameUsingVar() == 'NORMAN'

修改策略

“默认 delegate 被设置为 owner”，这句话隐含意思就是 delegate 的策略可以被调整，有下面四种策略，

Closure.OWNER_FIRST 默认的
Closure.DELEGATE_FIRST delegate 优先
Closure.OWNER_ONLY 只取 owner
Closure.DELEGATE_ONLY 只取 delegate
Closure.TO_SELF 如果用户自己实现 Closure 的子类，这个才有意义

class Person {
    String name
    int age
    def fetchAge = { age }
}
class Thing {
    String name
}

def p = new Person(name:'Jessica', age:42)
def t = new Thing(name:'Printer')
def cl = p.fetchAge
cl.delegate = p
assert cl() == 42
cl.delegate = t
assert cl() == 42                   // 默认情况下 Closure.OWNER_FIRST，所以此处断言是通过的
cl.resolveStrategy = Closure.DELEGATE_ONLY
cl.delegate = p
assert cl() == 42
cl.delegate = t
try {
    cl()                            // 只取 delegate，Thing 类无 age 字段，异常
    assert false
} catch (MissingPropertyException ex) {
    // 异常会在这里被捕获
}

以上内容均参考 http://www.groovy-lang.org/closures.html，文档中还讲到了 closures in GStrings、currying 等很有意思的内容。