今天看啥  ›  专栏  ›  涣涣虚心0215

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。

………………………………

原文地址:访问原文地址
快照地址: 访问文章快照
总结与预览地址:访问总结与预览