文章目录
- 一、闭包的代理策略引入
- 二、闭包的四种代理策略
一、闭包的代理策略引入
分别在 Groovy 脚本 和 Test 类中定义 fun 方法 , 打印不同的内容 ;
在闭包 Closure 中分别调用上述两个方法 ,
代码示例 :
代码语言：javascript复制// 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 脚本中的 fun 方法 ;
即使 closure2 闭包设置的是 Test 实例对象作为代理 , 其仍然执行的是 Groovy 脚本中的 fun 方法 ;
代码语言：javascript复制// 设置闭包的代理
closure2.delegate = new Test()这是因为 Closure 闭包的 代理策略问题导致的 ;
在 Closure 闭包中 , resolveStrategy 成员配置的是该闭包的代理策略 , 默认的代理策略 OWNER_FIRST , 也就是优先从 owner 中查找方法 ; 此时即使在 delegate 中有 fun 方法 , 也会被 owner 中的 fun 方法覆盖 ;
代码语言：javascript复制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;
}
