《深入理解Spring原理》 05-Spring AOP 底层实现详解

     spring家族包含了很多不同领域的模块，spring-aop是开发者比较常用的一个模块，那么本节将基于源码debug方式一起学习spring-aop底层原理。

    本文结构如下：

• 扫描xml中配置的bean.将xml配置转为Bean
• Spring-aop拦截的Bean是如何注入到IOC的
• Spring-aop执行流程

如下图所示是需要使用到的简单案例，该案例主要功能是使用Spring-AOP拦截 Demo中的get方法，在get方法执行前后分别打印日志。通过这个简单demo来学习spring-aop的流程。

public class DemoApplication {

    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXMlApplicationContext("classpath:applicationContext.xml");
        Demo demo = (Demo) applicationContext.getBean("demo");
        demo.get();
    }
}

public class Demo {
    public void get() {
        System.out.println("invoke Demo.get()");
    }
}


public class TestAop {

    public void test() {}

    public void before() {
        System.out.println("============ 开始执行方法 =============");
    }

    public void after() {
        System.out.println("============= 执行方法结束 =============");
    }
}




    
    

    
    
        
        
            
            
        
    

  

Step1：扫描xml中配置的bean.将xml配置转为Bean

     IOC启动第一步肯定是要将xml配置转为能被Spring识别的Bean，关于Spring是如何将xml转为Bean的不再本篇概述，感兴趣的读者可以阅读笔者  《深入理解Spring原理》 02-Bean定义详解。

     但是由于xml中配置了spring-aop相关的bean ,所以在解析时又会有些许差别。

     如下图所示是解析xml到Bean的方法入口，其中 if (delegate.isDefaultNamespace(ele)) 逻辑主要是判断当前xml中定义的bean是否是beans命名空间下的。当扫描到aop先关的bean时，if判断肯定不通过，所以会走到下面的else逻辑 parseCustomElement

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    if (delegate.isDefaultNamespace(root)) {
        NodeList nl = root.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (node instanceof Element) {
                Element ele = (Element) node;
                if (delegate.isDefaultNamespace(ele)) {
                    parseDefaultElement(ele, delegate);
                } else {
                    delegate.parseCustomElement(ele);
                }
            }
        }
    } else {
        delegate.parseCustomElement(root);
    }
}

     如下图所示是解析其他命名空间的方法入口，在本案例中处理beans命名空间外的就只有aop了。

     所以会找到aop先关的处理器，通过debug找到 ConfigBeanDefinitionParse

public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
    //获取xml中的命名空间uri
    String namespaceUri = getNamespaceURI(ele);
    if (namespaceUri == null) {
        return null;
    }
    //通过uri获取到指定的处理器
    NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
    if (handler == null) {
        error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
        return null;
    }
    //使用相应的处理器解析xml中定义的bean
    return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

  如下图所示是解析spring-aop bean xml配置，至于详细的解析流程本文将不再赘述。

public BeanDefinition parse(Element element, ParserContext parserContext) {
    CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
    parserContext.pushContainingComponent(compositeDef);

    configureAutoProxyCreator(parserContext, element);

    List < Element > childElts = DomUtils.getChildElements(element);
    for (Element elt: childElts) {
        String localName = parserContext.getDelegate().getLocalName(elt);
        if (POINTCUT.equals(localName)) {
            parsePointcut(elt, parserContext);
        } else if (ADVISOR.equals(localName)) {
            parseAdvisor(elt, parserContext);
        } else if (ASPECT.equals(localName)) {
            parseAspect(elt, parserContext);
        }
    }

    parserContext.popAndRegisterContainingComponent();
    return null;
}

Step2：Spring-aop拦截的Bean是如何注入到IOC的

当Ste1中将xml转为bean后，相当于完成了AbstractApplicationContext.refresh()方法的 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();  通过debug再往下走流程则走到了 refresh()方法的registerBeanPostProcessors(beanFactory); .

那么就看一下这个方法在使用spring-aop后有什么不同的变化：

 该方法第一步尝试获取将xml解析为beanDefinition中的bean是否存在实现BeanPostProcessor的bean，通过debug发现我们xml中的一个BeanPostProcessor  ： 即xml中配置的 。既然获取到了BeanPostProcessor,在本方法中肯定会将该BeanPostProcessor注入到IOC中 （由于笔者使用了spring-boot创建项目，所以该BeanPostProcssor为 AnnotationAwareAspectJAutoProxyCreator）

public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    //获取beanDefinition中是否有BeanPostProcessor类型的Bean
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    List < BeanPostProcessor > priorityOrderedPostProcessors = new ArrayList < >();
    List < BeanPostProcessor > internalPostProcessors = new ArrayList < >();
    List < String > orderedPostProcessorNames = new ArrayList < >();
    List < String > nonOrderedPostProcessorNames = new ArrayList < >();
    for (String ppName: postProcessorNames) {
        //判断是否是实现 PriorityOrdered接口的Bean
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        //判断是否是实现 Ordered接口的Bean
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        } else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    List < BeanPostProcessor > orderedPostProcessors = new ArrayList < >();
    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);

    // Now, register all regular BeanPostProcessors.
    List < BeanPostProcessor > nonOrderedPostProcessors = new ArrayList < >();
    for (String ppName: nonOrderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

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

    // Re-register post-processor for detecting inner beans as ApplicationListeners,
    // moving it to the end of the processor chain (for picking up proxies etc).
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

  registerBeanPostProcessors 方法执行完之后，再往下走就应该是初始化Bean： finishBeanFactoryInitialization

  关于Bean是如何注入的也不再本文赘述，感兴趣的读者可以阅读  《深入理解Spring原理》 03-IOC容器初始化之Bean注入详解

   本文关注的重点是使用aop之后与不使用的区别：

   最终会到 AbstractAutowireCapableBeanFactory.doCreateBean()进行Bean的实例化，该方法最终调用  exposedObject = initializeBean(beanName, exposedObject, mbd); 对Bean进行初始化，在Spring-aop后，该方法的执行发生了变化：

 还记得前面注入的 AnnotationAwareAspectJAutoProxyCreator 吗？

该方法的主要作用是执行Bean实现 Aware接口、BeanPostProcessor接口、init方法。

既然上面提到注入了一个 AnnotationAwareAspectJAutoProxyCreator BeanPostProcessor.那么在这个方法中执行BeanPostProcessor流程时肯定会执行 AnnotationAwareAspectJAutoProxyCreator 的实现。

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction