CGLIB动态代理对象执行流程分析

- 日理万妓 2023-09-24 23:04 83阅读 0赞

![format_png][]

### 前言 ###

--------------------

都说**CGLIB**动态代理对象执行方法的速度相较于**JDK**动态代理更快，那么为什么更快，实际是因为**CGLIB**中采用了**FastClass**机制，本篇文章将对**CGLIB**动态代理对象执行某一个方法的流程进行分析，并引出对**FastClass**机制的讲解。

### 正文 ###

--------------------

#### 一. 示例工程搭建 ####

首先编写两个被代理类。

publicclassKafkaService {
    
        publicbooleanproduce() {
            System.out.println("Kafka message produced.");
            returntrue;
        }
    
    }
    
    publicclassRedisService {
    
        publicvoidassembleName(String name) {
            System.out.println("Name assembled: " + name);
        }
    
        publicvoidassembleAge(int age) {
            System.out.println("Age assembled: " + age);
        }
    
    }
    复制代码

然后编写一个**ConnectHelper**实现**MethodInterceptor**接口，并提供一个公共方法来为被代理对象创建代理对象。

publicclassConnectHelperimplementsMethodInterceptor {
    
        public <T> T getInstance(Class<T> aClass) {
            Enhancerenhancer=newEnhancer();
            enhancer.setSuperclass(aClass);
            enhancer.setCallback(this);
            return (T) enhancer.create();
        }
    
        /**
         * @param o 代理对象
         * @param method 被代理对象的方法
         * @param objects 被代理对象的方法参数类型
         * @param methodProxy 被代理对象的方法的代理
         */@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy)throws Throwable {
            prepareConnect();
            // 代理对象继承了被代理对象，所以这里需要执行父类方法ObjectinvokeResult= methodProxy.invokeSuper(o, objects);
            closeRelease();
            return invokeResult;
        }
    
        privatevoidprepareConnect() {
            System.out.println("连接建立。");
        }
    
        privatevoidcloseRelease() {
            System.out.println("连接释放。");
        }
    
    }
    复制代码

编写测试程序，如下所示。

publicclassClient {
    
        publicstaticvoidmain(String[] args) {
            ConnectHelperconnectHelper=newConnectHelper();
    
            KafkaServicekafkaService= connectHelper.getInstance(
                    KafkaService.class);
            kafkaService.produce();
    
            RedisServiceredisService= connectHelper.getInstance(
                    RedisService.class);
            redisService.assembleName("DogLee");
            redisService.assembleAge(25);
        }
    
    }
    复制代码

执行结果如下所示。

![format_png 1][]

#### 二. CGLIB动态代理对象方法执行流程分析 ####

通过在程序中添加如下代码，可以将**CGLIB**动态代理类保存下来，如下所示。

System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, 目录);
    复制代码

第二节中的**KafkaService**的**CGLIB**动态代理类会生成如下三个。

![format_png 2][]

实际上**CGLIB**一开始只会生成KafkaService$$EnhancerByCGLIB$$b70fe9a2动态代理类，另外两个带**FastClass**标志的类是第一次执行代理方法时生成的，这点本节后面再详细分析，现在先看一下**CGLIB**动态代理类的内容，如下所示。

