在 Spring 种，所有的 BD 都会进行合并（Merger），为什么要进行合并呢？因为可能存在父 BD 的情况，所以要进行合并

    即：所有的 Bean 最终都会合并成一个 BD，也就是 RootBeanDefinition

    Spring 在合并 BD，第一次是在扫描 Bean 的时候，此时只会合并已经存在的 BD，和手动通过容器注册的 BD（ ac.registerBeanDefinition，其他的比如通过 BeanFactoryProcessor 注册的 bean，则会再 preInstantiateSingletons 的时候完成合并，因为 BeanFactoryProcessor 执行的时机晚于扫描 Bean 的时机），才会再第一次扫描的时候完成合并，然后 Spring 又会将其从 mergedBeanDefinitions 中清除掉，加入到 alreadyCreated 集合中去（这样做的目的是防止后面会对这个 Bean 做更改），然后继续进行一次合并

    1. // ★★★ 此时已经经过扫描
    2. // 此时第二次调用 getBeanNamesForType 可以拿到所有的 BD，同时完成了第一次的 BD 合并
    3. postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    4. ...
    5. // 开始进行合并
    6. RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

    以下，是完成合并的关键代码：

    1. protected RootBeanDefinition getMergedBeanDefinition(
    2.     String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
    3.     throws BeanDefinitionStoreException {
    5.     synchronized (this.mergedBeanDefinitions) {
    6.         // 用 RootBeanDefinition 记录合并之后 bd
    7.         // 可能是 本身，也可能是 父类
    8.         RootBeanDefinition mbd = null;
    10.         // Check with full lock now in order to enforce the same merged instance.
    11.         if (containingBd == null) {
    12.             mbd = this.mergedBeanDefinitions.get(beanName);
    13.         }
    15.         if (mbd == null) {
    16.             // 判断是否需要合并，如果 ParentName 为空，则不需要进行合并
    17.             if (bd.getParentName() == null) {
    18.                 // Use copy of given root bean definition.
    19.                 // 如果是 RootBeanDefinition
    20.                 if (bd instanceof RootBeanDefinition) {
    21.                     // 因为没有父类，所以直接 clone 给 RootBeanDefinition
    22.                     mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
    23.                 }
    24.                 else {
    25.                     // 构建了一个 RootBeanDefinition
    26.                     mbd = new RootBeanDefinition(bd);
    27.                 }
    28.             }
    29.             // 需要合并
    30.             else {
    31.                 // Child bean definition: needs to be merged with parent.
    32.                 BeanDefinition pbd;
    33.                 try {
    34.                     // 获取 父类 的名字
    35.                     String parentBeanName = transformedBeanName(bd.getParentName());
    36.                     if (!beanName.equals(parentBeanName)) {
    37.                         // 得到父类的 BD，这里是一个递归调用，是因为父类可能还有父类
    38.                         pbd = getMergedBeanDefinition(parentBeanName);
    39.                     }
    40.                     else {
    41.                         BeanFactory parent = getParentBeanFactory();
    42.                         if (parent instanceof ConfigurableBeanFactory) {
    43.                             pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
    44.                         }
    45.                         else {
    46.                             throw new NoSuchBeanDefinitionException(parentBeanName,
    47.                                                                     "Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
    48.                                                                     "': cannot be resolved without an AbstractBeanFactory parent");
    49.                         }
    50.                     }
    51.                 }
    52.                 catch (NoSuchBeanDefinitionException ex) {
    53.                     throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
    54.                                                            "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
    55.                 }
    56.                 // Deep copy with overridden values.
    57.                 // ★ 以父类为基准，先父类的 BD 合并到 RootBeanDefinition
    58.                 mbd = new RootBeanDefinition(pbd);
    59.                 // ★★★ 子类 覆盖 父类的 bean 属性
    60.                 mbd.overrideFrom(bd);
    61.             }
    63.             // Set default singleton scope, if not configured before.
    64.             if (!StringUtils.hasLength(mbd.getScope())) {
    65.                 mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
    66.             }
    68.             // A bean contained in a non-singleton bean cannot be a singleton itself.
    69.             // Let's correct this on the fly here, since this might be the result of
    70.             // parent-child merging for the outer bean, in which case the original inner bean
    71.             // definition will not have inherited the merged outer bean's singleton status.
    72.             if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
    73.                 mbd.setScope(containingBd.getScope());
    74.             }
    76.             // Cache the merged bean definition for the time being
    77.             // (it might still get re-merged later on in order to pick up metadata changes)
    78.             if (containingBd == null && isCacheBeanMetadata()) {
    79.                 // 合并完成之后，将放人 RootBeanDefinition 放入 mergedBeanDefinitions 中
    80.                 this.mergedBeanDefinitions.put(beanName, mbd);
    81.             }
    82.         }
    84.         return mbd;
    85.     }
    86. }

    总体来说：合并 BD，其实就是先寻找当前 BD 的父 BD，如果没有父 BD，则直接克隆当前 BD，交给 RootBeanDefinition，如果存在父 BD，则找到父 BD（此处会经过一个递归调用来寻找底层父 BD），然后先将父 BD 复制给一个新的 RootBeanDefinition，然后再找到子 BD 进行值的替换，就完成了一个完整的 BD