【Groovy】闭包 Closure ( 闭包的 delegate 代理策略 | OWNER_FIRST | DELEGATE_FIRST | OWNER_ONLY | DELEGATE_ONLY )

// I. 闭包中执行 Groovy 脚本中的方法
def fun() {
    println "fun"
}
def closure = {
    fun()
}
closure()
// II. 闭包中执行 Test 类中的方法
class Test {
    def fun() {
        println "fun2"
    }
}
// 闭包中不能直接调用 Test 对象中的方法
// 此时可以通过改变闭包代理进行调用
def closure2 = {
    fun()
}
// 设置闭包的代理
closure2.delegate = new Test()
// 执行闭包
closure2()

// 设置闭包的代理
closure2.delegate = new Test()

private int resolveStrategy = OWNER_FIRST;

/**
     * 设置此resolveStrategy后，闭包将首先尝试将属性引用和方法解析给所有者，
     * 然后是委托（<b>这是默认策略）。
     *
     * For example the following code :
     * <pre>
     * class Test {
     *     def x = 30
     *     def y = 40
     *
     *     def run() {
     *         def data = [ x: 10, y: 20 ]
     *         def cl = { y = x + y }
     *         cl.delegate = data
     *         cl()
     *         println x
     *         println y
     *         println data
     *     }
     * }
     *
     * new Test().run()
     * </pre>
     * will output :
     * <pre>
     * 30
     * 70
     * [x:10, y:20]
     * </pre>
     * 因为在测试类中声明的x和y字段在委托中定义了变量<p> 
     * <i>请注意，总是首先查找局部变量，而与解析策略无关。</i>
     */
    public static final int OWNER_FIRST = 0;
    /**
     * 设置此resolveStrategy后，闭包将首先尝试将属性引用和方法解析为委托，然后解析为所有者。
     *
     * 例如，以下代码：
     * <pre>
     * class Test {
     *     def x = 30
     *     def y = 40
     *
     *     def run() {
     *         def data = [ x: 10, y: 20 ]
     *         def cl = { y = x + y }
     *         cl.delegate = data
     *         cl.resolveStrategy = Closure.DELEGATE_FIRST
     *         cl()
     *         println x
     *         println y
     *         println data
     *     }
     * }
     *
     * new Test().run()
     * </pre>
     * will output :
     * <pre>
     * 30
     * 40
     * [x:10, y:30]
     * </pre>
     * 因为在测试类中声明的x和y字段在委托中定义了变量<p> 
     * <i>请注意，总是首先查找局部变量，而与解析策略无关。</i>
     */
    public static final int DELEGATE_FIRST = 1;
    /**
     * 使用此resolveStrategy集，闭包将只解析所有者的属性引用和方法，而不调用委托。
     * 例如，以下代码：
     *
     * <pre>
     * class Test {
     *     def x = 30
     *     def y = 40
     *
     *     def run() {
     *         def data = [ x: 10, y: 20, z: 30 ]
     *         def cl = { y = x + y + z }
     *         cl.delegate = data
     *         cl.resolveStrategy = Closure.OWNER_ONLY
     *         cl()
     *         println x
     *         println y
     *         println data
     *     }
     * }
     *
     * new Test().run()
     * </pre>
     *
     * 将抛出“No-this-property:z”错误，因为即使在委托中声明了z变量，也不会进行查找<p> 
     * <i>请注意，总是首先查找局部变量，而与解析策略无关</我>
     */
    public static final int OWNER_ONLY = 2;
    /**
     * 使用此resolveStrategy集，闭包将只解析委托的属性引用和方法，并完全绕过所有者。
     * 例如，以下代码：
     *
     * <pre>
     * class Test {
     *     def x = 30
     *     def y = 40
     *     def z = 50
     *
     *     def run() {
     *         def data = [ x: 10, y: 20 ]
     *         def cl = { y = x + y + z }
     *         cl.delegate = data
     *         cl.resolveStrategy = Closure.DELEGATE_ONLY
     *         cl()
     *         println x
     *         println y
     *         println data
     *     }
     * }
     *
     * new Test().run()
     * </pre>
     *
     * 将引发错误，因为即使所有者声明了“z”字段，解析策略也将绕过所有者中的查找<p> 
     * <i>请注意，总是首先查找局部变量，而与解析策略无关</i>
     */
    public static final int DELEGATE_ONLY = 3;
    /**
     * 使用此resolveStrategy集，闭包将解析自身的属性引用，
     * 并执行通常的元类查找过程。
     * 这意味着属性和方法既不能从所有者也不能从委托解析，
     * 只能在闭包对象本身上解析。
     * 这允许开发人员使用闭包本身的ExpandoMetaClass覆盖getProperty。<p>
     * <i>请注意，总是首先查找局部变量，与解析策略无关。</i>
     */
    public static final int TO_SELF = 4;
  private int resolveStrategy = OWNER_FIRST;
}