Spring如何解决循环依赖？
相信不少小伙伴在面试过程中被问到过这个问题，也有不少小伙伴看到这个问题会脱口而出：三级缓存！但是，你真的了解spring解决循环依赖的过程吗？三级缓存是哪三级呢？他们是如何发挥作用的呢？
解决循环依赖的核心类——DefaultSingletonBeanRegistry
核心成员变量
不少同学一定很好奇三级缓存究竟是哪三级呢，他们是以什么样的形式来发挥作用的呢？
// 单例对象的缓存：bean名称到bean实例。
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 当前正在创建的bean的名称。
private final Set<String> singletonsCurrentlyInCreation =
Collections.newSetFromMap(new ConcurrentHashMap<>(16));
// 早期单例对象的缓存：bean名称到bean实例。
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
- singletonObjects：用于保存单例Bean对象，其键为Bean名称，值为单例Bean对象。Spring容器启动时会将所有的单例Bean创建并保存在该成员变量中，以供后续的Bean注入和依赖查找使用。——这里面保存的是完整的，经历了创建和初始化之后的完整Bean对象
- singletonsCurrentlyInCreation：存放当前正在创建的单例bean的名称，在getSingleton方法中，如果singletonObjects、singletonFactories和registeredSingletons中都没有对应的单例对象，就会将当前bean的名称存放在其中，表示当前bean正在创建中。——这里面保存的是正在创建的Bean
- earlySingletonObjects：存放早期暴露出来的单例对象，即在创建单例对象过程中需要用到当前bean的单例对象，但是当前bean还未创建完成，此时就会将当前bean的代理对象（代理对象可以替代当前bean完成一些操作）存放在earlySingletonObjects中。——这里面保存的是创建完成，还未初始化的Bean
举个例子：有一个BeanA依赖来BeanB，但是BeanB还未完成创建，先对BeanA生成一个临时的代理对象C使BeanA可以用但是不是很完善，并将BeanA存放到earlySingletonObjects容器中，等待BeanB创建完成后再替换回来。
核心方法——getSingleton
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 快速检查没有完整bean
Object singletonObject = this.singletonObjects.get(beanName);
// 检查成员变量正在创建的bean中有没有
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 如果没有完整的bean，并且当前bean正在创建，尝试从半成品中寻找，如果找到了意味着很大概率发生了循环依赖。
//比如A和B循环依赖，所以A在创建之后会放在earlySingletonObjects中，初始化B的时候需要A，此时会尝试在earlySingletonObjects寻找A
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
// 如果半成品里也没有，并且允许早期引用
synchronized (this.singletonObjects) {
// 加锁防止其他线程修改
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) {
// 通过工厂方法创建出来这个bean，并将他放到earlySingletonObjects中
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
// 因为是单例模式，所以可以把工厂删掉了，以后就用它了
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
问题：我们只看见了将Bean放入了earlySingletonObjects，什么时候放入到singletonObjects呢？
在SpringBoot的启动过程中实际会有两次移除earlySingletonObjects的操作。
第一次尝试移除：添加Singleton Factory
AbstractAutowireCapableBeanFactory类的doCreateBean方法，代码有点长，我忽略了其他不重要信息。有兴趣的小伙伴可以自己去源码中阅读。
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
/** 忽略部分代码*/
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//添加Singleton Factory会移除一次，虽然此时还没有创建，没错就是这么严谨
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
populateBean(beanName, mbd, instanceWrapper);
// 初始化bean，这个方法里的代码在标题《删除earlySingletonObjects放入singletonObjects：完成bean后置处理器》中
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
/**忽略部分代码*/
addSingletonFactory方法代码：
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);
}
}
}
删除earlySingletonObjects放入singletonObjects：完成bean后置处理器
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//完成创建，这个方法调用链和本文最紧密的部分就是上面最开始的代码“getSingleton”
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
// 完成bean后置处理器，这个调用链与本文最紧密的代码在下方
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
// 移出earlySingletonObjects
this.earlySingletonObjects.remove(beanName);
// 存入registeredSingletons。此时该bean已经完整了
this.registeredSingletons.add(beanName);
}
}