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

2021-07-27 06:31:23

文章目录

一、闭包的代理策略引入

二、闭包的四种代理策略

一、闭包的代理策略引入

分别在 Groovy 脚本和 Test 类中定义 fun 方法 , 打印不同的内容 ;

在闭包 Closure 中分别调用上述两个方法 ,

代码示例 :

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

上述代码执行结果 :

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

执行上述代码后 , 两个闭包都执行的是 Groovy 脚本中的 fun 方法 ;

即使 closure2 闭包设置的是 Test 实例对象作为代理 , 其仍然执行的是 Groovy 脚本中的 fun 方法 ;

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

这是因为 Closure 闭包的代理策略问题导致的 ;

在 Closure 闭包中 , resolveStrategy 成员配置的是该闭包的代理策略 , 默认的代理策略 OWNER_FIRST , 也就是优先从 owner 中查找方法 ; 此时即使在 delegate 中有 fun 方法 , 也会被 owner 中的 fun 方法覆盖 ;

private int resolveStrategy = OWNER_FIRST;

二、闭包的四种代理策略

闭包的四种代理策略 :

OWNER_FIRST : 所有者中的方法优先 ;

DELEGATE_FIRST : 代理优先策略 , 代理中的方法优先 ;

OWNER_ONLY : 只执行所有者中的方法 ;

DELEGATE_ONLY : 只执行代理中的方法 ;

TO_SELF : 只在自身查找 ;

public abstract class Closure<V> extends GroovyObjectSupport implements Cloneable, Runnable, GroovyCallable<V>, Serializable {

/**
     * 设置此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;
}

码农公寓

相关文章