Spring IoC Bean-生命周期源码梳理分享

Spring IoC Bean-生命周期 一、什么是Spring 1、Spring IoC a.Dependency Injection(DI)–依赖注入 b.Dependency Lookup(DL)–依赖查找 c.Spring容器管理的对象包括什么 2、Spring AOP 二、Spring Bean 生命周期概览 1、概览图 a.Spring Bean的转换过程

下面这张图演示了一个可用的Spring Bean是如何从xml配置文件中演变过来的

ps：配置元信息来源不仅可以在xml中，也可以在properties文件里以及注解元信息。

从上面的图中，我们可以比较清楚的知道Bean的元信息经过解析得到BeanDefinition，然后通过InstantiationStrategy策略将Class实例化为相应的Bean实例，此时该Bean实例字段均为空，然后经过一系列 *** 作将一个可用的Bean实例提供出来供我们使用，在我们使用完之后，容器销毁时，将这些资源进行释放，最终有JVM进行垃圾回收。

b.Spring Bean生命周期概览图

Spring内部IoC容器默认实现为：DefaultListableBeanFactory

Bean的生命周期与方法映射如下图所示：

三、Spring Bean生命周期核心方法 1、registerBeanDefinition-Spring Bean注册

该方法定义于BeanDefinitionRegistry接口下，由DefaultListableBeanFactory提供具体实现，流程比较简单。

其实整个注册流程最核心的一段代码就是：this.beanDefinitionMap.put(beanName, beanDefinition);将相应的BeanDefinition注册到beanDefinitionMap中。key为baneName，value为BeanDefinition

// DefaultListableBeanFactory#registerBeanDefinition
/** Map of bean definition objects, keyed by bean name. */
// 存储beanName(key)与BeanDefinition(value)
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
// 存储beanName，实现容器BeanDefinition的顺序注册
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
/** Whether to allow re-registration of a different definition with the same name. */
// 是否允许相同名称不同BeanDefinition，后者覆盖前者
private boolean allowBeanDefinitionOverriding = true;
/** List of bean definition names, in registration order. */
//---------------------------------------------------------------------
// Implementation of BeanDefinitionRegistry interface
//---------------------------------------------------------------------
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
      throws BeanDefinitionStoreException {

   Assert.hasText(beanName, "Bean name must not be empty");
   Assert.notNull(beanDefinition, "BeanDefinition must not be null");

   if (beanDefinition instanceof AbstractBeanDefinition) {
      try {
         // <1> 对BeanDefinition的最后一次校验，主要对属性 methodOverrides 进行校验
         ((AbstractBeanDefinition) beanDefinition).validate();
      }
      catch (BeanDefinitionValidationException ex) {
         throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
               "Validation of bean definition failed", ex);
      }
   }
   // <2>从缓存中拿BeanDefinition
   BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
   // <2.1>如果缓存中有此BeanDefinition
   if (existingDefinition != null) {
     	// 如果存在但是不允许覆盖，抛出异常
      if (!isAllowBeanDefinitionOverriding()) {
         throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
      }
      // 覆盖 beanDefinition 大于 被覆盖的 beanDefinition 的 ROLE ，打印 info 日志
      else if (existingDefinition.getRole() < beanDefinition.getRole()) {
         // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
         if (logger.isInfoEnabled()) {
            logger.info("Overriding user-defined bean definition for bean '" + beanName +
                  "' with a framework-generated bean definition: replacing [" +
                  existingDefinition + "] with [" + beanDefinition + "]");
         }
      }
      // 覆盖 beanDefinition 与 被覆盖的 beanDefinition 不相同，打印 debug 日志
      else if (!beanDefinition.equals(existingDefinition)) {
         if (logger.isDebugEnabled()) {
            logger.debug("Overriding bean definition for bean '" + beanName +
                  "' with a different definition: replacing [" + existingDefinition +
                  "] with [" + beanDefinition + "]");
         }
      }
      // 其它，打印 trace 日志（很低的一种日志级别，一般不使用）
      else {
         if (logger.isTraceEnabled()) {
            logger.trace("Overriding bean definition for bean '" + beanName +
                  "' with an equivalent definition: replacing [" + existingDefinition +
                  "] with [" + beanDefinition + "]");
         }
      }
     	// 进行BeanDefinition覆盖
      this.beanDefinitionMap.put(beanName, beanDefinition);
   }
   // <2.2>正常情况下，注册流程会走下面这个流程：
   else {
      // 检测Bean创建阶段已经开启，如果开启了就需要对BeanDefinitionMap进行并发控制（这里进行并发控制的原因我理解应该是：如果是Spring容器启动时是单线程的话，那么在注册阶段就不会出现Bean创建阶段的情况，既然出现了不同阶段同时进行的情况，那么一定是处于多线程的情况下，所以需要避免线程不安全的场景，所以需要加锁）
      if (hasBeanCreationStarted()) {
         // beanDefinitionMap是全局变量，需要进行并发控制，避免并发情况
         // Cannot modify startup-time collection elements anymore (for stable iteration)
         synchronized (this.beanDefinitionMap) {
            // 将BeanDefinition加入到beanDefinitionMap中
            this.beanDefinitionMap.put(beanName, beanDefinition);
            // 将beanName加入到beanDefinitionNames中
            List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
            updatedDefinitions.addAll(this.beanDefinitionNames);
            updatedDefinitions.add(beanName);
            this.beanDefinitionNames = updatedDefinitions;
            // 从 manualSingletonNames 移除 beanName， manualSingletonNames用于存储registerBeanDefinition外的单例注册bean
            removeManualSingletonName(beanName);
         }
      }
      else {
         // Still in startup registration phase
         // 将BeanDefinition加入到beanDefinitionMap中
         this.beanDefinitionMap.put(beanName, beanDefinition);
         // 将beanName加入到beanDefinitionNames中
         this.beanDefinitionNames.add(beanName);
         // 从 manualSingletonNames 移除 beanName， manualSingletonNames用于存储registerBeanDefinition外的单例注册bean
         removeManualSingletonName(beanName);
      }
      this.frozenBeanDefinitionNames = null;
   }
   // 重新设置 beanName 对应的缓存
   if (existingDefinition != null || containsSingleton(beanName)) {
      resetBeanDefinition(beanName);
   }
}

