spring源码（11）bean的parent属性详解和获取RootBeanDefinition

一、bean标签的parent属性

Spring Framework Reference Documentation 6.7. Bean definition inheritance

注：本文中bean和definition意思等同

该节详细介绍了 bean的继承关系（bean标签的parent属性），下面简单翻译一下：

A bean definition can contain a lot of configuration information, 
including constructor arguments, property values, and container-specific 
information such as initialization method, static factory method name, and so on. 
A child bean definition inherits configuration data from a parent definition. 
The child definition can override some values, or add others, as needed. 
Using parent and child bean definitions can save a lot of typing. 
Effectively, this is a form of templating.

我们知道，BeanDefinition是 bean标签的抽象，BeanDefinition和bean标签中的属性是一一对应的。BeanDefinition中存储大量的配置信息。子BeanDefinition能够从父BeanDefinition中继承配置信息。当然子BeanDefinition也可以覆盖或者新增一些新的配置信息。使用父子BeanDefinition能少打很多字（？），更加高效，这是一种模板方式。

If you work with an ApplicationContext interface programmatically, 
child bean definitions are represented by the ChildBeanDefinition class. 
Most users do not work with them on this level, 
instead configuring bean definitions declaratively in something like the ClassPathXmlApplicationContext. 
When you use XML-based configuration metadata, 
you indicate a child bean definition by using the parent attribute, 
specifying the parent bean as the value of this attribute.

在spring中，子BeanDefinition用ChildBeanDefinition表示。但是大家一般不这么使用，而是直接使用ClassPathXmlApplicationContext来配置BeanDefinition。
当使用XML配置子BeanDefinition时，可以使用bean标签的parent属性来表示这个bean是个子bean。parent的属性值就是父bean。

<bean id="inheritedTestBean" abstract="true"
        class="org.springframework.beans.TestBean">
    <property name="name" value="parent"/>
    <property name="age" value="1"/>
bean>

<bean id="inheritsWithDifferentClass"
        class="org.springframework.beans.DerivedTestBean"
        parent="inheritedTestBean" init-method="initialize">
    <property name="name" value="override"/>
    
bean>

A child bean definition uses the bean class from the parent definition if none is specified, 
but can also override it. 
In the latter case, the child bean class must be compatible with the parent, 
that is, it must accept the parent’s property values.

如果子bean的class没有指定，则使用使用父bean的class。如果子bean有指定class，则会覆盖父bean的class。后一种情况（子bean指定了class），子bean的class必须要和父bean的class兼容，也就是说能够接受父bean的配置。

A child bean definition inherits scope, constructor argument values, 
property values, and method overrides from the parent, with the option to add new values. 
Any scope, initialization method, destroy method, 
and/or static factory method settings that you specify will override the corresponding parent settings.

子BeanDefinition继承父BeanDefinition的scorp、constructor 、property 、method overrides，并添加新配置。子BeanDefinition会覆盖父子BeanDefinition的配置有：initialization method、destroy method、static factory method settings。

The remaining settings are always taken from the child definition: 
depends on, autowire mode, dependency check, singleton, lazy init.

子BeanDefinition有些配置始终不会继承父BeanDefinition：depends on、autowire mode、dependency check、singleton、lazy init。

The preceding example explicitly marks the parent bean definition as abstract by using the abstract attribute. 
If the parent definition does not specify a class, 
explicitly marking the parent bean definition 
as abstract is required, 
as follows:

<bean id="inheritedTestBeanWithoutClass" abstract="true">
    <property name="name" value="parent"/>
    <property name="age" value="1"/>
bean>

<bean id="inheritsWithClass" class="org.springframework.beans.DerivedTestBean"
        parent="inheritedTestBeanWithoutClass" init-method="initialize">
    <property name="name" value="override"/>
    
bean>

前一个例子通过abstract属性将一个bean定义为抽象的。如果父bean没有指定class，则需要将其定义为抽象的。

The parent bean cannot be instantiated on its own because it is incomplete, 
and it is also explicitly marked as abstract. 
When a definition is abstract like this, 
it is usable only as a pure template bean definition that serves as a parent definition for child definitions. 
Trying to use such an abstract parent bean on its own, 
by referring to it as a ref property 
of another bean or doing an explicit getBean() call with the parent bean id, returns an error. 
Similarly, the container’s internal preInstantiateSingletons() method ignores 
bean definitions that are defined as abstract.

如果bean被定义为抽象，则不能初始化该bean。如果一个bean被指定为抽象，那么也就可以认为该bean就是一个模板，子bean通用配置的抽象。如果通过ref属性引用抽象bean，或者通过getBean获取抽象bean，则会返回错误。而且，spring的内部方法preInstantiateSingletons会忽略被定义为抽象的bean。

二、获取RootBeanDefinition

如果缓存中不存在已经加载的单例bean，就需要从头开始bean的加载过程了。

而加载bean的第一步就是获取bean的RootBeanDefinition，获取RootBeanDefinition的过程就是子bean合并父bean配置信息的过程

我们知道bean标签在spring内部的表现的BeanDefinition。

回忆下，在注册bean标签的时候，不论是子bean还是父bean都是用的GenericBeanDefinition表示。子bean为什么不使用ChildBeanDefinition?

进入ChildBeanDefinition源码，发现这样一段注释：

NOTE:Since Spring 2.5, the preferred way to register bean definitions programmatically 
is the {@link GenericBeanDefinition} class,which allows to dynamically define parent dependencies through the
{@link GenericBeanDefinition#setParentName} method. This effectively
supersedes the ChildBeanDefinition class for most use cases.

从spring2.5起，注册bean的首选是GenericBeanDefinition，GenericBeanDefinition允许动态的定义父bean（通过setParentName方法）。

下面分析代码：

protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
        // Quick check on the concurrent map first, with minimal locking.
        //查看mergedBeanDefinitions集合中是否存在，如果存在直接返回。最小化的同步mergedBeanDefinitions
        RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
        if (mbd != null) {
            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, BeanDefinition containingBd)
            throws BeanDefinitionStoreException {

        synchronized (this.mergedBeanDefinitions) {
            RootBeanDefinition mbd = 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) {
                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(RootBeanDefinition.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());
                }

                // Only cache the merged bean definition if we're already about to create an
                // instance of the bean, or at least have already created an instance before.
                if (containingBd == null && isCacheBeanMetadata()) {
                    this.mergedBeanDefinitions.put(beanName, mbd);
                }
            }

            return mbd;
        }
    }

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);
        }
        // Resolve merged bean definition locally.
        return getMergedLocalBeanDefinition(beanName);
    }

一提到父子bean，那么代码中肯定就是递归。不断的合并父bean的配置。

如果parentName 等于当前beanName，则需要到parentFactory中寻找parentName。如果找不到则抛出NoSuchBeanDefinitionException。

如果beanName不存在当前beanFactory中，则取parentFactory中寻找。