六、Spring源码-容器启动Bean的创建

容器启动最核心的步骤之一，初始化所有非懒加载的其余Bean

AbstractApplicationContext.finishBeanFactoryInitialization(…)

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.
  // 尽早初始化 LoadTimeWeaverAware Bean，以便尽早注册其转换器。
  String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
  for (String weaverAwareName : weaverAwareNames) {
      getBean(weaverAwareName);
  }

  // Stop using the temporary ClassLoader for type matching.
  // 停止使用临时的ClassLoader进行类型匹配。
  beanFactory.setTempClassLoader(null);

  // Allow for caching all bean definition metadata, not expecting further changes.
  // 设置 beanDefinition 元数据 不可以再修改
  beanFactory.freezeConfiguration();

  // Instantiate all remaining (non-lazy-init) singletons.
  // 实例化单例 bean
  beanFactory.preInstantiateSingletons();
}

DefaultListableBeanFactory.preInstantiateSingletons(…)

public 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.
  // 将 beanDefinitionNames 放到集合中
  List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

  // Trigger initialization of all non-lazy singleton beans...
  // 遍历
  for (String beanName : beanNames) {
      // 获取 bd 信息, 因为可能 定义了 parentBeanDefinition
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      // 非抽象, 单例, 且不是懒加载
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
          // 判断是否为 FactoryBean
          if (isFactoryBean(beanName)) {
              // FactoryBean 需要添加前缀 & ,通过 getBean(&beanName) 获取的是 FactoryBean 本身
              Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
              if (bean instanceof FactoryBean) {
                  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 {
              getBean(beanName);
          }
      }
  }

  // Trigger post-initialization callback for all applicable beans...
  // 如果 Bean 实现了 SmartInitializingSingleton,
  // 在这里会统一调用 afterSingletonsInstantiated 方法
  for (String beanName : beanNames) {
      Object singletonInstance = getSingleton(beanName);
      if (singletonInstance instanceof SmartInitializingSingleton) {
          StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
                  .tag("beanName", beanName);
          SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
          if (System.getSecurityManager() != null) {
              AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                  smartSingleton.afterSingletonsInstantiated();
                  return null;
              }, getAccessControlContext());
          }
          else {
              smartSingleton.afterSingletonsInstantiated();
          }
          smartInitialize.end();
      }
  }
}

AbstractBeanFactory.doGetBean(…)

/**
* 返回一个实例，该实例可以是指定bean的共享或独立的。
* 
* @param name – 要检索的 bean 的名称
* @param requiredType – 要检索的 bean 的必需类型，这个可以为空
* @param args –使用显式参数创建bean实例时要使用的参数（仅在创建新实例而不是检索现有实例时才应用）
* @param typeCheckOnly –是否为类型检查而不是实际使用获取实例
*
**/
protected <T> T doGetBean(
        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
        throws BeansException {

  // 去掉工厂引用的前缀, 同时转换别名
  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 直接返回, FactoryBean 则返回 FactoryBean 创建的 Bean
      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  }

  else {
      // Fail if we're already creating this bean instance:
      // We're assumably within a circular reference.
      // 返回指定的 原型bean (prototype 类型的 Bean) 是否当前正在创建中（在当前线程内）。
      if (isPrototypeCurrentlyInCreation(beanName)) {
          throw new BeanCurrentlyInCreationException(beanName);
      }

      // Check if bean definition exists in this factory.
      // 检查 BeanFactory 是否存在这个 Bean 的 BeanDefinition
      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) {
          // 将当前 beanName 放入一个 alreadyCreated 的 Set 集合中。
          // 标识本次调用方法，并非是要获取bean的类型，而是为了创建实例，将beanName存到alreadyCreated集合，代表该bean已经创建了，后面try。。catch有异常会清空该beanName
          markBeanAsCreated(beanName);
      }

      StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
              .tag("beanName", name);
      try {
          if (requiredType != null) {
              beanCreation.tag("beanType", requiredType::toString);
          }
          // 获取 Bean 的 BeanDefinition
          RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
          checkMergedBeanDefinition(mbd, beanName, args);

          // Guarantee initialization of beans that the current bean depends on.
          // 确保依赖的 Bean 已经被初始化, 比如 @DependsOn 注解
          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 {
                      // 创建依赖的 Bean
                      getBean(dep);
                  }
                  catch (NoSuchBeanDefinitionException ex) {
                      throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                              "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                  }
              }
          }

          // Create bean instance.
          if (mbd.isSingleton()) {
              // 单例 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);
          }
          // 创建原型Bean
          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();
              if (!StringUtils.hasLength(scopeName)) {
                  throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
              }
              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 ScopeNotActiveException(beanName, scopeName, ex);
              }
          }
      }
      catch (BeansException ex) {
          beanCreation.tag("exception", ex.getClass().toString());
          beanCreation.tag("message", String.valueOf(ex.getMessage()));
          cleanupAfterBeanCreationFailure(beanName);
          throw ex;
      }
      finally {
          beanCreation.end();
      }
  }

  // Check if required type matches the type of the actual bean instance.
  // 检查所需的类型是否与实际bean实例的类型匹配。
  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;
}

