Spring注解驱动开发（四）-源码解析AOP原理

发表于 | 分类于 | |

Spring AOP 基础

AOP：【动态代理】
指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式；

实现Spring AOP三部曲：

  1. 将业务逻辑组件和切面类都加入到容器中；告诉Spring哪个是切面类（@Aspect）

  2. 在切面类上的每一个通知方法上标注通知注解，告诉Spring何时何地运行（切入点表达式）

    1
    2
    3
    4
    5
    6
    通知方法：
    前置通知(@Before)：logStart：在目标方法运行之前运行
    后置通知(@After)：logEnd：在目标方法运行结束之后运行（无论方法正常结束还是异常结束）
    返回通知(@AfterReturning)：logReturn：在目标方法正常返回之后运行
    异常通知(@AfterThrowing)：logException：在目标方法出现异常以后运行
    环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）

  3. 开启基于注解的aop模式；@EnableAspectJAutoProxy

下文为Spring AOP源码解析

1.@EnableAspectJAutoProxy是什么？

AOP原理：【以@EnableAspectJAutoProxy为入口分析，看给容器中注册了什么组件？这个组件什么时候工作？这个组件的功能是什么？】

  • @Import(AspectJAutoProxyRegistrar.class)：给容器中导入AspectJAutoProxyRegistrar
1
2
3
4
5
6
7
8
9
10
11
package org.springframework.context.annotation;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({AspectJAutoProxyRegistrar.class})
public @interface EnableAspectJAutoProxy {
    boolean proxyTargetClass() default false;

    boolean exposeProxy() default false;
}
  • 因为AspectJAutoProxyRegistrar实现了ImportBeanDefinitionRegistrar接口，ImportBeanDefinitionRegistrar接口我们在前面Bean注册时曾提过，实现该接口可以允许自定义给容器中注册Bean。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
    AspectJAutoProxyRegistrar() {
    }

    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
        AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
            AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
        }

        if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
            AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
        }

    }
}

总结：利用AspectJAutoProxyRegistrar自定义给容器中注册bean；BeanDefinetion定义信息为
internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator

1544966035065

总结：给容器中注册一个AnnotationAwareAspectJAutoProxyCreator；

2AnnotationAwareAspectJAutoProxyCreator

2.1 AnnotationAwareAspectJAutoProxyCreator 的继承关系

AnnotationAwareAspectJAutoProxyCreator
->AspectJAwareAdvisorAutoProxyCreator
->AbstractAdvisorAutoProxyCreator
->AbstractAutoProxyCreator
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
总结：关注SmartInstantiationAwareBeanPostProcessor后置处理器（在bean初始化完成前后做事情）、BeanFactoryAware自动装配BeanFactory

1544966392400

2.2 注册AnnotationAwareAspectJAutoProxyCreator

着重关注如下几个类的方法，了解创建和注册AnnotationAwareAspectJAutoProxyCreator的过程

1
2
3
4
AbstractAutoProxyCreator.setBeanFactory()
AbstractAutoProxyCreator.有后置处理器的逻辑；
AbstractAdvisorAutoProxyCreator.setBeanFactory()-》initBeanFactory()
AnnotationAwareAspectJAutoProxyCreator.initBeanFactory()

以下是创建和注册AnnotationAwareAspectJAutoProxyCreator的过程

2.2.1 容器准备工作

  • 1）、传入配置类，创建ioc容器
  • 2）、注册配置类，调用refresh（）刷新容器；
1
2
3
4
5
public AnnotationConfigApplicationContext(Class... annotatedClasses) {
    this();
    this.register(annotatedClasses);
    this.refresh();
}
  • 3）、registerBeanPostProcessors(beanFactory);注册bean的后置处理器来方便拦截bean的创建；

1544967723945

2.2.2 registerBeanPostProcessors(beanFactory) 流程

  • 1）、先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor

1544969617607

  • 2）、给容器中加别的BeanPostProcessor
  • 3）、优先注册实现了PriorityOrdered接口的BeanPostProcessor；
