【spring源码分析】IOC容器初始化（七）

前言：在【spring源码分析】IOC容器初始化（六）中分析了从单例缓存中加载bean对象，由于篇幅原因其核心函数

FactoryBeanRegistrySupport#getObjectFromFactoryBean并未进行详细分析，本文将继续对bean加载过程的分析。

---

FactoryBeanRegistrySupport#getObjectFromFactoryBean

 protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
         // 为单例模式，其缓存中存在该bean实例
         if (factory.isSingleton() && containsSingleton(beanName)) {
             /**
              * 做同步，内部其实使用的就是{@link DefaultSingletonBeanRegistry#singletonObjects}
              */
             synchronized (getSingletonMutex()) {
                 // 从缓存中获取指定的factoryBean
                 Object object = this.factoryBeanObjectCache.get(beanName);
                 if (object == null) {
                     // 为空，则从FactoryBean中获取对象
                     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)
                     // 再次从缓存中获取bean对象，主要是因为循环依赖
                     Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                     if (alreadyThere != null) {
                         object = alreadyThere;
                     } else {
                         // 需要后续处理
                         if (shouldPostProcess) {
                             // 如果该Bean处于创建中，则返回处理对象，而不是存储该对象
                             if (isSingletonCurrentlyInCreation(beanName)) {
                                 // Temporarily return non-post-processed object, not storing it yet..
                                 return object;
                             }
                             // 单例bean的前置处理 用于添加标志，当前bean正处于创建中
                             beforeSingletonCreation(beanName);
                             try {
                                 // 对FactoryBean获取的对象进行后置处理，返回生成的对象
                                 object = postProcessObjectFromFactoryBean(object, beanName);
                             } catch (Throwable ex) {
                                 throw new BeanCreationException(beanName,
                                                                 "Post-processing of FactoryBean's singleton object failed", ex);
                             } finally {
                                 // 单例bean的后置处理 和前置处理相反，前置添加，后置移除 移除标志，当前bean不处于创建中
                                 afterSingletonCreation(beanName);
                             }
                         }
                         // 添加到factoryBeanObjectCache中进行缓存
                         if (containsSingleton(beanName)) {
                             this.factoryBeanObjectCache.put(beanName, object);
                         }
                     }
                 }
                 return object;
             }
         } else {
             // 不满足第一个条件，不是单例，或者缓存中不存在，则从FactoryBean中获取对象
             Object object = doGetObjectFromFactoryBean(factory, beanName);
             // 需要后续处理
             if (shouldPostProcess) {
                 try {
                     // 对FactoryBean获取的对象进行后处理
                     // 返回生成的对象
                     object = postProcessObjectFromFactoryBean(object, beanName);
                 } catch (Throwable ex) {
                     throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
                 }
             }
             return object;
         }
     }

分析：

函数分两大分支：

#1.单例且singletonObjects缓存中存在（该分支为同步方法）

• #1.1：FactoryBean为单例，并且缓存中存在该bean对象(containsSingleton方法其实就是判断singletonObjects集合中是否存在bean对象)，首先从缓存中获取factoryBean对象object，如果object=null，则从doGetObjectFromFactoryBean方法中获取对象。注意：这里再次从factoryBeanObjectCache缓存中尝试获取对象(主要是循环依赖问题，有可能这时该bean对象已经加载了，就不用再次加载了)，如果缓存中已存在bean对象，则使用缓存中对象，并直接返回。
• #1.2：如果factoryBeanObjectCache缓存中不存在对象且需要后置处理，则首先判断该bean对象是否正在被创建，如果是，则直接返回，注意这里未进行缓存；然后对单例bean进行前置添加处理(beforeSingletonCreation)、后置处理(postProcessObjectFromFactoryBean)、后置移除标志处理(afterSingletonCreation)。
• #1.3：最后将缓存生成的bean对象

#2.不满足(#1)中的任何一条件

• 首先从doGetObjectFromFactoryBean方法中获取获取bean对象，如果需要后置处理，则调用postProcessObjectFromFactoryBean方法进行处理，最后返回生成过的bean对象。

在上述分析中涉及到几个函数，下面一一进行分析。

