Spring为什么使用三级缓存来解决循环依赖

三级缓存

缓存	属性	说明
一级缓存	singletonObjects	保存初始化的单例Bean
二级缓存	earlySingletonObjects	保存实例化、未初始化的单例Bean或其代理
三级缓存	singletonFactories	保存创建bean或其代理的工厂对象

问题：为什么要使用三级缓存

在没有AOP的场景下，spring只需要二级缓存就可以解决单例bean在set注入时产生的循环依赖问题，但是引用spring AOP 之后，显然如果只有二级缓存，那么注入到被依赖的bean对象中的bean只能是原始对象，而非代理对象，如果这个被注入的bean需要被AOP代理，因为被注入的是原始对象，所以无法满足诉求，这就是为什么spring使用三级缓存解决spring的循环依赖问题

HOW：如何实现

我们现在假设AB相互依赖且需要被代理,假设A先被创建。

那么在调用doGetBean方法时，进入getSinglenton方法

if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							// Explicitly remove instance from singleton cache: It might have been put there
							// eagerly by the creation process, to allow for circular reference resolution.
							// Also remove any beans that received a temporary reference to the bean.
							destroySingleton(beanName);
							throw ex;
						}
					});
					beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

在getSinglenton方法中，有singletonObject = singletonFactory.getObject();这段代码实际上是执行外部的createBean(beanName, mbd, args)方法

那么开始创建A对象，在doCreateBean方法中，在实例化好A对象之后，spring会将创建A的早期引用的工厂对象放入三级缓存中

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

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;
	}

我们看到 () -> getEarlyBeanReference(beanName, mbd, bean)， 这个其实可以理解为ObjectFactory的一个实现，具体的调用时机是调用存放在三级缓存中的A的对应的工厂对象的getObject()方法时调用。当这个方法被调用后，返回的对象会存放在二级缓存，三级缓存中的工厂对象会被移除。

getEarlyBeanReference方法判断返回一个原始对象还是返回一个代理对象，这里我们不关注具体的实现细节。

那么当A的工厂对象被添加到三级缓存中之后，接着调用populateBean方法进行属性填充，在属性填充的过程中发现A的属性包含B，那么从beanFactory中getBean，接着继续走创建B的流程。

接着会与创建A的过程一致，将创建B对象的工厂对象添加到三级缓存中，接着populationBean进行属性装配的时候调用beanFactory.getBean(A)，那么返回的对象A的代理对象存放在二级缓存，三级缓存中的工厂对象被移除。在完成属性装配，实例化之后调用applyBeanPostProcessorsAfterInitialization返回被代理的对象，接着在getSingleton方法中的addSingleton方法中将对象B的代理对象放入一级缓存。

protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			this.singletonObjects.put(beanName, singletonObject);
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.add(beanName);
		}
	}

在完成B对象的创建之后，继续完成对A对象的属性填充和实例化之后，调用applyBeanPostProcessorsAfterInitialization返回被代理的对象，接着在getSingleton方法中的addSingleton方法中将对象B的代理对象放入一级缓存。

总结

当存在循环依赖的情况下，例如Bean A和Bean B相互依赖，假设我们先创建Bean A：

1. 在创建Bean A的过程中，首先会将A的ObjectFactory（用于生成Bean A实例的工厂）放入三级缓存singletonFactories中。

2. 当注入Bean B时，发现B依赖于A，此时会去缓存中查找A，首先查找一级缓存singletonObjects，没有找到，然后查找二级缓存earlySingletonObjects，也没有找到，最后在三级缓存singletonFactories找到了A的ObjectFactory，然后通过这个ObjectFactory创建出一个早期的Bean A实例，放入二级缓存earlySingletonObjects中。

3. 创建完Bean B后，继续完成Bean A的创建，此时会将Bean A从二级缓存earlySingletonObjects移除，并放入一级缓存singletonObjects中。

4. 对于Bean B，由于它的创建并没有产生循环依赖（因为当它需要依赖的Bean A在二级缓存中已经存在了），所以它的实例直接被放入一级缓存singletonObjects中，不会经过二级缓存earlySingletonObjects。