深入学习SpringAOP源码（三）——揭开JDK动态代理和CGLIB代理的神秘面纱

前言

版本：【Spring 5.1.4】、【SpringAOP 5.1.4】

经过前两个章节的介绍，已经了解了Spring是如何注册解析AnnotationAwareAspectJAutoProxyCreator，然后AnnotationAwareAspectJAutoProxyCreator又是如何解析通知、创建代理，创建代理的目的又是什么呢？那么接下来本片文章将从深入解析源码的方式并借以《深入学习SpringAOP源码（一）》里Demo为例，来揭开JDK动态代理和CGLIB代理。

深入学习SpringAOP源码（一）——注册AnnotationAwareAspectJAutoProxyCreator
深入学习SpringAOP源码（二）—— 深入AnnotationAwareAspectJAutoProxyCreator

正文

1. CGLIB动态代理

1.1 引入简单的CGLIB例子

在讲解CGLIB动态代理之前，先看一下最简单的CGLIB动态代理的例子。

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class EnhancerDemo {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(EnhancerDemo.class);
        enhancer.setCallback(new MethodInterceptorImpl());
        EnhancerDemo demo = (EnhancerDemo) enhancer.create();
        demo.test();
        System.out.println(demo);
    }
    
    public void test() {
        System.out.println("EnhancerDemo test()");
    }
    
    private static class MethodInterceptorImpl implements MethodInterceptor {
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.err.println("Before invoke " + method);
            Object result = methodProxy.invokeSuper(o, objects);
            System.err.println("After invoke" + method);
            return result;
        }
    }
}

运行结果如下：

EnhancerDemo test()
After invokepublic void com.bruis.learnaop.testcglibaop.EnhancerDemo.test()
Before invoke public java.lang.String java.lang.Object.toString()
Before invoke public native int java.lang.Object.hashCode()
After invokepublic native int java.lang.Object.hashCode()
After invokepublic java.lang.String java.lang.Object.toString()
com.bruis.learnaop.testcglibaop.EnhancerDemo$$EnhancerByCGLIB$$413eae0d@53e25b76

可以看到运行结果，除了demo.test()方法之外，System.our.println(demo)也被代理了，首先调用了toString()方法，然后又调用了hashCode，生成的对象为EnhancerDemo的实例，这个类是运行时由CGLIB产生的，Enhancer最关键的步骤就是setCallback()方法来设置拦截器，来拦截代理类的方法。Demo中用到的Enhancer是CGLIB的字节码增强器，用于为无接口的类创建代理proxy，方便对代理类进行拓展，Demo中的代理类就是EnhancerDemo。它的功能与java自带的Proxy类挺相似的，它会根据某个给定的类创建子类，并且非final的方法都带有回调方法。

创建代理对象的几个步骤：

• 生成代理类的二进制字节码文件
• 加载二进制字节码，生成Class对象（例如使用Class.forName()方法）
• 通过反射机制获取实例构造，并创建代理类对象

具体可以查看Enhancer create()源码方法。

1.2 深入代理逻辑源码

先用一张流程图来大致浏览下整个CGLIB的代码逻辑

回到SpringAOP源码。在《深入学习SpringAOP源码（二）》中，介绍到DefaultAopProxyFactory源码部分

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
            return new JdkDynamicAopProxy(config);
        } else {
            Class targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: Either an interface or a target is required for proxy creation.");
            } else {
                return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
            }
        }
    }
}

从createAopProxy()源码中可以看到，创建SpringAOP有两种方式，一、JDK动态代理；二、CGLIB动态代理；点进ObjenesisCglibAopProxy源码，发现它继承了CglibAopFactory

class ObjenesisCglibAopProxy extends CglibAopProxy {
    protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
        // 通过增强器获取代理类的class对象
        Class proxyClass = enhancer.createClass();
        Object proxyInstance = null;
        if (objenesis.isWorthTrying()) {
            try {
                // 创建代理类实例对象
                proxyInstance = objenesis.newInstance(proxyClass, enhancer.getUseCache());
            } catch (Throwable var7) {
                logger.debug("Unable to instantiate proxy using Objenesis, falling back to regular proxy construction", var7);
            }
        }

        if (proxyInstance == null) {
            try {
                Constructor ctor = this.constructorArgs != null ? proxyClass.getDeclaredConstructor(this.constructorArgTypes) : proxyClass.getDeclaredConstructor();
                ReflectionUtils.makeAccessible(ctor);
                proxyInstance = this.constructorArgs != null ? ctor.newInstance(this.constructorArgs) : ctor.newInstance();
            } catch (Throwable var6) {
                throw new AopConfigException("Unable to instantiate proxy using Objenesis, and regular proxy instantiation via default constructor fails as well", var6);
            }
        }