FactoryBeanRegistrySupport#doGetObjectFromFactoryBean

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

         Object object;
         try {
             // 如果权限不为空
             if (System.getSecurityManager() != null) {
                 AccessControlContext acc = getAccessControlContext();
                 try {
                     // 从FactoryBean中获取Bean对象[factory::getObject] 其实与else分支一样的
                     object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
                 } catch (PrivilegedActionException pae) {
                     throw pae.getException();
                 }
             } else {
                 // 如果权限为空，则从Factory中获取Bean对象
                 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) {
             // 如果bean正在被创建，则抛出异常
             if (isSingletonCurrentlyInCreation(beanName)) {
                 throw new BeanCurrentlyInCreationException(
                         beanName, "FactoryBean which is currently in creation returned null from getObject");
             }
             object = new NullBean();
         }
         return object;
     }

分析：

根据是否具有权限，通过FactoryBean#getObject获取bean对象，如果bean对象为null且正在被创建，则抛出异常，否则实例化一个NullBean对象进行返回。

DefaultSingletonBeanRegistry#isSingletonCurrentlyInCreation

     /**
      * 正在创建中的单例 Bean 的名字的集合
      * Names of beans that are currently in creation.
      */
     private final Set<String> singletonsCurrentlyInCreation =
             Collections.newSetFromMap(new ConcurrentHashMap<>(16));

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

分析：

该函数判断bean是否正处于创建之中，该方法要与beforeSingletonCreation和afterSingletonCreation配合起来分析才能明白其重要性，他们记录了bean的加载状态，是检查当前bean是否处于创建中的关键处，对解决bean的循环依赖起着重要作用。

DefaultSingletonBeanRegistry#beforeSingletonCreation

     protected void beforeSingletonCreation(String beanName) {
         // 这里会添加到正在创建bean的集合中
         // 注意第一个条件，如果存在，则为false，直接短路
         // 只有当第一个条件不存在[false]时，才会去进行添加操作
         if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
             throw new BeanCurrentlyInCreationException(beanName);
         }
     }

分析：

注意这里就会将正在创建的beanName添加到singletonsCurrentlyInCreation集合中，第一个条件是判断该bean是否不会被检测。

DefaultSingletonBeanRegistry#afterSingletonCreation

 protected void afterSingletonCreation(String beanName) {
         if (!this.inCreationCheckExclusions.contains(beanName)
                 && !this.singletonsCurrentlyInCreation.remove(beanName)) { // 移除
             // 如果移除失败，则抛出IllegalStateException异常
             throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
         }
     }

分析：

afterSingletonCreation方法与beforeSingletonCreation方法的功能相反，用于将beanName移除正在创建的集合singletonsCurrentlyInCreation，表明bean创建完成。

postProcessObjectFromFactoryBean

该方法的默认实现，就是返回当前bean对象。

 // FactoryBeanRegistrySupport
 protected Object postProcessObjectFromFactoryBean(Object object, String beanName) throws BeansException {
         return object;
     }

当然，子类可以对该方法进行重写。

 // AbstractAutowireCapableBeanFactory

     protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
         return applyBeanPostProcessorsAfterInitialization(object, beanName);
     }

 public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
             throws BeansException {

         Object result = existingBean;
         // 遍历BeanPostProcessor
         for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
             // 进行处理
             // TODO: 2019/4/2 具体处理过程需详细查看，这里先走大流程
             Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
             // 返回为空，则返回传入的Object对象
             if (current == null) {
                 return result;
             }
             // 修改result
             result = current;
         }
         return result;
     }

分析：

这里主要是遍历BeanPostProcessor，然后对bean对象进行处理，关于后置处理器的分析后面再做分析。

