AbstractBeanFactory.getMergedBea

AbstractBeanFactory.getMergedBeanDefinition

protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
        RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
        //已经缓存的 mbd中有当前bean，且不需要再合并则直接返回 RootBeanDefinition
        if (mbd != null && !mbd.stale) {
            return mbd;
        }
        return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
    }

protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
            throws BeanDefinitionStoreException {

        return getMergedBeanDefinition(beanName, bd, null);
    }


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

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

            //父级 bean 为空
            if (containingBd == null) {
                mbd = this.mergedBeanDefinitions.get(beanName);
            }
//已经缓存的 mbd 不存在 / 或需要合并
            if (mbd == null || mbd.stale) {
                previous = mbd;
        //获取待合并的 BeanDefinition 的父级 BeanDefinition 的名字
                //父级 BeanDefinition 名字为 空
                if (bd.getParentName() == null) {
                    // Use copy of given root bean definition.
                    if (bd instanceof RootBeanDefinition) {
            // 如果当前待合同 bd已经是 RootBeanDefinition 则复制属性生成新的 mbd
                        mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
                    }
                    else {
            //否则 new一个新的 mbd
                        mbd = new RootBeanDefinition(bd);
                    }
                }
        //父级 BeanDefinition 名字不为 空
                else {
                    //子级 BeanDefinition 需要与父级BeanDefinition合并
                    BeanDefinition pbd;
                    try {
            //同样合并前对父级 BeanDefinition 名字进行处理
                        String parentBeanName = transformedBeanName(bd.getParentName());
            //如果 父级 BeanDefinition 名字 和待合同bd名字不相同
                        if (!beanName.equals(parentBeanName)) {
              //递归调用 getMergedBeanDefinition 因为生成的bd可能还是ChildBeanDefinition,所以一直递归
                            pbd = getMergedBeanDefinition(parentBeanName);
                        }
             //如果 父级 BeanDefinition 名字 和待合同bd名字相同
                        else {
              //获取 当前 BeanFactory的 父级 BeanFactory
                            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 a ConfigurableBeanFactory parent");
                            }
                        }
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
                                "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
                    }
          //现在已经获取 bd 的parent bd到pbd
                    // Deep copy with overridden values.
                    mbd = new RootBeanDefinition(pbd);
                    mbd.overrideFrom(bd);
                }

                // scope没有设置 则默认是 单例
                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;
        }
  
  //递归调用
  @Override
    public BeanDefinition getMergedBeanDefinition(String name) throws BeansException {
        String beanName = transformedBeanName(name);
        // Efficiently check whether bean definition exists in this factory.
        if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
            return ((ConfigurableBeanFactory) 
              //递归调当前方法 每次递归方法持有者不同
              getParentBeanFactory()).getMergedBeanDefinition(beanName);
        }
        // 递归调用最上层方法
        return getMergedLocalBeanDefinition(beanName);
    }
  
    }