关于SpringBoot的三级缓存的思考问题小结

@Component
@Data
public class CycleDependenceTestA {
    @Autowired
    public CycleDependenceTestB cycleDependenceTestB;
    public CycleDependenceTestA() {}
}
@Component
@Data
public class CycleDependenceTestB {
    @Autowired
    public CycleDependenceTestA cycleDependenceTestA;
    public CycleDependenceTestB() {}
}

@Component
@Data
public class CycleDependenceTestA {
    public CycleDependenceTestB cycleDependenceTestB;
    public CycleDependenceTestA(CycleDependenceTestB cycleDependenceTestB) {
        this.cycleDependenceTestB = cycleDependenceTestB;
    }
}
@Component
@Data
public class CycleDependenceTestB {
    public CycleDependenceTestA cycleDependenceTestA;
    public CycleDependenceTestB(CycleDependenceTestA cycleDependenceTestA) {
        this.cycleDependenceTestA = cycleDependenceTestA;
    }
}

Description:
The dependencies of some of the beans in the application context form a cycle:
┌─────┐
|  cycleDependenceTestA defined in file [E:\Java space\codes\SpringBootDemo\target\classes\org\example\springbootdemo\beans\CycleDependenceTestA.class]
↑     ↓
|  cycleDependenceTestB defined in file [E:\Java space\codes\SpringBootDemo\target\classes\org\example\springbootdemo\beans\CycleDependenceTestB.class]
└─────┘
Action:
Despite circular references being allowed, the dependency cycle between beans could not be broken. Update your application to remove the dependency cycle.
Process finished with exit code 1

@Component
@Data
public class CycleDependenceTestA {
    public CycleDependenceTestB cycleDependenceTestB;
    public CycleDependenceTestA(CycleDependenceTestB cycleDependenceTestB) {
        this.cycleDependenceTestB = cycleDependenceTestB;
    }
}
@Component
@Data
public class CycleDependenceTestB {
    @Autowired
    public CycleDependenceTestA cycleDependenceTestA;
    public CycleDependenceTestB() {}
}

Description:
The dependencies of some of the beans in the application context form a cycle:
┌─────┐
|  cycleDependenceTestA defined in file [E:\Java space\codes\SpringBootDemo\target\classes\org\example\springbootdemo\beans\CycleDependenceTestA.class]
↑     ↓
|  cycleDependenceTestB (field public org.example.springbootdemo.beans.CycleDependenceTestA org.example.springbootdemo.beans.CycleDependenceTestB.cycleDependenceTestA)
└─────┘
Action:
Despite circular references being allowed, the dependency cycle between beans could not be broken. Update your application to remove the dependency cycle.
Process finished with exit code 1

@Component
@Data
public class CycleDependenceTestA {
    @Autowired
    public CycleDependenceTestB cycleDependenceTestB;
    public CycleDependenceTestA() {}
}
@Component
@Data
public class CycleDependenceTestB {
    public CycleDependenceTestA cycleDependenceTestA;
    public CycleDependenceTestB(CycleDependenceTestA cycleDependenceTestA) {
        this.cycleDependenceTestA = cycleDependenceTestA;
    }
}

// 核心逻辑：AbstractAutowireCapableBeanFactory#doCreateBean
// 1. 创建 Bean 实例（构造函数注入在此阶段完成）
instanceWrapper = createBeanInstance(beanName, mbd, args);
// 2. 暴露早期引用，将用于生成代理的 ObjectFactory 放入第三级缓存
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
// 3. 属性依赖注入（此阶段执行 @Autowired、@Value 等注解逻辑）
//   关键处理器：AutowiredAnnotationBeanPostProcessor
populateBean(beanName, mbd, instanceWrapper);
// 4. Bean 初始化（执行初始化回调与 AOP 代理创建等逻辑）
//   关键处理器：AbstractAutoProxyCreator 及其他 BeanPostProcessor
exposedObject = initializeBean(beanName, exposedObject, mbd);

// 一级缓存：存放完全初始化完成的单例 Bean
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 二级缓存：存放提前暴露但尚未完全初始化的 Bean 实例
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
// 三级缓存：存放可以生成 Bean 早期引用的工厂（通常是用于生成代理的 ObjectFactory）
private final Map<String, ObjectFactory<?>> singletonFactories = new ConcurrentHashMap<>(16);

// 源码
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) {
				if (!this.singletonLock.tryLock()) {
					// Avoid early singleton inference outside of original creation thread.
					return null;
				}
				try {
					// 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();
								// Singleton could have been added or removed in the meantime.
								if (this.singletonFactories.remove(beanName) != null) {
									this.earlySingletonObjects.put(beanName, singletonObject);
								}
								else {
									singletonObject = this.singletonObjects.get(beanName);
								}
							}
						}
					}
				}
				finally {
					this.singletonLock.unlock();
				}
			}
		}
		return singletonObject;
	}

private final Map<String, ObjectFactory<?>> singletonFactories = new ConcurrentHashMap<>(16);

addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

// class AbstractAutowireCapableBeanFactory
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
	Object exposedObject = bean;
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
			exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
		}
	}
	return exposedObject;
}

// class AbstractAutoProxyCreator
@Override
public Object getEarlyBeanReference(Object bean, String beanName) {
	Object cacheKey = getCacheKey(bean.getClass(), beanName);
	this.earlyBeanReferences.put(cacheKey, bean);
	return wrapIfNecessary(bean, beanName, cacheKey);
}

// AbstractAutowireCapableBeanFactory（伪代码改造）
if (earlySingletonExposure) {
	if (logger.isTraceEnabled()) {
		logger.trace("Eagerly caching bean '" + beanName +
				"' to allow for resolving potential circular references");
	}
	addEarlySingletonObjects(beanName, getEarlyBeanReference(beanName, mbd, bean));
}