引言

在 Spring 框架中，BeanDefinition 是一個(gè)核心概念，用于定義和配置 bean 的元數(shù)據(jù)，雖然在實(shí)際應(yīng)用中，我們一般并不會(huì)或者很少直接定義 BeanDefinition，但是，我們?cè)?XML 文件中所作的配置，以及利用 Java 代碼做的各種 Spring 配置，都會(huì)被解析為 BeanDefinition，然后才會(huì)做進(jìn)一步的處理。BeanDefinition 允許開(kāi)發(fā)人員以一種聲明性的方式定義和組織 bean，這里有很多屬性，今天松哥單純的來(lái)和小伙伴們聊一聊它的 parentName 屬性，parentName 屬性在 BeanDefinition 中扮演著重要的角色，用于建立 bean 之間的父子關(guān)系。

之前有一篇文章和小伙伴們聊了 BeanFactory 之間的父子關(guān)系（Spring 中的父子容器是咋回事？），大家注意和今天的內(nèi)容進(jìn)行區(qū)分，今天我們聊的是 BeanDefinition 之間的父子關(guān)系。

BeanDefinition 的 parentName 屬性的主要功能是允許我們?cè)趧?chuàng)建一個(gè) bean 的同時(shí)，能夠繼承另一個(gè)已經(jīng)定義好的 bean。通過(guò)指定 parentName 屬性，我們可以重用已有 bean 的配置，并在此基礎(chǔ)上進(jìn)行修改或擴(kuò)展。

先不廢話了，我先來(lái)舉兩個(gè)例子，小伙伴們先感受一下 BeanDefinition 的作用。

1. 實(shí)踐

假設(shè)我有如下兩個(gè)類，首先是一個(gè)動(dòng)物的基類，如下：

public class Animal {
    private String name;
    private Integer age;
    //省略 getter/setter
}

然后有一個(gè) Dog 類，如下：

public class Dog {
    private String name;
    private Integer age;
    private String color;
    //省略 getter/setter
}

 小伙伴們注意，這里的 Dog 類并沒(méi)有繼承自 Animal 類，但是有兩個(gè)跟 Animal 同名的屬性。之所以這樣設(shè)計(jì)是希望小伙伴們理解 BeanDefinition 中的 parentName 屬性和 Java 中的繼承并無(wú)關(guān)系，雖然大部分情況下我們用到 parentName 的時(shí)候，Java 中相關(guān)的類都是繼承關(guān)系。

現(xiàn)在，有一些通用的屬性我想在 Animal 中進(jìn)行配置，Dog 中特有的屬性則在 Dog 中進(jìn)行配置，我們來(lái)看下通過(guò) XML 和 Java 分別該如何配置。

1.1 XML 配置

<bean id="animal" class="org.javaboy.demo.p2.Animal">
    <property name="name" value="小黑"/>
    <property name="age" value="3"/>
</bean>
<bean class="org.javaboy.demo.p2.Dog" id="dog" parent="animal">
    <property name="color" value="黑色"/>
</bean>

小伙伴們看到，首先我們配置 Animal，Animal 中有 name 和 age 兩個(gè)屬性，然后我又配置了 Dog Bean，并未之指定了 parent 為 animal，然后給 Dog 設(shè)置了 color 屬性。

現(xiàn)在，Dog Bean 定義出來(lái)的 BeanDefinition 中將來(lái)就包含了 animal 中的屬性值。

1.2 Java 配置

再來(lái)看看 Java 配置該如何寫。

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
RootBeanDefinition pbd = new RootBeanDefinition();
MutablePropertyValues pValues = new MutablePropertyValues();
pValues.add("name", "小黃");
pbd.setBeanClass(Animal.class);
pbd.setPropertyValues(pValues);
GenericBeanDefinition cbd = new GenericBeanDefinition();
cbd.setBeanClass(Dog.class);
cbd.setParentName("parent");
MutablePropertyValues cValues = new MutablePropertyValues();
cValues.add("name", "小強(qiáng)");
cbd.setPropertyValues(cValues);
ctx.registerBeanDefinition("parent", pbd);
ctx.registerBeanDefinition("child", cbd);
ctx.refresh();
Dog child = (Dog) ctx.getBean("child");
System.out.println("child = " + child);

這里我使用了 RootBeanDefinition 來(lái)做 parent，其實(shí)從名字上就能看出來(lái) RootBeanDefinition 適合做 parent，并且 RootBeanDefinition 不能作為 child。強(qiáng)行設(shè)置運(yùn)行時(shí)會(huì)拋出異常，RootBeanDefinition#setParentName 方法如下：

@Override
public void setParentName(@Nullable String parentName) {
    if (parentName != null) {
        throw new IllegalArgumentException("Root bean cannot be changed into a child bean with parent reference");
    }
}

