@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創(chuàng)建之前, 判斷bean是否需要檢查，
				// 并且將beanName添加到singletonsCurrentlyInCreation(正在創(chuàng)建bean的集合，是一個setFromMap集合)中
				beforeSingletonCreation(beanName);
				boolean newSingleton = false;
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet<>();
				}
				try {
					// 此處是一個回調，回去執(zhí)行createBean()方法,也就是開始真正的創(chuàng)建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創(chuàng)建完畢，從singletonsCurrentlyInCreation(正在創(chuàng)建的集合)中移除
					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正在創(chuàng)建中
		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) {
								// 如果存在單例對象工廠，則通過工廠創(chuàng)建一個單例對象
								singletonObject = singletonFactory.getObject();
								// 放入到二級緩存中
								this.earlySingletonObjects.put(beanName, singletonObject);
								// 并從三級緩存中移除
								this.singletonFactories.remove(beanName);
							}
						}
					}
				}
			}
		}
		return singletonObject;
	}

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
		// 該方法主要用于提前獲取 bean 的引用，以便于解決循環(huán)依賴的問題
		// 將當前 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 的引用，以便于解決循環(huán)依賴的問題
		// 將當前 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);
		// 創(chuàng)建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");
			}
			// 將創(chuàng)建的bean 的 lambda 表達式放入到三級緩存中
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}