【Spring源码】AOP实现(1)--创建AopProxy代理对象

悠悠 2022-05-20 07:15 360阅读 0赞

# **前言** #

Github：[https://github.com/yihonglei/thinking-in-spring][https_github.com_yihonglei_thinking-in-spring]

关于AOP概念和AOP的实战：

[Spring使用注解 AOP实战][Spring_ AOP]

[Spring使用XML AOP实战][Spring_XML AOP]

本篇是以ProxyFactoryBean的配置来讲的，这个是最能体现AOP思想的一个配置方式，也是我们学习AOP一个入口。

# 一 设计原理 #

在Spring的AOP模块中，一个主要的部分就是AopProxy代理对象的生成，而对于Spring应用，可以看到，是通过配置

和调用Spring的ProxyFactoryBean来完成这个任务的。在ProxyFactoryBean中，封装了主要代理对象的生成过程。

在这个生成过程中，可以使用JDK的Proxy和CGLIB两种方式。

**关于代理模式和JDK、CGLIB动态代理参考：**

[代理模式][Link 1]

[JDK动态代理实现原理][JDK]

[CGLIB动态代理实现原理][CGLIB]

**以ProxyFactory的设计为中心，看下整个继承关系图：**

![70][]

在这个类继承关系图中，可以看到完成AOP应用的类，类说明：

**ProxyConfig：**

作为共同基类，可以看成是一个数据基类，这个数据基类为ProxyFactoryBean这样的子类提供了配置属性。

**AdvisedSupport：**

封装了AOP对通知和通知器的相关操作，这些操作对于不同的AOP的代理对象的生成都是一样的，但对于

具体的AOP代理对象的创建，AdvisedSupport把它交给它的子类们去完成。

**ProxyCreatorSupport：**

是其子类创建AOP代理对象的一个辅助类。

**AspectJProxyFactory：**

集成Spring和AspectJ的作用，适用于需要使用AspectJ的AOP应用。

**ProxyFactoryBean：**

Spring的AOP应用，可以在IOC中声明式配置。

**ProxyFactory：**

Spring的AOP应用，需要编程式使用。

# 二 配置ProxyFactoryBean #

在分析Spring AOP的实现原理中，主要以ProxyFactoryBean的实现作为例子和实现的基本线索进行分析。这是因为

ProxyFactoryBean是在Spring IOC环境中创建AOP最底层的方法，也是最灵活的方法，Spring通过它完成了对AOP使用

的封装。以ProxyFactoryBean为实现入口，逐层深入，是快速理解Spring AOP实现的学习路径。

在了解ProxyFactoryBean的实现之前，先了解ProxyFactoryBean的配置和使用，在基于XML配置Spring的Bean时

需要经历以下几个步骤：

1）定义使用的通知器Advisor，这个通知器应该作为一个Bean来定义。这个通知器实现了对目标对象进行增强的

切面行为，也就是Advice通知；

2）定义ProxyFactoryBean：interceptorNames是指定义的通知器，可以有多个；

3）定义target属性，需要增强的类，从源码上看只能有一个；

**Spring XML关于ProxyFactoryBean使用配置：**

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop.xsd">
        
        <bean name="conferenceService" class="com.jpeony.spring.ConferenceServiceImpl"></bean>
    
        
        <bean name="logAdvice" class="com.jpeony.spring.aop.LoggerAdvice"></bean>
    
        
        <bean name="aopMethod" class="org.springframework.aop.framework.ProxyFactoryBean">
            
            <property name="interceptorNames">
                <list>
                    <value>logAdvice</value>
                </list>
            </property>
            
            <property name="target" ref="conferenceService"/>
        </bean>
    
    </beans>

**定义通知器Advisor：**

package com.jpeony.spring.aop;
    
    import org.springframework.aop.MethodBeforeAdvice;
    
    import java.lang.reflect.Method;
    import java.util.Arrays;
    import java.util.Date;
    
    public class LoggerAdvice implements MethodBeforeAdvice{
    
        @Override
        public void before(Method method, Object[] args, Object target) throws Throwable {
            System.out.println("系统日志："+(new Date())+":"+"调用了"+method.getName()+" :使用了参数"+(Arrays.toString(args)));
        }
    }

**定义Target：**

package com.jpeony.spring;
    
    public interface ConferenceService {
        void conference();
    }

package com.jpeony.spring;
    
    public class ConferenceServiceImpl implements ConferenceService {
    
        @Override
        public void conference() {
            System.out.println("开会......");
        }
    
    }

**测试类：**

package com.jpeony.spring;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class TestAop {
    
        @Test
        public void testAop() {
            // 根据配置文件创建IOC容器
            ApplicationContext context =
                    new ClassPathXmlApplicationContext("applicationContext-aop.xml");
            // 从容器中获取Bean
            ConferenceService conferenceService = (ConferenceService) context.getBean("aopMethod");
            // 调用Bean方法
            conferenceService.conference();
        }
    
    }

**结果:**

![70 1][]

从打印结果，可以看到，成功对目标类实现了增强功能。

下面接着看ProxyFactoryBean是如何对Target对象起作用的，为何如此配置就能实现增强的效果。

# 三 ProxyFactoryBean生成AopProxy代理对象 #

在Spring AOP的使用中，我们已经了解到，可以通过ProxyFactoryBean来配置目标对象和切面行为。

这个ProxyFactoryBean是一个FactoryBean，关于FactoryBean和BeanFactory说明参考：

[FactoryBean和BeanFactory区别][FactoryBean_BeanFactory]。

在ProxyFactoryBean中，通过interceptorNames属性来配置已经定义好的通知器Advisor。

虽然名字叫interceptorNames，但实际上是提供AOP应用配置通知的地方。在ProxyFactoryBean中需要为

target目标对象生成Proxy代理对象，从而为AOP横切面的编织做好准备工作。

**AopProxy代理对象的生成过程：**

![70 2][]

从FactoryBean中获取对象，以getObject()方法作为入口完成的，ProxyFactoryBean需要实现FactoryBean中的

getObject()方法。对于ProxyFactoryBean来说，把需要对target目标对象增加的增强处理，都通过getObject()方法

进行封装，这些增强处理是为AOP功能实现提供服务的。

getObject()首先对通知链进行初始化，通知器链封装了一序列的拦截器，这些拦截器都要从序列中读取，然后为

代理对象的生成做好准备。在生成代理对象时，因为Spring中有singleton类型和prototype类型这两种不同的bean，

所以要对代理对象的生成做一个区分。ProxyFactoryBean的AOP实现需要依赖JDK或者CGLIB提供的Proxy特性。

**ProxyFactoryBean的类图：**

![70 3][]

**ProxyFactoryBean.getObject()方法源码：**

@Override
    public Object getObject() throws BeansException {
       // 通知器链进行初始化，通知器链封装了一序列的拦截器，这些拦截器都要从序列中读取，
       // 然后为代理对象的生成做好准备。
       initializeAdvisorChain();
       // 判断是singleton还是prototype属性，选择不同的AopProxy创建实现
       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();
       }
    }