MutablePropertyValues 是為相應(yīng)的對(duì)象設(shè)置屬性值。

child 我這里使用了 GenericBeanDefinition，這個(gè)主要是做 child 的處理，最早有一個(gè)專門做 child 的 ChildBeanDefinition，不過(guò)自從 Spring2.5 開(kāi)始提供了 GenericBeanDefinition 之后，現(xiàn)在用來(lái)做 child 首選 GenericBeanDefinition。

在上述案例中，parent 和 child 都設(shè)置了 name 屬性，那么 child 會(huì)覆蓋掉 parent，這一點(diǎn)和 Java 中的繼承一致。

用法就是這樣，并不難。

這就是 Spring BeanDefinition 中的父子關(guān)系問(wèn)題。

2. 源碼分析

那么接下來(lái)我們也把這塊的源碼稍微來(lái)分析一下。

簡(jiǎn)便起見(jiàn)，我們就不從 Bean 的創(chuàng)建開(kāi)始分析了，直接來(lái)看和 BeanDefinition 中 parentName 屬性相關(guān)的地方，但是前面涉及到的方法還是給小伙伴們梳理一下，就是下圖：

那么這里涉及到的關(guān)鍵方法其實(shí)就是 AbstractBeanFactory#getMergedBeanDefinition：

protected RootBeanDefinition getMergedBeanDefinition(
        String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
        throws BeanDefinitionStoreException {
    synchronized (this.mergedBeanDefinitions) {
        RootBeanDefinition mbd = null;
        RootBeanDefinition previous = 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 || mbd.stale) {
            previous = mbd;
            if (bd.getParentName() == null) {
                // Use copy of given root bean definition.
                if (bd instanceof RootBeanDefinition rootBeanDef) {
                    mbd = rootBeanDef.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 {
                        if (getParentBeanFactory() instanceof ConfigurableBeanFactory parent) {
                            pbd = parent.getMergedBeanDefinition(parentBeanName);
                        }
                        else {
                            throw new NoSuchBeanDefinitionException(parentBeanName,
                                    "Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
                                            "': cannot be resolved without a ConfigurableBeanFactory parent");
                        }
                    }
                }
                // 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(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;
    }
}

這個(gè)方法看名字就是要獲取一個(gè)合并之后的 BeanDefinition，就是將 child 中的屬性和 parent 中的屬性進(jìn)行合并，然后返回，這個(gè)方法中有一個(gè)名為 mbd 的變量，這就是合并之后的結(jié)果。

• 首先會(huì)嘗試從 mergedBeanDefinitions 變量中獲取到合并之后的 BeanDefinition，mergedBeanDefinitions 相當(dāng)于就是一個(gè)臨時(shí)緩存，如果之前已經(jīng)獲取過(guò)了，那么獲取成功之后就將之保存到 mergedBeanDefinitions 中，如果是第一次進(jìn)入到該方法中，那么該變量中就沒(méi)有我們需要的數(shù)據(jù)，所以會(huì)繼續(xù)執(zhí)行后面的步驟。
• 當(dāng)?shù)?1 步并未拿到 mbd 的時(shí)候，接下來(lái)繼續(xù)判斷 bd.getParentName() 是否為空，這個(gè)其實(shí)就是查看當(dāng)前的 BeanDefinition 是否有設(shè)置 parentName，如果有設(shè)置，這里獲取到的就不為 null，否則為 null。如果這里獲取到的值為 null，那么就會(huì)根據(jù)當(dāng)前傳入的 BeanDefinition 生成一個(gè) mbd，至于具體的生成方式：如果傳入的 BeanDefinition 是 RootBeanDefinition 類型的，則調(diào)用 clone 方法去生成 mbd（本質(zhì)上也是 new 一個(gè)新的 RootBeanDefinition），如果傳入的 BeanDefinition 不是 RootBeanDefinition 類型的，則直接 new 一個(gè)新的 RootBeanDefinition，在 new 的過(guò)程中，會(huì)把傳入的 BeanDefinition 上的屬性都復(fù)制到新的 RootBeanDefinition 中。
• 如果 bd.getParentName() 不為空，則意味著存在 parent BeanDefinition，所以就要進(jìn)行合并處理了，合并時(shí)候又有一個(gè)小細(xì)節(jié)，如果 parentBeanName 等于當(dāng)前的 beanName，由于 Spring 在同一個(gè)容器中不允許存在同名的 bean，所以這就說(shuō)明 parentBeanName 可能是父容器的 Bean，此時(shí)就要去父容器中去處理，當(dāng)然最終調(diào)用到的還是當(dāng)前方法，關(guān)于父子容器這一塊，小伙伴們可以參考之前的 Spring 中的父子容器是咋回事？ 一文。如果 parentBeanName 不等于當(dāng)前 beanName，那么現(xiàn)在就可以調(diào)用 getMergedBeanDefinition 方法去獲取到 parentBeanDefinition 了，getMergedBeanDefinition 是當(dāng)前方法的重載方法，該方法最終也會(huì)調(diào)用到當(dāng)前方法，原因就在于 parentBeanDefinition 本身也可能存在 parentBeanDefinition。
• 有了 pbd 之后，接下來(lái) new 一個(gè) RootBeanDefinition，然后調(diào)用 overrideFrom 方法進(jìn)行屬性合并，合并的方式就是用傳入的 BeanDefinition 中的屬性去覆蓋 pbd 中同名的屬性。
• 最后就是再設(shè)置 scope 屬性等，然后把 mbd 返回即可。

核心流程就是上面這個(gè)步驟，如此之后，拿到手的就是和 parent 合并之后的 BeanDefinition 了。

3. 小結(jié)

最后我們?cè)賮?lái)稍微總結(jié)下：

