Spring源码分析：bean加载流程

背景

在Spring中，Bean的加载和管理是其核心功能之一，包括配置元数据解析、Bean定义注册、实例化、属性填充、初始化、后置处理器处理、完成创建和销毁等步骤。

源码入口

AbstractBeanFactory#doGetBean

具体源码流程如下：

bean加载流程（#getBean方法）分析：

1、提取beanName

提取FactoryBean修饰符，比如name=“&aa”，那么就要去掉&，使得name=“aa”
或者，提取指定的beanName，比如别名A->B的bean则返回B

2、从缓存中加载单例

创建单例时，为避免循环依赖，不等完全bean创建，就将创建bean的ObjectFactory提早曝光；即，ObjectFactory放到缓存Map中，一旦下一个bean需要依赖上个bean，就直接使用 ObjectFactory即可。

singletonObjects：key=BeanName，value=构造完成的bean实例
earlySingletonObjects：key=BeanName，value=构造完成的bean实例，用来解决循环依赖问题
singletonFactories：key=BeanName，value=ObjectFactory工厂实例

三级缓存实现原理

当Spring容器创建Bean时，首先会从singletonObjects缓存中查找Bean实例，如果能找到则直接返回。

如果在singletonObjects缓存中没有找到Bean实例，则从earlySingletonObjects缓存中查找，如果找到了一个未完成初始化的Bean实例，则将其返回，并在后续的处理中完成初始化。
如果在earlySingletonObjects缓存中也没有找到Bean实例，则从singletonFactories缓存中查找是否存在创建Bean实例的工厂对象，如果存在，则通过工厂对象创建一个新的Bean实例，并将工厂对象从singletonFactories缓存中移除。
如果在singletonFactories缓存中也没有找到工厂对象，则需要创建一个新的工厂对象，并放到singletonFactories缓存中，以便后续使用。
创建Bean实例时，如果Bean存在循环依赖，那么Spring框架会先创建一个用于创建Bean实例的工厂对象，放到singletonFactories缓存中。然后通过工厂对象创建一个新的Bean实例，并将其放到earlySingletonObjects缓存中，以便后续处理。

下面是DefaultSingletonBeanRegistry源码

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


/** Cache of singleton factories: bean name to ObjectFactory. */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);


/** Cache of early singleton objects: bean name to bean instance. */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);


@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   Object singletonObject = this.singletonObjects.get(beanName);
   // 【1】
   if (singletonObject == null 
       && isSingletonCurrentlyInCreation(beanName)) {
     // 【2】
      synchronized (this.singletonObjects) {
          // 【3】
         singletonObject = this.earlySingletonObjects.get(beanName);
         if (singletonObject == null && allowEarlyReference) {
             // 【4】
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
                // 【5】
               singletonObject = singletonFactory.getObject();
               // 【6】
               this.earlySingletonObjects.put(beanName, singletonObject);
               // 【7】
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return singletonObject;


}

代码分析：

【1】isSingletonCurrentlyInCreation 判断是否循环依赖
【2】用synchronized 锁住singleObjects一级缓存全局变量，确保线程安全，因为有3个全局变量要修改的
【3】从 earlySingletonObjects 二级缓存取 object
- 如果object不为空，说明bean正在被创建，则跳出来
- 如果object为空，说明bean没在被创建，需要执行下面逻辑
【4】从 singletonFactories 三级缓存取 ObjectFactory（某些方法提前初始化了ObjectFactory策略到 singletonFactories 中）
- 【5】如果object不为空，说明已经有预设好的ObjectFactory，可以实例化它：通过预设的getBean ObjectFactory@getObject() 创建bean实例
- 【6】记录到 earlySingletonObjects 中，说明此bean正在被创建
- 【7】earlySingletonObjects 和 singletonFactories是互斥的，因此要remove调

3、多例对象-是否创建中检测

if (isPrototypeCurrentlyInCreation(beanName)) {
   throw new BeanCurrentlyInCreationException(beanName);
}

单例才检测循环依赖，多例抛异常。

4、检测parentBeanFactory

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

缓存没有数据，直接转到父类工厂上去加载工厂方法

5、解析Defination类的类型转换，换成可用的BeanDefination

final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);

6、寻找递归解决bean依赖，并加载和初始化这些依赖 -- 递归思想哦！

String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
   for (String dep : dependsOn) {
      if (isDependent(beanName, dep)) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
               "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
      }
      registerDependentBean(dep, beanName);
      try {
         getBean(dep);
      }
      catch (NoSuchBeanDefinitionException ex) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
               "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
      }
   }
}

7、正式根据scope去创建bean

bean创建的特别之处

Spring 解决循环依赖依靠的是 Bean 的 " 中间态 " 这个概念，而这个中间态指的是已经实例化但还没初始化的状态 —>半成品。

实例化的过程又是通过构造器创建的，如果 A 还没创建好出来怎么可能提前曝光，所以构造器的循环依赖无法解决。

由于 spring 中的 bean 的创建过程为先实例化再初始化 ( 在进行对象实例化的过程中不必赋值 ) 将实例化好的对象暴露出去, 供其他对象调用 , 然而使用构造器注入 , 必须要使用构造器完成对象的初始化的操作 ,就会陷入死循环的状态。

单例scope：实例化bean

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

代码分析：

实例化bean：createBean -》
- doCreateBean -》，参考下面的源码分析【1】
  
  addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
- createBeanInstance，参考下面的源码分析【2】
getSingleton：beanName是一个参数，另一个匿名函数则是ObjectFactory<?> singletonFactory，即构造bean的工厂方法
- singletonObjects：添加经过了实例化+初始化的bean实例
- singletonFactories：移除
- earlySingletonObjects：移除
- addSingleton(beanName, singletonObject)：三级缓存的清理赋值

