Spring源码分析（三）（解决循环依赖）

    spring解决循环依赖主要通过三级缓存去完成。

	/** Cache of singleton objects: bean name --> bean instance */
	private final Map singletonObjects = new ConcurrentHashMap(256);

	/** Cache of singleton factories: bean name --> ObjectFactory */
	private final Map> singletonFactories = new HashMap>(16);

	/** Cache of early singleton objects: bean name --> bean instance */
	private final Map earlySingletonObjects = new HashMap(16);

在doGetBean中，它首先会通过getSingleton方法去尝试获取bean。

Object sharedInstance = getSingleton(beanName);

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   /** 首先从singletonObjects获取bean实例 */
   Object singletonObject = this.singletonObjects.get(beanName);
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      synchronized (this.singletonObjects) {
         /** 
          * 如果singletonObjects还没有此bean，有两种情况
          * 1.这个bean正在创建状态，先从earlySingletonObjects获取
          * 2.这个bean还没开始创建
          */
         singletonObject = this.earlySingletonObjects.get(beanName);
         if (singletonObject == null && allowEarlyReference) {
            /** 
             * 如果earlySingletonObjects还没有此bean，有两种情况
             * 1.说明还未被其他bean注入，正在创建状态，先从singletonFactories获取
             * 2.该bean还没开始创建
             */
            ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
               singletonObject = singletonFactory.getObject();
               //将此bean放到提前缓存到earlySingletonObjects中
               this.earlySingletonObjects.put(beanName, singletonObject);
               //从singletonObject删除bean
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return singletonObject;
}

这个方法做了这么一件事，逐步从三级缓存中获取bean：

1. 先到singletonObjects中获取，如果有表示实例化已经完成；
2. 否则到earlySingletonObjects获取，如果有表示已经有bean，且存在循环依赖，将此bean作为属性注入了
3. 否则到singletonFactories获取，如果存在循环依赖，且此属性是第一次被其他bean作为属性注入

相应的在doCreateBean中有这么一串代码：

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

		// Instantiate the bean.
		//BeanWrapper是用来持有创建出来的Bean对象的
		BeanWrapper instanceWrapper = null;
		//如果是Singleton先把缓存中同名的清除
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		//这是创建Bean的地方由createBeanInstance来完成
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
		Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
		mbd.resolvedTargetType = beanType;

		// Allow post-processors to modify the merged bean definition.
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		// 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.isDebugEnabled()) {
				logger.debug("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, new ObjectFactory