Spring源碼剖析之Spring處理循環依賴的問題

public class BeanA {

    private BeanB beanB;

    public BeanA(BeanB beanB){
        this.beanB = beanB;
    }
}

public class BeanB {

    private BeanA beanA;

    public BeanB(BeanA beanA){
        this.beanA = beanA;
    }
}

<bean id="beanA" class="cn.itsource._01_di.BeanA" >
        <constructor-arg type="cn.itsource._01_di.BeanB" ref="beanB"  />
 </bean>


 <bean id="beanB" class="cn.itsource._01_di.BeanB"  >
         <constructor-arg type="cn.itsource._01_di.BeanA" ref="beanA" />
 </bean>

public class BeanA {

    private BeanB beanB;

    public void setBeanB(BeanB beanB){
        this.beanB = beanB;
    }
}

@Data
public class BeanB {

    private BeanA beanA;

    public void setBeanA(BeanA beanA){
        this.beanA = beanA;
    }
}

<bean id="beanA" class="cn.itsource._01_di.BeanA" >
    <property name="beanB" ref="beanB" />
</bean>

<bean id="beanB" class="cn.itsource._01_di.BeanB">
    <property name="beanA" ref="beanA" />
</bean>

public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {

	@Nullable
	private Boolean allowBeanDefinitionOverriding;
	//是否允許循環依賴
	@Nullable
	private Boolean allowCircularReferences;
	
	//設置循環依賴
	public void setAllowCircularReferences(boolean allowCircularReferences) {
		this.allowCircularReferences = allowCircularReferences;
	}

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
//禁用循環依賴
applicationContext.setAllowCircularReferences(false);
//刷新容器
applicationContext.refresh();
...

//正在創建中的Bean
private final Set<String> singletonsCurrentlyInCreation =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		...省略...
		//把該Bean的名字加入 singletonsCurrentlyInCreation 正在創建池 中
		beforeSingletonCreation(beanName);
		boolean newSingleton = false;
		boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
		if (recordSuppressedExceptions) {
			this.suppressedExceptions = new LinkedHashSet<>();
		}
		try {
			//調用ObjectFactory創建Bean的實例
			singletonObject = singletonFactory.getObject();
			newSingleton = true;
		}
...省略...


//如果singletonsCurrentlyInCreation中沒該Ｂｅａｎ，就把該Bean存儲到singletonsCurrentlyInCreation中，
//如果 singletonsCurrentlyInCreation 中有 該Bean，就報錯循環依賴異常BeanCurrentlyInCreationException
//也就意味著同一個beanName進入該方法2次就會拋異常
protected void beforeSingletonCreation(String beanName) {
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
	}

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

		final String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		//緩存中獲取Bean,解決瞭循環依賴問題
		Object sharedInstance = getSingleton(beanName);
     	...緩存中沒有走下面...
		if (mbd.isSingleton()) {
					//走 DefaultSingletonBeanRegistry#getSingleton ，方法會把bean加入“正在創建bean池”
					//然後調用ObjectFactory實例化Bean
					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;
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
		//實例化Bean
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		...省略...
		//如果是單利 ，如果是允許循環依賴，如果 beanName 出於創建中，已經被添加到“創建中的bean池”
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isDebugEnabled()) {
				logger.debug("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			//把ObjectFactory 添加到 singletonFactories 中。
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}
		
	try {
		//走依賴註入流程
			populateBean(beanName, mbd, instanceWrapper);
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}


//緩存單利Bean的創建工廠，用於解決循環依賴
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(singletonFactory, "Singleton factory must not be null");
		synchronized (this.singletonObjects) {
			//singletonObjects單利緩存中是否包含Bean
			if (!this.singletonObjects.containsKey(beanName)) {
				//提前暴露ObjectFactory，把ObjectFactory放到singletonFactories中，
				//後面解決循環依賴，獲取Bean實例的時候會用到
				this.singletonFactories.put(beanName, singletonFactory);
				//早期單利bean緩存中移除Bean
				this.earlySingletonObjects.remove(beanName);
				//把註冊的Bean加入registeredSingletons中
				this.registeredSingletons.add(beanName);
			}
		}
	}

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

		final String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		//從緩存中獲取Bean
		Object sharedInstance = getSingleton(beanName);

		...省略...

		//如果緩存中沒有Bean，就創建Bean
		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;
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

//allowEarlyReference ：是否創建早期應用，主要用來解決循環依賴
	@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		// Quick check for existing instance without full singleton lock
		//從Map中 singletonObjects = new ConcurrentHashMap<>(256); 獲取單利Bean

		//【一級緩存】singletonObject緩存中是否有Bean , 它存儲的是已經實例化好的Bean
		Object singletonObject = this.singletonObjects.get(beanName);

		//如果singletonObjects中沒有Bean，但是Bean出於正在創建池中，即： Set<String> singletonsCurrentlyInCreation中有Bean，
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			
			//【二級緩存】從早期單例對象的緩存 earlySingletonObjects 中獲取
			singletonObject = this.earlySingletonObjects.get(beanName);
			
			//早期單利對象緩存中也沒有，但是允許循環依賴
			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) {
							
							//【三級緩存】獲取ObjectFactory ， 對象創建工廠,得到Bean創建過程中提前暴露的工廠。
							ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
							if (singletonFactory != null) {
								//通過工廠ObjectFactory 獲取對象實例
								singletonObject = singletonFactory.getObject();
								//把對象存儲到早期緩存中
								this.earlySingletonObjects.put(beanName, singletonObject);
								//把ObjectFactory移除
								this.singletonFactories.remove(beanName);
							}
						}
					}
				}
			}
		}
		return singletonObject;
	}