详解Spring循环依赖的解决方案

protected <T> T doGetBean(   final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)   throws BeansException {  final String beanName = transformedBeanName(name);  Object bean;  // Eagerly check singleton cache for manually registered singletons.  Object sharedInstance = getSingleton(beanName); //关注点1  if (sharedInstance != null && args == null) {   if (logger.isDebugEnabled()) {    if (isSingletonCurrentlyInCreation(beanName)) {     logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +       "' that is not fully initialized yet - a consequence of a circular reference");    }    else {     logger.debug("Returning cached instance of singleton bean '" + beanName + "'");    }   }   bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);  }  else {   // Fail if we're already creating this bean instance:   // We're assumably within a circular reference.   if (isPrototypeCurrentlyInCreation(beanName)) {    throw new BeanCurrentlyInCreationException(beanName);   }   // Check if bean definition exists in this factory.   BeanFactory parentBeanFactory = getParentBeanFactory();   if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {    // Not found -> check parent.    String nameToLookup = originalBeanName(name);    if (args != null) {     // Delegation to parent with explicit args.     return (T) parentBeanFactory.getBean(nameToLookup, args);    }    else {     // No args -> delegate to standard getBean method.     return parentBeanFactory.getBean(nameToLookup, requiredType);    }   }   if (!typeCheckOnly) {    markBeanAsCreated(beanName);   }   try {    final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);    checkMergedBeanDefinition(mbd, beanName, args);    // Guarantee initialization of beans that the current bean depends on.    String[] dependsOn = mbd.getDependsOn();    if (dependsOn != null) {     for (String dependsOnBean : dependsOn) {      if (isDependent(beanName, dependsOnBean)) {       throw new BeanCreationException(mbd.getResourceDescription(), beanName,         "Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");      }      registerDependentBean(dependsOnBean, beanName);      getBean(dependsOnBean);     }    }    // Create bean instance.    if (mbd.isSingleton()) {     //关注点2     sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {      @Override      public Object getObject() throws BeansException {       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);    }    else if (mbd.isPrototype()) {     // It's a prototype -> create a new instance.     Object prototypeInstance = null;     try {      beforePrototypeCreation(beanName);      prototypeInstance = createBean(beanName, mbd, args);     }     finally {      afterPrototypeCreation(beanName);     }     bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);    }    else {     String scopeName = mbd.getScope();     final Scope scope = this.scopes.get(scopeName);     if (scope == null) {      throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");     }     try {      Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {       @Override       public Object getObject() throws BeansException {        beforePrototypeCreation(beanName);        try {         return createBean(beanName, mbd, args);        }        finally {         afterPrototypeCreation(beanName);        }       }      });      bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);     }     catch (IllegalStateException ex) {      throw new BeanCreationException(beanName,        "Scope '" + scopeName + "' is not active for the current thread; consider " +        "defining a scoped proxy for this bean if you intend to refer to it from a singleton",        ex);     }    }   }   catch (BeansException ex) {    cleanupAfterBeanCreationFailure(beanName);    throw ex;   }  }  // Check if required type matches the type of the actual bean instance.  if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {   try {    return getTypeConverter().convertIfNecessary(bean, requiredType);   }   catch (TypeMismatchException ex) {    if (logger.isDebugEnabled()) {     logger.debug("Failed to convert bean '" + name + "' to required type [" +       ClassUtils.getQualifiedName(requiredType) + "]", ex);    }    throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());   }  }  return (T) bean; }

 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 != NULL_OBJECT ? singletonObject : null); }

public boolean isSingletonCurrentlyInCreation(String beanName) {  return this.singletonsCurrentlyInCreation.contains(beanName); }

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {  Assert.notNull(beanName, "'beanName' must not be null");  synchronized (this.singletonObjects) {   Object singletonObject = this.singletonObjects.get(beanName);   if (singletonObject == null) {    if (this.singletonsCurrentlyInDestruction) {     throw new BeanCreationNotAllowedException(beanName,       "Singleton bean creation not allowed while the singletons of this factory are in destruction " +       "(Do not request a bean from a BeanFactory in a destroy method implementation!)");    }    if (logger.isDebugEnabled()) {     logger.debug("Creating shared instance of singleton bean '" + beanName + "'");    }    beforeSingletonCreation(beanName);    boolean newSingleton = false;    boolean recordSuppressedExceptions = (this.suppressedExceptions == null);    if (recordSuppressedExceptions) {     this.suppressedExceptions = new LinkedHashSet<Exception>();    }    try {     singletonObject = singletonFactory.getObject();     newSingleton = true;    }    catch (IllegalStateException ex) {     // Has the singleton object implicitly appeared in the meantime ->     // if yes, proceed with it since the exception indicates that state.     singletonObject = this.singletonObjects.get(beanName);     if (singletonObject == null) {      throw ex;     }    }    catch (BeanCreationException ex) {     if (recordSuppressedExceptions) {      for (Exception suppressedException : this.suppressedExceptions) {       ex.addRelatedCause(suppressedException);      }     }     throw ex;    }    finally {     if (recordSuppressedExceptions) {      this.suppressedExceptions = null;     }     afterSingletonCreation(beanName);    }    if (newSingleton) {     addSingleton(beanName, singletonObject);    }   }   return (singletonObject != NULL_OBJECT ? singletonObject : null);  } }

protected void beforeSingletonCreation(String beanName) {  if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {   throw new BeanCurrentlyInCreationException(beanName);  } }

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {  // 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 != null ? instanceWrapper.getWrappedInstance() : null);  Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);  // Allow post-processors to modify the merged bean definition.  synchronized (mbd.postProcessingLock) {   if (!mbd.postProcessed) {    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);    mbd.postProcessed = true;   }  }  // Eagerly cache singletons to be able to resolve circular references  // even when triggered by lifecycle interfaces like BeanFactoryAware.  //关注点3  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<Object>() {    @Override    public Object getObject() throws BeansException {     return getEarlyBeanReference(beanName, mbd, bean);    }   });  }  // Initialize the bean instance.  Object exposedObject = bean;  try {   populateBean(beanName, mbd, instanceWrapper);   if (exposedObject != null) {    exposedObject = initializeBean(beanName, exposedObject, mbd);   }  }  catch (Throwable ex) {   if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {    throw (BeanCreationException) ex;   }   else {    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);   }  }  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<String>(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.");     }    }   }  }  // Register bean as disposable.  try {   registerDisposableBeanIfNecessary(beanName, bean, mbd);  }  catch (BeanDefinitionValidationException ex) {   throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);  }  return exposedObject; }

public boolean isSingletonCurrentlyInCreation(String beanName) {  return this.singletonsCurrentlyInCreation.contains(beanName); }

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {  Assert.notNull(singletonFactory, "Singleton factory must not be null");  synchronized (this.singletonObjects) {   if (!this.singletonObjects.containsKey(beanName)) {    this.singletonFactories.put(beanName, singletonFactory);    this.earlySingletonObjects.remove(beanName);    this.registeredSingletons.add(beanName);   }  } }

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 != NULL_OBJECT ? singletonObject : null); }