1
2
3
// First, register the BeanPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
  • 4）、再给容器中注册实现了Ordered接口的BeanPostProcessor；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Next, register the BeanPostProcessors that implement Ordered.
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : orderedPostProcessorNames) {
    BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
    orderedPostProcessors.add(pp);
    if (pp instanceof MergedBeanDefinitionPostProcessor) {
        internalPostProcessors.add(pp);
    }
}
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);

//其中AbstractAutoProxyCreator 实现了Order接口，就是通过此时注册的
AbstractAutoProxyCreator extends ProxyProcessorSupport 
ProxyProcessorSupport extends ProxyConfig implements Ordered

    • （a） BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);

      1
      2
      3
      4
      5
      public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
      @Override
          public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
              return doGetBean(name, requiredType, null, false);
          }

    • （b）然而IOC容器中第一次不会存在该bean,尝试创建Bean

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory
      // Create bean instance.
      if (mbd.isSingleton()) {
      	//获取单实例bean为空，尝试createBean
          sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
              @Override
              public Object getObject() throws BeansException {
                  try {
                      return createBean(beanName, mbd, args);
                  }
                  catch (BeansException ex) {
                      // Explicitly remove instance from singleton cache: It might have been put there
                      // eagerly by the creation process, to allow for circular reference resolution.
                      // Also remove any beans that received a temporary reference to the bean.
                      destroySingleton(beanName);
                      throw ex;
                  }
              }
          });
          bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
      }
    • （c）执行createBean:481, AbstractAutowireCapableBeanFactory 和doCreateBean:553, AbstractAutowireCapableBeanFactory
    • （d）initializeBean:1618, AbstractAutowireCapableBeanFactory 详细initializeBean过程见（6）

  • 5）、注册没实现优先级接口的BeanPostProcessor；

1
2
3
4
5
6
// Now, register all regular BeanPostProcessors.
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

// Finally, re-register all internal BeanPostProcessors.
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);

  • 6）、注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象，保存在容器中；

    • 创建internalAutoProxyCreator的BeanPostProcessor【(类型为)AnnotationAwareAspectJAutoProxyCreator】
    • 1）、创建Bean的实例 doCreateBean（）553, AbstractAutowireCapableBeanFactory
    • 2）、populateBean；给bean的各种属性赋值

    1544970821277

    • 3）、initializeBean：初始化bean；

      • 1）、invokeAwareMethods()：处理Aware接口的方法回调
      • 2）、applyBeanPostProcessorsBeforeInitialization()：应用后置处理器的postProcessBeforeInitialization（）
      • 3）、invokeInitMethods()；执行自定义的初始化方法
      • 4）、applyBeanPostProcessorsAfterInitialization()；执行后置处理器的postProcessAfterInitialization（）；
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
          if (System.getSecurityManager() != null) {
              AccessController.doPrivileged(new PrivilegedAction<Object>() {
                  @Override
                  public Object run() {
                      invokeAwareMethods(beanName, bean);
                      return null;
                  }
              }, getAccessControlContext());
          }
          else {
              invokeAwareMethods(beanName, bean);
          }

          Object wrappedBean = bean;
          if (mbd == null || !mbd.isSynthetic()) {
              wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
          }

          try {
              invokeInitMethods(beanName, wrappedBean, mbd);
          }
          catch (Throwable ex) {
              throw new BeanCreationException(
                  (mbd != null ? mbd.getResourceDescription() : null),
                  beanName, "Invocation of init method failed", ex);
          }
          if (mbd == null || !mbd.isSynthetic()) {
              wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
          }
          return wrappedBean;
      }

    • 4）、BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功；–>aspectJAdvisorsBuilder

      1
      2
      3
      4
      5
      6
      7
      8
      protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
          super.initBeanFactory(beanFactory);
          if (this.aspectJAdvisorFactory == null) {
              this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
          }

          this.aspectJAdvisorsBuilder = new AnnotationAwareAspectJAutoProxyCreator.BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
      }

  • 7）、把BeanPostProcessor注册到BeanFactory中；registerBeanPostProcessors(beanFactory, internalPostProcessors);

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    /**
    	 * Register the given BeanPostProcessor beans.
    	 */
    private static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {

        for (BeanPostProcessor postProcessor : postProcessors) {
            beanFactory.addBeanPostProcessor(postProcessor);
        }
    }

