本文参考:
画图带你彻底弄懂三级缓存和循环依赖的问题
Spring 三级缓存解决bean循环依赖,为何用三级缓存而非二级_笑矣乎的博客-CSDN博客
Spring为何需要三级缓存解决循环依赖,而不是二级缓存?_石杉的架构笔记的博客-CSDN博客
主要的三级缓存工作机理学习参考 画图带你彻底弄懂三级缓存和循环依赖的问题
文章中解决了“是什么”的问题,这里主要梳理下”为什么“的问题,即为什么非得是三级缓存才能解决呢?也就是上面积累下来的问题
七、不用三级缓存,用二级缓存能不能解决循环依赖
遇到这种面试题,你就跟面试官说,如果行的话,Spring的作者为什么不这么写呢?
哈哈,开个玩笑,接下来说说到底为什么不行。
这里我先说一下前面没提到的细节,那就是通过ObjectFactory获取的Bean可能是两种类型,第一种就是实例化阶段创建出来的对象,还是一种就是实例化阶段创建出来的对象的代理对象。至于是不是代理对象,取决于你的配置,如果添加了事务注解又或是自定义aop切面,那就需要代理。这里你不用担心,如果这里获取的是代理对象,那么最后完全创建好的对象也是代理对象,ObjectFactory获取的对象和最终完全创建好的还是同一个,不是同一个肯定会报错,所以上面的理论依然符合,这里只是更加的细节化。
有了这个知识点之后,我们就来谈一下为什么要三级缓存。
第一级缓存,也就是缓存完全创建好的Bean的缓存,这个缓存肯定是需要的,因为单例的Bean只能创建一次,那么肯定需要第一级缓存存储这些对象,如果有需要,直接从第一级缓存返回。那么如果只能有二级缓存的话,就只能舍弃第二级或者第三级缓存。
假设舍弃第三级缓存
舍弃第三级缓存,也就是没有ObjectFactory,那么就需要往第二缓存放入早期的Bean,那么是放没有代理的Bean还是被代理的Bean呢?
1)如果直接往二级缓存添加没有被代理的Bean,那么可能注入给其它对象的Bean跟最后最后完全生成的Bean是不一样的,因为最后生成的是代理对象,这肯定是不允许的;
2)那么如果直接往二级缓存添加一个代理Bean呢?
- 假设没有循环依赖,提前暴露了代理对象,那么如果跟最后创建好的不一样,那么项目启动就会报错,
- 假设没有循环依赖,使用了ObjectFactory,那么就不会提前暴露了代理对象,到最后生成的对象是什么就是什么,就不会报错,
- 如果有循环依赖,不论怎样都会提前暴露代理对象,那么如果跟最后创建好的不一样,那么项目启动就会报错
通过上面分析,如果没有循环依赖,使用ObjectFactory,就减少了提前暴露代理对象的可能性,从而减少报错的可能。
假设舍弃第二级缓存
假设舍弃第二级缓存,也就是没有存放早期的Bean的缓存,其实肯定也不行。上面说过,ObjectFactory其实获取的对象可能是代理的对象,那么如果每次都通过ObjectFactory获取代理对象,那么每次都重新创建一个代理对象,这肯定也是不允许的。
从上面分析,知道为什么不能使用二级缓存了吧,第三级缓存就是为了避免过早地创建代理对象,从而避免没有循环依赖过早暴露代理对象产生的问题,而第二级缓存就是防止多次创建代理对象,导致对象不同。
为了从源码角度解决“不用三级缓存,用二级缓存能不能解决循环依赖”的问题,继续去找各种文章去解答:
参考 Spring 三级缓存解决bean循环依赖,为何用三级缓存而非二级_笑矣乎的博客-CSDN博客
DefaultSingletonBeanRegistry.java中有三级缓存,以及如何获取的源码
/** * Return the (raw) singleton object registered under the given name. *
Checks already instantiated singletons and also allows for an early * reference to a currently created singleton (resolving a circular reference). * @param beanName the name of the bean to look for * @param allowEarlyReference whether early references should be created or not * @return the registered singleton object, or {@code null} if none found */ @Nullable protected Object getSingleton(String beanName, boolean allowEarlyReference) { // Quick check for existing instance without full singleton lock Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { singletonObject = this.earlySingletonObjects.get(beanName); if (singletonObject == null && allowEarlyReference) { synchronized (this.singletonObjects) { // Consistent creation of early reference within full singleton lock // 查询一级缓存 singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { // 若一级缓存不存在,查询二级缓存 singletonObject = this.earlySingletonObjects.get(beanName); if (singletonObject == null) { // 若二级缓存不存在,查询三级缓存 ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); if (singletonFactory != null) { singletonObject = singletonFactory.getObject(); this.earlySingletonObjects.put(beanName, singletonObject); this.singletonFactories.remove(beanName); } } } } } } return singletonObject; }
AbstractBeanFactory下面有一个createBean()的中心方法,其核心实现方法doCreateBean(),可以看出来是在类实例化以后,属性填充之前,先检查是否允许提前暴露,如果允许则将其加入三级缓存工厂中
文章作者认为二级缓存不能解决问题,主要是因为在AOP的场景下,注入到其他bean的,不是AOP代理对象,而是原始对象。但其实这也不完全对,完全可以让AOP代理对象注入到二级缓存中,但是这有悖于AOP的设计原理。AOP就是要等Bean实例化,属性填充,初始化完成之后才去 生成AOP代理对象的,如果使用二级缓存,又要将AOP代理对象注入的话,就需要强行将AOP的代理工作提前到早期暴露实例之前。
但是上面总归还是理论性的知识,在源码层面上,三级缓存究竟做了什么还需要探究,参考
Spring为何需要三级缓存解决循环依赖,而不是二级缓存?_石杉的架构笔记的博客-CSDN博客
三级缓存中key-value加入的是一个beanName 和一个ObjectFactory的工厂类
/** * Add the given singleton factory for building the specified singleton * if necessary. *
To be called for eager registration of singletons, e.g. to be able to * resolve circular references. * @param beanName the name of the bean * @param singletonFactory the factory for the singleton object */ protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) { Assert.notNull(singletonFactory, "Singleton factory must not be null"); synchronized (this.singletonObjects) { if (!this.singletonObjects.containsKey(beanName)) { this.singletonFactories.put(beanName, singletonFactory); this.earlySingletonObjects.remove(beanName); this.registeredSingletons.add(beanName); } } }
在前面获取的时候,也是直接调用ObjectFactory的工厂类的getObject方法
// 若二级缓存不存在,查询三级缓存
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
最终调用getEarlyBeanReference方法
/**
* Obtain a reference for early access to the specified bean,
* typically for the purpose of resolving a circular reference.
* @param beanName the name of the bean (for error handling purposes)
* @param mbd the merged bean definition for the bean
* @param bean the raw bean instance
* @return the object to expose as bean reference
*/
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}
从getSingleton()中可以看出,在AOP的情况下,每次singletonFactory.getObject()取出来的都是不同的Aservice代理类,由于Aservice是单例的,这样子显然不行。因此将singletonFactory.getObject()取出来的东西放入二级缓存中,key还是beanName,这样子别的Bean在取的时候直接就可以从二级缓存中拿出来,不必每次调用singletonFactory.getObject()产生一个新的代理对象。
总而言之,在没有AOP的情况下,确实可以通过两级缓存解决循环依赖问题,但是如果加上AOP,两级缓存就不行了。
最后再复习下CGLib动态代理的用法:
package com.jxz.AopTest;
import net.sf.cglib.proxy.Enhancer;
/**
* @Author jiangxuzhao
* @Description
* @Date 2023/9/16
*/
public class CGlibTest {
public static void main(String[] args) {
WeakService weakService = new WeakService();
Enhancer enhancer = new Enhancer();
enhancer.setClassLoader(weakService.getClass().getClassLoader());
enhancer.setSuperclass(weakService.getClass());
enhancer.setCallback(new JXZMethodInterceptor());
// 创建代理类
WeakService proxy = (WeakService)enhancer.create();
proxy.f("I'm jxz");
}
}
package com.jxz.AopTest;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* @Author jiangxuzhao
* @Description
* @Date 2023/9/16
*/
public class JXZMethodInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("增强前...");
// 这里调用父类方法,不然一直调用本方法死循环了
Object result = methodProxy.invokeSuper(o, objects);
System.out.println("增强后...");
return result;
}
}