publicclassKafkaService$$EnhancerByCGLIB$$b70fe9a2extendsKafkaServiceimplementsFactory {
        
        // ...
    	
        // 被代理类的方法的方法对象privatestaticfinal Method CGLIB$clone$4$Method;
        // 被代理类的方法的代理对象privatestaticfinal MethodProxy CGLIB$clone$4$Proxy;
    
        staticvoid CGLIB$STATICHOOK1() {
            
    	// ...
    		
            CGLIB$produce$0$Method = ReflectUtils.findMethods(newString[]{"produce", "()Z"}, (var1 = Class.forName("cn.sakura.sacrifice.dynamic.connecttest.cglibproxy.KafkaService")).getDeclaredMethods())[0];
            CGLIB$produce$0$Proxy = MethodProxy.create(var1, var0, "()Z", "produce", "CGLIB$produce$0");
        }
    
        finalboolean CGLIB$produce$0() {
    	// 最终，在这里调用被代理对象的方法returnsuper.produce();
        }
    
        publicfinalbooleanproduce() {
            MethodInterceptorvar10000=this.CGLIB$CALLBACK_0;
            if (var10000 == null) {
                CGLIB$BIND_CALLBACKS(this);
                var10000 = this.CGLIB$CALLBACK_0;
            }
    
            if (var10000 != null) {
    	    // 首先，在这里调用MethodInterceptor的intercept()方法Objectvar1= var10000.intercept(this, CGLIB$produce$0$Method, CGLIB$emptyArgs, CGLIB$produce$0$Proxy);
                return var1 == null ? false : (Boolean)var1;
            } else {
                returnsuper.produce();
            }
        }
    
        // ...
    	
    }
    复制代码

那么可以对**CGLIB**动态代理类的特点进行如下归纳。

*  **CGLIB**动态代理类继承了被代理类，是被代理类的子类；

*  **CGLIB**动态代理类实现了**Factory**接口；

*  **CGLIB**动态代理类中持有被代理类方法的方法对象（**Method**）和方法的代理对象（**MethodProxy**）;

*  调用**CGLIB**动态代理类的代理方法，会调用到**MethodInterceptor**的**intercept()** 方法。

所以**CGLIB**动态代理生成的代理类是被代理类的子类，以及当代理类调用方法时，会通过**MethodInterceptor**来调用被代理类的方法和增强方法。那么现在从代理类的**produce()** 方法开始，探究一下**CGLIB**的代理方法的执行步骤和原理。

已知代理类的**produce()** 方法会调用到**MethodInterceptor**的**intercept()** 方法，在例子中**MethodInterceptor**为**ConnectHelper**，所以看一下**ConnectHelper**的**intercept()** 方法，如下所示。

/**
     * @param o 代理对象
     * @param method 被代理对象的方法
     * @param objects 被代理对象的方法参数类型
     * @param methodProxy 被代理对象的方法的代理
     */@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy)throws Throwable {
        prepareConnect();
        // 代理对象继承了被代理对象，所以这里需要执行父类方法ObjectinvokeResult= methodProxy.invokeSuper(o, objects);
        closeRelease();
        return invokeResult;
    }
    复制代码

因为**intercept()** 方法的第一个参数为代理对象本身，而代理对象是被代理对象的子类，所以要执行被代理对象的方法，需要调用**MethodProxy**的**invokeSuper()** 方法，探究**invokeSuper()** 方法前，先看一下**MethodProxy**是如何被生成的。在**CGLIB**代理类的静态代码块中，有如下两行代码。

// 获取被代理类的方法对象
    CGLIB$produce$0$Method = ReflectUtils.findMethods(newString[]{"produce", "()Z"}, (var1 = Class.forName("cn.sakura.sacrifice.dynamic.connecttest.cglibproxy.KafkaService")).getDeclaredMethods())[0];
    // 创建被代理类的方法的代理对象
    CGLIB$produce$0$Proxy = MethodProxy.create(var1, var0, "()Z", "produce", "CGLIB$produce$0");
    复制代码

**MethodProxy**是通过**MethodProxy**的**create()** 方法创建的，下面看一下**create()** 方法的实现。

