Spring——AOP原理及源码四【系列完】

前情回顾：

　　上文我们一路分析了从容器创建开始直到我们的AOP注解导入的核心组件AnnotationAwareAspectJAutoProxyCreator执行postProcessBeforeInstantiation()方法的整个过程

　　分析得到：在所有bean创建之前，都会调用resolveBeforeInstantiation方法来试图返回一个代理对象

---

本篇预告

下图可以看到resolveBeforeInstantiation方法包含了

applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);

applyBeanPostProcessorsAfterInitialization(bean, beanName);

两个方法

 

在本篇我们将完整走完 resolveBeforeInstantiation 全过程，并一直到返回代理对象为止

---

1、调试的起点

　　开始调试，还是一路跳到下一断点，直到AbstractAutoProxyCreator.postProcessBeforeInstantiation()（从resolveBeforeInstantiation方法进入到这里的过程上一篇已经分析了）

可以看到当前的bean为org.springframework.context.event.internalEventListenerProcessor，和我们要测试的AOP无关。

因为当前方法打上了断点，所以我们调到下一个断点直到来到class aop.MathCalculator

@Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        Object cacheKey = getCacheKey(beanClass, beanName);

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

        // Create proxy here if we have a custom TargetSource.
        // Suppresses unnecessary default instantiation of the target bean:
        // The TargetSource will handle target instances in a custom fashion.
        if (beanName != null) {
            TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
            if (targetSource != null) {
                this.targetSourcedBeans.add(beanName);
                Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
                Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
                this.proxyTypes.put(cacheKey, proxy.getClass());
                return proxy;
            }
        }

        return null;
    }

从上往下一步步step voer，下面是对应行的讲解

3、获取bean在容器中的缓存

5、判断目标源Bean中是否存在有当前bean的缓存信息。

（可以在21行看到添加目标源bean的操作，在23行就创建了代理对象。所以这步也是相当于判断当前bean是否已经创建过代理对象。）

　　因为是第一次执行MathCalculator这个bean，这里我们是进入判断的

　　接下来 this.advisedBeans.containsKey(cacheKey) 判断advisedBeans中是否有缓存（这里我们将advisedBeans称为增强器）

　　我们这里判断是不满足的，接着往下走。

9、进行 isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName) 判断

　　下面分别进入第九行的两个方法进行查看。

---

　　1、isInfrastructureClass(beanClass) 是否是基础类型

　　　　进入后我们会发现有如下两个方法

　　　　super.isInfrastructureClass(beanClass) || this.aspectJAdvisorFactory.isAspect(beanClass)

　　

　　先进入父类的 isInfrastructureClass 方法，经过一系列判断，最后返回false，表明当前bean不是基础类型。

 　　

 　　

　　接着来到 isAspect(beanClass) ，通过类上是否有@Aspect注解来判断这个类是否是切面（这里 MathCalculator显然不是一个切面）

　　

 　　返回出来可以看到 isInfrastructureClass(beanClass) 的判断为false

　　

　　

　　2、shouldSkip 判断是否要跳过

　　

　　在方法中遍历所有的增强器，红框中表面获取的增强器便是日志方法。　　

　　并判断增强器是否是AspectJPointcutAdvisor类型，我们这里判断不满足

　　末尾来到父类的  shouldSkip 方法，进入可以看到直接返回了 false

　　

 　　

最终我们来到外层的判断，可以看到返回了false

---

2、退出 applyBeanPostProcessorsBeforeInstantiation 方法

接着来到下面这块代码，看注释表明如果存在自定义目标Source，我们将在此创建代理对象

step voer，在259行判断targetSource为null，所以这里是没有自定义目标Source的

我们一直往下走，走完 applyBeanPostProcessorsBeforeInstantiation 方法，直到回到 resolveBeforeInstantiation 方法，返回的bean为null

所以接下来也不会进入 applyBeanPostProcessorsAfterInitialization 方法

到此为止，我们的 resolveBeforeInstantiation 方法执行完了，从以上可以得知，方法没有给我们返回代理对象

如下图所示，我们将接着执行 createBean 流程，接下来将调用 doCreateBean 

---

3、postProcessAfterInitialization方法探究

我们执行 doCreateBean 方法，来到了配置类的bean方法

接着跳到下一个断点直到 postProcessAfterInitialization 方法，下面的方法栈我们是熟悉的

从finishBeanFactoryInitialization一路到initializeBean

不过我们现在进入的是postProcessAfterInitialization 

从下图的 initializeBean 方法的流程也可以看明白

前面执行完了 applyBeanPostProcessorsBeforeInitialization 和 invokeInitMethods 两个方法

