spring解决循环依赖

• spring创建了三个map结构；也就是我们通常所说的三级缓存

• 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) {
  			instanceWrapper = createBeanInstance(beanName, mbd, args);
  		}
  		final Object bean = instanceWrapper.getWrappedInstance();
  		Class<?> beanType = instanceWrapper.getWrappedClass();
  		if (beanType != NullBean.class) {
  			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, () -> getEarlyBeanReference(beanName, mbd, bean));
  		}

  上述代码的最后几行，代表如果支持循环依赖，则先把当前beanname放到singletonFactories的map中去

•     if (earlySingletonExposure) {
  			Object earlySingletonReference = getSingleton(beanName, false);
  			if (earlySingletonReference != null) {
  				if (exposedObject == bean) {
  					exposedObject = earlySingletonReference;
  				}
  				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
  					String[] dependentBeans = getDependentBeans(beanName);
  					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
  					for (String dependentBean : dependentBeans) {
  						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.");
  					}
  				}
  			}
  		}
  

  上述代码是如果支持循环依赖的话，则进入getSingleton(beanName, false)

• @Nullable
  	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  		Object singletonObject = this.singletonObjects.get(beanName);
  		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  			synchronized (this.singletonObjects) {
  				singletonObject = this.earlySingletonObjects.get(beanName);
  				if (singletonObject == null && allowEarlyReference) {
  					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
  					if (singletonFactory != null) {
  						singletonObject = singletonFactory.getObject();
  						this.earlySingletonObjects.put(beanName, singletonObject);
  						this.singletonFactories.remove(beanName);
  					}
  				}
  			}
  		}
  		return singletonObject;
  	}

  这个方法很明显是进行三层map缓存   解决循环依赖的