我们知道Spring是通过JDK或者CGLib实现动态代理的，今天我们讨论一下JDK实现动态代理的原理。

一、简述

Spring在解析Bean的定义之后会将Bean的定义生成一个BeanDefinition对象并且由BeanDefinitionHolder对象持有。在这个过程中，如果Bean需要被通知切入，BeanDefinition会被重新转换成一个proxyDefinition（其实也是一个BeanDefinition对象，只不过描述的是一个ProxyFactoryBean）。ProxyFactoryBean是一个实现了FactoryBean的接口，用来生成被被切入的对象。Spring AOP的实现基本上是通过ProxyFactoryBean实现的。我们今天讨论的重点也是这个类。

　　在讨论ProxyFactoryBean之前，我们先看一下一个BeanDefinition转换成proxyDefintion的过程。

public final BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definitionHolder, ParserContext parserContext) {        BeanDefinitionRegistry registry = parserContext.getRegistry();        // get the root bean name - will be the name of the generated proxy factory bean        String existingBeanName = definitionHolder.getBeanName();        BeanDefinition targetDefinition = definitionHolder.getBeanDefinition();        BeanDefinitionHolder targetHolder = new BeanDefinitionHolder(targetDefinition, existingBeanName + ".TARGET");        // delegate to subclass for interceptor definition        BeanDefinition interceptorDefinition = createInterceptorDefinition(node);        // generate name and register the interceptor        String interceptorName = existingBeanName + "." + getInterceptorNameSuffix(interceptorDefinition);        BeanDefinitionReaderUtils.registerBeanDefinition(                new BeanDefinitionHolder(interceptorDefinition, interceptorName), registry);        BeanDefinitionHolder result = definitionHolder;        if (!isProxyFactoryBeanDefinition(targetDefinition)) {            // create the proxy definition 这里创建proxyDefinition对象，并且从原来的BeanDefinition对象中复制属性            RootBeanDefinition proxyDefinition = new RootBeanDefinition();            // create proxy factory bean definition            proxyDefinition.setBeanClass(ProxyFactoryBean.class);            proxyDefinition.setScope(targetDefinition.getScope());            proxyDefinition.setLazyInit(targetDefinition.isLazyInit());            // set the target            proxyDefinition.setDecoratedDefinition(targetHolder);            proxyDefinition.getPropertyValues().add("target", targetHolder);            // create the interceptor names list            proxyDefinition.getPropertyValues().add("interceptorNames", new ManagedList
    
     ());            // copy autowire settings from original bean definition.            proxyDefinition.setAutowireCandidate(targetDefinition.isAutowireCandidate());            proxyDefinition.setPrimary(targetDefinition.isPrimary());            if (targetDefinition instanceof AbstractBeanDefinition) {                proxyDefinition.copyQualifiersFrom((AbstractBeanDefinition) targetDefinition);            }            // wrap it in a BeanDefinitionHolder with bean name            result = new BeanDefinitionHolder(proxyDefinition, existingBeanName);        }        addInterceptorNameToList(interceptorName, result.getBeanDefinition());        return result;    }
    

二、ProxyFactoryBean的原理

我们先来看一下ProxyFactoryBean的继承关系：

ProxyFactoryBean实现了FactoryBean、BeanClassLoaderAware、BeanFactoryAware接口，这里就不多说了。ProxyCreatorSupport这个类则是创建代理对象的关键所在。　　我们先来看看产生代理对象的方法：

