一文掌握Spring中循环依赖与三级缓存

@Component
public class A {
	// A 中依赖 B
	@Autowired
	private B b;
}
@Component
public class B {
	// B 中依赖 A
	@Autowired
	private A a;
}

@Component
public class A {
	// A 中依赖 B
	public A(B b){
	}
}
@Component
public class B {
	// B 中依赖 A
	public B(A a){
	}
}

@Component
public class A {
	// A 中依赖 B
	@Autowired
	private B b;
}
@Component
public class B {
	// B 中依赖 A
	@Autowired
	private A a;
}

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		// beanName 断言处理
		Assert.notNull(beanName, "Bean name must not be null");
		// 对一级缓存加锁处理
		synchronized (this.singletonObjects) {
			// 从一级缓存中获取
			Object singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null) {
				// 一级缓存中获取不到
				if (this.singletonsCurrentlyInDestruction) {
					throw new BeanCreationNotAllowedException(beanName,
							"Singleton bean creation not allowed while singletons of this factory are in destruction " +
							"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
				}
				// 此处是在单例bean创建之前, 判断bean是否需要检查，
				// 并且将beanName添加到singletonsCurrentlyInCreation(正在创建bean的集合，是一个setFromMap集合)中
				beforeSingletonCreation(beanName);
				boolean newSingleton = false;
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet<>();
				}
				try {
					// 此处是一个回调，回去执行createBean()方法,也就是开始真正的创建bean
					singletonObject = singletonFactory.getObject();
					newSingleton = true;
				}
				catch (IllegalStateException ex) {
					// Has the singleton object implicitly appeared in the meantime ->
					// if yes, proceed with it since the exception indicates that state.
					singletonObject = this.singletonObjects.get(beanName);
					if (singletonObject == null) {
						throw ex;
					}
				}
				catch (BeanCreationException ex) {
					if (recordSuppressedExceptions) {
						for (Exception suppressedException : this.suppressedExceptions) {
							ex.addRelatedCause(suppressedException);
						}
					}
					throw ex;
				}
				finally {
					if (recordSuppressedExceptions) {
						this.suppressedExceptions = null;
					}
					// 至此，beanName创建完毕，从singletonsCurrentlyInCreation(正在创建的集合)中移除
					afterSingletonCreation(beanName);
				}
				if (newSingleton) {
					// 将成品的bean添加到一级缓存，并从二级缓存、三级缓存中移除，并添加到已完成注册的单例bean集合中
					addSingleton(beanName, singletonObject);
				}
			}
			return singletonObject;
		}
	}

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
		// 对 singletonFactory 进行非空校验
		Assert.notNull(singletonFactory, "Singleton factory must not be null");
		// 对一级缓存进行加锁
		synchronized (this.singletonObjects) {
			// 如果一级缓存中不存在 beanName 对应的单例对象
			if (!this.singletonObjects.containsKey(beanName)) {
				// 将 singletonFactory 添加到三级缓存中
				this.singletonFactories.put(beanName, singletonFactory);
				// 将 beanName 从二级缓存中移除
				this.earlySingletonObjects.remove(beanName);
				// 将 beanName 添加到 registeredSingletons 中
				this.registeredSingletons.add(beanName);
			}
		}
	}

@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		// Quick check for existing instance without full singleton lock
		// 从一级缓存中获取该beanName实例
		Object singletonObject = this.singletonObjects.get(beanName);
		// 如果以及缓存中不存在并且该beanName对应的单例bean正在创建中
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			// 从二级缓存中获取该beanName实例
			singletonObject = this.earlySingletonObjects.get(beanName);
			// 二级缓存中不存在并且允许提前引用
			if (singletonObject == null && allowEarlyReference) {
				// 锁定全局变量进行操作
				synchronized (this.singletonObjects) {
					// Consistent creation of early reference within full singleton lock
					// 从一级缓存中获取该beanName实例
					singletonObject = this.singletonObjects.get(beanName);
					// 如果一级缓存中获取不到
					if (singletonObject == null) {
						// 从二级缓存中获取
						singletonObject = this.earlySingletonObjects.get(beanName);
						// 二级缓存中也获取不到
						if (singletonObject == null) {
							// 当某些方法需要提前初始化的时候则会调用addSingletonFactory方法将对应的 ObjectFactory 初始化策略存储在 singletonFactories
							ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
							if (singletonFactory != null) {
								// 如果存在单例对象工厂，则通过工厂创建一个单例对象
								singletonObject = singletonFactory.getObject();
								// 放入到二级缓存中
								this.earlySingletonObjects.put(beanName, singletonObject);
								// 并从三级缓存中移除
								this.singletonFactories.remove(beanName);
							}
						}
					}
				}
			}
		}
		return singletonObject;
	}

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
		// 该方法主要用于提前获取 bean 的引用，以便于解决循环依赖的问题
		// 将当前 bean 赋值给 exposedObject
		Object exposedObject = bean;
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			// 这块代码是用代理对象替换原始对象，这样就可以在原始对象的基础上做一些增强操作
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				// AOP --> AnnotationAwareAspectJAutoProxyCreator
				if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
					exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
				}
			}
		}
		return exposedObject;
	}

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
		Object exposedObject = bean;
		return exposedObject;
	}

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
		// 该方法主要用于提前获取 bean 的引用，以便于解决循环依赖的问题
		// 将当前 bean 赋值给 exposedObject
		Object exposedObject = bean;
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			// 这块代码是用代理对象替换原始对象，这样就可以在原始对象的基础上做一些增强操作
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				// AOP --> AnnotationAwareAspectJAutoProxyCreator
				if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
					exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
				}
			}
		}
		return exposedObject;
	}

public Object getEarlyBeanReference(Object bean, String beanName) {
		// 根据bean的类型和名称获取缓存的key，如果beanName为空，则使用bean的类型作为key
		// 如果beanName不为空，则使用beanName作为key，如果beanName是一个FactoryBean的名称，则使用&+beanName作为key
		Object cacheKey = getCacheKey(bean.getClass(), beanName);
		// 添加到earlyProxyReferences中
		this.earlyProxyReferences.put(cacheKey, bean);
		// 创建aop代理
		return wrapIfNecessary(bean, beanName, cacheKey);
	}

        // Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		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");
			}
			// 将创建的bean 的 lambda 表达式放入到三级缓存中
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}