        // 为代理类实例创建回调方法（拦截器链）
        ((Factory)proxyInstance).setCallbacks(callbacks);
        return proxyInstance;
    }
}

createProxyClassAndInstance方法和前面总结的CGLIB创建代理的步骤一样。

继续查看CglibAopProxy是如何准备Enhancer增强器以及创建拦截器链的。

class CglibAopProxy implements AopProxy, Serializable {
    public Object getProxy(@Nullable ClassLoader classLoader) {
        if (logger.isTraceEnabled()) {
            logger.trace("Creating CGLIB proxy: " + this.advised.getTargetSource());
        }

        try {
            // 获取目标代理类
            Class rootClass = this.advised.getTargetClass();
            Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");
            Class proxySuperClass = rootClass;
            int x;
            if (ClassUtils.isCglibProxyClass(rootClass)) {
                proxySuperClass = rootClass.getSuperclass();
                Class[] additionalInterfaces = rootClass.getInterfaces();
                Class[] var5 = additionalInterfaces;
                int var6 = additionalInterfaces.length;

                for(x = 0; x < var6; ++x) {
                    Class additionalInterface = var5[x];
                    this.advised.addInterface(additionalInterface);
                }
            }
            // 验证class
            this.validateClassIfNecessary(proxySuperClass, classLoader);
            // 获取增强器
            Enhancer enhancer = this.createEnhancer();
            // 为Enhancer设置类加载器
            if (classLoader != null) {
                enhancer.setClassLoader(classLoader);
                if (classLoader instanceof SmartClassLoader && ((SmartClassLoader)classLoader).isClassReloadable(proxySuperClass)) {
                    enhancer.setUseCache(false);
                }
            }

            // 设置代理类，这一步很关键哦。
            enhancer.setSuperclass(proxySuperClass);
            enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
            enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
            // 设置strategy策略器
            enhancer.setStrategy(new CglibAopProxy.ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));
            Callback[] callbacks = this.getCallbacks(rootClass);
            Class[] types = new Class[callbacks.length];

            for(x = 0; x < types.length; ++x) {
                types[x] = callbacks[x].getClass();
            }
            // 设置回调过滤器
            enhancer.setCallbackFilter(new CglibAopProxy.ProxyCallbackFilter(this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
            enhancer.setCallbackTypes(types);
            // 创建代理类实例，调用子类的createProxyClassAndInstance()方法
            return this.createProxyClassAndInstance(enhancer, callbacks);
        } catch (IllegalArgumentException | CodeGenerationException var9) {
            throw new AopConfigException("Could not generate CGLIB subclass of " + this.advised.getTargetClass() + ": Common causes of this problem include using a final class or a non-visible class", var9);
        } catch (Throwable var10) {
            throw new AopConfigException("Unexpected AOP exception", var10);
        }
    }
    
    // 获取回调方法
    private Callback[] getCallbacks(Class rootClass) throws Exception {
        // 获取expose-proxy属性设置
        boolean exposeProxy = this.advised.isExposeProxy();
        boolean isFrozen = this.advised.isFrozen();
        boolean isStatic = this.advised.getTargetSource().isStatic();
        // 将aop拦截器封装在DynamicAdvisedInterceptor中
        Callback aopInterceptor = new CglibAopProxy.DynamicAdvisedInterceptor(this.advised);
        Object targetInterceptor;
     
        if (exposeProxy) {
            targetInterceptor = isStatic ? new CglibAopProxy.StaticUnadvisedExposedInterceptor(this.advised.getTargetSource().getTarget()) : new CglibAopProxy.DynamicUnadvisedExposedInterceptor(this.advised.getTargetSource());
        } else {
            targetInterceptor = isStatic ? new CglibAopProxy.StaticUnadvisedInterceptor(this.advised.getTargetSource().getTarget()) : new CglibAopProxy.DynamicUnadvisedInterceptor(this.advised.getTargetSource());
        }

        Callback targetDispatcher = isStatic ? new CglibAopProxy.StaticDispatcher(this.advised.getTargetSource().getTarget()) : new CglibAopProxy.SerializableNoOp();
        // 添加主要的拦截器链
        Callback[] mainCallbacks = new Callback[]{aopInterceptor, (Callback)targetInterceptor, new CglibAopProxy.SerializableNoOp(), (Callback)targetDispatcher, this.advisedDispatcher, new CglibAopProxy.EqualsInterceptor(this.advised), new CglibAopProxy.HashCodeInterceptor(this.advised)};
        Callback[] callbacks;
        if (isStatic && isFrozen) {
            Method[] methods = rootClass.getMethods();
            Callback[] fixedCallbacks = new Callback[methods.length];
            this.fixedInterceptorMap = new HashMap(methods.length);

            for(int x = 0; x < methods.length; ++x) {
                List