**ProxyFactoryBean.****initializeAdvisorChain****()方法源码：**

private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {
       if (this.advisorChainInitialized) {
          return;
       }
    
       if (!ObjectUtils.isEmpty(this.interceptorNames)) {
          if (this.beanFactory == null) {
             throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) " +
                   "- cannot resolve interceptor names " + Arrays.asList(this.interceptorNames));
          }
    
          // Globals can't be last unless we specified a targetSource using the property...
          if (this.interceptorNames[this.interceptorNames.length - 1].endsWith(GLOBAL_SUFFIX) &&
                this.targetName == null && this.targetSource == EMPTY_TARGET_SOURCE) {
             throw new AopConfigException("Target required after globals");
          }
    
          // Materialize interceptor chain from bean names.
          // 这里添加Advisor链的调用，通过interceptorNames属性进行配置
          for (String name : this.interceptorNames) {
             if (logger.isTraceEnabled()) {
                logger.trace("Configuring advisor or advice '" + name + "'");
             }
    
             if (name.endsWith(GLOBAL_SUFFIX)) {
                if (!(this.beanFactory instanceof ListableBeanFactory)) {
                   throw new AopConfigException(
                         "Can only use global advisors or interceptors with a ListableBeanFactory");
                }
                addGlobalAdvisor((ListableBeanFactory) this.beanFactory,
                      name.substring(0, name.length() - GLOBAL_SUFFIX.length()));
             }
    
             else {
                // If we get here, we need to add a named interceptor.
                // We must check if it's a singleton or prototype.
                // 如果程序在这里被调用，那么需要加入命名的拦截器Advice，并且需要检查Bean是singleton还是prototype类型。
                Object advice;
                // singleton类型处理
                if (this.singleton || this.beanFactory.isSingleton(name)) {
                   // Add the real Advisor/Advice to the chain.
                   advice = this.beanFactory.getBean(name);
                }
                else {
                   // It's a prototype Advice or Advisor: replace with a prototype.
                   // Avoid unnecessary creation of prototype bean just for advisor chain initialization.
                  // prototype类型处理
                   advice = new PrototypePlaceholderAdvisor(name);
                }
                addAdvisorOnChainCreation(advice, name);
             }
          }
       }
    
       this.advisorChainInitialized = true;
    }

initializeAdvisorChain()方法为Proxy代理对象配置Advisor链。通过advisorChainInitialized来判断通知器链是否初始化。

