Spring到处可见的getMergedBeanDefinition,到底什么是MergedBeanDefinition

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
    // 返回合并的RootBeanDefinition，如果指定的bean存在父bean定义,则需要合并父bean的定义
    // 为什么存在父BeanDefinition,因为BeanDefinition也存在父子关系,子BeanDefinition需要继承父的BeanDefinition,并且还要保存自身的定义配置
    // 为什么getMergedLocalBeanDefinition,为什么是Merged"Local"BeanDefinition呢?因为之前凡是调用过这个方法处理过的beanName,都会被缓存到本地
    // 并且缓存的是合并过后的RootBeanDefinition,不在存在父BeanDefinition了

    /**
     * <pre>
     *  例如: 我们手动注入两个BD,并且两个BD存在父子关系
     *  context.registerBeanDefinition("luck", new RootBeanDefinition(ParentBean.class));
     *  // 定义一个子BeanDefinition,父beanName为luck
     *  // 从而ChildBeanDefinition的配置会与RootBeanDefinition进行合并,并且保存ChildBeanDefinition的属性
     *  ChildBeanDefinition definition = new ChildBeanDefinition("luck");
     *  definition.setBeanClass(ChildBean.class);
     *  context.registerBeanDefinition("child", definition);
     *
     *    这个方法所做的逻辑就是,获取beanName对应的BD,如果BD不存在父BD,直接封装成将当前Bean的BD拷贝到RootBeanDefinition中,并且缓存到mergedBeanDefinitions中
     *    如果DB存在父BD,那么判断当前父beanName和子beanName在不在同一个BeanFactory中,如果在,直接获取父BD,然后与当前BD进行合并成新的RootBeanDefinition
     *    如果父beanName和子beanName不在同一BeanFactory中,表示父Bean可能在当前BeanFactory的父BeanFactory(父容器)中,于是从父容器获取父BD
     *    如果获取到父BD,那么与当前BD进行合并,返回RootBeanDefinition,如果没找到对应的父BD,抛出异常
     * </pre>
     */
    protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
        // 查找mergedBeanDefinitions是否处理过这个BeanName
        RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
        // 如果处理过,并且不需要合并BeanDefinition
        if (mbd != null && !mbd.stale) {
            return mbd;
        }
        // 获取当前beanName的BeanDefinition
        return getMergedBeanDefinition(beanName, getBeanDefinition(beanName)) {
            return getMergedBeanDefinition(beanName, bd, containingBd = null) {
                // 加锁处理
                synchronized (this.mergedBeanDefinitions) {
                    // 最终合并之后的BeanDefinition
                    RootBeanDefinition mbd = null;
                    // 上一个合并的BeanDefinition
                    RootBeanDefinition previous = null;
                    // 再次判断containingBd是否为空,防止并发操作,上面传递的为null
                    if (containingBd == null) {
                        // 获取缓存
                        mbd = this.mergedBeanDefinitions.get(beanName);
                    }
                    // 如果没有保存过mergedBeanDefinitions中,或者就算保存了
                    // stale标识这还需要合并当前BeanDefinition
                    if (mbd == null || mbd.stale) {
                        // 保存合并的BeanDefinition
                        previous = mbd;
                        // 如果当前Bean的BeanDefinition中,不存在父名称
                        // 表示不存在BeanDefinition的父子关系,就不需要对BeanDefinition进行合并
                        if (bd.getParentName() == null) {
                            // 如果是RootBeanDefinition类型
                            if (bd instanceof RootBeanDefinition) {
                                // 拷贝一份BeanDefinition
                                mbd = ((RootBeanDefinition) bd).cloneBeanDefinition() {
                                    return new RootBeanDefinition(this) {
                                        // AbstractBeanDefinition
                                        // 设置一些bean的定义信息
                                        super(original)
                                        setParentName(original.getParentName());
                                        setBeanClassName(original.getBeanClassName());
                                        setScope(original.getScope());
                                        setAbstract(original.isAbstract());
                                        setFactoryBeanName(original.getFactoryBeanName());
                                        setFactoryMethodName(original.getFactoryMethodName());
                                        setRole(original.getRole());
                                        setSource(original.getSource());
                                        copyAttributesFrom(original);
                                        if(original instanceof AbstractBeanDefinition){
                                            AbstractBeanDefinition originalAbd = (AbstractBeanDefinition) original;
                                            if (originalAbd.hasBeanClass()) {
                                                setBeanClass(originalAbd.getBeanClass());
                                            }
                                            if (originalAbd.hasConstructorArgumentValues()) {
                                                setConstructorArgumentValues(new ConstructorArgumentValues(original.getConstructorArgumentValues()));
                                            }
                                            if (originalAbd.hasPropertyValues()) {
                                                setPropertyValues(new MutablePropertyValues(original.getPropertyValues()));
                                            }
                                            if (originalAbd.hasMethodOverrides()) {
                                                setMethodOverrides(new MethodOverrides(originalAbd.getMethodOverrides()));
                                            }
                                            Boolean lazyInit = originalAbd.getLazyInit();
                                            if (lazyInit != null) {
                                                setLazyInit(lazyInit);
                                            }
                                            setAutowireMode(originalAbd.getAutowireMode());
                                            setDependencyCheck(originalAbd.getDependencyCheck());
                                            setDependsOn(originalAbd.getDependsOn());
                                            setAutowireCandidate(originalAbd.isAutowireCandidate());
                                            setPrimary(originalAbd.isPrimary());
                                            copyQualifiersFrom(originalAbd);
                                            setInstanceSupplier(originalAbd.getInstanceSupplier());
                                            setNonPublicAccessAllowed(originalAbd.isNonPublicAccessAllowed());
                                            setLenientConstructorResolution(originalAbd.isLenientConstructorResolution());
                                            setInitMethodName(originalAbd.getInitMethodName());
                                            setEnforceInitMethod(originalAbd.isEnforceInitMethod());
                                            setDestroyMethodName(originalAbd.getDestroyMethodName());
                                            setEnforceDestroyMethod(originalAbd.isEnforceDestroyMethod());
                                            setSynthetic(originalAbd.isSynthetic());
                                            setResource(originalAbd.getResource());
                                        }else{
                                            setConstructorArgumentValues(new ConstructorArgumentValues(original.getConstructorArgumentValues()));
                                            setPropertyValues(new MutablePropertyValues(original.getPropertyValues()));
                                            setLazyInit(original.isLazyInit());
                                            setResourceDescription(original.getResourceDescription());
                                        }
                                    }
                                    this.decoratedDefinition = original.decoratedDefinition;
                                    this.qualifiedElement = original.qualifiedElement;
                                    this.allowCaching = original.allowCaching;
                                    this.isFactoryMethodUnique = original.isFactoryMethodUnique;
                                    this.targetType = original.targetType;
                                    this.factoryMethodToIntrospect = original.factoryMethodToIntrospect;
                                }
                            }
                        } else {
                            // 其他类型也一样,重新新建一个新的BeanDefinition
                            mbd = new RootBeanDefinition(bd);
                        }
                    }
                    // 如果存在父名称,表示当前bean需要与父BeanDefinition进行合并
                    else {
                        // 父的BeanDefinition
                        BeanDefinition pbd;
                        try {
                            // 获取当前设置的父名称在父容器的的BeanName
                            String parentBeanName = transformedBeanName(bd.getParentName());
                            // 如果父名称和和本身的beanName不一样
                            if (!beanName.equals(parentBeanName)) {
                                // 通过父beanName继续获取BeanName,相当于再走一遍逻辑,通过父Name去找MergedBeanDefinition的逻辑
                                pbd = getMergedBeanDefinition(parentBeanName) {
                                    // 解析beanName,这里是父BeanName
                                    String beanName = transformedBeanName(name);
                                    // 如果当前的bean工厂不存在这个bean,那么这个bean有可能在父工厂中
                                    if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
                                        // 递归不断获取父工厂以及父工厂的父工厂中的BeanDefinition
                                        return ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName);
                                    }
                                    // 如果当前Bean工厂存在这个Bean,表示父子BeanDefinition在同一个Bean工厂中
                                    // 继续获取父BeanName的BeanDefinition
                                    // 又到了最开始的逻辑,这里又是一个递归
                                    // 这个方法所做的逻辑就是,获取beanName对应的BD,如果BD不存在父BD,直接封装成将当前Bean的BD拷贝到RootBeanDefinition中,并且缓存到mergedBeanDefinitions中
                                    // 如果DB存在父BD,那么判断当前父beanName和子beanName在不在同一个BeanFactory中,如果在,直接获取父BD,然后与当前BD进行合并成新的RootBeanDefinition
                                    // 如果父beanName和子beanName不在同一BeanFactory中,表示父Bean可能在当前BeanFactory的父BeanFactory(父容器)中,于是从父容器获取父BD
                                    // 如果获取到父BD,那么与当前BD进行合并,返回RootBeanDefinition,如果没找到对应的父BD,抛出异常
                                    return getMergedLocalBeanDefinition(beanName);
                                }
                            }
                            // 如果两个名称一样
                            else {
                                // 获取父工厂
                                BeanFactory parent = getParentBeanFactory();
                                // 获取父工厂的存在此beanName对应的BeanDefinition
                                if (parent instanceof ConfigurableBeanFactory) {
                                    pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
                                }
                                // 如果父工厂不是ConfigurableBeanFactory类型,直接报错
                                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);
                        }
                        // 克隆父BD,使用父BD作为基础配置
                        mbd = new RootBeanDefinition(pbd);
                        // 保存子BD原来的配置,覆盖父BD
                        mbd.overrideFrom(bd);
                    }

                    // 设置默认的单例作用域，如果之前没有配置的话
                    if (!StringUtils.hasLength(mbd.getScope())) {
                        mbd.setScope(SCOPE_SINGLETON);
                    }

                    // 如果作用域不是默认的,要保存之前设置的作用域
                    if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
                        mbd.setScope(containingBd.getScope());
                    }
                    // 第一次处理,containingBd肯定是为null,因为传递的就是null
                    // isCacheBeanMetadata:默认值为为true,需要缓存Bean定义
                    // 保存合并后的BeanDefinition
                    // 所以,只要调用这个方法,都会存在合并后的BD,保存到mergedBeanDefinitions中
                    if (containingBd == null && isCacheBeanMetadata()) {
                        this.mergedBeanDefinitions.put(beanName, mbd);
                    }
                }
                // 如果以前的BeanDefinition previous不为null,
                if (previous != null) {
                    // 将以前的某些配置拷贝到合并后的BeanDefinition
                    copyRelevantMergedBeanDefinitionCaches(previous, mbd) {
                        if (ObjectUtils.nullSafeEquals(mbd.getBeanClassName(), previous.getBeanClassName()) &&
                                ObjectUtils.nullSafeEquals(mbd.getFactoryBeanName(), previous.getFactoryBeanName()) &&
                                ObjectUtils.nullSafeEquals(mbd.getFactoryMethodName(), previous.getFactoryMethodName())) {
                            ResolvableType targetType = mbd.targetType;
                            ResolvableType previousTargetType = previous.targetType;
                            if (targetType == null || targetType.equals(previousTargetType)) {
                                mbd.targetType = previousTargetType;
                                mbd.isFactoryBean = previous.isFactoryBean;
                                mbd.resolvedTargetType = previous.resolvedTargetType;
                                mbd.factoryMethodReturnType = previous.factoryMethodReturnType;
                                mbd.factoryMethodToIntrospect = previous.factoryMethodToIntrospect;
                            }
                        }
                    }
                }
                return mbd;
            }
        }
    }
}