Spring 源码之核心加载方法(11) 实例化对象

11.finishBeanFactoryInitialization

定位: org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization

/**
 * 完成此上下文的beanFactory的初始化，初始化所有剩余的单例对象。
 */
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   // Initialize conversion service for this context.
   // beanFactory 初始化 conversionService (类型转换器)
   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.
   // 如果没有embedded的后置处理器, 则注册一个默认的embedded后置处理器。 主要用于解析注解属性值
   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的metadata，不期被进一步的修改。
   beanFactory.freezeConfiguration();

   // Instantiate all remaining (non-lazy-init) singletons.
   // 初始化所有剩余的(非懒加载)的单例bean  ***重点***
   beanFactory.preInstantiateSingletons();
}

11.1 DefaultListableBeanFactory#preInstantiateSingletons

定位: org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons

@Override
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.
   // 遍历一个副本以允许使用init方法，这些方法依次注册新的bean定义。
   // 尽管这可能不是常规工厂引导程序的一部分，但可以正常运行。
   List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

   // Trigger initialization of all non-lazy singleton beans...
   // 触发初始化所有非懒加载单例bean
   for (String beanName : beanNames) {
      // 如果指定的bean对应一个子bean定义，遍历父BeanDefinition并合并成RootBeanDefinition
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      // RootBeanDefinition 不是抽象的、是单例的、不是懒加载的bean
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
         // 是否是FactoryBean
         if (isFactoryBean(beanName)) {
            // 返回 beanName 对应的 FactoryBean
            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) {
                  // 初始化 bean
                  getBean(beanName);
               }
            }
         }
         else {
            // 初始化 bean
            getBean(beanName);
         }
      }
   }

   // Trigger post-initialization callback for all applicable beans...
   // 遍历beanNames, 触发所有 SmartInitializingSingleton 的后初始化回调
   for (String beanName : beanNames) {
      Object singletonInstance = getSingleton(beanName);
      // 判断singletonInstance是否实现了SmartInitializingSingleton接口
      if (singletonInstance instanceof SmartInitializingSingleton) {
         final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
         // 是否存在 Java安全管理器
         if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
               smartSingleton.afterSingletonsInstantiated();
               return null;
            }, getAccessControlContext());
         }
         else {
            // 触发SmartInitializingSingleton实现类的afterSingletonsInstantiated方法
            smartSingleton.afterSingletonsInstantiated();
         }
      }
   }
}

11.1.1 AbstractBeanFactory#getMergedLocalBeanDefinition

定位: org.springframework.beans.factory.support.AbstractBeanFactory#getMergedLocalBeanDefinition

/**
 * Bean定义公共的抽象类是AbstractBeanDefinition，普通的Bean在Spring加载Bean定义的时候，实例化出来的是GenericBeanDefinition，
 * 而Spring上下文包括实例化所有Bean用的AbstractBeanDefinition是RootBeanDefinition，这时候就使用getMergedLocalBeanDefinition方法做了一次转化，
 * 将非RootBeanDefinition转换为RootBeanDefinition以供后续操作。
 */
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
   // Quick check on the concurrent map first, with minimal locking.
   // 检查beanName对应的mergedBeanDefinitions是否存在于缓存中,此缓存是在beanFactoryPostProcessor中添加的
   RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
   if (mbd != null && !mbd.stale) {
      // mdb已获取到, 且mbd不需要重新合并定义
      return mbd;
   }
   // 如果不存在与缓存中或者需要重新合并定义，则根据beanName和BeanDefinition，获取mergedBeanDefinitions
   return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}

11.1.2 AbstractBeanFactory#getMergedBeanDefinition

定位: org.springframework.beans.factory.support.AbstractBeanFactory#getMergedBeanDefinition

/**
 * 如果给定的BeanDefinition是一个子BeanDefinition, 则需要合并父BeanDefinition，最后返回对于给定的bean的RootBeanDefinition
 */