到这里从单例缓存中获取bean对象的相应源码已分析完成，接下来看单例缓存中无bean对象时，Spring的处理流程，再次将getBean的切入点代码贴出来。

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

         // .........省略从单例缓存中获取bean对象的代码
         } else {
             // Fail if we're already creating this bean instance:
             // We're assumably within a circular reference.
             // Spring只能解决单例模式下的循环依赖，在原型模式下如果存在循环依赖则抛出异常
             // 这里检测原型模式下，该bean是否在加载，如果在加载则抛出异常
             if (isPrototypeCurrentlyInCreation(beanName)) {
                 throw new BeanCurrentlyInCreationException(beanName);
             }

             // 如果当前容器中没有找到，则从父类容器中加载
             // Check if bean definition exists in this factory.
             BeanFactory parentBeanFactory = getParentBeanFactory();
             /**
              * 调用{@link DefaultListableBeanFactory#containsBeanDefinition(String)}方法
              * 其实就是在beanDefinitionMap中判断是否存在beanName对应的BeanDefinition
              */
             if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                 // Not found -> check parent.
                 // 确定原始的beanName
                 String nameToLookup = originalBeanName(name);
                 // 如果父类容器为AbstractBeanFactory，则委托父类处理
                 if (parentBeanFactory instanceof AbstractBeanFactory) {
                     return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                             nameToLookup, requiredType, args, typeCheckOnly);
                 } else if (args != null) { // 用明确的args从parentBeanFactory中，获取Bean对象
                     // Delegation to parent with explicit args.
                     // 委托给父类构造函数getBean()处理
                     return (T) parentBeanFactory.getBean(nameToLookup, args);
                 } else if (requiredType != null) { // 用明确的requiredType从parentBeanFactory中，获取Bean对象
                     // No args -> delegate to standard getBean method.
                     // 没有args，委托给标准的getBean()处理
                     return parentBeanFactory.getBean(nameToLookup, requiredType);
                 } else {
                     // 直接使用nameToLookup从parentBeanFactory中获取Bean对象
                     return (T) parentBeanFactory.getBean(nameToLookup);
                 }
             }

             // 如果不仅仅是做类型检查，而是创建bean，这里需要记录
             if (!typeCheckOnly) {
                 markBeanAsCreated(beanName);
             }

             try {
                 /**
                  * 从容器中获取beanName对应的GenericBeanDefinition对象，并转换成RootBeanDefinition对象
                  * GenericBeanDefinition的创建{@link BeanDefinitionReaderUtils#createBeanDefinition}方法
                  */
                 final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                 // 检查合并的BeanDefinition
                 checkMergedBeanDefinition(mbd, beanName, args);

                 // Guarantee initialization of beans that the current bean depends on.
                 // 处理所依赖的bean
                 String[] dependsOn = mbd.getDependsOn();
                 if (dependsOn != null) {
                     for (String dep : dependsOn) {
                         // 若给定的依赖bean已经注册为依赖给定的bean
                         // 即循环依赖情况，抛出BeanCreationException异常
                         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);
                         }
                     }
                 }
                 // bean实例化
                 // Create bean instance.
                 // 单例模式
                 /**
                  * 这里有个已创建bean的重要方法createBean
                  * {@link AbstractAutowireCapableBeanFactory#createBean(String, RootBeanDefinition, Object[])}
                  */
                 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.
                             // 显式从单例缓存中删除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);
                         /**
                          * 创建bean {@link AbstractAutowireCapableBeanFactory#createBean}
                          */
                         prototypeInstance = createBean(beanName, mbd, args);
                     } finally {
                         /**
                          * 后置处理 与前置处理相反从{@link prototypesCurrentlyInCreation}中移除
                          */
                         afterPrototypeCreation(beanName);
                     }
                     bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                 } else { //其他作用域
                     // 获得scopeName对应的Scope对象
                     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 {
                         /**
                          * 从指定的scope下创建bean
                          * {@link SimpleThreadScope#get方法}
                          */
                         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;
             }
         }

         // 检查需要的类型是否符合bean的实际类型
         // 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;
     }

分析：

#1.首先通过AbstractBeanFactory#isPrototypeCurrentlyInCreation检查bean对象是否处于原型模式下的循环依赖，因为Spring只能解决单例模式下的循环依赖，如果在原型模式下也存在该bean对象，则会抛出异常。

 // AbstractBeanFactory
     /**
      * 原型模式下存储beanName的ThreadLocal<br/>
      * Names of beans that are currently in creation.
      */
     private final ThreadLocal<Object> prototypesCurrentlyInCreation =
             new NamedThreadLocal<>("Prototype beans currently in creation");
     protected boolean isPrototypeCurrentlyInCreation(String beanName) {
         Object curVal = this.prototypesCurrentlyInCreation.get();
         return (curVal != null &&
                 (curVal.equals(beanName) //相等
                         || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName)))); // 包含
     }

• 这里就是检查原型模式的ThreadLocal中是否已经存在对应的beanName。

#2.AbstractBeanFactory#getParentBeanFactory检查其父类BeanFactory是否存在，如果存在且beanDefinitionMap中不存在该BeanDefinition，则委托其父类通过getBean方法获取bean对象。注意这里首先会通过originalBeanName方法获取原始beanName。

 // AbstractBeanFactory
     protected String originalBeanName(String name) {
         String beanName = transformedBeanName(name);
         if (name.startsWith(FACTORY_BEAN_PREFIX)) {
             // 如果beanName以&开头，则在加上&进行返回 因为transformedBeanName中会去掉&
             beanName = FACTORY_BEAN_PREFIX + beanName;
         }
         return beanName;
     }