2、getMergedBeanDefinition-Spring Bean合并

该方法定义于ConfigurableBeanFactory接口下，由AbstractBeanFactory实现（考虑层次性容器）

此方法会返回一个BeanDefinition实例，如果当前Bean有parent指定，那么会返回一个父子合并后的BeanDefinition。

// AbstractBeanFactory#getMergedBeanDefinition
/*用来存储合并后的RootBeanDefinition缓存*/
private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap<>(256);
// 考虑层次性容器时会调用此方法（目前学习的过程当中还没有发现哪里有调用此方法）
@Override
public BeanDefinition getMergedBeanDefinition(String name) throws BeansException {
  //<1> 根据给定的name获得真正的beanName（有可能给定的name是别名）
  String beanName = transformedBeanName(name);
  // Efficiently check whether bean definition exists in this factory.
  //<2> 当前容器是否包含此BeanDefinition
  if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
    // <2.1> 如果当前容器没有，并且父容器实例是ConfigurableBeanFactory，那么就去到父容器中去递归查找
    return ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName);
  }
  // Resolve merged bean definition locally.
  // <3> 获取当前容器的BeanDefinition
  return getMergedLocalBeanDefinition(beanName);
}

// AbstractBeanFactory#getMergedLocalBeanDefinition
// 在spring执行doGetBean()方法时，调用的此方法 主要用于查找当前容器的BeanDefinition（不考虑层次性容器的场景）
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
  // Quick check on the concurrent map first, with minimal locking.
  // <1> 去到mergedBeanDefinitions中查找RootBeanDefinition信息
  RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
  // <2> 如果找到了，并且当前mbd不允许重新合并时，直接返回（stale字段的含义就是决定BeanDefinition是否重新合并）
  if (mbd != null && !mbd.stale) {
    return mbd;
  }
  // <3> 重载方法，获取当前容器下父子Bean合并后的BeanDefinition
  return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}

// AbstractBeanFactory#getMergedBeanDefinition
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
  throws BeanDefinitionStoreException {
	// <1> 重载方法（处理BeanDefinition合并的核心方法）
  return getMergedBeanDefinition(beanName, bd, null);
}

// AbstractBeanFactory#getMergedBeanDefinition
protected RootBeanDefinition getMergedBeanDefinition(
  String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
  throws BeanDefinitionStoreException {

  synchronized (this.mergedBeanDefinitions) {
    RootBeanDefinition mbd = null;
    RootBeanDefinition previous = null;

    // Check with full lock now in order to enforce the same merged instance.
    if (containingBd == null) {
      mbd = this.mergedBeanDefinitions.get(beanName);
    }

    if (mbd == null || mbd.stale) {
      previous = mbd;
      if (bd.getParentName() == null) {
        // Use copy of given root bean definition.
        if (bd instanceof RootBeanDefinition) {
          mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
        }
        else {
          mbd = new RootBeanDefinition(bd);
        }
      }
      else {
        // Child bean definition: needs to be merged with parent.
        BeanDefinition pbd;
        try {
          String parentBeanName = transformedBeanName(bd.getParentName());
          if (!beanName.equals(parentBeanName)) {
            pbd = getMergedBeanDefinition(parentBeanName);
          }
          else {
            BeanFactory parent = getParentBeanFactory();
            if (parent instanceof ConfigurableBeanFactory) {
              pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
            }
            else {
              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.
        mbd = new RootBeanDefinition(pbd);
        mbd.overrideFrom(bd);
      }

      // Set default singleton scope, if not configured before.
      if (!StringUtils.hasLength(mbd.getScope())) {
        mbd.setScope(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.
      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)
      if (containingBd == null && isCacheBeanMetadata()) {
        this.mergedBeanDefinitions.put(beanName, mbd);
      }
    }
    if (previous != null) {
      copyRelevantMergedBeanDefinitionCaches(previous, mbd);
    }
    return mbd;
  }
}

3、resolveBeforeInstantiation 4、createBeanInstance 5、populateBean 6、initializeBean 7、preInstantiateSingletons 8、destroyBean