protected RootBeanDefinition getMergedBeanDefinition(
      String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
      throws BeanDefinitionStoreException {

   synchronized (this.mergedBeanDefinitions) {
      // 用于存储bd的MergedBeanDefinition
      RootBeanDefinition mbd = null;
      RootBeanDefinition previous = null;

      // Check with full lock now in order to enforce the same merged instance.
      // 检查beanName对应的MergedBeanDefinition是否存在于缓存中
      if (containingBd == null) {
         mbd = this.mergedBeanDefinitions.get(beanName);
      }
      // mbd 为null 并且 mbd需要重新合并
      if (mbd == null || mbd.stale) {
         previous = mbd;
         mbd = null;
         // 如果bd的parentName为空，代表bd没有父定义，无需与父定义进行合并操作
         // bean的ParentName
         if (bd.getParentName() == null) {
            // Use copy of given root bean definition.
            // 如果bd的类型为RootBeanDefinition，则bd的MergedBeanDefinition就是bd本身，则直接克隆一个副本
            if (bd instanceof RootBeanDefinition) {
               mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
            }
            else {
               // 否则，将bd作为参数，构建一个RootBeanDefinition。
               // 正常使用下，BeanDefinition在被加载后是GenericBeanDefinition或ScannedGenericBeanDefinition
               mbd = new RootBeanDefinition(bd);
            }
         }
         else {
            // Child bean definition: needs to be merged with parent.
            // bd存在父定义，需要与父定义合并
            BeanDefinition pbd;
            try {
               // 获取父bean的名称，并进行转换
               String parentBeanName = transformedBeanName(bd.getParentName());
               // 如果当前beanName和父beanName不相同，那么递归调用合并方法
               if (!beanName.equals(parentBeanName)) {
                  pbd = getMergedBeanDefinition(parentBeanName);
               }
               else {
                  // 如果父定义的beanName与bd的beanName相同，则拿到父BeanFactory，
                  // 只有在存在父BeanFactory的情况下，才允许父定义beanName与自己相同，否则就是将自己设置为父定义
                  BeanFactory parent = getParentBeanFactory();
                  // 如果父BeanFactory是ConfigurableBeanFactory，则通过父BeanFactory获取父定义的MergedBeanDefinition
                  if (parent instanceof ConfigurableBeanFactory) {
                     // 从父BeanFactory获取BeanDefinition
                     pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
                  }
                  else {
                     // 如果父BeanFactory不是ConfigurableBeanFactory，则抛异常
                     throw new NoSuchBeanDefinitionException(parentBeanName,
                           "Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
                           "': cannot be resolved without an AbstractBeanFactory parent");
                  }
               }
            }
            catch (NoSuchBeanDefinitionException ex) {
               throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
                     "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
            }
            // Deep copy with overridden values.
            // 根据父BeanFactory获取的BeanDefinition创建新的BeanDefinition
            mbd = new RootBeanDefinition(pbd);
            // 将原始的部分属性拷贝到mbd
            mbd.overrideFrom(bd);
         }

         // Set default singleton scope, if not configured before.
         // 如果没有配置scope，则设置为默认的单例scope
         if (!StringUtils.hasLength(mbd.getScope())) {
            mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
         }

         // A bean contained in a non-singleton bean cannot be a singleton itself.
         // Let's correct this on the fly here, since this might be the result of
         // parent-child merging for the outer bean, in which case the original inner bean
         // definition will not have inherited the merged outer bean's singleton status.
         // 一个bean包含非单例bean, 则他不是一个单例bean
         // 我们在此时进行修改scope，因为这可能是外部bean的父子合并的结果，在这种情况下，原始内部beanDefinition将不会继承合并的外部bean的单例状态
         if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
            mbd.setScope(containingBd.getScope());
         }

         // Cache the merged bean definition for the time being
         // (it might still get re-merged later on in order to pick up metadata changes)
         // 将beanName与mbd放到mergedBeanDefinitions缓存，以便之后可以直接使用
         if (containingBd == null && isCacheBeanMetadata()) {
            this.mergedBeanDefinitions.put(beanName, mbd);
         }
      }
      if (previous != null) {
         // 拷贝相关的MergedBeanDefinition字段
         copyRelevantMergedBeanDefinitionCaches(previous, mbd);
      }
      return mbd;
   }
}

11.1.3 AbstractBeanFactory#doGetBean

定位: org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean

• 根据传入的 beanName 转换成 Spring 中的 beanName
• 查询缓存中的 bean 单例对象

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
      @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

   // 传入的 name 可能是 beanName, alias, &beanName (FactoryBean)
   // 将 name 转换成 beanName
   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 + "'");
         }
      }
      // 返回对象的实例
      // 当你实现了FactoryBean接口的对象，需要获取具体的对象的时候就需要此方法来进行获取了
      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.
      // 检查该工厂中是否存在bean定义
      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.
            // 父级创建对象 bean 实例
            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);
         }
      }

      // 如果不是做类型检查，那么表示要创建bean，此处在集合中做一个记录
      if (!typeCheckOnly) {
         markBeanAsCreated(beanName);
      }

      try {
         // 此处做了BeanDefinition对象的转换,
         // 当我们从xml文件中加载 BeanDefinition 对象的时候，封装的对象是 GenericBeanDefinition,
         // 此处要做类型转换，如果是子类bean的话，会合并父类的相关属性
         final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
         checkMergedBeanDefinition(mbd, beanName, args);

         // Guarantee initialization of beans that the current bean depends on.
         // 确保当前bean依赖的bean的初始化
         String[] dependsOn = mbd.getDependsOn();
         if (dependsOn != null) {
            // 如果存在依赖，则需要递归实例化依赖的bean
            for (String dep : dependsOn) {
               if (isDependent(beanName, dep)) {
                  throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
               }
               // 注册各个bean的依赖关系，方便进行销毁
               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()) {
            // 创建单例对象
            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对象创建
            // 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 {
            // 指定的scope上实例化bean
            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.
   // 检查所需的类型是否与实际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;
}

11.1.3.1 DefaultSingletonBeanRegistry#getSingleton(String, boolean)

定位: org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(String, boolean)

从缓存中获取单例对象

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   // 从单例对象缓存(一级缓存)中获取beanName对应的单例对象
   Object singletonObject = this.singletonObjects.get(beanName);
   // 如果单例对象缓存中没有，并且该beanName对应的单例bean正在创建中(下面的代码只有在存在循环引用才会调用)
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      synchronized (this.singletonObjects) {
         // 从早期单例对象缓存(二级缓存)中获取单例对象（之所称成为早期单例对象，
         // 是因为earlySingletonObjects里的对象的都是通过提前曝光的ObjectFactory创建出来的，
         // 还未进行属性填充等操作）
         singletonObject = this.earlySingletonObjects.get(beanName);
         // 如果在早期单例对象缓存(二级缓存)中也没有，并且允许创建早期单例对象引用
         if (singletonObject == null && allowEarlyReference) {
            // 当某些方法需要提前初始化的时候则会调用addSingletonFactory方法,
            // 将对应的ObjectFactory初始化策略存储在三级缓存
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
               // 如果存在单例对象工厂，则通过工厂创建一个单例对象
               singletonObject = singletonFactory.getObject();
               // 记录在缓存中，二级缓存和三级缓存的对象不能同时存在
               this.earlySingletonObjects.put(beanName, singletonObject);
               // 从三级缓存中移除
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return singletonObject;
}

11.1.3.2 DefaultSingletonBeanRegistry#getObjectForBeanInstance

定位: org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getObjectForBeanInstance

/**
 * 获取给定bean实例的对象，即bean
 * 实例本身或其创建的对象（对于FactoryBean）。
 */
protected Object getObjectForBeanInstance(
      Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

   // Don't let calling code try to dereference the factory if the bean isn't a factory.
   // 通过beanName判断是否有factoryBean的前缀(即 name包含&)
   if (BeanFactoryUtils.isFactoryDereference(name)) { //
      if (beanInstance instanceof NullBean) {
         return beanInstance;
      }
      if (!(beanInstance instanceof FactoryBean)) {
         // beanInstance 没有实现 FactoryBean 接口
         throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
      }
      if (mbd != null) {
         mbd.isFactoryBean = true;
      }
      return beanInstance;
   }

   // Now we have the bean instance, which may be a normal bean or a FactoryBean.
   // If it's a FactoryBean, we use it to create a bean instance, unless the
   // caller actually wants a reference to the factory.
   // 当我们有了bean的实例之后，这个实例可能是正常的bean，也可能是FactoryBean，
   // 如果是FactoryBean那么就直接创建实例，
   // 但是如果用户想要直接获取工厂实例而不是工厂的getObject方法对应的实例，那么传入的参数应该加&前缀
   if (!(beanInstance instanceof FactoryBean)) {
      // beanInstance 没有实现 FactoryBean 接口
      return beanInstance;
   }

   // 创建FactoryBean中的bean
   Object object = null;
   if (mbd != null) {
      mbd.isFactoryBean = true;
   }
   else {
      // 尝试从缓存中加载bean
      object = getCachedObjectForFactoryBean(beanName);
   }
   if (object == null) {
      // Return bean instance from factory.
      // 将beanInstance转换为FactoryBean类型
      FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
      // Caches object obtained from FactoryBean if it is a singleton.
      if (mbd == null && containsBeanDefinition(beanName)) {
         // 将存储xml配置文件的 GenericBeanDefinition 转换为RootBeanDefinition，
         // 如果指定BeanName是子Bean的话，同时会合并父类的相关属性
         mbd = getMergedLocalBeanDefinition(beanName);
      }
      // 判断当前bean是否是用户定义的，而不是应用程序本身定义的
      boolean synthetic = (mbd != null && mbd.isSynthetic());
      object = getObjectFromFactoryBean(factory, beanName, !synthetic); // factory::getObject
   }
   return object;
}

11.1.3.2.1 FactoryBeanRegistrySupport#getObjectFromFactoryBean

定位: org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getObjectForBeanInstance

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
   if (factory.isSingleton() && containsSingleton(beanName)) {
      synchronized (getSingletonMutex()) {
         Object object = this.factoryBeanObjectCache.get(beanName);
         if (object == null) {
            object = doGetObjectFromFactoryBean(factory, beanName);
            // Only post-process and store if not put there already during getObject() call above
            // (e.g. because of circular reference processing triggered by custom getBean calls)
            Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
            if (alreadyThere != null) {
               object = alreadyThere;
            }
            else {
               // 需要处理
               if (shouldPostProcess) {
                  // 单例对象直接返回
                  if (isSingletonCurrentlyInCreation(beanName)) {
                     // Temporarily return non-post-processed object, not storing it yet..
                     return object;
                  }
                  beforeSingletonCreation(beanName);
                  try {
                     // 进行后置处理器处理
                     object = postProcessObjectFromFactoryBean(object, beanName);
                  }
                  catch (Throwable ex) {
                     throw new BeanCreationException(beanName,
                           "Post-processing of FactoryBean's singleton object failed", ex);
                  }
                  finally {
                     afterSingletonCreation(beanName);
                  }
               }
               if (containsSingleton(beanName)) {
                  // 如果包含了FactoryBean,就将创建的对象缓存
                  this.factoryBeanObjectCache.put(beanName, object);
               }
            }
         }
         return object;
      }
   }
   else {
      // FactoryBean是原型的话
      Object object = doGetObjectFromFactoryBean(factory, beanName);
      if (shouldPostProcess) {
         try {
            // 调用ObjectFactory的后置处理器
            object = postProcessObjectFromFactoryBean(object, beanName);
         }
         catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
         }
      }
      return object;
   }
}

private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
      throws BeanCreationException {

   Object object;
   try {
      if (System.getSecurityManager() != null) {
         AccessControlContext acc = getAccessControlContext();
         try {
            object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
         }
         catch (PrivilegedActionException pae) {
            throw pae.getException();
         }
      }
      else {
         // 直接调用getObject方法，返回具体的对象
         object = factory.getObject();
      }
   }
   catch (FactoryBeanNotInitializedException ex) {
      throw new BeanCurrentlyInCreationException(beanName, ex.toString());
   }
   catch (Throwable ex) {
      throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
   }

   // Do not accept a null value for a FactoryBean that's not fully
   // initialized yet: Many FactoryBeans just return null then.
   if (object == null) {
      // 如果是正在创建的FactoryBean,还没能获得bean，就报异常
      if (isSingletonCurrentlyInCreation(beanName)) {
         throw new BeanCurrentlyInCreationException(
               beanName, "FactoryBean which is currently in creation returned null from getObject");
      }
      object = new NullBean();
   }
   return object;
}

11.1.3.3 DefaultSingletonBeanRegistry#registerDependentBean

定位: org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#registerDependentBean

public void registerDependentBean(String beanName, String dependentBeanName) {
   // 获取name的最终别名或者是全类名
   String canonicalName = canonicalName(beanName);

   // 使用存储bean名称到该bean名称要依赖的bean名称的Map作为锁，保证线程安全
   synchronized (this.dependentBeanMap) {
      // 获取canonicalName对应的用于存储依赖Bean名的Set集合，如果没有就创建一个LinkeHashSet，
      // 并与canonicalName绑定到dependentBeans中
      Set<String> dependentBeans =
            this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
      // 如果dependentBeans已经添加过来了dependentBeanName，就结束该方法，不执行后面操作。
      if (!dependentBeans.add(dependentBeanName)) {
         return;
      }
   }

   // 使用Bean依赖关系Map作为锁，保证线程安全
   synchronized (this.dependenciesForBeanMap) {
      // 添加dependentBeanName依赖于canonicalName的映射关系到存储bean名到依赖于该bean名的bean名称的Map中
      Set<String> dependenciesForBean =
            this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
      dependenciesForBean.add(canonicalName);
   }
}

11.1.3.4 DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory<?>)