• 首先通过transformedBeanName(该方法前面已经分析)获取真正的beanName，如果name以"&"开头，则将beanName加上"&"符号，因为transformedBeanName方法会去掉"&"符号。

#3.判断bean是否需要做类型检查，如果不仅仅做类型检查，则需要调用markBeanAsCreated函数进行记录。

 // AbstractBeanFactory
     /**
      * 已创建Bean的名字集合<br/>
      * Names of beans that have already been created at least once.
      */
     private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));

 protected void markBeanAsCreated(String beanName) {
         // 没有创建
         if (!this.alreadyCreated.contains(beanName)) {
             // 做同步
             synchronized (this.mergedBeanDefinitions) {
                 // 再次进行检查，DoubleCheck模式
                 if (!this.alreadyCreated.contains(beanName)) {
                     // Let the bean definition get re-merged now that we're actually creating
                     // the bean... just in case some of its metadata changed in the meantime.
                     // 从mergedBeanDefinitions中删除beanName，并在下次访问时重新创建它
                     clearMergedBeanDefinition(beanName);
                     // 添加到已创建bean集合中
                     this.alreadyCreated.add(beanName);
                 }
             }
         }
     }

#4. 接下来将对BeanDefinition进行转换，因为最开始创建的BeanDefinition类型为GenericBeanDefinition，getMergedLocalBeanDefinition方法在前面已经进行了分析，这里不在赘述。

#5.调用checkMergedBeanDefinition对转换后的RootBeanDefinition，如果RootBeanDefinition仍为抽象的，则抛出异常，这里抽象的对象还不能进行实例化。代码如下：

 // AbstractBeanFactory
 protected void checkMergedBeanDefinition(RootBeanDefinition mbd, String beanName, @Nullable Object[] args)
             throws BeanDefinitionStoreException {

         if (mbd.isAbstract()) {
             throw new BeanIsAbstractException(beanName);
         }
     }

#6.处理依赖，如果在加载bean对象时，发现它有依赖bean的话，那么在初始化该bean的时候需要先初始化依赖的bean对象

 // 处理所依赖的bean
                 String[] dependsOn = mbd.getDependsOn();
                 if (dependsOn != null) {
                     for (String dep : dependsOn) {
                         // 若给定的依赖bean已经注册为依赖给定的bean
                         // 即循环依赖情况，抛出BeanCreationException异常
                         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);
                         }
                     }
                 }

分析：

DefaultSingletonBeanRegistry#isDependent

 protected boolean isDependent(String beanName, String dependentBeanName) {
         synchronized (this.dependentBeanMap) {
             return isDependent(beanName, dependentBeanName, null);
         }
     }
 private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
         // alreadySeen 已经检测的依赖bean
         if (alreadySeen != null && alreadySeen.contains(beanName)) {
             return false;
         }
         // 获取原始的beanName
         String canonicalName = canonicalName(beanName);
         // 获取当前beanName的依赖集合
         Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
         // 不存在，则说明不存在注册依赖
         if (dependentBeans == null) {
             return false;
         }
         // 存在，则证明已经存在注册依赖
         if (dependentBeans.contains(dependentBeanName)) {
             return true;
         }
         // 递归检测依赖
         for (String transitiveDependency : dependentBeans) {
             if (alreadySeen == null) {
                 alreadySeen = new HashSet<>();
             }
             // 添加到alreadySeen
             alreadySeen.add(beanName);
             // 递推
             if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
                 return true;
             }
         }
         return false;
     }

分析：

这里通过一些列判断，是否依赖的bean是否已经注入，如果注入则返回true，否则返回false。

#7.如果依赖检测通过，则调用registerDependentBean对依赖bean进行注入。

 // DefaultSingletonBeanRegistry

     /**
      * 保存的是依赖beanName  映射关系：beanName --> 依赖beanName的集合<br/>
      * Map between dependent bean names: bean name to Set of dependent bean names.
      */
     private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);

     /**
      * 保存的是依赖 beanName 之间的映射关系：依赖 beanName - > beanName 的集合
      * Map between depending bean names: bean name to Set of bean names for the bean's dependencies.
      */
     private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);

 public void registerDependentBean(String beanName, String dependentBeanName) {
         // 获取beanName
         String canonicalName = canonicalName(beanName);

         // 做同步 添加<canonicalName,<dependentBeanName>>到dependentBeanMap中
         synchronized (this.dependentBeanMap) {
             Set<String> dependentBeans =
                     this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
             if (!dependentBeans.add(dependentBeanName)) {
                 return;
             }
         }
         // 做同步 添加<canonicalName,<dependentBeanName>>到dependenciesForBeanMap中
         synchronized (this.dependenciesForBeanMap) {
             Set<String> dependenciesForBean =
                     this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
             dependenciesForBean.add(canonicalName);
         }
     }

