public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
	/** Cache of singleton objects: bean name --> bean instance */
	//用于存放完全初始化好的 bean從該緩存中取出的 bean可以直接使用
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
	/** Cache of singleton factories: bean name --> ObjectFactory */
	//存放 bean工廠對(duì)象解決循環(huán)依賴(lài)
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
	//存放原始的bean對(duì)象用于解決循環(huán)依賴(lài),注意：存到里面的對(duì)象還沒(méi)有被填充屬性
	/** Cache of early singleton objects: bean name --> bean instance */
	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
}

protected <T> T doGetBean(...){
	... 
	// 標(biāo)記beanName a是已經(jīng)創(chuàng)建過(guò)至少一次的~~~ 它會(huì)一直存留在緩存里不會(huì)被移除（除非拋出了異常）
	// 參見(jiàn)緩存Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256))
	if (!typeCheckOnly) {
		markBeanAsCreated(beanName);
	}
	// 此時(shí)a不存在任何一級(jí)緩存中，且不是在創(chuàng)建中  所以此處返回null
	// 此處若不為null，然后從緩存里拿就可以了(主要處理FactoryBean和BeanFactory情況吧)
	Object beanInstance = getSingleton(beanName, false);
	...
	// 這個(gè)getSingleton方法非常關(guān)鍵。
	//1、標(biāo)注a正在創(chuàng)建中~
	//2、調(diào)用singletonObject = singletonFactory.getObject();（實(shí)際上調(diào)用的是createBean()方法）  因此這一步最為關(guān)鍵
	//3、此時(shí)實(shí)例已經(jīng)創(chuàng)建完成  會(huì)把a(bǔ)移除整整創(chuàng)建的緩存中
	//4、執(zhí)行addSingleton()添加進(jìn)去。（備注：注冊(cè)bean的接口方法為registerSingleton，它依賴(lài)于addSingleton方法）
	sharedInstance = getSingleton(beanName, () -> { ... return createBean(beanName, mbd, args); });
}

protected Object doCreateBean(){
	...
	// 使用構(gòu)造器/工廠方法   instanceWrapper是一個(gè)BeanWrapper
	instanceWrapper = createBeanInstance(beanName, mbd, args);
	// 此處bean為"原始Bean"   也就是這里的A實(shí)例對(duì)象：A@1234
	final Object bean = instanceWrapper.getWrappedInstance();
	...
	// 是否要提前暴露（允許循環(huán)依賴(lài)）  現(xiàn)在此處A是被允許的
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
	// 允許暴露，就把A綁定在ObjectFactory上，注冊(cè)到三級(jí)緩存`singletonFactories`里面去保存著
	// Tips:這里后置處理器的getEarlyBeanReference方法會(huì)被促發(fā)，自動(dòng)代理創(chuàng)建器在此處創(chuàng)建代理對(duì)象（注意執(zhí)行時(shí)機(jī) 為執(zhí)行三級(jí)緩存的時(shí)候）
	if (earlySingletonExposure) {
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}
	...
	// exposedObject 為最終返回的對(duì)象，此處為原始對(duì)象bean也就是A@1234,下面會(huì)有用處
	Object exposedObject = bean; 
	// 給A@1234屬性完成賦值，@Autowired在此處起作用~
	// 因此此處會(huì)調(diào)用getBean("b")，so 會(huì)重復(fù)上面步驟創(chuàng)建B類(lèi)的實(shí)例
	// 此處我們假設(shè)B已經(jīng)創(chuàng)建好了 為B@5678
	// 需要注意的是在populateBean("b")的時(shí)候依賴(lài)有beanA，所以此時(shí)候調(diào)用getBean("a")最終會(huì)調(diào)用getSingleton("a")，
	//此時(shí)候上面說(shuō)到的getEarlyBeanReference方法就會(huì)被執(zhí)行。這也解釋為何我們@Autowired是個(gè)代理對(duì)象，而不是普通對(duì)象的根本原因
	populateBean(beanName, mbd, instanceWrapper);
	// 實(shí)例化。這里會(huì)執(zhí)行后置處理器BeanPostProcessor的兩個(gè)方法
	// 此處注意：postProcessAfterInitialization()是有可能返回一個(gè)代理對(duì)象的，這樣exposedObject 就不再是原始對(duì)象了
	exposedObject = initializeBean(beanName, exposedObject, mbd);
	... // 至此，相當(dāng)于A@1234已經(jīng)實(shí)例化完成、初始化完成（屬性也全部賦值了~）
	// 這一步我把它理解為校驗(yàn)：校驗(yàn)：校驗(yàn)是否有循環(huán)引用問(wèn)題~~~~~
	if (earlySingletonExposure) {
		// 注意此處第二個(gè)參數(shù)傳的false，表示不去三級(jí)緩存里singletonFactories再去調(diào)用一次getObject()方法了~~~
		// 上面建講到了由于B在初始化的時(shí)候，會(huì)觸發(fā)A的ObjectFactory.getObject()  所以a此處已經(jīng)在二級(jí)緩存earlySingletonObjects里了
		// 因此此處返回A的實(shí)例：A@1234
		Object earlySingletonReference = getSingleton(beanName, false);
		if (earlySingletonReference != null) {
			// 這個(gè)等式表示，exposedObject若沒(méi)有再被代理過(guò)，這里就是相等的
			// 顯然此處我們的a對(duì)象的exposedObject它是沒(méi)有被代理過(guò)的  所以if會(huì)進(jìn)去~
			// 這種情況至此，就全部結(jié)束了~~~
			if (exposedObject == bean) {
				exposedObject = earlySingletonReference;
			}
			// 繼續(xù)以A為例，比如方法標(biāo)注了@Aysnc注解，exposedObject此時(shí)候就是一個(gè)代理對(duì)象，因此就會(huì)進(jìn)到這里來(lái)
			//hasDependentBean(beanName)是肯定為true，因?yàn)間etDependentBeans(beanName)得到的是["b"]這個(gè)依賴(lài)
			else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
				String[] dependentBeans = getDependentBeans(beanName);
				Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
				// A@1234依賴(lài)的是["b"]，所以此處去檢查b
				// 如果最終存在實(shí)際依賴(lài)的bean：actualDependentBeans不為空 那就拋出異常  證明循環(huán)引用了~
				for (String dependentBean : dependentBeans) {
					// 這個(gè)判斷原則是：如果此時(shí)候b并還沒(méi)有創(chuàng)建好，this.alreadyCreated.contains(beanName)=true表示此bean已經(jīng)被創(chuàng)建過(guò)，就返回false
					// 若該bean沒(méi)有在alreadyCreated緩存里，就是說(shuō)沒(méi)被創(chuàng)建過(guò)(其實(shí)只有CreatedForTypeCheckOnly才會(huì)是此倉(cāng)庫(kù))
					if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
						actualDependentBeans.add(dependentBean);
					}
				}
				if (!actualDependentBeans.isEmpty()) {
					throw new BeanCurrentlyInCreationException(beanName,
							"Bean with name '" + beanName + "' has been injected into other beans [" +
							StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
							"] in its raw version as part of a circular reference, but has eventually been " +
							"wrapped. This means that said other beans do not use the final version of the " +
							"bean. This is often the result of over-eager type matching - consider using " +
							"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
				}
			}
		}
	}
}