定位: org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(String, ObjectFactory<?>)

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
   Assert.notNull(beanName, "Bean name must not be null");
   // 全局变量需要同步
   synchronized (this.singletonObjects) {
      // 首先检查一级缓存中是否存在对应的bean
      Object singletonObject = this.singletonObjects.get(beanName);
      // 如果对象不存在，才需要进行bean的实例化
      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 {
            // 开始进行bean对象的创建
            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;
            }
            // 移除缓存中对该bean的正在加载状态的记录
            afterSingletonCreation(beanName);
         }
         // 加入到一级缓存中
         if (newSingleton) {
            // 添加单例对象到缓存, 并从二级和三级缓存移除单例对象
            addSingleton(beanName, singletonObject);
         }
      }
      return singletonObject;
   }
}

protected void addSingleton(String beanName, Object singletonObject) {
   synchronized (this.singletonObjects) {
      // 将单例对象放入一级缓存
      this.singletonObjects.put(beanName, singletonObject);
      // 将单例对象从三级缓存中移除
      this.singletonFactories.remove(beanName);
      // 将单例对象从二级缓存中移除
      this.earlySingletonObjects.remove(beanName);
      // 将单例对象 beanName 添加到 已注册的集合中
      this.registeredSingletons.add(beanName);
   }
}