【Spring源码】- 03 Spring IoC容器启动之Bean创建流程

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
 // 初始化类型转换器
 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));
 }

 // 占位符表达式解析器，比如解析@Value("${test.name}")
 if (!beanFactory.hasEmbeddedValueResolver()) {
  beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
 }

 // 初始化LoadTimeWeaverAware Bean，getBean则是让实现LoadTimeWeaverAware的对象提前实例化
 String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
 for (String weaverAwareName : weaverAwareNames) {
  getBean(weaverAwareName);
 }

 //停止使用临时的类加载器
 beanFactory.setTempClassLoader(null);

 // 冻结所有的BeanDefinition定义，不期望以后会被修改或进一步处理，因为马上要创建Bean实例对象了
 beanFactory.freezeConfiguration();

 // 实例化所有的non-lazy-init 单例
 beanFactory.preInstantiateSingletons();
}

@Override
public void preInstantiateSingletons() throws BeansException {

 // 获取到所有BeanDefinition名称，后面用于遍历处理
 List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

 // 遍历触发每个BeanDefinition实例化
 for (String beanName : beanNames) {
  //getMergedLocalBeanDefinition()可以简单理解成获取BeanDefinition即可
        //主要涉及到将其它类型的BeanDefinition统一转成成RootBeanDefinition或继承关系导致的多个BeanDefinition合并成一个
  RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  /**
  * 作用域是singleton，且不是abstract和lazy-init，才会执行初始化
  * 只有singleton的Bean才会提前实例化好，其它作用域和lazy属性的Bean都是在使用时调用getBean()方法时才会被创建
  */
  if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
   /**
   * 是否为FactoryBean,不是的话直接getBean(beanName)，也就是实例化
   * 如果是FactoryBean，走IF语句块
   */
   if (isFactoryBean(beanName)) {
    //通过getBean(&beanName)拿到的是FactoryBean本身；通过getBean(beanName)拿到的是FactoryBean创建的Bean实例
    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
    if (bean instanceof FactoryBean) {
     final FactoryBean<?> factory = (FactoryBean<?>) bean;
     //判断这个FactoryBean是否希望急切的初始化
     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 {
    //非FactoryBean实例化
    getBean(beanName);
   }
  }
 }

    /**
 * 这里出现了另一个扩展点：SmartInitializingSingleton，用于所有Singleton实例创建全部完成(包括各种依赖注入、初始化等)后，
 * 去执行SmartInitializingSingleton#afterSingletonsInstantiated回调方法
 */
 for (String beanName : beanNames) {
  Object singletonInstance = getSingleton(beanName);
  // 如果实例实现了SmartInitializingSingleton，执行afterSingletonsInstantiated方法。
  if (singletonInstance instanceof SmartInitializingSingleton) {
   final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
   if (System.getSecurityManager() != null) {
    AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
     smartSingleton.afterSingletonsInstantiated();
     return null;
    }, getAccessControlContext());
   }
   else {
    smartSingleton.afterSingletonsInstantiated();
   }
  }
 }
}

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

 //解析beanName，主要是解析别名、去掉FactoryBean的前缀“&”
 final String beanName = transformedBeanName(name);
 Object bean;

 /**
 * 通过singletonObjects()方法先尝试从缓存中获取bean实例，获取不到再走后面创建的流程，通过缓存解决循环依赖问题
 *
 * 获取到有两种情况：
 *   一种是Bean创建完成后，会存储到该缓存中
 *   另一种是未创建完成，但先预存到一个单独的缓存中，这种是针对可能存在循环引用的情况的处理。
 *  如A引用B,B又引用了A,因而在初始化A时，A会先调用构造函数创建出一个实例，在依赖注入B之前，现将A实例缓存起来
 *  然后在初始化A时，依赖注入阶段，会触发初始化B，B创建后需要依赖注入A时，先从缓存中获取A（这个时候的A是不完整的)，避免循环依赖的问题出现。
 */
 Object sharedInstance = getSingleton(beanName);
 if (sharedInstance != null && args == null) {
  /**
  * 这里主要处理实现了FactoryBean的情况，需要调用重写的getObject()方法来获取实际的Bean实例。
  * 普通Bean会直接返回sharedInstance本身
  * preInstantiateSingletons方法中也有处理FactoryBean分支，但是那是针对Singleton且提前实例化情况，
  * 对于Lazy类型的FactoryBean，那个流程是走不到的，而是在getBean时才会创建，所以这里还要处理FactoryBean
  */
  bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
 }
 //缓存没有则创建
 else {
  //原型对象不允许循环创建，如果是原型对象则抛异常
  if (isPrototypeCurrentlyInCreation(beanName)) {
   throw new BeanCurrentlyInCreationException(beanName);
  }

  /**
  * BeanFactory也存在继承关系，如果当前BeanFactory中找不到BeanDefinition，则到parentBeanFactory容器中找，递归向上查找
  */
  BeanFactory parentBeanFactory = getParentBeanFactory();
  if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
   String nameToLookup = originalBeanName(name);
   if (parentBeanFactory instanceof AbstractBeanFactory) {
    return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
      nameToLookup, requiredType, args, typeCheckOnly);
   }
   else if (args != null) {
    return (T) parentBeanFactory.getBean(nameToLookup, args);
   }
   else if (requiredType != null) {
    return parentBeanFactory.getBean(nameToLookup, requiredType);
   }
   else {
    return (T) parentBeanFactory.getBean(nameToLookup);
   }
  }

  // typeCheckOnly=true表示调用这个方法只是做类型检查，不会去做真正对象创建，正常情况下typeCheckOnly=false
  if (!typeCheckOnly) {
   //如果不是仅仅做类型检测，而是需要创建bean实例，这里要将beanName放到alreadyCreated缓存，进行已创建标记
   markBeanAsCreated(beanName);
  }

  try {
   // 根据名字获取合并过的对应的RootBeanDefinition
   final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
   // 检查mbd是否为抽象的或mbd为单例，但存在args的情况（args只有初始化原型对象才允许存在)
   checkMergedBeanDefinition(mbd, beanName, args);

   /**
   * 拿到当前bean依赖的bean名称集合，如使用@DependsOn，在实例化自己之前，保证依赖的这些Bean全部被初始化，递归getBean
   */
   String[] dependsOn = mbd.getDependsOn();
   if (dependsOn != null) {
    for (String dep : dependsOn) {
     registerDependentBean(dep, beanName);
     // 先实例化@DependsOn中的bd
     getBean(dep);
    }
   }

   if (mbd.isSingleton()) {//创建单例Bean
    // 会先尝试从缓存中获取，获取失败就通过ObjectFactory的createBean方法创建
    sharedInstance = getSingleton(beanName, () -> {
     try {
      // 创建单例对象
      return createBean(beanName, mbd, args);
     }
     catch (BeansException ex) {
      destroySingleton(beanName);
      throw ex;
     }
    });
    //这里主要处理实现了FactoryBean的情况，需要调用重写的getObject()方法来获取实际的Bean实例。
    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
   }
   else if (mbd.isPrototype()) {//创建多例Bean
    ...//省略    
   }
   else {//创建其它作用域的Bean
    ...//省略
   }
  }
  catch (BeansException ex) {
   cleanupAfterBeanCreationFailure(beanName);
   throw ex;
  }
 }

 // 检查是否为要求的类型，如果不是则尝试进行类型转换
 if (requiredType != null && !requiredType.isInstance(bean)) {
  ...//省略
 }
 return (T) bean;
}

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

 ...//省略
        
 /**
 * 实例化前的处理，如果有实现InstantiationAwareBeanPostProcessor的BeanPostProcessor可以直接返回真正的bean实例
 * 然后依次所有注册的BeanPostProcessor的postProcessAfterInitialization方法（同样如果任意一次返回不为null,即终止调用。
 */
 Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
 // 如果不为空，说明提前生成了实例，直接返回
 if (bean != null) {
  return bean;
 }

    ...//省略
        
 //创建Bean实例（一般真正创建Bean的方法）
 Object beanInstance = doCreateBean(beanName, mbdToUse, args);
 return beanInstance;
}

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



  // Initialize the bean instance.
  // 开始对Bean实例进行初始化，依赖注入在这里发生，exposedObject 在初始化处理完后会返回作为依赖注入完成后的Bean
  Object exposedObject = bean;//这里还是原生对象
  try {
   /**

   populateBean(beanName, mbd, instanceWrapper);
   /**
    * 完成属性依赖注入后，进一步初始化Bean，具体进行了以下操作：
    *   1.若实现了BeanNameAware， BeanClassLoaderAware，BeanFactoryAwareAware等接口，则注入相关对象
    *   2.遍历后置处理器，调用实现的postProcessBeforeInitialization方法，
    *   3.如果实现了InitialzingBean，调用实现的 afterPropertiesSet()
    *   4.如果配置了init-mothod，调用相应的init方法
    *   5.遍历后置处理器，调用实现的postProcessAfterInitialization
    *
    * initializeBean方法执行bean的初始化方法
    * 经过AOP处理,原生对象转换成了代理对象
    * 执行后置处理器，aop就是在这里完成的处理
    */
   exposedObject = initializeBean(beanName, exposedObject, mbd);
  }
  catch (Throwable ex) {
   if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
    throw (BeanCreationException) ex;
   }
   else {
    throw new BeanCreationException(
      mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
   }
  }

  if (earlySingletonExposure) {
   Object earlySingletonReference = getSingleton(beanName, false);
   if (earlySingletonReference != null) {
    if (exposedObject == bean) {
     exposedObject = earlySingletonReference;
    }
    else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
     String[] dependentBeans = getDependentBeans(beanName);
     Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
     for (String dependentBean : dependentBeans) {
      if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
       actualDependentBeans.add(dependentBean);
      }
     }
     if (!actualDependentBeans.isEmpty()) {
      throw new BeanCurrentlyInCreationException(beanName,
        "Bean with name '" + beanName + "' has been injected into other beans [" +
        StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
        "] in its raw version as part of a circular reference, but has eventually been " +
        "wrapped. This means that said other beans do not use the final version of the " +
        "bean. This is often the result of over-eager type matching - consider using " +
        "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
     }
    }
   }
  }

  // Register bean as disposable.
  try {
   // 如果实现了Disposable接口，会在这里进行注册，最后在销毁的时候调用相应的destroy方法
   registerDisposableBeanIfNecessary(beanName, bean, mbd);
  }
  catch (BeanDefinitionValidationException ex) {
   throw new BeanCreationException(
     mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  }

  return exposedObject;
 }