分析：

这里就是就是将依赖的beanName关系添加到dependentBeanMap、dependenciesForBeanMap集合中。

#8.最后通过getBean方法实例化依赖bean对象，该方法会在后面进行分析。

各种scope的Bean创建

在经过单例缓存中获取bean对象、从父类工厂中获取bean对象、处理依赖bean这三步后，接下来来到对各种scope的bean的创建。首先是单例模式bean对象的创建，我们知道singleton为Spring的bean的默认作用域，当然除了singleton之外，还有prototype、request等其他的scope。

#1.singleton的初始化代码如下

 // AbstractBeanFactory

 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.
                             // 显式从单例缓存中删除Bean实例
                             // 因为单例模式下为了解决循环依赖，可能它已经存在，所以销毁它
                             destroySingleton(beanName);
                             throw ex;
                         }
                     });
                     bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
 }

分析：

单例模式bean的初始化是从getSingleton方法开始，当然这里还有一个重要的createBean方法，该方法我们留在后面进行分析，首先来看getSingleton方法。

 // DefaultSingletonBeanRegistry

 public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
         Assert.notNull(beanName, "Bean name must not be null");
         // 做同步
         synchronized (this.singletonObjects) {
             // 从缓存中检查一遍
             // 因为singlton模式其实已经复用了创建的bean，所以该步骤必须检查
             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);
                 // 首先将新的newSingleton设置为false
                 boolean newSingleton = false;
                 boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
                 if (recordSuppressedExceptions) {
                     this.suppressedExceptions = new LinkedHashSet<>();
                 }
                 try {
                     // 初始化bean
                     // 该过程其实是调用createBean()方法 这里是一个回调方法
                     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);
                 }
                 // 新的bean 加入缓存中
                 if (newSingleton) {
                     addSingleton(beanName, singletonObject);
                 }
             }
             return singletonObject;
         }
     }

分析（该方法同样为同步方法）：

该方法其实并未真正创建bean对象，获取bean对象的核心点在于singletonObject = singletonFactory.getObject()，但该方法是由createBean回调产生的。这里仅仅是做了一部分准备和预处理步骤：

• 再次从缓存中检查bean是否已经加载过，如果缓存中存在则直接返回。
• beforeSingletonCreation前面已经分析过，记录加载单例bean的状态，表示正在被加载。
• 然后调用singletonFactory.getObject方法实例化bean对象
• afterSingletonCreation前面也分析过了，移除bean正在被加载的标志。
• 将生成的bean对象加入缓存。

DefaultSingletonBeanRegistry#addSingleton

     /**
      * Cache of singleton objects: bean name to bean instance.
      * 存放的是单例 bean 的映射。
      * <p>
      * 对应关系为 bean name --> bean instance
      */
     private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

     /**
      * Cache of singleton factories: bean name to ObjectFactory.<br/>
      * 存放的是 ObjectFactory，可以理解为创建单例 bean 的 factory 。
      * <p>
      * 对应关系是 bean name --> ObjectFactory
      */
     private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

     /**
      * Cache of early singleton objects: bean name to bean instance.<br/>
      * 存放的是早期的 bean，对应关系也是 bean name --> bean instance。
      * <p>
      * 它与 {@link #singletonFactories} 区别在于 earlySingletonObjects 中存放的 bean 不一定是完整。
      * <p>
      * 从 {@link #getSingleton(String)} 方法中，我们可以了解，bean 在创建过程中就已经加入到 earlySingletonObjects 中了。
      * 所以当在 bean 的创建过程中，就可以通过 getBean() 方法获取。
      * <p>
      * 这个 Map 也是【循环依赖】的关键所在。
      */
     private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

     /**
      * 存储已经注册的单例 进行缓存<br/>
      * Set of registered singletons, containing the bean names in registration order.
      */
     private final Set<String> registeredSingletons = new LinkedHashSet<>(256);    

     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);
         }
     }

分析：

