本文参考：
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.
* <p>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.
* <p>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;
}
}
