面试必问系列之最强源码分析，带你一步步弄清楚 Spring 如何解决循环依赖

public class Bee {   /**    * 性别    */   private String sex;   /**    * 年龄    */   private Integer age;
   @Autowired   private Flower flower;
   /**    * 采蜜    */   public void pickingHoney() {       // 花产蜜       flower.product();
  }
   public String getSex() {       return sex;  }
   public void setSex(String sex) {       this.sex = sex;  }
   public Integer getAge() {       return age;  }
   public void setAge(Integer age) {       this.age = age;  }}

public class Bee {   /**    * 性别    */   private String sex;   /**    * 年龄    */   private Integer age;

   /**    * 采蜜    */   public void pickingHoney() {       // 花产蜜       Flower flower = new Flower();       flower.product();
  }
   public String getSex() {       return sex;  }
   public void setSex(String sex) {       this.sex = sex;  }
   public Integer getAge() {       return age;  }
   public void setAge(Integer age) {       this.age = age;  }}

 /**    * 采蜜    */   public void pickingHoney() {      Class clazz = Class.forName("com.example.demo.test.Flower");       Flower flower = (Flower)clazz.getDeclaredConstructor().newInstance();       flower.product();
  }

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"      xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
   <bean id="a" class="com.example.demo.test.A">       <property name="b" ref="b"></property>   </bean>
   <bean id="b" class="com.example.demo.test.B">       <property name="a" ref="a"></property>   </bean>
</beans>