一个put、两个remove、一个add。

• 由于已经实例化了bean，因此需要将单例bean进行缓存，singletonObjects.put。
• 同理单例BeanFactory和提前曝光的bean也需要移除，singletonFactories.remove和earlySingletonObjects.remove。
• registeredSingletons.add，已实例化的bean需要进行注册。

#2.原型模式

 if (mbd.isPrototype()) { // 原型模式
                     // It's a prototype -> create a new instance.
                     Object prototypeInstance = null;
                     try {
                         // 前置处理
                         beforePrototypeCreation(beanName);
                         /**
                          * 创建bean {@link AbstractAutowireCapableBeanFactory#createBean}
                          */
                         prototypeInstance = createBean(beanName, mbd, args);
                     } finally {
                         /**
                          * 后置处理 与前置处理相反从{@link prototypesCurrentlyInCreation}中移除
                          */
                         afterPrototypeCreation(beanName);
                     }
                     bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                 }

分析：

原型模式下bean的初始化很简单，直接创建一个新Bean实例就可以了。

• beforePrototypeCreation：记录加载原型模式bean的加载状态，前置处理。
• createBean创建实例对象，该方法非常重要，后续会详细进行分析。
• afterPrototypeCreation：移除创建时添加的标志，后置处理与beforePrototypeCreation方法功能相反。
• 最后调用getObjectForBeanInstance获取实例，该方法在【spring源码分析】IOC容器初始化（六）中已经分析，这里不再赘述。

AbstractBeanFactory#beforePrototypeCreation

 1    /**
      * 原型模式下存储beanName的ThreadLocal<br/>
      * Names of beans that are currently in creation.
      */
 private final ThreadLocal<Object> prototypesCurrentlyInCreation =
             new NamedThreadLocal<>("Prototype beans currently in creation");

 protected void beforePrototypeCreation(String beanName) {
         // 从ThreadLocal中取出对象
         Object curVal = this.prototypesCurrentlyInCreation.get();
         if (curVal == null) {
             // 如果为空，则设置值
             this.prototypesCurrentlyInCreation.set(beanName);
         } else if (curVal instanceof String) {
             // 如果curVal为String类型，则进行添加
             Set<String> beanNameSet = new HashSet<>(2);
             beanNameSet.add((String) curVal);
             beanNameSet.add(beanName);
             this.prototypesCurrentlyInCreation.set(beanNameSet);
         } else {
             // 否则将curVal转换成set集合，添加beanName
             Set<String> beanNameSet = (Set<String>) curVal;
             beanNameSet.add(beanName);
         }
     }

分析：

这里的前置处理就是将beanName加入ThreadLocal中，逻辑简单。

AbstractBeanFactory#afterPrototypeCreation

     protected void afterPrototypeCreation(String beanName) {
         Object curVal = this.prototypesCurrentlyInCreation.get();
         if (curVal instanceof String) {
             this.prototypesCurrentlyInCreation.remove();
         } else if (curVal instanceof Set) {
             Set<String> beanNameSet = (Set<String>) curVal;
             beanNameSet.remove(beanName);
             if (beanNameSet.isEmpty()) {
                 this.prototypesCurrentlyInCreation.remove();
             }
         }
     }

分析：

后置处理与前置处理beforePrototypeCreation正好相反，将标记从ThreadLocal中移除。

#3.其他作用域

 // 获得scopeName对应的Scope对象
                     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 {
                         /**
                          * 从指定的scope下创建bean
                          * {@link SimpleThreadScope#get方法}
                          */
                         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;
             }

分析：

其他作用域bean的创建过程与原型模式的流程一样，只是获取bean的方式变成了Scope#get(String name,ObjectFactory<?> objectFactory)。

 //  SimpleThreadScope
 public Object get(String name, ObjectFactory<?> objectFactory) {
         // 获取scope缓存
         Map<String, Object> scope = this.threadScope.get();
         Object scopedObject = scope.get(name);
         if (scopedObject == null) {
             // 这里getObject也是进行方法回调
             scopedObject = objectFactory.getObject();
             // 加入缓存
             scope.put(name, scopedObject);
         }
         return scopedObject;
     }

这里仅仅是Scope接口的一种实现，该接口还有其他多种实现，其具体源码可查看相应实现类：

至此，Bean加载的大致流程已分析完毕，当然本篇文章并未分析一个很重要的函数createBean，该函数留在后续的文章继续分析。

---

by Shawn Chen，2019.04.22，下午。