2.2.3 创建和注册AnnotationAwareAspectJAutoProxyCreator的过程总结

流程总结：

  • 1）、先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor

  • 2）、给容器中加别的BeanPostProcessor

  • 3）、优先注册实现了PriorityOrdered接口的BeanPostProcessor；

  • 4）、再给容器中注册实现了Ordered接口的BeanPostProcessor；

  • 5）、注册没实现优先级接口的BeanPostProcessor；

  • 6）、注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象，保存在容器中；

    • 创建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】
    • 1）、创建Bean的实例
    • 2）、populateBean；给bean的各种属性赋值
    • 3）、initializeBean：初始化bean；
      • 1）、invokeAwareMethods()：处理Aware接口的方法回调
      • 2）、applyBeanPostProcessorsBeforeInitialization()：应用后置处理器的postProcessBeforeInitialization（）
      • 3）、invokeInitMethods()；执行自定义的初始化方法
      • 4）、applyBeanPostProcessorsAfterInitialization()；执行后置处理器的postProcessAfterInitialization（）；
    • 4）、BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功；–>aspectJAdvisorsBuilder

  • 7）、把BeanPostProcessor注册到BeanFactory中；beanFactory.addBeanPostProcessor(postProcessor);

2.3 AnnotationAwareAspectJAutoProxyCreator执行时机

finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作；创建剩下的单实例bean

  • 1）、遍历获取容器中所有的Bean，依次创建对象getBean(beanName);
    ​ getBean->doGetBean()->getSingleton()->

  • 2）、创建bean
    【AnnotationAwareAspectJAutoProxyCreator在所有bean创建之前会有一个拦截，InstantiationAwareBeanPostProcessor，会调用postProcessBeforeInstantiation()】

    • 1）、先从缓存中获取当前bean，如果能获取到，说明bean是之前被创建过的，直接使用，否则再创建；只要创建好的Bean都会被缓存起来；

    • 2）、createBean（）;创建bean；
      AnnotationAwareAspectJAutoProxyCreator 会在任何bean创建之前先尝试返回bean的实例

      • 1）、resolveBeforeInstantiation(beanName, mbdToUse);解析BeforeInstantiation希望后置处理器在此能返回一个代理对象；后置处理器先尝试返回对象；如果能返回代理对象就使用，如果不能就继续执行第二步doCreateBean().

        • 拿到所有后置处理器，如果是InstantiationAwareBeanPostProcessor;就执行postProcessBeforeInstantiation
        1
        2
        3
        4
        bean = applyBeanPostProcessorsBeforeInstantiation（）：
        if (bean != null) {
        	 bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
        }

      • 2）、doCreateBean(beanName, mbdToUse, args);真正的去创建一个bean实例；和3.6流程一样；

2.3.1后置处理器区别

  • BeanPostProcessor是在Bean对象创建完成初始化前后调用的
  • InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回对象的】

2.4 InstantiationAwareBeanPostProcessor的作用

2.4.1 postProcessBeforeInstantiation

  • 1）、每一个bean创建之前，调用postProcessBeforeInstantiation()；
    • 1）、判断当前bean是否在advisedBeans中（保存了所有需要增强bean）
    • 2）、判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean，或者是否是切面（@Aspect）
    • 3）、是否需要跳过
      • 1）、获取候选的增强器（切面里面的通知方法）【List candidateAdvisors】，每一个封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor；判断每一个增强器是否是 AspectJPointcutAdvisor 类型的；返回true
      • 2）、永远返回false