synchronized (mbd.postProcessingLock) {
 if (!mbd.postProcessed) {
  try {
   //获取所有实现MergedBeanDefinitionPostProcessor接口的后置处理器，调用其postProcessMergedBeanDefinition方法
   applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
  }
  catch (Throwable ex) {
   throw new BeanCreationException(mbd.getResourceDescription(), beanName,
     "Post-processing of merged bean definition failed", ex);
  }
  mbd.postProcessed = true;
 }
}

// 提前将Bean暴露到IoC容器中，用于解决循环依赖
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");
 }

 /**
 * 提前暴露beanName的ObjectFactory，用于解决循环引用，确保其他Bean能引用到此bean
 *
 * 其实就是调用singletonFactories.put(beanName, singletonFactory)将ObjectFactory存储到Map中
 *
 * A引用B，同时B也引用A
 * 1、在初始化A过程中执行到这里时，由于还没有初始化完成，所以会将A包装成一个ObjectFactory提前暴露出去；
 * 2、初始化A继续向下执行，当执行到populate进行依赖注入时，发现需要对象B，这时就getBean(B)递归进入到创建B的流程里面去了；
 * 3、B初始化过程中，也执行到了populate方法进行依赖注入时，需要getBean(A)获取对象A进行依赖注入；
 * 4、getBean(A)过程中首先getSingleton()从缓存中获取，getSingleton()就可以获取到提前暴露的A对应的ObjectFactory对象；
 * 5、然后调用ObjectFactory.getObject()，进而调用getEarlyBeanReference()
 * 6、getEarlyBeanReference()方法会触发一个扩展点：SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference如果返回非null，则可以覆盖当前bean
 */
 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
 Object exposedObject = bean;
 if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  for (BeanPostProcessor bp : getBeanPostProcessors()) {
   if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
    SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
    exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
   }
  }
 }
 return exposedObject;
}