使用 parentName 屬性的一個(gè)主要優(yōu)勢(shì)是提高代碼的可維護(hù)性和重用性。當(dāng)我們需要?jiǎng)?chuàng)建多個(gè)相似的 bean 時(shí)，可以通過(guò)定義一個(gè)基礎(chǔ) bean，并在其他 bean 中使用 parentName 屬性來(lái)繼承其配置。這樣，我們只需在基礎(chǔ) bean 中定義一次配置，而不必為每個(gè)派生 bean 重復(fù)相同的配置。

另一個(gè)使用 parentName 屬性的場(chǎng)景是在多個(gè)層次結(jié)構(gòu)中定義 bean。假設(shè)我們有一個(gè)通用的基礎(chǔ)服務(wù)層 bean，而不同的業(yè)務(wù)模塊需要在此基礎(chǔ)上進(jìn)行擴(kuò)展。通過(guò)使用 parentName 屬性，我們可以為每個(gè)業(yè)務(wù)模塊定義一個(gè)派生 bean，并在其中添加特定于模塊的配置。這種層次結(jié)構(gòu)的定義使得我們可以更好地組織和管理不同模塊之間的 bean。

通過(guò)使用 parentName 屬性，我們可以輕松地創(chuàng)建和管理 bean 的層次結(jié)構(gòu)。這種繼承關(guān)系使得我們可以更好地組織和重用 bean 的配置，減少了代碼的冗余性。同時(shí)，它還提供了一種靈活的方式來(lái)定義不同模塊之間的 bean，使得應(yīng)用程序更易于擴(kuò)展和維護(hù)。

綜上所述，Spring 框架中的 BeanDefinition 的 parentName 屬性允許我們?cè)诙x bean 時(shí)建立父子關(guān)系，從而提高代碼的可維護(hù)性和重用性。通過(guò)繼承已有 bean 的配置，我們可以避免重復(fù)編寫相似的配置，并更好地組織和管理不同層次結(jié)構(gòu)的 bean。

有的小伙伴們可能會(huì)搞混今天內(nèi)容和之前松哥所寫的 Spring 父子容器之間的關(guān)系，小伙伴們參考這篇文章就清楚啦：Spring 中的父子容器是咋回事？。

另外，Spring BeanDefinition 中的 parentName 和 Java 中的繼承雖然有點(diǎn)像，但是并不能同等看待，它們之間也還是有一些區(qū)別的：

• 概念和作用：Java 中的繼承是一種面向?qū)ο蟮木幊谈拍?，用于定義類之間的父子關(guān)系，子類繼承父類的屬性和方法。而在 Spring 中，BeanDefinition 的 parentName 屬性是用于定義 bean 之間的父子關(guān)系，一個(gè)派生 bean 可以繼承另一個(gè)已定義的 bean 的配置。
• 語(yǔ)法和用法：在 Java 中，繼承是通過(guò)使用關(guān)鍵字 extends 來(lái)實(shí)現(xiàn)的，子類通過(guò)繼承父類來(lái)獲得父類的屬性和方法。而在 Spring 中，通過(guò)在 BeanDefinition 中配置 parentName 屬性來(lái)指定一個(gè) bean 的父 bean，從而繼承父 bean 的配置。
• 范圍和應(yīng)用：Java 中的繼承主要用于類的繼承關(guān)系，用于定義類之間的層次結(jié)構(gòu)和代碼的重用。而在 Spring 中，BeanDefinition 的繼承主要用于定義 bean 之間的配置繼承關(guān)系，用于組織和管理 bean 的配置，提高代碼的可維護(hù)性和重用性。

好啦，Spring BeanDefinition 中的 parentName 屬性現(xiàn)在大家明白了吧~

以上就是Spring BeanDefinition父子關(guān)系示例解析的詳細(xì)內(nèi)容，更多關(guān)于Spring BeanDefinition父子關(guān)系的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！