public Object getObject() throws BeansException {        initializeAdvisorChain();        if (isSingleton()) {                        //单例            return getSingletonInstance();        }        else {            if (this.targetName == null) {                logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +                        "Enable prototype proxies by setting the 'targetName' property.");            }                        //非单例            return newPrototypeInstance();        }    }

initializeAdvisorChain() 方法是将通知链实例化。然后判断对象是否要生成单例而选择调用不同的方法，这里我们只看生成单例对象的方法。

private synchronized Object getSingletonInstance() {        if (this.singletonInstance == null) {            this.targetSource = freshTargetSource();                        //如果以接口的方式代理对象            if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {                // Rely on AOP infrastructure to tell us what interfaces to proxy.                Class
     targetClass = getTargetClass();                if (targetClass == null) {                    throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");                }                      //获取目标类实现的所有接口，并注册给父类的interfaces属性，为jdk动态代理做准备                setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));            }            // Initialize the shared singleton instance.            super.setFrozen(this.freezeProxy);                   //这里产生代理对象            this.singletonInstance = getProxy(createAopProxy());        }        return this.singletonInstance;    }

我们可以看到，产生代理对象是通过getProxy()方法实现的，这个方法我们看一下：

protected Object getProxy(AopProxy aopProxy) {        return aopProxy.getProxy(this.proxyClassLoader);    }

AopProxy对象的getProxy()方法产生我们需要的代理对象，究竟AopProxy这个类是什么，我们接下来先看一下产生这个对象的方法createAopProxy()：

protected final synchronized AopProxy createAopProxy() {        if (!this.active) {            activate();        }        return getAopProxyFactory().createAopProxy(this);    }createAopProxy方法：    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {                //目标对象不是接口类的实现或者没有提供代理接口        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {            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.");            }              //代理对象自身是接口            if (targetClass.isInterface()) {                return new JdkDynamicAopProxy(config);            }            return new ObjenesisCglibAopProxy(config);        }        else {            return new JdkDynamicAopProxy(config);        }    }

在这里我们只看JdkDynamicAopProxy这个类的实现，我们前面提到，真正代理对象的生成是由AopProxy的getProxy方法完成的，这里我们看一下JdkDynamicAopProxy的getProxy方法，这也是本文讨论的重点：

public Object getProxy(ClassLoader classLoader) {        if (logger.isDebugEnabled()) {            logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());        }        Class
    [] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);        findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);    }

我们看可以很清楚的看到，代理对象的生成直接使用了jdk动态代理:Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);而代理逻辑是通过实现了InvocationHandler接口的invoke方法实现的。而这里用到的实现了InvocationHandler接口的类就是JdkDynamicAopProxy自身。JdkDynamicAopProxy自身实现了InvocationHandler接口，完成了Spring AOP拦截器链拦截等一系列逻辑，我们看一下JdkDynamicAopProxy的invoke方法的具体实现：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        MethodInvocation invocation;        Object oldProxy = null;        boolean setProxyContext = false;        TargetSource targetSource = this.advised.targetSource;        Class
     targetClass = null;        Object target = null;        try {            //没有重写equals方法            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {                // The target does not implement the equals(Object) method itself.                return equals(args[0]);            }            //没有重写hashCode方法            if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {                // The target does not implement the hashCode() method itself.                return hashCode();            }          //代理的类是Advised，这里直接执行，不做任何代理            if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&                    method.getDeclaringClass().isAssignableFrom(Advised.class)) {                // Service invocations on ProxyConfig with the proxy config...                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);            }            Object retVal;            if (this.advised.exposeProxy) {                // Make invocation available if necessary.                oldProxy = AopContext.setCurrentProxy(proxy);                setProxyContext = true;            }            // May be null. Get as late as possible to minimize the time we "own" the target,            // in case it comes from a pool.            //获得代理对象            target = targetSource.getTarget();            if (target != null) {                targetClass = target.getClass();            }            // Get the interception chain for this method.            //获得已经定义的拦截器链            List

拦截器链的调用

从上面的代码和注释中我们可以看到spring实现aop的主要流程，具体如何调用拦截器链，我们来看一下MethodInvocation的proceed方法

public Object proceed() throws Throwable {        //  We start with an index of -1 and increment early.        //   currentInterceptorIndex是从-1开始的，所以拦截器链调用结束的时候index是 this.interceptorsAndDynamicMethodMatchers.size() - 1        //  调用链结束后执行目标方法        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {            return invokeJoinpoint();        }        //  获得当前处理到的拦截器        Object interceptorOrInterceptionAdvice =                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);        //  这里判断是否是InterceptorAndDynamicMethodMatcher，如果是，这要判断是否匹配methodMatcher，不匹配则此拦截器不生效        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {            // Evaluate dynamic method matcher here: static part will already have            // been evaluated and found to match.            InterceptorAndDynamicMethodMatcher dm =                    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;            if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {                return dm.interceptor.invoke(this);            }            else {                // Dynamic matching failed.                // Skip this interceptor and invoke the next in the chain.                return proceed();            }        }        else {            // It's an interceptor, so we just invoke it: The pointcut will have            // been evaluated statically before this object was constructed.            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);        }    }

proceed()方法是一个递归方法，我们可以根据代码的注释知道大体逻辑，InterceptorAndDynamicMethodMatcher的代码如下，我们可以看到，InterceptorAndDynamicMethodMatcher 持有一个MethodInterceptor 对象和一个MethodMatcher 对象，在拦截器链调用过程中，如果拦截器是InterceptorAndDynamicMethodMatcher ，则会先根据MethodMatcher 判断是否匹配，匹配MethodInterceptor 才会生效。

class InterceptorAndDynamicMethodMatcher {    final MethodInterceptor interceptor;    final MethodMatcher methodMatcher;    public InterceptorAndDynamicMethodMatcher(MethodInterceptor interceptor, MethodMatcher methodMatcher) {        this.interceptor = interceptor;        this.methodMatcher = methodMatcher;    }}

至于MethodInterceptor 是什么，MethodInterceptor 的逻辑是怎么样的，我们可以看一下MethodInterceptor 的一个子类AfterReturningAdviceInterceptor的实现：

public class AfterReturningAdviceInterceptor implements MethodInterceptor, AfterAdvice, Serializable {    private final AfterReturningAdvice advice;    /**     * Create a new AfterReturningAdviceInterceptor for the given advice.     * @param advice the AfterReturningAdvice to wrap     */    public AfterReturningAdviceInterceptor(AfterReturningAdvice advice) {        Assert.notNull(advice, "Advice must not be null");        this.advice = advice;    }    @Override    public Object invoke(MethodInvocation mi) throws Throwable {        Object retVal = mi.proceed();        this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());        return retVal;    }}

AfterReturningAdviceInterceptor的作用是在被代理的方法返回结果之后添加我们需要的处理逻辑，其实现方式我们可以看到，先调用MethodInvocation 的proceed，也就是先继续处理拦截器链，等调用完成后执行我们需要的逻辑：this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());

到这里，spring使用jdk动态代理实现aop的分析基本上结束，其中拦截器链的调用比较难懂而且比较重要，需要的同学可以多看看这一块。最后，欢迎做Java的工程师朋友们加入Java高级架构；603619042

群内有技术大咖指点难题，还提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料）

比你优秀的对手在学习，你的仇人在磨刀，你的闺蜜在减肥，隔壁老王在练腰， 我们必须不断学习，否则我们将被学习者超越！

趁年轻，使劲拼，给未来的自己一个交代！