if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
 for (BeanPostProcessor bp : getBeanPostProcessors()) {
  /**
  * InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation：Bean创建之后，依赖注入之前执行，最后一次机会在属性注入前修改Bean的属性值
  * postProcessAfterInstantiation()一般都是返回true,
  * 如果返回false，则表示不必继续进行依赖注入，立即停止后续的postProcessAfterInstantiation方法执行，并跳出populateBean方法执行。
  */
  if (bp instanceof InstantiationAwareBeanPostProcessor) {
   InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
   if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
    return;
   }
  }
 }
}

/**
* Spring内部可以对BeanDefinition进行设置值, 参照自定义的 BeanFactory中获取到BeanDefinition.getPropertyValue().addXXX();
* pvs是一个MutablePropertyValues实例，里面存储PropertyValue集合，通过PropertyValue实现对属性的赋值、依赖注入
*/
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

/**
*  自动注入方式：byName还是byType，依赖注入方式：如果设置了相关的依赖装配方式，会遍历Bean中的属性，根据类型或名称来完成相应注入，无需额外配置
*  @Autowired注解默认是AUTOWIRE_NO=0，即不走以下逻辑
*/
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
 // 深拷贝当前已有的配置
 MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
 // 自动根据名称注入
 if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
  autowireByName(beanName, mbd, bw, newPvs);
 }
 // 自动根据类型注入
 if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
  autowireByType(beanName, mbd, bw, newPvs);
 }
 //组合需要依赖注入配置数据
 pvs = newPvs;
}

