Spring AOP源码解读1 - 程序入口

╰半夏微凉° 2022-07-14 12:08 218阅读 0赞

# 前言 #

> 最近看了《从零开始写JavaWeb框架》，想比较一下Spring AOP的实现方式和书的上实现方式有什么不同，所以先把Spring AOP的源码读一下，再进行比较。
> 
> Spring的源码实在是复杂，在读的过程中参考了很多书和网上的文章，本文算是这些文章的总结，再加上一些我自己对个别细节的理解。
> 
> 本文分成 3 部分：
> 
>  *  程序入口
>  *  切面和增强的取得
>  *  代理的生成

# 一，注册AspectJAnnotationAutoProxyCreator #

如果使用`<aop:aspectj-autoproxy />`标签来自动生成代理的话，入口程序是`AopNamespaceHandler`。在`AopNamespaceHandler`中，下面一段代码是对`<aop:aspectj-autoproxy />`标签执行的调用：

registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());

AspectJAutoProxyBeanDefinitionParser解析器中，首先调用的parse方法。parse方法中有一行代码：

AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);

我们看一下`registerAspectJAnnotationAutoProxyCreatorIfNecessary`方法的实际内容：

public static void registerAutoProxyCreatorIfNecessary(
        ParserContext parserContext, Element sourceElement) {
        // 注册或更新 AutoProxyCreator 定义 beanName 为 org.Springframework.aop.config.internalAutoProxyCreator的BeanDefinition
        // 如果internalAutoProxyCreator的BeanDefinition已经存在，而根据优先级更新BeanDefinition
        // 在这里我们注册的是AnnotationAwareAspectJAutoProxyCreator
        BeanDefinition beanDefinition = AopConfigUtils.registerAutoProxyCreatorIfNecessary(
                parserContext.getRegistry(), parserContext.extractSource(sourceElement));
        // 对于 proxy-target-class 以及 expose-proxy 属性的处理
        useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
        // 注册组件并通知，便于监听器作进一步处理
        // 其中 beanDefinition 的 className 为 AnnotationAwareAspectJAutoProxyCreator
        registerComponentIfNecessary(beanDefinition, parserContext);
    }

**问题1：那为什么注册AnnotationAwareAspectJAutoProxyCreator，注册AnnotationAwareAspectJAutoProxyCreator有什么用呢?**

其实，实现AOP处理是其实是通过BeanPostProcessor机制实现的。AnnotationAwareAspectJAutoProxyCreator的父类也实现一个BeanPostProcessor类型的接口，而生成代理的逻辑就在AnnotationAwareAspectJAutoProxyCreator的BeanPostProcessor接口实现里面。  
更严谨地说，`AnnotationAwareAspectJAutoProxyCreator`的父类实现的接口是  
`SmartInstantiationAwareBeanPostProcessor`，主要是Spring框架内部使用的一个接口。而这个接口的父接口`InstantiationAwareBeanPostProcessor` 是实现代理的重点之一。

> 这3个接口的关系如下：  
> `SmartInstantiationAwareBeanPostProcessor -> InstantiationAwareBeanPostProcessor -> BeanPostProcessor`

**问题2：为什么说是是`InstantiationAwareBeanPostProcessor`接口的子接口，接口是重点之一？那`InstantiationAwareBeanPostProcessor`接口是什么接口呢？**

`BeanPostProcessor`主要作用于`Bean`实例化后，初始化前后。`InstantiationAwareBeanPostProcessor`虽然是`BeanPostProcessor`的子接口，但它的调用时间点其发生在Bean实例化前，在真正调用`doCreate()`创建bean实例之前。  
在创建`Bean`实例之前，会先调用`resolveBeforeInstantiation`方法，这个方法是生成`Bean`代理的地方。如果此方法返回值不为空则直接返回生成的`Bean`的代理，如果为空就向下走正常的`Bean`生成流程。

> spring注释“Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. ”给BeanPostProcessors一个机会返回代理proxy对象。

而`InstantiationAwareBeanPostProcessor`接口方法，就是在`resolveBeforeInstantiation`方法中调用的。所以可以看出，`BeanPostProcessor`有很多，但Spring AOP的实现就是通过`InstantiationAwareBeanPostProcessor`这个`BeanPostProcessor`实现的。看一下源码：

protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
            throws BeanCreationException {
        ......
        try {
            // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
            // 如果返回值不为空，说明生成成了此BeanName的代理，直接返回代理对象
            Object bean = resolveBeforeInstantiation(beanName, mbd);
            if (bean != null) {
                return bean;
            }
        }
        catch (Throwable ex) {
            ......
        }
    
        // 如果没有生成代理对象，就按正常流程走，生成Bean对象
        Object beanInstance = doCreateBean(beanName, mbd, args);
        .....
        return beanInstance;
    }

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
        Object bean = null;
        if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
            // Make sure bean class is actually resolved at this point.
            if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
                Class<?> targetType = determineTargetType(beanName, mbd);
                if (targetType != null) {
                    // 调用InstantiationAwareBeanPostProcessor接口的地方
                    bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    if (bean != null) {
                        bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }
                }
            }
            mbd.beforeInstantiationResolved = (bean != null);
        }
        return bean;
    }

protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName)
                throws BeansException {
    
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    // 转换成InstantiationAwareBeanPostProcessor接口，并调用
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
                    if (result != null) {
                        return result;
                    }
                }
            }
            return null;
        }

> 顺带说一下，注册AnnotationAwareAspectJAutoProxyCreator的目的是：把这个类的BeanDefinition通过registerBeanDefinition方法（DefaultListableBeanFactory类中）加入到beanDefinitionMap中，作为一个Bean让Spring管理，这样Spring就可以随意取得它了。

**问题3：如果使用`<aop:aspectj-autoproxy />`标签来自动生成代理的话，入口程序是`AopNamespaceHandler`。那`AopNamespaceHandler` 是在什么地方被调用的呢？**

这个问题让我们从容器启动的地方开始说明。以`FileSystemXmlApplicationContext` 为例，这个类的入口是构造函数里面的`refresh()` 方法。从`refresh()` 方法开始，调用流程是这样的：（以下流程全部是嵌套调用的关系）

1. refresh() ->
       刷新容器 
    2. obtainFreshBeanFactory() ->
       获得刷新后的Bean容器
    3. refreshBeanFactory() ->
       刷新Bean容器
    4. loadBeanDefinitions() ->
       加载BeanDefinition
    5. XmlBeanDefinitionReader#loadBeanDefinitions
       新建一个XmlBeanDefinitionReader实例(new XmlBeanDefinitionReader(beanFactory))，调用这个实例的loadBeanDefinitions方法。
    6. XmlBeanDefinitionReader#doLoadBeanDefinitions
    7. XmlBeanDefinitionReader#registerBeanDefinitions
    8. XmlBeanDefinitionReader#createBeanDefinitionDocumentReader
       在这个方法中取得了DefaultBeanDefinitionDocumentReader实例。接下来调用这个实例的方法。
    9. DefaultBeanDefinitionDocumentReader#registerBeanDefinitions
       在这个方法中，根据URI判断是否使用AopNamespaceHandler
    10. DefaultBeanDefinitionDocumentReader#parseBeanDefinitions
       从registerBeanDefinitions方法开始，内部连续调用一系列方法，一直调用到parseBeanDefinitions方法。在这个方法中，根据XML文件的URI判断使用哪些解析器，例如是<Beans>类标签解析器，还是<aop>类标签解析器。
       如果是需要<aop>标签解析器的话，在this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri)代码中，从配置文件（spring.handlers）从取出AopNamespaceHandler的类名，生成这个类的实例，然后调用这个类的parse方法。
    11. AopNamespaceHandler#parse
       这个方法的功能是，根据具体标签调用具体解析器的parse方法。
       - <aop:aspectj-autoproxy>：AspectJAutoProxyBeanDefinitionParser
       - <aop:config>:ConfigBeanDefinitionParser
       等。
       这个方法的调用，又回到了我们最初讲的AopNamespaceHandler入口的地方。

到此为止，从容器到AopNamespaceHandler类调用的过程也讲完了。

# 二，AspectJAnnotationAutoProxyCreator的处理流程 #

通过上面的内容，我们知道了注册`AnnotationAwareAspectJAutoProxyCreator`的意义，并且知道了生成代理是在它的`BeanPostProcessor`接口里做的，现在看看被实现的接口的内容。（postProcessAfterInitialization 具体实现是在其父类 AbstractAutoProxyCreator 中完成的）：

@Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
       if (bean != null) {
          // 根据给定的 bean 的 class 和 name 构建出个 key，格式：beanClassName_beanName
          Object cacheKey = getCacheKey(bean.getClass(), beanName);
          if (!this.earlyProxyReferences.contains(cacheKey)) {
             // 如果它适合被代理，则需要封装指定 bean。
             return wrapIfNecessary(bean, beanName, cacheKey);
          }
       }
       return bean;
    }

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
       // 是否已经处理过
       if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
          return bean;
       }
       // 无需增强
       if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
          return bean;
       }
       // 给定的 bean 类是否代表一个基础设施类，基础设施类不应代理，或者配置了指定 bean 不需要自动代理
       if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
          this.advisedBeans.put(cacheKey, Boolean.FALSE);
          return bean;
       }
    
       // 如果存在增强方法则创建代理（*重要*）
       Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
       // 如果获取到了增强则需要针对增强创建代理
       if (specificInterceptors != DO_NOT_PROXY) {
          this.advisedBeans.put(cacheKey, Boolean.TRUE);
          // 创建代理（*重要*）
          Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
          this.proxyTypes.put(cacheKey, proxy.getClass());
          return proxy;
       }
    
       this.advisedBeans.put(cacheKey, Boolean.FALSE);
       return bean;
    }

这里有两个方法特别重要：

> 1.  getAdvicesAndAdvisorsForBean：如果Bean是要被代理的对象的话，取得Bean相关的Interceptor
> 2.  createProxy：创建代理

下一篇文章，我们就这两个方法的下面的流程分开来分析一下，首先分析`getAdvicesAndAdvisorsForBean`相关代码。

> 关于接口实现的补充：
> 
> `AnnotationAwareAspectJAutoProxyCreator` 一共实现了2个`BeanPostProcessor` 的接口，的4个方法：
> 
>  *  postProcessBeforeInstantiation（InstantiationAwareBeanPostProcessor）
>  *  postProcessAfterInstantiation（InstantiationAwareBeanPostProcessor）
>  *  postProcessBeforeInitialization（BeanPostProcessor）
>  *  postProcessAfterInitialization（BeanPostProcessor）
> 
> `postProcessBeforeInstantiation`（`InstantiationAwareBeanPostProcessor`接口）方法中，这个方法是在`AnnotationAwareAspectJAutoProxyCreator`的基类`AbstractAutoProxyCreator`中实现的。细看一下，在`postProcessAfterInitialization`方法中也有类似的生成代理的代码。这是为什么呢？
> 
> 上网找了一些资料，在`postProcessBeforeInstantiation`方法中有一个判断：
> 
> > 如果某个`Bean`设置了自定义`TargetSource`的话，就在本方法中进行生成代理
> 
> 而`postProcessAfterInitialization`则没有这样的判断，只是在生成代理前判断了一下代理是否已经生成。具体为什么有这样的必须还不清楚（以后有需要调查一下），但结果就是：
> 
> >  *  如果`Bean`设置了自定义`TargetSource`，就在`postProcessBeforeInstantiation`中生成代理
> >  *  如果没有，就在`postProcessAfterInitialization`中生成代理。
> 
> 最后，不管理在哪个方法里生成代理，在创建每个Bean时都会被调用这两个方法，代理的生成逻辑就是在这两个方法中实现的。
> 
> > 关于TargetSource：[spring-aop组件详解——TargetSource目标源][spring-aop_TargetSource]  
> > 关于自定义TargetSource：[《Spring揭密》的9.6章节][Spring_9.6]

参考：  
[Spring 源码分析(三) —— AOP（一）AOP原理][Spring _ _ AOP_AOP]：AOP系列一共6篇文章建议看看  
[Spring AOP源码分析（三）Spring AOP中的一些基本接口及其概念][Spring AOP_Spring AOP]：这篇文章讲了AOP的接口，如果不明白接口的目的的话，理解AOP的代码有些困难，建议看看。  
[Spring AOP 简单模拟][Spring AOP] ：把Spring AOP的整个结构给简单化了，变成的容易明白

[spring-aop_TargetSource]: https://my.oschina.net/lixin91/blog/688188
[Spring_9.6]: http://book.51cto.com/art/200908/147353.htm
[Spring _ _ AOP_AOP]: https://my.oschina.net/kaywu123/blog/626135
[Spring AOP_Spring AOP]: http://lgbolgger.iteye.com/blog/2117214
[Spring AOP]: http://tansumanong.github.io/2016/08/07/spring/Spring-AOP-简单模拟/