publicclassMethodProxy {
    
        // 被代理对象的方法的签名，这里为produceprivate Signature sig1;
        // 代理对象中的方法的签名，这里叫CGLIB$produce$0，代理对象中有一个方法就叫做CGLIB$produce$0()// 通过CGLIB$produce$0()方法可以调用到代理对象的父对象（即被代理对象）的produce()方法private Signature sig2;
        // CreateInfo中保存着代理类KafkaService$$EnhancerByCGLIB$$b70fe9a2和被代理类KafkaService的Class对象private MethodProxy.CreateInfo createInfo;
    
        // ...publicstatic MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) {
            MethodProxyproxy=newMethodProxy();
            proxy.sig1 = newSignature(name1, desc);
            proxy.sig2 = newSignature(name2, desc);
            proxy.createInfo = newMethodProxy.CreateInfo(c1, c2);
            return proxy;
        }
    
        // ...
    
    }
    复制代码

**MethodProxy**的**create()** 方法就是创建一个**MethodProxy**对象出来并初始化其中的一些字段，**sig1**和**sig2**字段记录方法信息，**createInfo**字段记录代理类和被代理类的**Class**对象信息，这些都是为后面引入**FastClass**机制做准备。

现在回到**ConnectHelper**的**intercept()** 方法中，要调用被代理对象的方法，需要通过**MethodProxy**的**invokeSuper()** 方法，那么下面进入**invokeSuper()** 方法，分析一下怎么最终调用到被代理对象的方法。**invokeSuper()** 方法实现如下。

public Object invokeSuper(Object obj, Object[] args)throws Throwable {
        try {
            // 生成FastClassthis.init();
            // 获取FastClassInfo
            MethodProxy.FastClassInfofci=this.fastClassInfo;
            // 通过代理类对应的FastClass来执行方法return fci.f2.invoke(fci.i2, obj, args);
        } catch (InvocationTargetException var4) {
            throw var4.getTargetException();
        }
    }
    
    privatevoidinit() {
        if (this.fastClassInfo == null) {
            synchronized(this.initLock) {
                if (this.fastClassInfo == null) {
                    // CreateInfo中有方法签名以及代理类和被代理类的Class对象
                    MethodProxy.CreateInfoci=this.createInfo;
                    // 创建FastClassInfo，然后开始初始化字段
                    MethodProxy.FastClassInfofci=newMethodProxy.FastClassInfo();
                    // 创建被代理类对应的FastClasss并赋值给CreateInfo的f1字段
                    fci.f1 = helper(ci, ci.c1);
                    // 创建代理类对应的FastClass并赋值给CreateInfo的f2字段
                    fci.f2 = helper(ci, ci.c2);
                    // 计算produce在f1中的索引
                    fci.i1 = fci.f1.getIndex(this.sig1);
                    // 计算CGLIB$produce$0在f2中的索引
                    fci.i2 = fci.f2.getIndex(this.sig2);
                    this.fastClassInfo = fci;
                    this.createInfo = null;
                }
            }
        }
    }
    复制代码

在**invokeSuper()** 方法中会首先调用**init()** 方法，在**init()** 方法中会为代理类和被代理类生成**FastClass**，代理类对应的**FastClass**会为代理类的每个方法生成一个索引，同理被代理类对应的**FastClass**也会为被代理类的每个方法生成一个索引，然后会根据当前需要调用的方法的信息（代理类中需要被调用的方法名为CGLIB$produce$0，被代理类中需要被调用的方法名为**produce**），计算各自的方法在各自的**FastClass**中的索引，并赋值给**CreateInfo**的**f1**和**f2**字段。下图是**init()** 方法执行后，**MethodProxy**中的**CreateInfo**的值的情况。

![format_png 3][]

上图所示的**CreateInfo**表明被代理类**KafkaService**的**produce()** 方法在其对应的**FastClass**中的索引为0，代理类KafkaService$$EnhancerByCGLIB$$b70fe9a2的CGLIB$produce$0()方法在其对应的**FastClass**中的索引为18。那么这个索引有什么用呢，继续看**invokeSuper()** 的如第三行代码。

// f2是代理对象对应的FastClass// fci.i2是代理对象方法CGLIB$produce$0()在FastClass中的索引// obj是代理对象本身return fci.f2.invoke(fci.i2, obj, args);
    复制代码

所以在**invokeSuper()** 方法中就调用到了代理对象对应的**FastClass**的**invoke()** 方法，如下所示。

public Object invoke(int paramInt, Object paramObject, Object[] paramArrayOfObject)throws InvocationTargetException {
        try {
            switch (paramInt) {
                case0:
                // ...case18:
                    returnnewBoolean(((KafkaService$$EnhancerByCGLIB$$b70fe9a2)paramObject).CGLIB$produce$0());
                // ...case20:
                    KafkaService$$EnhancerByCGLIB$$b70fe9a2.CGLIB$STATICHOOK1();
                    returnnull;
            }
        } catch (Throwable throwable) {
            thrownewInvocationTargetException(null);
        }
        thrownewIllegalArgumentException("Cannot find matching method/constructor");
    }
    复制代码

所以到这里就可以看明白了，通过传入的代理对象**paramObject**和代理对象的方法索引**paramInt**，可以快速的调用到代理对象的CGLIB$produce$0()方法，而代理对象的CGLIB$produce$0()方法是下面这样。

finalboolean CGLIB$produce$0() {
        returnsuper.produce();
    }
    复制代码

所以最终就调用到了被代理对象的**produce()** 方法，而且这样的好处就在于通过方法索引的方式来调用能够比反射调用更快，这也就是**CGLIB**中采用**FastClass**机制来执行比**JDK**动态代理执行更快的原因。

### 总结 ###

--------------------

**CGLIB**中代理对象执行方法的流程可以总结如下。

1.  调用代理对象重写的**produce()** 方法；

1.  在代理对象的**produce()** 方法中调用到拦截器**MethodInterceptor**的**intercept()** 方法；

1.  在**MethodInterceptor**的**intercept()** 方法中调用到**MethodProxy**的**invokeSuper()** 方法；

1.  在**MethodProxy**的**invokeSuper()** 方法中调用到代理对象对应的**FastClass**的**invoke()** 方法；

1.  在代理对象对应的**FastClass**的**invoke()** 方法中调用到代理对象为**produce()** 方法生成的CGLIB$produce$0()方法；

1.  在代理对象的CGLIB$produce$0()方法中调用到被代理对象的**produce()** 方法。

那么**CGLIB**与**JDK**动态代理的区别可以概括如下。

1.  **JDK**动态代理类实现了被代理类的接口，**CGLIB**动态代理类继承了被代理类；

1.  **JDK**动态代理类和**CGLIB**动态代理都是在运行期生成字节码，并且**JDK**动态代理字节码生成快于**CGLIB**；

1.  **JDK**动态代理执行方法时是基于反射调用，而**CGLIB**动态代理执行方法时是基于**FastClass**机制，所以**CGLIB**执行效果更高。

还有几个常见问题。

1.  接口是否可以被代理。可以，比如**MyBatis**的映射接口。

1.  **CGLIB**的动态代理类，能不能再被**CGLIB**动态代理。不能，因为**CGLIB**动态代理类实现了**Factory**接口，如果再为**CGLIB**动态代理类生成动态代理类，在生成动态代理类时会报错，因为第二个动态代理类会重复实现**Factory**接口，这是不被允许的。

1.  **CGLIB**的动态代理类，能不能再被**JDK**动态代理。不能。

1.  **JDK**的动态代理类，能不能再被**CGLIB**动态代理。不能，因为**JDK**动态代理类是**final**类。

1.  **JDK**的动态代理类，能不能再被**JDK**动态代理。如果使用同一个**InvocationHandler**，则不能；否则，能。

[format_png]: https://img-blog.csdnimg.cn/img_convert/f7edb336083b8a3cf75f4ee714cdeca0.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/a3ade5e4745426c566406b5df292d92b.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/5ca17d0454da033d1c15e3ca154b43a5.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/98f4b326b4a0981c64ea299ff0059558.webp?x-oss-process=image/format,png