Spring IOC（9）为啥要用三级缓存而非二级缓存

涣涣虚心0215 · 简书 · · 2021-01-04 15:13

Spring IOC（8）里面主要介绍了三级缓存是如何工作的，但是提出了一个问题，为什么不能用二级缓存来解决呢？
对于正常的Singleton bean，二级缓存已经够用了，但是如果涉及到AOP的时候，再出现依赖循环的时候，会有什么问题么？这就是这章需要解决的。

Spring AOP的实现

首先我们先通过XML配置简单理解一下AOP。

aop关联的术语
PointCut（切入点）：定义切入点，在哪个类或者哪些方法上进行增强。
Advice（增强）：早期定义为通知，表示在方法执行的什么时机（when：方法前/方法后/方法前后）做什么（what：增强）
Aspect（切面）/ Advisor（通知期）：切入点PointCut+增强Advice，即什么时机，什么地点，做什么增强。
-- <aop:aspect>与<aop:advisor>作用一样，只是实现方式不同，advisor需要使用Advice提供一些接口，例如MethodBeforeAdvice。
Waving（织入）：把切面Aspect应用到对象，并创建出代理对象的过程（由spring完成）。

我们定义一个Student的bean，以及跟AOP相关的切面bean: AdviceHandler。
AdviceHandler定义了一个around方式的切片，在Student的方法前后加上增强的逻辑。

<bean id="student" class="com.gary.spring.Student" />
<bean id="adviceHandler" class="com.gary.spring.AdviceHandler" />
<aop:config>
    <aop:aspect id="aspect" ref="adviceHandler">
        <aop:pointcut id="pointCut" expression="execution(* com.gary.spring.Student.*(..)) "/>
        <aop:around method="doAround"  pointcut-ref="pointCut"/>
    </aop:aspect>
    //aop:advisor等同于aop:aspect，只是AdviceHandler需要实现Advice接口
     <aop:pointcut id="pointCut" expression="execution(* com.gary.spring.Student.*(..)) "/>
    <aop:advisor advice-ref="adviceHandler" pointcut-ref="pointCut"/>
</aop:config>

ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
Student student = (Student) ac.getBean("student");
student.sayName();

在运行测试的时候，可以直接通过ClassPathXmlApplicationContext来处理，因为ClassPathXmlApplicationContext已经将相关的BeanPostProcessor都初始化好了。
如果想使用DefaultListableBeanFactory，那么就需要手动addBeanPostProcessor，因为在loadBeanDefinition的时候，已经注册了跟AOP相关的BeanDefinition（org.springframework.aop.config.internalAutoProxyCreator），但是没有初始化相关的BeanPostProcessor。

Resource resource = new ClassPathResource("applicationContext.xml");
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
//通过BeanDefinitionReader读取beanDefinition，最终加载到BeanFactory中
BeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
beanDefinitionReader.loadBeanDefinitions(resource);
//获取BeanPostProcessor相关的Bean Name。
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
//添加BeanPostProcessor
BeanPostProcessor pp = beanFactory.getBean(postProcessorNames[0], BeanPostProcessor.class);
beanFactory.addBeanPostProcessor(pp);
Student student = (Student) beanFactory.getBean("student");
student.sayName();

AOP创建Proxy对象的地方有两个：

常规一点的就是在BeanFactory.initializeBean()方法里面调用初始化方法之后，调用applyBeanPostProcessorsAfterInitialization() --> AbstractAutoProxyCreator.wrapIfNecessary()生成proxy对象。
还有就是在存在循环依赖的时候，在doCreateBean() --> addSingletonFactory(beanName, () --> getEarlyBeanReference(beanName, mbd, bean)); --> 然后在getSingleton()的时候从三级缓存中取对象的时候，会调用getEarlyBeanReference() --> AbstractAutoProxyCreator.wrapIfNecessary()生成proxy对象。

因为测试代码是为Student对象创建了代理类，那么针对上述两种情况，是如何分别发生的呢？

第一种情况，Student是代理对象，但是getBean("teacher")。
在创建Teacher bean的时候，然后populateBean("student")，开始创建Student的bean实例，在创建完bean实例的之后也开始populateBean("teacher")，接着又开始创建Teacher的bean实例，这时候doGetBean("teacher")-->getSingleton("teacher")的时候会从三级缓存中获取bean对象，直接返回。因为Teacher是正常的singleton bean，那么返回之后Student继续下面步骤，即initializeBean()-->applyBeanPostProcessorsAfterInitialization()开始为Student创建Proxy对象，再返回到Teacher的创建，Teacher设置的就是Student的Proxy对象，然后Teacher继续调用initializeBean()完成初始化。
第二种情况，Student是代理对象，同时getBean("student")。
这种情况下就先开始创建Student对象的bean，同样的开始populateBean("teacher")，就开始创建Teacher的bean，创建完Teacher bean之后，接着开始populateBean("student")，循环依赖开始创建student的bean，那么这个时候这时候doGetBean("student")-->getSingleton("student")的时候会从三级缓存中获取bean对象，跟第一种情况不一样的是，Student是需要被AOP代理的，那么这时候从三级缓存中取出的是getEarlyBeanReference()方法返回的代理对象Proxy， 然后将这个proxy对象放到二级缓存earlySingletonObjects中 。后面Teacher populateBean("student")就拿到了Student的代理Proxy，完成Teacher的initializeBean()完成初始化，然后回到创建student的bean创建，populateBean("teacher")设置好Teacher之后，开始完成student的initializeBean()初始化，这里applyBeanPostProcessorsAfterInitialization()-->wrapIfNecessary()不会再创建代理对象，因为缓存earlyProxyReferences里面已经存在student的proxy对象，这也就导致exposedObject = initializeBean(beanName, exposedObject, mbd) 这个exposedObject不是代理对象proxy，而是真实对象，如果这样返回就有问题了，所以这里二级缓存的作用就体现出来了，在initializeBean()之后会再次调用getSingleton()去检查二级缓存，此时拿到earlySingletonReference是student对象的proxy对象，那么此时就将exposedObject从真实对象换成proxy代理对象，然后返回。

if (earlySingletonExposure) {
    //再次检查二级缓存的值
    Object earlySingletonReference = getSingleton(beanName, false);
    if (earlySingletonReference != null) {
        if (exposedObject == bean) {
            //将真实对象转换成代理Proxy对象
            exposedObject = earlySingletonReference;
        }
        。。。省略代码
    }
}

所以综上所述，多一级缓存意义就是在bean循环引用过程中，发生了AOP增强，避免返回真实对象而非代理对象Proxy。

原文地址：访问原文地址
快照地址：访问文章快照

分享到微博