2.4.2 postProcessAfterInitialization

  • 2）、创建对象 postProcessAfterInitialization；

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    return wrapIfNecessary(bean, beanName, cacheKey);//包装如果需要的情况下
    1）、获取当前bean的所有增强器（通知方法）  Object[]  specificInterceptors
    	1、找到候选的所有的增强器（找哪些通知方法是需要切入当前bean方法的）
    	2、获取到能在bean使用的增强器。
    	3、给增强器排序
    2）、保存当前bean在advisedBeans中；
    3）、如果当前bean需要增强，创建当前bean的代理对象；
    	1）、获取所有增强器（通知方法）
    	2）、保存到proxyFactory
    	3）、创建代理对象：Spring自动决定
    		JdkDynamicAopProxy(config);jdk动态代理；
    		ObjenesisCglibAopProxy(config);cglib的动态代理；
    4）、给容器中返回当前组件使用cglib增强了的代理对象；
    5）、以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程；

2.4.3 目标方法执行

3）、目标方法执行 ；
​ 容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存了详细信息（比如增强器，目标对象，xxx）；

  • 1）、CglibAopProxy.intercept();拦截目标方法的执行
  • 2）、根据ProxyFactory对象获取将要执行的目标方法拦截器链；
    List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
    • 1）、List interceptorList保存所有拦截器 5
      一个默认的ExposeInvocationInterceptor 和 4个增强器；
    • 2）、遍历所有的增强器，将其转为Interceptor；
      registry.getInterceptors(advisor);
    • 3）、将增强器转为List；
      如果是MethodInterceptor，直接加入到集合中
      如果不是，使用AdvisorAdapter将增强器转为MethodInterceptor；
      转换完成返回MethodInterceptor数组；

  • 3）、如果没有拦截器链，直接执行目标方法;

    拦截器链（每一个通知方法又被包装为方法拦截器，利用MethodInterceptor机制）

  • 4）、如果有拦截器链，把需要执行的目标对象，目标方法，

    拦截器链等信息传入创建一个 CglibMethodInvocation 对象，

    并调用 Object retVal = mi.proceed();

  • 5）、拦截器链的触发过程;

    • 1)、如果没有拦截器执行执行目标方法，或者拦截器的索引和拦截器数组-1大小一样（指定到了最后一个拦截器）执行目标方法；
    • 2)、链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行；拦截器链的机制，保证通知方法与目标方法的执行顺序；

2.4.3.1 拦截器链

1544974697813

3. Spring AOP 源码解析总结

总结：

  • 1）、 @Enabl eAspectJAutoProxy 开启AOP功能

  • 2）、 @EnableAspectJAutoProxy 会给容器中注册一个组件 AnnotationAwareAspectJAutoProxyCreator

  • 3）、AnnotationAwareAspectJAutoProxyCreator是一个后置处理器；

  • 4）、容器的创建流程：

    • 1）、registerBeanPostProcessors（）注册后置处理器；创建AnnotationAwareAspectJAutoProxyCreator对象

    • 2）、finishBeanFactoryInitialization（）初始化剩下的单实例bean

      • 1）、创建业务逻辑组件和切面组件

      • 2）、AnnotationAwareAspectJAutoProxyCreator拦截组件的创建过程

      • 3）、组件创建完之后，判断组件是否需要增强

        是：切面的通知方法，包装成增强器（Advisor）;给业务逻辑组件创建一个代理对象（cglib）；

  • 5）、执行目标方法：

    • 1）、代理对象执行目标方法

    • 2）、CglibAopProxy.intercept()；

      • 1）、得到目标方法的拦截器链（增强器包装成拦截器MethodInterceptor）

      • 2）、利用拦截器的链式机制，依次进入每一个拦截器进行执行；

      • 3）、效果：

        正常执行：前置通知-》目标方法-》后置通知-》返回通知

        出现异常：前置通知-》目标方法-》后置通知-》异常通知

4 希望大家手动敲一遍代码，会收获颇丰！

5.欢迎关注米宝窝，持续更新中，谢谢！

米宝窝 https://rocklei123.github.io/

-------------本文结束感谢您的阅读-------------
欢迎持续关注米宝窝，定期更新谢谢！ https://rocklei123.github.io/
欢迎持续关注我的CSDN https://blog.csdn.net/rocklei123
rocklei123的技术点滴
熬夜写博客挺辛苦的，生怕猝死，所以每当写博客都带着听诊器，心脏一有异响，随时按Ctrl+S。
rocklei123 微信支付

微信支付

rocklei123 支付宝

支付宝