Spring-IOC加载Bean【四】bean依赖信息处理与RootBeanDefinition

首先获取并检查RootBeanDefinition，之后再处理依赖bean。

1、获取RootBeanDefinition

// 从容器中获取 beanName 相应的 GenericBeanDefinition，并将其转换为 RootBeanDefinition
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//返回合并的RootBeanDefinition，如果指定的bean对应于子bean定义，则遍历父bean定义。
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
        // 首先快速检查map，使用最小的锁定。
        RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
        if (mbd != null) {
            return mbd;
        }
        //首先根据beanName获取BeanDefinition
        //获取合并好的RootBeanDefinition
        return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
    }

这段代码就是先从缓存中获取RootBeanDefinition,如果没有则合并父类的相关属性等创建RootBeanDefinition,以前分析从单例获取bean的时候，分析过。

2、检查RootBeanDefinition

//检查给定的合并bean定义，可能会引发验证异常。
protected void checkMergedBeanDefinition(RootBeanDefinition mbd, String beanName, @Nullable Object[] args)
            throws BeanDefinitionStoreException {
   if (mbd.isAbstract()) {
       throw new BeanIsAbstractException(beanName);
   }
}

检查RootBeanDefinition是否是抽象的。

3、处理依赖

// 保证当前bean所依赖的bean的初始化。
              // 返回此bean所依赖的bean名称。
              String[] dependsOn = mbd.getDependsOn();
              // 如果有依赖
              if (dependsOn != null) {
                  for (String dep : dependsOn) {
                      //确定指定的依赖bean是否已注册为依赖于给定bean或依赖于其传递依赖项。
                      //循环依赖的情况
                      if (isDependent(beanName, dep)) {
                          throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                  "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                      }
                      //为给定bean注册一个依赖bean，在销毁给定bean之前销毁它。
                      registerDependentBean(dep, beanName);
                      try {
                          //实例化依赖bean
                          getBean(dep);
                      } catch (NoSuchBeanDefinitionException ex) {
                          throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                  "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                      }
                  }
              }

• 获取所有的依赖bean
• 检查依赖是否已经被注册
• 为给定bean注册一个依赖bean，在销毁给定bean之前销毁它
• 实例化依赖bean

4、依赖检测

//从属bean名称之间的映射:从bean名称映射到一组从属bean名称。
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
//确定指定的依赖bean是否已注册为依赖于给定bean或依赖于其传递依赖项。
protected boolean isDependent(String beanName, String dependentBeanName) {
        //锁定依赖bean map
        synchronized (this.dependentBeanMap) {
            return isDependent(beanName, dependentBeanName, null);
        }
    }

    private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
        if (alreadySeen != null && alreadySeen.contains(beanName)) {
            return false;
        }
        //确定原始名称，将别名解析为规范名称。
        String canonicalName = canonicalName(beanName);
        //依赖bean
        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.add(beanName);
            if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
                return true;
            }
        }
        return false;
    }

5、registerDependentBean

将该依赖进行注册，便于在销毁 bean 之前对其进行销毁。

//从属bean名称之间的映射:从bean名称映射到一组从属bean名称。
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
//在依赖bean名称之间映射:bean名称到bean依赖项的bean名称集。
private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
//为给定bean注册一个依赖bean，在销毁给定bean之前销毁它。
public void registerDependentBean(String beanName, String dependentBeanName) {
        //确定原始名称，将别名解析为规范名称。
        String canonicalName = canonicalName(beanName);

        //从属bean名称之间的映射:从bean名称映射到一组从属bean名称。
        synchronized (this.dependentBeanMap) {
            Set<String> dependentBeans =
                    this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
            if (!dependentBeans.add(dependentBeanName)) {
                return;
            }
        }

        synchronized (this.dependenciesForBeanMap) {
            Set<String> dependenciesForBean =
                    this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
            dependenciesForBean.add(canonicalName);
        }
    }