/**
* 一級緩存
* 用于保存beanName和創(chuàng)建bean實例之間的關系，是已經實例化和初始化完成的bean
*/
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
/**
* 二級緩存
* 用于保存beanName和創(chuàng)建bean實例之間的關系，與singletonObject的區(qū)別是這里面的bean是半成品，只完成實例化沒有完成初始化;
* 與singletonFactories的區(qū)別是，當一個單例bean被放到這里之后，那么當bean還在創(chuàng)建過程中就可以通過getBean方法獲取到，可以方便進行循環(huán)依賴的檢測。
*/
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
/**
* 三級緩存
* 用于保存beanName和和創(chuàng)建bean的工廠之間的關系，ObjectFactory就是一個Lambda表達式。
*/
private final Map<String, ObjectFactory<?>> singletonFactories = new ConcurrentHashMap<>(16);

@Component
public class A {
    @Autowired
    private B b;
    public B getB() {
        return b;
    }
    public void setB(B b) {
        this.b = b;
    }
}
@Component
public class B {
    @Autowired
    private A a;
    public A getA() {
        return a;
    }
    public void setA(A a) {
        this.a = a;
    }
}
@Configuration
@ComponentScan(basePackages = "com.mashibing.selfcycle")
public class CycleConfig {
}
public class TestCycle {
    public static void main(String[] args) {
        final AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(CycleConfig.class);
        ac.close();
    }
}

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
// 為避免后期循環(huán)依賴，可以在bean初始化完成前將創(chuàng)建實例的ObjectFactory加入工廠
// bean是實例化后的bean對象
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
	// 默認最終公開的對象是bean,通過createBeanInstance創(chuàng)建出來的普通對象
	Object exposedObject = bean;
	// mbd的systhetic屬性：設置此bean定義是否是"synthetic"，一般是指只有AOP相關的pointCut配置或者Advice配置才會將 synthetic設置為true
	// 如果mdb不是synthetic且此工廠擁有InstantiationAwareBeanPostProcessor
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		// 遍歷工廠內的所有后處理器
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			// 如果bp是SmartInstantiationAwareBeanPostProcessor實例
			if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
				SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
				// 讓exposedObject經過每個SmartInstantiationAwareBeanPostProcessor的包裝
				exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
			}
		}
	}
}

	public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
			throws BeansException {
		return beanFactory.getBean(beanName);
	}

DefaultSingleBeanRegistry.java
@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)) {
		//從早期單例對象緩存中獲取單例對象（之所稱成為早期單例對象，是因為earlySingletonObjects里
		// 的對象的都是通過提前曝光的ObjectFactory創(chuàng)建出來的，還未進行屬性填充等操作）
		singletonObject = this.earlySingletonObjects.get(beanName);
		// 如果在早期單例對象緩存中也沒有，并且允許創(chuàng)建早期單例對象引用
		if (singletonObject == null && allowEarlyReference) {
			// 如果為空，則鎖定全局變量并進行處理
			synchronized (this.singletonObjects) {
				// Consistent creation of early reference within full singleton lock
				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 void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			// 將映射關系添加到單例對象的高速緩存中
			this.singletonObjects.put(beanName, singletonObject);
			// 移除beanName在單例工廠緩存中的數據
			this.singletonFactories.remove(beanName);
			// 移除beanName在早期單例對象的高速緩存的數據
			this.earlySingletonObjects.remove(beanName);
			// 將beanName添加到已注冊的單例集中
			this.registeredSingletons.add(beanName);
		}
	}