Spring源码分析——AOP

2019-03-19 | 阅读：次

[TOC]

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

@EnableAspectJAutoProxy

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({AspectJAutoProxyRegistrar.class})//给容器中导入组件
public @interface EnableAspectJAutoProxy {
    boolean proxyTargetClass() default false;

    boolean exposeProxy() default false;
}

AspectJAutoProxyRegistrar

源码之中最重要的就是@Import注解，导入的AspectJAutoProxyRegistrar继承ImportBeanDefinitionRegistrar接口，主要是将自定义的组件注册到容器之中。

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
    AspectJAutoProxyRegistrar() {
    }

    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
      //注册一个registerAspectJAnnotationAutoProxyCreator，实际上就是就是注册了一个名字为internalAutoProxyCreator的AnnotationAwareAspectJAutoProxyCreator（自动代理创建器）
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
        AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
            AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
        }

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

    }
}

AnnotationAwareAspectJAutoProxyCreator

继承关系：

AnnotationAwareAspectJAutoProxyCreator 重写父类的initBeanFactory

——》AspectJAwareAdvisorAutoProxyCreator

————》AbstractAdvisorAutoProxyCreator 重写父类的setBeanFactory-》initBeanFactory

——————》AbstractAutoProxyCreator setBeanFactory和后置处理器相关的方法

implements SmartInstantiationAwareBeanPostProcessor，BeanFactoryAware 后置处理器是重要的实现，BeanFactoryAware 实现自动装配BeanFactory

后置处理器

……
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        Object cacheKey = this.getCacheKey(beanClass, beanName);
        if (beanName == null || !this.targetSourcedBeans.contains(beanName)) {
            if (this.advisedBeans.containsKey(cacheKey)) {
                return null;
            }

            if (this.isInfrastructureClass(beanClass) || this.shouldSkip(beanClass, beanName)) {
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return null;
            }
        }

        if (beanName != null) {
            TargetSource targetSource = this.getCustomTargetSource(beanClass, beanName);
            if (targetSource != null) {
                this.targetSourcedBeans.add(beanName);
                Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
                Object proxy = this.createProxy(beanClass, beanName, specificInterceptors, targetSource);
                this.proxyTypes.put(cacheKey, proxy.getClass());
                return proxy;
            }
        }

        return null;
    }

    public boolean postProcessAfterInstantiation(Object bean, String beanName) {
        return true;
    }

    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) {
        return pvs;
    }

    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean != null) {
            Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
            if (!this.earlyProxyReferences.contains(cacheKey)) {
                return this.wrapIfNecessary(bean, beanName, cacheKey);
            }
        }

        return bean;
    }

BeanFactoryAware

public void setBeanFactory(BeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }

AOP实现流程

流程：

1）、传入配置类，创建ioc容器
2）、注册配置类，调用refresh（）刷新容器；
3）、registerBeanPostProcessors(beanFactory);注册bean的后置处理器来方便拦截bean的创建；
- 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);

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

AnnotationAwareAspectJAutoProxyCreator 实现了=> InstantiationAwareBeanPostProcessor
4）、finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作；创建剩下的单实例bean
- 1）、遍历获取容器中所有的Bean，依次创建对象getBean(beanName);
  - getBean->doGetBean()->getSingleton()->
- 2）、创建bean
  
  【AnnotationAwareAspectJAutoProxyCreator在所有bean创建之前会有一个拦截（InstantiationAwareBeanPostProcessor），会调用postProcessBeforeInstantiation()】
  - 1）、先从缓存中获取当前bean，如果能获取到，说明bean是之前被创建过的，直接使用，否则再创建；
    - 只要创建好的Bean都会被缓存起来（spring保证bean单实例的原因）
  - 2）、createBean（）;创建bean；
    - AnnotationAwareAspectJAutoProxyCreator 会在任何bean创建之前先尝试返回bean的实例
    - 【BeanPostProcessor是在Bean对象创建完成初始化前后调用的】
    - 【InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回对象的】
    - 1）、resolveBeforeInstantiation(beanName, mbdToUse);解析BeforeInstantiation
      - 希望后置处理器在此能返回一个代理对象；如果能返回代理对象就使用，如果不能就继续
      - 1）、后置处理器先尝试返回对象；
        
        bean = applyBeanPostProcessorsBeforeInstantiation（）：
        
        拿到所有后置处理器，如果是InstantiationAwareBeanPostProcessor;
        
        就执行postProcessBeforeInstantiation
        
        如果bean不等于空
        
        if (bean != null) { bean = applyBeanPostProcessorsAfterInitialization(bean, beanName); }
      - 2）、doCreateBean(beanName, mbdToUse, args);真正的去创建一个bean实例；和3.6流程一样；

AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】的作用：

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

postProcessAfterInitialization；

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）、以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程；
3）、目标方法执行；
- 容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存了详细信息（比如增强器，目标对象，xxx）；
- 1）、CglibAopProxy.intercept();拦截目标方法的执行
- 2）、根据ProxyFactory对象获取将要执行的目标方法拦截器链；
  - List
  - 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方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行；拦截器链的机制，保证通知方法与目标方法的执行顺序；

yuanyi

袁艺

Spring源码分析——AOP

@EnableAspectJAutoProxy

AspectJAutoProxyRegistrar

AnnotationAwareAspectJAutoProxyCreator