下面进入 postProcessAfterInitialization 方法：

　　如果先前的代理参考中不存在当前bean对象，就调用 wrapIfNecessary(bean, beanName, cacheKey) 并返回其结果

　　

 　　进入wrapIfNecessary（进行包装如果需要的话）：

/**
     * Wrap the given bean if necessary, i.e. if it is eligible for being proxied.
     * @param bean the raw bean instance
     * @param beanName the name of the bean
     * @param cacheKey the cache key for metadata access
     * @return a proxy wrapping the bean, or the raw bean instance as-is
     */
    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;
        }
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }

        // Create proxy if we have advice.
        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;
    }

9~18行：还是先进行判断，是否是基础类型等，在这里我们判断都不是

21：拿到增强器放入 Object[] specificInterceptors 中

24~25：传入拿到的增强器等信息，创建代理对象

下面我们着重来看 getAdvicesAndAdvisorsForBean 拿增强器的过程：

　　一进来先调用findEligibleAdvisors，找到合格的增强器（日志方法）

　　

 　　进入findEligibleAdvisors，方法先调用findCandidateAdvisors，获取所有候选增强器

　　然后又调用findAdvisoersThatCanApply从候选增强器中选出可以用于当前bean的

　　接着判断选出的增强器队列不为空，就给其排序，最后返回选出的增强器队列

　　 

 　　

 　　findCandidateAdvisors 我们就不说了

　　重点看看 findAdvisoersThatCanApply

　　如下图，可以发现它是利用AopUtils，也就是AOP工具类进行筛选

　　 

 　　进入工具类方法，看到方法又进行了一层判断，将最终符合条件的增强器（日志方法）放入选择队列中

　　 

 　　获取完后我们一路返回，又回到了 findEligibleAdvisors

　　如下图可以看到，最终排序完后将返回有五个增强器的增强器队列

 

---

4、创建代理对象

最终我们获取到了需要的增强器（日志方法）放入一个叫特殊拦截器的数组（这里暂且称为拦截器数组）

判断不为空后，将当前bean的缓存放入adviseBeans 中

接着调用createProxy来创建代理对象

 

/**
     * Create an AOP proxy for the given bean.
     * @param beanClass the class of the bean
     * @param beanName the name of the bean
     * @param specificInterceptors the set of interceptors that is
     * specific to this bean (may be empty, but not null)
     * @param targetSource the TargetSource for the proxy,
     * already pre-configured to access the bean
     * @return the AOP proxy for the bean
     * @see #buildAdvisors
     */
    protected Object createProxy(
            Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {

        if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
            AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
        }

        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.copyFrom(this);

        if (!proxyFactory.isProxyTargetClass()) {
            if (shouldProxyTargetClass(beanClass, beanName)) {
                proxyFactory.setProxyTargetClass(true);
            }
            else {
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }

        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        proxyFactory.addAdvisors(advisors);
        proxyFactory.setTargetSource(targetSource);
        customizeProxyFactory(proxyFactory);

        proxyFactory.setFrozen(this.freezeProxy);
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }

        return proxyFactory.getProxy(getProxyClassLoader());
    }

从上往下看
19行创建代理对象对象工厂proxyFactory ，31~34在代理对象工厂中加入增强器、目标Source等属性
41行调用proxyFactory.getProxy(getProxyClassLoader()) 获取当前bean的代理对象

 

先创建Aop代理对象

 

可以看到结果一系列调用后来到下图，有3种动态代理对象可能返回，我们这里返回的是Cglib动态代理对象

 

一步步将代理对象返回，执行完当前bean的 applyBeanPostProcessorsAfterInitialization方法，返回其代理对象

 

 

可以得知：返回的代理对象将代替bean对象存入容器中

到此为止，我们的代理对象创建步骤就完成了。

---

总结：

　　initializeBean方法在初始化bean时，将通过 applyBeanPostProcessorsAfterInitialization 创建并返回目标bean的代理对象，并存入容器中。

　　目前为止的过程，都是在初始化bean前完成的

　　下面两张图中的代码流程是关键

　　

　1、initializeBean流程

　　

　　

　2、refresh流程（AOP中我们需要了解的）

1. postProcessBeanFactory(beanFactory);
2. invokeBeanFactoryPostProcessors(beanFactory);
3. finishBeanFactoryInitialization(beanFactory);

refresh完整流程参考如下：

@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                // Reset 'active' flag.
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

　　在下一篇中，也是本系列的最后一篇，我们将探究增强器（日志方法）是如何通过代理对象，在代理对象方法执行的时候发挥作用的。