【1】源码addSingletonFactory：创建bean实例

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
      isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
   addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}


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

代码分析：该方法用于添加单例工厂，主要功能包括：

检查传入的单例工厂是否为null，若为null则抛出异常。
同步锁住singletonObjects确保线程安全。
若singletonObjects中没有beanName对应的对象，则将singletonFactory放入singletonFactories映射中，并移除earlySingletonObjects中的对应项，最后将beanName加入registeredSingletons集合。

这也侧面说明了，bean还没有完全初始化，就把工厂方法提前暴露到了singletonFactories

【2】源码createBeanInstance：bean实例化

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
   // Make sure bean class is actually resolved at this point.
   Class<?> beanClass = resolveBeanClass(mbd, beanName);


   if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
      throw new BeanCreationException(mbd.getResourceDescription(), beanName,
            "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
   }


   Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
   if (instanceSupplier != null) {
      return obtainFromSupplier(instanceSupplier, beanName);
   }


   if (mbd.getFactoryMethodName() != null) {
      return instantiateUsingFactoryMethod(beanName, mbd, args);
   }


   // Shortcut when re-creating the same bean...
   boolean resolved = false;
   boolean autowireNecessary = false;
   if (args == null) {
      synchronized (mbd.constructorArgumentLock) {
         if (mbd.resolvedConstructorOrFactoryMethod != null) {
            resolved = true;
            autowireNecessary = mbd.constructorArgumentsResolved;
         }
      }
   }
   if (resolved) {
      if (autowireNecessary) {
         return autowireConstructor(beanName, mbd, null, null);
      }
      else {
         return instantiateBean(beanName, mbd);
      }
   }


   // Candidate constructors for autowiring?
   Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
   if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
      return autowireConstructor(beanName, mbd, ctors, args);
   }


   // Preferred constructors for default construction?
   ctors = mbd.getPreferredConstructors();
   if (ctors != null) {
      return autowireConstructor(beanName, mbd, ctors, null);
   }


   // No special handling: simply use no-arg constructor.
   return instantiateBean(beanName, mbd);
}

代码分析：

createBeanInstance 用于创建 Bean 的实例，负责根据不同的条件和配置来实例化 Bean，并处理相关的异常情况：

解析并验证 Bean 类。
如果允许，尝试从 Supplier 获取实例。
若配置了工厂方法，则通过工厂方法实例化。
否则，根据参数情况选择构造器自动装配或直接实例化。

初始化bean：填充属性

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean#populateBean

@SuppressWarnings("deprecation")  // for postProcessPropertyValues
protected void populateBean(
    String beanName, RootBeanDefinition mbd, 
    @Nullable BeanWrapper bw) {
    //【1】
   if (bw == null) {
      if (mbd.hasPropertyValues()) {
         throw new BeanCreationException(
               mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
      }
      else {
         return;
      }
   }


    //【2】
   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
               return;
            }
         }
      }
   }


   PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);


    //【3】
   int resolvedAutowireMode = mbd.getResolvedAutowireMode();
   if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
      MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
      // Add property values based on autowire by name if applicable.
      if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
         autowireByName(beanName, mbd, bw, newPvs);
      }
      // Add property values based on autowire by type if applicable.
      if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
         autowireByType(beanName, mbd, bw, newPvs);
      }
      pvs = newPvs;
   }


   boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
   boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);


   PropertyDescriptor[] filteredPds = null;
   if (hasInstAwareBpps) {
      if (pvs == null) {
         pvs = mbd.getPropertyValues();
      }
      //【4】
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
            if (pvsToUse == null) {
               if (filteredPds == null) {
                  filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
               }
               pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
               if (pvsToUse == null) {
                  return;
               }
            }
            pvs = pvsToUse;
         }
      }
   }


   if (needsDepCheck) {
      if (filteredPds == null) {
         filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
      }
      //【5】
      checkDependencies(beanName, mbd, filteredPds, pvs);
   }


   if (pvs != null) {
       //【6】
      applyPropertyValues(beanName, mbd, bw, pvs);
   }
}

代码分析：

【1】检查BeanWrapper是否为空，若为空且存在属性值，则抛出异常；否则跳过属性填充。
【2】若存在实例化需要的后置处理器，则调用它们对bean进行处理。
【3】根据自动装配模式（按名或按类型）添加属性值。
【4】调用实例化后置处理器处理属性值。
【5】检查依赖关系并进行依赖检查。
【6】应用最终的属性值到bean上

多例scope：实例化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);
}

代码分析：

createBean：流程参考单例scope的创建，是类似的。

8、通用：初始化bean & 注入依赖

之前已经实例化过bean了，现在则是完成注入属性；属性注入的顺序是，优先通过autowireByName，然后才是autowireByType。

int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
   MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
   // Add property values based on autowire by name if applicable.
   if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
      autowireByName(beanName, mbd, bw, newPvs);
   }
   // Add property values based on autowire by type if applicable.
   if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
      autowireByType(beanName, mbd, bw, newPvs);
   }
   pvs = newPvs;
}

9、再执行当前bean的initializeBean初始化

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
         invokeAwareMethods(beanName, bean);
         return null;
      }, getAccessControlContext());
   }
   else {
      invokeAwareMethods(beanName, bean);
   }


   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }


   try {
      invokeInitMethods(beanName, wrappedBean, mbd);
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            (mbd != null ? mbd.getResourceDescription() : null),
            beanName, "Invocation of init method failed", ex);
   }
   if (mbd == null || !mbd.isSynthetic()) {
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }


   return wrappedBean;
}

该Java函数initializeBean用于初始化一个Bean：