上面代码比较长，基本上步骤已经添加相应的注释，基本上可以分为三步：

• 1.从缓存中获取到 Bean，创建对应的 Bean；
• 2.没有从缓存中获取到 Bean，创建对应的 Bean；
• 3.检查所需的类型是否与实际bean实例的类型匹配。

下面从这三个步骤分别介绍：

1.从缓存中获取到 Bean，创建对应的 Bean

public Object getSingleton(String beanName) {
    return getSingleton(beanName, true);
}
/**
 * 返回以给定名称注册的（原始）单例对象。
 *
 * 检查已经实例化的单例，并允许早期引用当前创建的单例（解析循环引用）
 */
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  // Quick check for existing instance without full singleton lock
  // private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
  // 缓存了 单例 Bean
  Object singletonObject = this.singletonObjects.get(beanName);
  // 如果没有获取到, 并且当前 Bean 正在被创建中
  if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      // private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
      // 早期的单例对象, 先从 earlySingletonObjects 中获取
      singletonObject = this.earlySingletonObjects.get(beanName);
      // 没有从 earlySingletonObjects 缓存中获取到
      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) {
                      // private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
                      // 从 singletonFactories 缓存中获取
                      ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                      if (singletonFactory != null) {
                          singletonObject = singletonFactory.getObject();
                          // 添加到 earlySingletonObjects 缓存中
                          this.earlySingletonObjects.put(beanName, singletonObject);
                          // 从 singletonFactories 缓存中删除
                          this.singletonFactories.remove(beanName);
                      }
                  }
              }
          }
      }
  }
  return singletonObject;
}

这里可以看出，获取一个 Bean ：

• 1.先从 singletonObjects 中获取 Bean；
• 2.获取不到，从 earlySingletonObjects 中获取 Bean；
• 3.获取不到，从 singletonFactories 中获取 Bean。

当然这一块涉及到循环引用，篇幅有限，后面会专门介绍循环引用。

2.没有从缓存中获取到 Bean，创建对应的 Bean

// Create bean instance.
if (mbd.isSingleton()) {
  // 单例 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);
} else if (mbd.isPrototype()) {
  // 创建原型Bean
  
} else {
  // 委托给实现类处理
  String scopeName = mbd.getScope();
}

DefaultSingletonBeanRegistry.getSingleton(…)

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
  Assert.notNull(beanName, "Bean name must not be null");
  // 加锁
  synchronized (this.singletonObjects) {
      // 检查 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 + "'");
          }
          // 将 Bean 添加到 singletonsCurrentlyInCreation 集合中, 表示正在创建
          beforeSingletonCreation(beanName);
          boolean newSingleton = false;
          boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
          if (recordSuppressedExceptions) {
              this.suppressedExceptions = new LinkedHashSet<>();
          }
          try {
              // 调用工厂方法
              // 也就是调用 createBean(beanName, mbd, args)
              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;
              }
              // 创建成功, 从 singletonsCurrentlyInCreation 移除
              afterSingletonCreation(beanName);
          }
          if (newSingleton) {
              // 将给定的单例对象添加到该工厂的单例缓存中
              //     this.singletonObjects.put(beanName, singletonObject);
              //     this.singletonFactories.remove(beanName);
              //     this.earlySingletonObjects.remove(beanName);
              //     this.registeredSingletons.add(beanName);
              addSingleton(beanName, singletonObject);
          }
      }
      return singletonObject;
  }
}

返回以给定名称注册的（原始）单例对象，如果尚未注册，则创建并注册一个新对象。

这一块一共可以拆成三部分来理解：

• 1.从缓存中获取 singletonObjects

  singletonObject 是什么？

  /** Cache of singleton objects: bean name to bean instance. */
  private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
  

• 2.创建singletonObject

  在从缓存中没有获取到 singletonObject ，创建新的对象

  singletonObject = singletonFactory.getObject();

  这一步其实就是调用外边的 createBean(beanName, mbd, args) 方法，这是一个工厂方法。 通过 createBean 方法，会创建一个新的 singletonObject

• 3.将创建的 singletonObject 添加到缓存中

  protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        this.singletonObjects.put(beanName, singletonObject);
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        // 已经成功创建的单例
        this.registeredSingletons.add(beanName);
    }
  }
  

  这一步涉及到三个缓存，以及一个成功创建的单例列表。

    /** Cache of singleton objects: bean name to bean instance. */
  /** 缓存单例对象， K-V -> BeanName - Bean 实例 */
  private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
  
  /** Cache of singleton factories: bean name to ObjectFactory. */
  /** 缓存 Bean 工厂 */
  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 ConcurrentHashMap<>(16);
  
  /** Set of registered singletons, containing the bean names in registration order. */
  /** 已注册的单例列表，按注册顺序保存 BeanName。 */
  private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
  

