【Groovy】闭包 Closure ( 闭包类 Closure 简介 | this、owner、delegate 成员赋值及源码分析 )

2023-03-30 10:18:48 浏览数 (2)

文章目录

  • 总结
  • 一、闭包类 Closure 简介
  • 二、闭包类 Closure 中 this、owner、delegate 成员 源码分析
  • 三、分析编译后的字节码文件内容

总结

在闭包中 , 打印 this , owner , delegate , 打印结果都是闭包所在的类 ;

一、闭包类 Closure 简介

在闭包 Closure 中有

3

个成员 , this , owner , delegate , 在闭包中打印这

3

个成员 ,

代码语言：javascript复制
def closure = {
    println "this : ${this}"
    println "owner : ${owner}"
    println "delegate : ${delegate}"
}

执行闭包的 call() 方法 , 或者直接使用 闭包() 执行闭包 ;

代码语言：javascript复制
closure()

打印结果如下 , 打印的是闭包对象 ;

代码语言：javascript复制
this : Groovy@5c45d770
owner : Groovy@5c45d770
delegate : Groovy@5c45d770

Groovy.groovy 代码编译后的字节码文件是 Groovy.class , 其中

二、闭包类 Closure 中 this、owner、delegate 成员 源码分析

闭包类 Closure 中的 delegate , owner , thisObject 成员如下 , 在构造函数中 , 为 Object owner, Object thisObject 这

2

个成员赋值 ;

在闭包中 , 访问 owner , 实际上是调用 getOwner 函数 , 访问 delegate 实际上是调用 getDelegate 函数 , this 就是 thisObject ;

特别注意 , 在构造函数中 , 为这

3

个成员进行了赋值 ;

闭包类 Closure 中 this、owner、delegate 成员 源码 :

代码语言：javascript复制
public abstract class Closure<V> 
		extends GroovyObjectSupport 
		implements Cloneable, Runnable, GroovyCallable<V>, Serializable {

    private Object delegate;
    private Object owner;
    private Object thisObject;

	// 闭包构造函数 
    public Closure(Object owner, Object thisObject) {
        this.owner = owner;
        this.delegate = owner;
        this.thisObject = thisObject;

        final CachedClosureClass cachedClass = 
        	(CachedClosureClass) ReflectionCache.getCachedClass(getClass());
        parameterTypes = cachedClass.getParameterTypes();
        maximumNumberOfParameters = cachedClass.getMaximumNumberOfParameters();
    }

    /**
     * @return 方法调用将转到的所有者对象，通常是构造闭包时的外部类
     */
    public Object getOwner() {
        return this.owner;
    }

    /**
     * @return 构造闭包时，方法调用将转到的委托对象通常是外部类
     */
    public Object getDelegate() {
        return this.delegate;
    }
}

三、分析编译后的字节码文件内容

查看 Groovy 代码编译后的字节码文件 Groovy.class ,

代码语言：javascript复制
public class Groovy extends Script

在该编译后的字节码文件中 , 声明的闭包变量

代码语言：javascript复制
def closure = {
    println "this : ${this}"
    println "owner : ${owner}"
    println "delegate : ${delegate}"
}

生成的对应的闭包类为 :

代码语言：javascript复制
final class _run_closure1 extends Closure implements GeneratedClosure

该闭包类的构造函数是在 public class Groovy extends Script 中的 run 方法中调用 , 将 Groovy 实例对象传入到了闭包构造函数中 ;

代码语言：javascript复制
		// 创建闭包 , 传入的参数 this 是 class Groovy extends Script 类实例对象 
        Object closure = new _run_closure1(this, this);

在闭包类的构造函数中 , 调用了父类的构造函数 , 分别将 _outerInstance 赋值给 owner 成员 , 将 _thisObject 赋值给 thisObject 成员 , 而 _thisObject 和 _outerInstance 参数都是 this , 即 Groovy 脚本的生成类 , class Groovy extends Script ;

代码语言：javascript复制
        	// 闭包构造函数 
            public _run_closure1(Object _outerInstance, Object _thisObject) {
                CallSite[] var3 = $getCallSiteArray();
                // 此处调用了父类的构造函数 , 分别
                // 将 _outerInstance 赋值给 owner 成员
                // 将 _thisObject 赋值给 thisObject 成员 
                // 而 _thisObject 和 _outerInstance 参数都是 this 
                // 即 Groovy 脚本的生成类 , class Groovy extends Script
                super(_outerInstance, _thisObject);
            }

编译后的字节码内容如下 :

代码语言：javascript复制
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

import groovy.lang.Binding;
import groovy.lang.Closure;
import groovy.lang.Script;
import groovy.transform.Generated;
import org.codehaus.groovy.runtime.GStringImpl;
import org.codehaus.groovy.runtime.GeneratedClosure;
import org.codehaus.groovy.runtime.InvokerHelper;
import org.codehaus.groovy.runtime.callsite.CallSite;

public class Groovy extends Script {
    public Groovy() {
        CallSite[] var1 = $getCallSiteArray();
        super();
    }

    public Groovy(Binding context) {
        CallSite[] var2 = $getCallSiteArray();
        super(context);
    }

    public static void main(String... args) {
        CallSite[] var1 = $getCallSiteArray();
        var1[0].call(InvokerHelper.class, Groovy.class, args);
    }

    public Object run() {
        CallSite[] var1 = $getCallSiteArray();

		// 闭包类
        final class _run_closure1 extends Closure implements GeneratedClosure {
        	// 闭包构造函数 
            public _run_closure1(Object _outerInstance, Object _thisObject) {
                CallSite[] var3 = $getCallSiteArray();
                // 此处调用了父类的构造函数 , 分别
                // 将 _outerInstance 赋值给 owner 成员
                // 将 _thisObject 赋值给 thisObject 成员 
                // 而 _thisObject 和 _outerInstance 参数都是 this 
                // 即 Groovy 脚本的生成类 , class Groovy extends Script
                super(_outerInstance, _thisObject);
            }
            
			// 调用闭包
            public Object doCall(Object it) {
                CallSite[] var2 = $getCallSiteArray();
                var2[0].callCurrent(this, new GStringImpl(new Object[]{this.getThisObject()}, new String[]{"this : ", ""}));
                var2[1].callCurrent(this, new GStringImpl(new Object[]{var2[2].callGroovyObjectGetProperty(this)}, new String[]{"owner : ", ""}));
                return var2[3].callCurrent(this, new GStringImpl(new Object[]{var2[4].callGroovyObjectGetProperty(this)}, new String[]{"delegate : ", ""}));
            }

			// 调用闭包 
            @Generated
            public Object doCall() {
                CallSite[] var1 = $getCallSiteArray();
                return this.doCall((Object)null);
            }
        }

		// 创建闭包 , 传入的参数 this 是 class Groovy extends Script 类实例对象 
        Object closure = new _run_closure1(this, this);
        return var1[1].call(closure);
    }
}
闭包 编译 对象 函数 源码分析

0 人点赞