高性能多级网关与多级缓存架构落地实战 寒林空见日斜时

高性能多级网关与多级缓存架构落地实战

download：https://www.51xuebc.com/thread-602-1-1.html

在 Spring 框架中，BeanDefinition 是一个中心概念，用于定义和配置 bean 的元数据，固然在实践应用中，我们普通并不会或者很少直接定义 BeanDefinition，但是，我们在 XML 文件中所作的配置，以及应用 Java 代码做的各种 Spring 配置，都会被解析为 BeanDefinition，然后才会做进一步的处置。BeanDefinition 允许开发人员以一种声明性的方式定义和组织 bean，这里有很多属性，今天松哥单纯的来和小同伴们聊一聊它的 parentName 属性，parentName 属性在 BeanDefinition 中扮演着重要的角色，用于树立 bean 之间的父子关系。

之前松哥有一篇文章和小同伴们聊了 BeanFactory 之间的父子关系，大家留意和今天的内容停止辨别，今天我们聊的是 BeanDefinition 之间的父子关系。

BeanDefinition 的 parentName 属性的主要功用是允许我们在创立一个 bean 的同时，可以继承另一个曾经定义好的 bean。经过指定 parentName 属性，我们能够重用已有 bean 的配置，并在此根底上停止修正或扩展。

先不废话了，我先来举两个例子，小同伴们先感受一下 BeanDefinition 的作用。

1. 理论

假定我有如下两个类，首先是一个动物的基类，如下：

public class Animal {

private String name;

private Integer age;

//省略 getter/setter

}

然后有一个 Dog 类，如下：

public class Dog {

private String name;

private Integer age;

private String color;

//省略 getter/setter

}

小同伴们留意，这里的 Dog 类并没有继承自 Animal 类，但是有两个跟 Animal 同名的属性。之所以这样设计是希望小同伴们了解 BeanDefinition 中的 parentName 属性和 Java 中的继承并无关系，固然大局部状况下我们用到 parentName 的时分，Java 中相关的类都是继承关系。

如今，有一些通用的属性我想在 Animal 中停止配置，Dog 中特有的属性则在 Dog 中停止配置，我们来看下经过 XML 和 Java 分别该如何配置。

1.1 XML 配置

小同伴们看到，首先我们配置 Animal，Animal 中有 name 和 age 两个属性，然后我又配置了 Dog Bean，并未之指定了 parent 为 animal，然后给 Dog 设置了 color 属性。

如今，Dog Bean 定义出来的 BeanDefinition 中未来就包含了 animal 中的属性值。

1.2 Java 配置

再来看看 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", "小强");

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 来做 parent，其实从名字上就能看出来 RootBeanDefinition 合适做 parent，并且 RootBeanDefinition 不能作为 child。强行设置运转时会抛出异常，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 是为相应的对象设置属性值。

child 我这里运用了 GenericBeanDefinition，这个主要是做 child 的处置，最早有一个特地做 child 的 ChildBeanDefinition，不过自从 Spring2.5 开端提供了 GenericBeanDefinition 之后，如今用来做 child 首选 GenericBeanDefinition。

在上述案例中，parent 和 child 都设置了 name 属性，那么 child 会掩盖掉 parent，这一点和 Java 中的继承分歧。

用法就是这样，并不难。

这就是 Spring BeanDefinition 中的父子关系问题。

2. 源码剖析

那么接下来我们也把这块的源码略微来剖析一下。

烦琐起见，我们就不从 Bean 的创立开端剖析了，直接来看和 BeanDefinition 中 parentName 属性相关的中央，但是前面触及到的办法还是给小同伴们梳理一下，就是下图：

那么这里触及到的关键办法其实就是 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;

}

}

这个办法看名字就是要获取一个兼并之后的 BeanDefinition，就是将 child 中的属性和 parent 中的属性停止兼并，然后返回，这个办法中有一个名为 mbd 的变量，这就是兼并之后的结果。

首先会尝试从 mergedBeanDefinitions 变量中获取到兼并之后的 BeanDefinition，mergedBeanDefinitions 相当于就是一个暂时缓存，假如之前曾经获取过了，那么获取胜利之后就将之保管到 mergedBeanDefinitions 中，假如是第一次进入到该办法中，那么该变量中就没有我们需求的数据，所以会继续执行后面的步骤。