public class BeanDefinitionDefaults {
 private Boolean lazyInit;
 private int autowireMode = AbstractBeanDefinition.AUTOWIRE_NO;
 private int dependencyCheck = AbstractBeanDefinition.DEPENDENCY_CHECK_NONE;
 private String initMethodName;
 private String destroyMethodName;
}

PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
 if (pvs == null) {
   pvs = mbd.getPropertyValues();
 }
 /**
 * 回调InstantiationAwareBeanPostProcessor#postProcessProperties方法
 * AutowiredAnnotationBeanPostProcessor，就是在这个方法中完成@Autowired、@Value注解的依赖注入
 * CommonAnnotationBeanPostProcessor：支持JSR-250的一些注解，如：@Resource、@PostConstruct、@PreDestroy等
 */
 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) {
     //获取出对象的所有set get方法,现在是有一个 getClass()方法,因为继承了Object, 没什么其他卵用
     filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
    }
    //postProcessPropertyValues方法已废弃，被postProcessProperties替代
    pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
    if (pvsToUse == null) {
     return;
    }
   }
   pvs = pvsToUse;
  }
 }
}

if (pvs != null) {
 applyPropertyValues(beanName, mbd, bw, pvs);
}

BeanDefinitionBuilder bdb = BeanDefinitionBuilder.rootBeanDefinition(User.class);
//注入指定值
bdb.addPropertyValue("name", "张三");
//注入一个引用值，第二个参数指定beanName，依赖注入时从IoC查找到beanName对应的Bean进行注入
bdb.addPropertyReference("friend", "user03");
beanDefinitionRegistry.registerBeanDefinition("user", bdb.getBeanDefinition());

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 {
  /**
  * 如果实现了Aware接口，就对该bean进行一些设置。
  *  比如实现了BeanNameAware接口，那么对其bean的属性beanName上set上对应的beanName。
  *  如果实现了BeanFactoryAware接口，那么对其beanFactory属性设置上创建该bean使用的bean工厂。
  */
  invokeAwareMethods(beanName, bean);
 }

 /**
 * 这里执行BeanPostProcessor#postProcessBeforeInitialization，因为马上就要执行init初始化工作
 * 这里会执行到InitDestroyAnnotationBeanPostProcessor#postProcessBeforeInitialization，
 * 这个方法中就实现了对Bean中@PostConstruct方法的调用
 */
 Object wrappedBean = bean;
 if (mbd == null || !mbd.isSynthetic()) {
  wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
 }

 try {
  //执行初始化方法init
  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()) {
  /**
  * initMethod方法执行完成后，回调BeanPostProcessor#postProcessAfterInitialization方法
  * 
  * 执行Bean后置处理器初始化完成后after方法（aop增强就是在这里完成的）
  * AbstractAutoProxyCreator回调它的before()方法时,仅仅是标记哪些对象需要进行增强哪些对象不需增强,而没有立即生成代理对象
  * applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)：生成代理对象的逻辑就在这里面
  */
  wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
 }
 return wrappedBean;
}

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
   throws Throwable {
 //实现InitializingBean，则调用afterPropertiesSet()方法
 boolean isInitializingBean = (bean instanceof InitializingBean);
 if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
   ((InitializingBean) bean).afterPropertiesSet();
         ...//省略
 }
 /**
 * 执行BeanDefinition中设置到initMethodName的初始化方法，
 * 在ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsForBeanMethod()方法中会解析@Bean注解上的initMethod设置进来
 */
 if (mbd != null && bean.getClass() != NullBean.class) {
  String initMethodName = mbd.getInitMethodName();
  if (StringUtils.hasLength(initMethodName) &&
    !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
    !mbd.isExternallyManagedInitMethod(initMethodName)) {
   invokeCustomInitMethod(beanName, bean, mbd);
  }
 }
}