AbstractAutowireCapableBeanFactory.createBean(…)

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

  if (logger.isTraceEnabled()) {
      logger.trace("Creating instance of bean '" + beanName + "'");
  }
  RootBeanDefinition mbdToUse = mbd;

  // Make sure bean class is actually resolved at this point, and
  // clone the bean definition in case of a dynamically resolved Class
  // which cannot be stored in the shared merged bean definition.
  // 获取真实的类型
  Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
  if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
      // 创建新的 mbd 防止 其他线程修改
      mbdToUse = new RootBeanDefinition(mbd);
      mbdToUse.setBeanClass(resolvedClass);
  }

  // Prepare method overrides.
  try {
      // 验证并准备为此bean定义的方法替代。 检查是否存在具有指定名称的方法。
      mbdToUse.prepareMethodOverrides();
  }
  catch (BeanDefinitionValidationException ex) {
      throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
              beanName, "Validation of method overrides failed", ex);
  }

  try {
      // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
      // 应用实例化之前的后处理器，以解决指定的bean是否存在实例化快捷方式。
      // InstantiationAwareBeanPostProcessor 后置处理器 
      // postProcessBeforeInstantiation 方法可能会已经实例化 Bean
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
      if (bean != null) {
          return bean;
      }
  }
  catch (Throwable ex) {
      throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
              "BeanPostProcessor before instantiation of bean failed", ex);
  }

  try {
      // 实例化 Bean
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      if (logger.isTraceEnabled()) {
          logger.trace("Finished creating instance of bean '" + beanName + "'");
      }
      return beanInstance;
  }
  catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
      // A previously detected exception with proper bean creation context already,
      // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
      throw ex;
  }
  catch (Throwable ex) {
      throw new BeanCreationException(
              mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
  }
}

这个方法中涉及到：创建 Bean 实例 , 填充 Bean , 应用 PostProcessor。

其中实例化 Bean 是在 doCreateBean 中。现在重点看一下 doCreateBean 方法。

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

  // Instantiate the bean.
  // Bean 的 对象包装
  BeanWrapper instanceWrapper = null;
  if (mbd.isSingleton()) {
      // 从缓存中获取
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  }
  if (instanceWrapper == null) {
      // 缓存中获取不到则直接创建, 这里创建的 BeanInstance !!!
      instanceWrapper = createBeanInstance(beanName, mbd, args);
  }
  // 获取 Bean 实例以及类型
  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 {
              // 如果允许修改 mbd
              // 调用 MergedBeanDefinitionPostProcessor 后置处理器的
              // postProcessMergedBeanDefinition(mbd, beanType, beanName);
              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.
  // mbd 是单例 且 允许循环引用, (默认 true) 且在创建
  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");
      }
      // 先获取 之前的 Bean 的引用, 从 beanPostProcessorCache 中 获取 SmartInstantiationAwareBeanPostProcessor
      // 然后从 SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference 获取之前的引用
      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  }

  // Initialize the bean instance.
  Object exposedObject = bean;
  try {
      // 属性赋值
      populateBean(beanName, mbd, instanceWrapper);
      // 执行 init 方法
      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) {
      // 获取早期的 Bean, 如果没有循环依赖 则获取不到
      Object earlySingletonReference = getSingleton(beanName, false);

      // 有循环依赖
      if (earlySingletonReference != null) {
          // 创建的是不是同一个，可能会有代理对象
          if (exposedObject == bean) {
              exposedObject = earlySingletonReference;
          }
          else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
              // 获取依赖的 Bean 并 循环放入到 actualDependentBeans
              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;
}

分步骤阅读：

如果这个 Bean 是单例 Bean 且允许循环引用且在创建中，则说明在有循环引用。则调用：

addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

这一行代码涉及到两个方法，分别是getEarlyBeanReference和addSingletonFactory

• getEarlyBeanReference

• addSingletonFactory

  

  这一块可以看到将创建的一个单例对象的 singletonFactory 添加到了 singletonFactories 缓存中。

  同时将 earlySingletonObjects 缓存中的单例对象移除。

Spring 的 Bean 实例化的时候用到的三级缓存其实是：

• singletonObjects： 一级缓存，存储单例对象，Bean 已经实例化，初始化完成。
• earlySingletonObjects： 二级缓存，存储 singletonObject，这个 Bean 实例化了，还没有初始化。
• singletonFactories： 三级缓存，存储 singletonFactory

下面会初始化 Bean

这里关注重点关注下面一部分：

• populateBean

  对 Bean 的属性进行赋值。

  这块需要注意的是，在对属性进行赋值时，发现依赖了其他 Bean，就会去先创建其他 Bean。

  我这边使用的注解 @Autowired 就会执行下面一部分：

在这里解析属性的时候，就会去创建内部依赖的 Bean。

• initializeBean

getObjectForBeanInstance

获取给定bean实例的对象，如果是FactoryBean，则为bean实例本身或其创建的对象。

这一块逻辑相对比较简单，就是根据前面你创建的 beanInstance ， 判断其类型，从而创建 Bean 实例。