当第 1 步并未拿到 mbd 的时分，接下来继续判别 bd.getParentName() 能否为空，这个其实就是查看当前的 BeanDefinition 能否有设置 parentName，假如有设置，这里获取到的就不为 null，否则为 null。假如这里获取到的值为 null，那么就会依据当前传入的 BeanDefinition 生成一个 mbd，至于详细的生成方式：假如传入的 BeanDefinition 是 RootBeanDefinition 类型的，则调用 clone 办法去生成 mbd（实质上也是 new 一个新的 RootBeanDefinition），假如传入的 BeanDefinition 不是 RootBeanDefinition 类型的，则直接 new 一个新的 RootBeanDefinition，在 new 的过程中，会把传入的 BeanDefinition 上的属性都复制到新的 RootBeanDefinition 中。

假如 bd.getParentName() 不为空，则意味着存在 parent BeanDefinition，所以就要停止兼并处置了，兼并时分又有一个小细节，假如 parentBeanName 等于当前的 beanName，由于 Spring 在同一个容器中不允许存在同名的 bean，所以这就阐明 parentBeanName 可能是父容器的 Bean，此时就要去父容器中去处置，当然最终调用到的还是当前办法，关于父子容器这一块，小同伴们能够参考松哥之前的 一文。假如 parentBeanName 不等于当前 beanName，那么如今就能够调用 getMergedBeanDefinition 办法去获取到 parentBeanDefinition 了，getMergedBeanDefinition 是当前办法的重载办法，该办法最终也会调用到当前办法，缘由就在于 parentBeanDefinition 自身也可能存在 parentBeanDefinition。

有了 pbd 之后，接下来 new 一个 RootBeanDefinition，然后调用 overrideFrom 办法停止属性兼并，兼并的方式就是用传入的 BeanDefinition 中的属性去掩盖 pbd 中同名的属性。

最后就是再设置 scope 属性等，然后把 mbd 返回即可。

中心流程就是上面这个步骤，如此之后，拿到手的就是和 parent 兼并之后的 BeanDefinition 了。

3. 小结

最后我们再来略微总结下：

运用 parentName 属性的一个主要优势是进步代码的可维护性和重用性。当我们需求创立多个类似的 bean 时，能够经过定义一个根底 bean，并在其他 bean 中运用 parentName 属性来继承其配置。这样，我们只需在根底 bean 中定义一次配置，而不用为每个派生 bean 反复相同的配置。

另一个运用 parentName 属性的场景是在多个层次构造中定义 bean。假定我们有一个通用的根底效劳层 bean，而不同的业务模块需求在此根底上停止扩展。经过运用 parentName 属性，我们能够为每个业务模块定义一个派生 bean，并在其中添加特定于模块的配置。这种层次构造的定义使得我们能够更好地组织和管理不同模块之间的 bean。

经过运用 parentName 属性，我们能够轻松地创立和管理 bean 的层次构造。这种继承关系使得我们能够更好地组织和重用 bean 的配置，减少了代码的冗余性。同时，它还提供了一种灵敏的方式来定义不同模块之间的 bean，使得应用程序更易于扩展和维护。

综上所述，Spring 框架中的 BeanDefinition 的 parentName 属性允许我们在定义 bean 时树立父子关系，从而进步代码的可维护性和重用性。经过继承已有 bean 的配置，我们能够防止反复编写类似的配置，并更好地组织和管理不同层次构造的 bean。

有的小同伴们可能会搞混今天内容和之前松哥所写的 Spring 父子容器之间的关系，小同伴们参考这篇文章就分明啦

另外，Spring BeanDefinition 中的 parentName 和 Java 中的继承固然有点像，但是并不能同等对待，它们之间也还是有一些区别的：

概念和作用：Java 中的继承是一种面向对象的编程概念，用于定义类之间的父子关系，子类继承父类的属性和办法。而在 Spring 中，BeanDefinition 的 parentName 属性是用于定义 bean 之间的父子关系，一个派生 bean 能够继承另一个已定义的 bean 的配置。

语法和用法：在 Java 中，继承是经过运用关键字 extends 来完成的，子类经过继承父类来取得父类的属性和办法。而在 Spring 中，经过在 BeanDefinition 中配置 parentName 属性来指定一个 bean 的父 bean，从而继承父 bean 的配置。

范围和应用：Java 中的继承主要用于类的继承关系，用于定义类之间的层次构造和代码的重用。而在 Spring 中，BeanDefinition 的继承主要用于定义 bean 之间的配置继承关系，用于组织和管理 bean 的配置，进步代码的可维护性和重用性。

好啦，Spring BeanDefinition 中的 parentName 属性如今大家明白了吧~