public class SpringTestApplication {   public static void main(String[] args) {       ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");  }}

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)throws BeansException {
super(parent);setConfigLocations(configLocations);if (refresh) {           // 此处是我们的第一站refresh();}}

public void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {// 完成准备，设置时间啊等等，我们无需太关心prepareRefresh();
// 无需多关心ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// bean factory 创建前的准备阶段，对应我们上述图的流程prepareBeanFactory(beanFactory);
try {               //BeanFactory的处理过程，跟我们的对象创建关系不大 开始// Allows post-processing of the bean factory in context subclasses.postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.initMessageSource();
// Initialize event multicaster for this context.initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.onRefresh();
// Check for listener beans and register them.registerListeners();               //BeanFactory的处理过程，跟我们的对象创建关系不大 完成
// Instantiate all remaining (non-lazy-init) singletons.               //实例化，所有的非懒加载的单例bean对象，可见第二站入口来了，开启finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.finishRefresh();}
catch (BeansException ex) {if (logger.isWarnEnabled()) {logger.warn("Exception encountered during context initialization - " +"cancelling refresh attempt: " + ex);}
// Destroy already created singletons to avoid dangling resources.destroyBeans();
// Reset 'active' flag.cancelRefresh(ex);
// Propagate exception to caller.throw ex;}
finally {// Reset common introspection caches in Spring's core, since we// might not ever need metadata for singleton beans anymore...resetCommonCaches();}}}

/** Cache of singleton objects: bean name to bean instance. */// 一级缓存private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
/** Cache of singleton factories: bean name to ObjectFactory. */// 三级缓存private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
/** Cache of early singleton objects: bean name to bean instance. */// 二级缓存private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {// Initialize conversion service for this context.if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {beanFactory.setConversionService(beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));}
// Register a default embedded value resolver if no bean post-processor// (such as a PropertyPlaceholderConfigurer bean) registered any before:// at this point, primarily for resolution in annotation attribute values.if (!beanFactory.hasEmbeddedValueResolver()) {beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);for (String weaverAwareName : weaverAwareNames) {getBean(weaverAwareName);}
// Stop using the temporary ClassLoader for type matching.beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.       // 实例化，所有的非懒加载的单例bean对象beanFactory.preInstantiateSingletons();}

@Overridepublic void preInstantiateSingletons() throws BeansException {if (logger.isTraceEnabled()) {logger.trace("Pre-instantiating singletons in " + this);}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.// While this may not be part of the regular factory bootstrap, it does otherwise work fine.List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...       // 根据BeanDefinition 获取bean定义信息for (String beanName : beanNames) {RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);           // 首先 A对象 此处非抽象类 单例 非懒加载才能进入，A对象符合条件，进入if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {if (isFactoryBean(beanName)) {Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);if (bean instanceof FactoryBean) {final FactoryBean<?> factory = (FactoryBean<?>) bean;boolean isEagerInit;if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)((SmartFactoryBean<?>) factory)::isEagerInit,getAccessControlContext());}else {isEagerInit = (factory instanceof SmartFactoryBean &&((SmartFactoryBean<?>) factory).isEagerInit());}if (isEagerInit) {getBean(beanName);}}}else {                   //A对象 进入getBean(beanName);}}}
// 省略}

@Overridepublic Object getBean(String name) throws BeansException {       // Spring源码内 do开头，都是真正做事情的方法return doGetBean(name, null, null, false);}

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.      // 1. 获取单例bean对象 第四站入口    Object sharedInstance = getSingleton(beanName);      // 根据第四站代码分析，此时A对象为空，返回空，将继续执行    if (sharedInstance != null && args == null) {      if (logger.isTraceEnabled()) {        if (isSingletonCurrentlyInCreation(beanName)) {          logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +              "' that is not fully initialized yet - a consequence of a circular reference");        }        else {          logger.trace("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 (parentBeanFactory instanceof AbstractBeanFactory) {          return ((AbstractBeanFactory) parentBeanFactory).doGetBean(              nameToLookup, requiredType, args, typeCheckOnly);        }        else if (args != null) {          // Delegation to parent with explicit args.          return (T) parentBeanFactory.getBean(nameToLookup, args);        }        else if (requiredType != null) {          // No args -> delegate to standard getBean method.          return parentBeanFactory.getBean(nameToLookup, requiredType);        }        else {          return (T) parentBeanFactory.getBean(nameToLookup);        }      }
      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 dep : dependsOn) {            if (isDependent(beanName, dep)) {              throw new BeanCreationException(mbd.getResourceDescription(), beanName,                  "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");            }            registerDependentBean(dep, beanName);            try {              getBean(dep);            }            catch (NoSuchBeanDefinitionException ex) {              throw new BeanCreationException(mbd.getResourceDescription(), beanName,                  "'" + beanName + "' depends on missing bean '" + dep + "'", ex);            }          }        }
        // Create bean instance.                // 3. 创建对象        if (mbd.isSingleton()) {                    // 进入方法          sharedInstance = getSingleton(beanName, () -> {            try {                            // 5. 创建对象 实现A 对象实例              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, () -> {              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 && !requiredType.isInstance(bean)) {      try {        T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);        if (convertedBean == null) {          throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());        }        return convertedBean;      }      catch (TypeMismatchException ex) {        if (logger.isTraceEnabled()) {          logger.trace("Failed to convert bean '" + name + "' to required type '" +              ClassUtils.getQualifiedName(requiredType) + "'", ex);        }        throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());      }    }      // 返回    return (T) bean;  }

@Nullableprotected Object getSingleton(String beanName, boolean allowEarlyReference) {       // 2.       // 一级缓存中查找，是否存在bean A对象，此时为空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;}

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {Assert.notNull(beanName, "Bean name must not be null");       // 4. 执行对象处理synchronized (this.singletonObjects) {           // 一级缓存中获取A 对象，无Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null) {               //进入判断if (this.singletonsCurrentlyInDestruction) {throw new BeanCreationNotAllowedException(beanName,"Singleton bean creation not allowed while 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<>();}try {                   // 获取对象 ObjectFactory<?> 通过匿名内部类执行，匿名内部类 ，获取到A实例化对象，此时A 为实例化状态，创建中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;}}

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) {           //实例A创建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.       // 此处 A对象已创建，会进入判断boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));if (earlySingletonExposure) {if (logger.isTraceEnabled()) {logger.trace("Eagerly caching bean '" + beanName +"' to allow for resolving potential circular references");}           //三级缓存，放入实例化对象A 此时A 未完全状态 缓存内状态，见代码下图示addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));}
// Initialize the bean instance.Object exposedObject = bean;try {           // 6. 填充beanpopulateBean(beanName, mbd, instanceWrapper);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<>(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 " +"'getBeanNamesForType' 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;}

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {// 省略
if (pvs != null) {           //处理属性内容applyPropertyValues(beanName, mbd, bw, pvs);}}

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {// 省略代码
// Create a deep copy, resolving any references for values.List<PropertyValue> deepCopy = new ArrayList<>(original.size());boolean resolveNecessary = false;for (PropertyValue pv : original) {if (pv.isConverted()) {deepCopy.add(pv);}else {               // B对象String propertyName = pv.getName();               // 值为 nullObject originalValue = pv.getValue();if (originalValue == AutowiredPropertyMarker.INSTANCE) {Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod();if (writeMethod == null) {throw new IllegalArgumentException("Autowire marker for property without write method: " + pv);}originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true);}               // 7. 解决B对象Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);Object convertedValue = resolvedValue;//省略代码}

@Nullablepublic Object resolveValueIfNecessary(Object argName, @Nullable Object value) {// We must check each value to see whether it requires a runtime reference// to another bean to be resolved.if (value instanceof RuntimeBeanReference) {RuntimeBeanReference ref = (RuntimeBeanReference) value;           //B对象作为A对象属性值，类型为RuntimeBeanReference 进入判断，执行方法resolveReferencereturn resolveReference(argName, ref);}// 省略代码

@Nullableprivate Object resolveReference(Object argName, RuntimeBeanReference ref) {try {Object bean;Class<?> beanType = ref.getBeanType();if (ref.isToParent()) {BeanFactory parent = this.beanFactory.getParentBeanFactory();if (parent == null) {throw new BeanCreationException(this.beanDefinition.getResourceDescription(), this.beanName,"Cannot resolve reference to bean " + ref +" in parent factory: no parent factory available");}if (beanType != null) {bean = parent.getBean(beanType);}else {                   // A对象依赖B对象，获取B对象bean = parent.getBean(String.valueOf(doEvaluate(ref.getBeanName())));}}//省略代码

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.  //进入获取Object sharedInstance = getSingleton(beanName);if (sharedInstance != null && args == null) {if (logger.isTraceEnabled()) {if (isSingletonCurrentlyInCreation(beanName)) {logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +"' that is not fully initialized yet - a consequence of a circular reference");}else {logger.trace("Returning cached instance of singleton bean '" + beanName + "'");}}bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);}   //省略代码

@Nullableprotected Object getSingleton(String beanName, boolean allowEarlyReference) {       // 此时一级缓存中获取A对象，同样 A对象为空，此时一级缓存中不存在Object singletonObject = this.singletonObjects.get(beanName);       // A对象状态为 实例化 因此，在创建中，进入判断if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {synchronized (this.singletonObjects) {                              // 二级缓存中获取 A对象 ，A对象为空，进入判断singletonObject = this.earlySingletonObjects.get(beanName);if (singletonObject == null && allowEarlyReference) {                   //三级缓存中获取 A对象，可以读取到值ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);if (singletonFactory != null) {singletonObject = singletonFactory.getObject();                       // 将A 对象放入 二级缓存this.earlySingletonObjects.put(beanName, singletonObject);                       // 将A 对象从三级缓存中删除this.singletonFactories.remove(beanName);}}}}return singletonObject;}

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {Assert.notNull(beanName, "Bean name 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 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<>();}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) {                   // 8. A对象属性对象 B对象完成初始化后执行addSingleton(beanName, singletonObject);}}return singletonObject;}}

protected void addSingleton(String beanName, Object singletonObject) {synchronized (this.singletonObjects) {           // 一级缓存放入 B对象 完全态this.singletonObjects.put(beanName, singletonObject);           // 三级缓存删除 B对象this.singletonFactories.remove(beanName);           // 二级缓存删除 B对象this.earlySingletonObjects.remove(beanName);this.registeredSingletons.add(beanName);}}

protected void addSingleton(String beanName, Object singletonObject) {synchronized (this.singletonObjects) {           // 一级缓存放入 A对象 完全态this.singletonObjects.put(beanName, singletonObject);           // 三级缓存删除 A对象this.singletonFactories.remove(beanName);           // 二级缓存删除 A对象this.earlySingletonObjects.remove(beanName);this.registeredSingletons.add(beanName);}}

@Overridepublic void preInstantiateSingletons() throws BeansException {if (logger.isTraceEnabled()) {logger.trace("Pre-instantiating singletons in " + this);}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.// While this may not be part of the regular factory bootstrap, it does otherwise work fine.List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...       // 根据BeanDefinition 获取bean定义信息for (String beanName : beanNames) {RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);           // 首先 A对象 此处非抽象类 单例 非懒加载才能进入，A对象符合条件，进入if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {if (isFactoryBean(beanName)) {Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);if (bean instanceof FactoryBean) {final FactoryBean<?> factory = (FactoryBean<?>) bean;boolean isEagerInit;if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)((SmartFactoryBean<?>) factory)::isEagerInit,getAccessControlContext());}else {isEagerInit = (factory instanceof SmartFactoryBean &&((SmartFactoryBean<?>) factory).isEagerInit());}if (isEagerInit) {getBean(beanName);}}}else {                   //B对象 进入getBean(beanName);}}}
// 省略}

@Nullableprotected Object getSingleton(String beanName, boolean allowEarlyReference) {       // 从一级缓存中获取B对象，获取得到，直接返回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;}

/** Cache of singleton objects: bean name to bean instance. */// 一级缓存private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
/** Cache of singleton factories: bean name to ObjectFactory. */// 三级缓存 返回值类型 泛型为 ObjectFactory<?> 能够处理更多的事项private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
/** Cache of early singleton objects: bean name to bean instance. */// 二级缓存private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);