如果已经初始化，就无需再初始化，直接返回；完成初始化之后，把从IOC容器中取得的通知器加入拦截器链中，

这个动作由addAdvisorOnChainCreation完成。

**接下来看ProxyFactoryBean.getSingletonInstance()方法源码：**

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.
             // 根据AOP框架来判断需要代理的接口
             Class<?> targetClass = getTargetClass();
             if (targetClass == null) {
                throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
             }
             // 设置代理对象的接口
             setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
          }
          // Initialize the shared singleton instance.
          super.setFrozen(this.freezeProxy);
          // 使用相应的动态代理技术生产AopProxy代理对象
          this.singletonInstance = getProxy(createAopProxy());
       }
       return this.singletonInstance;
    }

getSingletonInstance()这个方法是ProxyFactoryBean生成AopProxy代理对象的调用入口。代理对象会封装对target目标

对象的调用，也即是通过createAopProxy()返回代理对象。

**代理对象生成ProxyCreatorSupport.createAopProxy()方法源码：**

protected final synchronized AopProxy createAopProxy() {
       if (!this.active) {
          activate();
       }
       // 通过AopProxyFactory取得AopProxy，这个AopProxyFactory是在初始函数中定义的，使用DefaultAopProxyFactory。
       return getAopProxyFactory().createAopProxy(this);
    }

**具体对象生成在接口AopProxyFactory中的createAopProxy()，方法签名：**

AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException;

createAopProxy方法的具体实现在DefaultAopProxyFactory中实现。

**DefaultAopProxyFactory.createAopProxy()方法源码：**

@Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
       if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
          Class<?> targetClass = config.getTargetClass();
          // 如果targetClass是接口类，使用JDK来生成Proxy
          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() || Proxy.isProxyClass(targetClass)) {
             return new JdkDynamicAopProxy(config);
          }
          // 如果不是接口类，使用CGLIB生成Proxy
          return new ObjenesisCglibAopProxy(config);
       }
       else {
          return new JdkDynamicAopProxy(config);
       }
    }

该方法在AopProxy生成过程中，首先需要从AdvisedSupport对象中取得配置的目标对象，然后根据目标对象类型，

选择不同的代理对象生成方式。

关于AopProxy代理对象的生成，需要考虑使用哪种方式生成，如果目标对象是接口类，适合用JDK动态代理生成，

否则，适合用CGLIB动态代理生成。

# 四 JDK生成AopProxy代理对象 #

上面说过，AopProxy代理对象可以由JDK或CGLIB来生成，而JdkDynamicAopProxy和CglibAopProxy实现

都继承了AopProxy接口。

**AopProxy继承关系图：**

![70 4][]

这里主要讨论JdkDynamicAopProxy如何生成AopProxy代理对象的。

**先回顾一下ProxyFactoryBean.getSingletonInstance()方法源码：**

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");
             }
             setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
          }
          // Initialize the shared singleton instance.
          super.setFrozen(this.freezeProxy);
          this.singletonInstance = getProxy(createAopProxy());
       }
       return this.singletonInstance;
    }

在该法中有一个createAopProxy()，该方法具体实现在DefaultAopProxyFactory中。

**DefaultAopProxyFactory.createAopProxy()方法源码：**

该方法会返回一个JdkDynamicAopProxy或者CglibAopProxy对象，返回的对象会传入getProxy()方法中。

this.singletonInstance = getProxy(createAopProxy());

真正生成我们想要的AopProxy代理对象在getProxy()方法中完成。

**ProxyFactoryBean.getProxy()方法源码：**

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

getProxy()方法为AopProxy的一个接口方法，签名如下：

Object getProxy(ClassLoader classLoader);

上面说过，JdkDynamicAopProxy和CglibAopProxy为具体实现，这里讨论jdk，所以看下JdkDynamicAopProxy

中的实现。

**JdkDynamicAopProxy.getProxy()源码：**

@Override
    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, true);
       findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
       // 调用jdk生成proxy的地方
       return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }

生成代理对象时，需要指明三个参数，类加载器，代理接口，Proxy回调方法所在的对象。

# 五 CGLIB生成AopProxy代理对象 #

关于CGLIB生成代理对象直接看CglibAopProxy关于getProxy()方法的实现，前面流程与jdk生产代理对象一样。

**CglibAopProxy.getProxy()源码：**

@Override
    public Object getProxy(ClassLoader classLoader) {
       if (logger.isDebugEnabled()) {
          logger.debug("Creating CGLIB proxy: target source is " + this.advised.getTargetSource());
       }
       // 从advised中取得在IOC容器中配置的target对象
       try {
          Class<?> rootClass = this.advised.getTargetClass();
          Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");
    
          Class<?> proxySuperClass = rootClass;
          if (ClassUtils.isCglibProxyClass(rootClass)) {
             proxySuperClass = rootClass.getSuperclass();
             Class<?>[] additionalInterfaces = rootClass.getInterfaces();
             for (Class<?> additionalInterface : additionalInterfaces) {
                this.advised.addInterface(additionalInterface);
             }
          }
    
          // Validate the class, writing log messages as necessary.
          // 验证代理对象的接口设置
          validateClassIfNecessary(proxySuperClass, classLoader);
    
          // Configure CGLIB Enhancer...
          // 创建并配置Cglib的Enhancer，这个Enhancer对象是Cglib的主要操作类
          Enhancer enhancer = createEnhancer();
          if (classLoader != null) {
             enhancer.setClassLoader(classLoader);
             if (classLoader instanceof SmartClassLoader &&
                   ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
                enhancer.setUseCache(false);
             }
          }
          // 设置Enhancer对象，包括设置代理接口，回调方法
          // 来自advised的IOC容器配置
          enhancer.setSuperclass(proxySuperClass);
          enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
          enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
          enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));
    
          Callback[] callbacks = getCallbacks(rootClass);
          Class<?>[] types = new Class<?>[callbacks.length];
          for (int x = 0; x < types.length; x++) {
             types[x] = callbacks[x].getClass();
          }
          // fixedInterceptorMap only populated at this point, after getCallbacks call above
          enhancer.setCallbackFilter(new ProxyCallbackFilter(
                this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
          enhancer.setCallbackTypes(types);
    
          // Generate the proxy class and create a proxy instance.
          // 创建AopProxy代理对象
          return createProxyClassAndInstance(enhancer, callbacks);
       }
       catch (CodeGenerationException ex) {
          throw new AopConfigException("Could not generate CGLIB subclass of class [" +
                this.advised.getTargetClass() + "]: " +
                "Common causes of this problem include using a final class or a non-visible class",
                ex);
       }
       catch (IllegalArgumentException ex) {
          throw new AopConfigException("Could not generate CGLIB subclass of class [" +
                this.advised.getTargetClass() + "]: " +
                "Common causes of this problem include using a final class or a non-visible class",
                ex);
       }
       catch (Throwable ex) {
          // TargetSource.getTarget() failed
          throw new AopConfigException("Unexpected AOP exception", ex);
       }
    }

到这里，我们生产了代理对象，通过使用AopProxy对象封装target目标对象之后，

ProxyFactoryBean的getObject()方法得到的对象就不是一个普通的Java对象了，而是一个AopProxy的代理对象。

这个时候已经不会让应用直接调用target的方法实现了，而是先被AopProxy代理对象拦截，对于不同的AopProxy

代理对象的不同生成方法，拦截入口不同。比如：JDK使用的是InvocationHandler使用的是invoke入口，

而Cglib使用的是设置好的callback回调。

可以把AOP的实现部分看成是由基础设施准备和AOP运行辅助两个部分组成，这里讨论的AopProxy代理对象的生成，

可以看成是一个静态的AOP基础设施的建立过程。通过这个准备过程，把代理对象、拦截器(通知器)这些待调用的部分

都准备好，等待着AOP运行过程中对这些基础设施的使用。

对于应用触发的AOP应用，会涉及AOP框架的运行和对AOP基础设施的使用。这些动态的运行部分，是从前面提到

的拦截器的回调入口开始的，这些拦截器调用的实现原理，和AopProxy代理对象生成一样，也是AOP实现的重要组成

部分，下篇文章重点分析Spring AOP拦截器调用的实现原理。

# 参考文献 #

**1、《Spring技术内幕》**

**2、《Spring实战》**

**3、Spring官网API**

**4、Spring源码**

[https_github.com_yihonglei_thinking-in-spring]: https://github.com/yihonglei/thinking-in-spring
[Spring_ AOP]: https://blog.csdn.net/yhl_jxy/article/details/78815636
[Spring_XML AOP]: https://blog.csdn.net/yhl_jxy/article/details/78823746
[Link 1]: https://blog.csdn.net/yhl_jxy/article/details/52679882#t3
[JDK]: https://blog.csdn.net/yhl_jxy/article/details/80586785
[CGLIB]: https://blog.csdn.net/yhl_jxy/article/details/80633194
[70]: /images/20220520/f57a3a878c12413daa3cdfe08a2094d6.png
[70 1]: /images/20220520/215e891e949a43f9a32af8619358b086.png
[FactoryBean_BeanFactory]: https://blog.csdn.net/yhl_jxy/article/details/80991201
[70 2]: /images/20220520/5b9c9de5e32144d581f24377e6e97da8.png
[70 3]: /images/20220520/ff8b2313b71a45e2acda60ef31c5223a.png
[70 4]: /images/20220520/7652709ce05e4c04a3291e1a97dc900f.png