Spring高手之路12——BeanDefinitionRegistry与BeanDefinition合并解析
文章目录
- 1. 什么是BeanDefinitionRegistry？
- 2. BeanDefinitionRegistry 的使用
-
- 2.1 BeanDefinitionRegistry 简单例子
- 2.2 有关ImportBeanDefinitionRegistrar的实现类的例子
- 3. BeanDefinition的合并
-
- 3.1 调试验证BeanDefinition的合并
- 3.2 BeanDefinition合并的目的
- 4. BeanDefinition的合并的源码分析
-
- 4.1 BeanDefinition合并过程时序图
- 4.2 BeanDefinition合并过程源码解读
1. 什么是BeanDefinitionRegistry？
BeanDefinitionRegistry 是一个非常重要的接口，存在于 Spring 的 org.springframework.beans.factory.support 包中，它是 Spring 中注册和管理 BeanDefinition 的核心组件。
让我们回顾一下上一篇说的 BeanDefinition。在 Spring 中，一个 Bean 就是一个被 Spring 管理的对象，而一个 BeanDefinition 则是一个 Bean 的配置描述，它描述了一个 Bean 的数据。它包含了 Bean 的类名、是否为抽象类、构造函数和属性值等信息。这些元数据将指导 Spring 如何创建和初始化 Bean。
再来看一下 BeanDefinitionRegistry 的作用，BeanDefinitionRegistry 的主要职责就是注册和管理这些 BeanDefinition。我们可以把它看作是一个存放 BeanDefinition 的注册表，向其中注册新的 BeanDefinition，或者检索和删除现有的 BeanDefinition。它提供了一些方法，如 registerBeanDefinition(String, BeanDefinition)， removeBeanDefinition(String)，和 getBeanDefinition(String)，用于执行这些操作。
在 Spring 的内部，BeanDefinitionRegistry 通常由 BeanFactory 实现，特别是 DefaultListableBeanFactory 和 GenericApplicationContext，它们都实现了这个接口。
2. BeanDefinitionRegistry 的使用
2.1 BeanDefinitionRegistry 简单例子
在这个例子中，我们将创建一个简单的 Bean，注册到 DefaultListableBeanFactory（它实现了 BeanDefinitionRegistry 接口），然后从工厂中获取并使用这个 Bean。
全部代码如下：
首先，我们需要一个 Bean 类，这是一个简单的 POJO 类：
package com.example.demo.bean;
public class MyBean {
private String message;
public void doSomething() {
System.out.println("Hello, world!");
}
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}
然后，我们可以使用 DefaultListableBeanFactory 和 RootBeanDefinition 来创建并注册这个 Bean：
package com.example.demo;
import com.example.demo.bean.MyBean;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.RootBeanDefinition;
public class DemoApplication {
public static void main(String[] args) {
// 创建 BeanDefinitionRegistry
DefaultListableBeanFactory registry = new DefaultListableBeanFactory();
// 创建一个 BeanDefinition
BeanDefinition beanDefinition = new RootBeanDefinition(MyBean.class);
// 注册 BeanDefinition
registry.registerBeanDefinition("myBean", beanDefinition);
// 从 BeanFactory 中获取 Bean
MyBean myBean = registry.getBean("myBean", MyBean.class);
// 使用 Bean
myBean.doSomething(); // 输出：Hello, world!
}
}
这个程序会创建一个名为 "myBean" 的 Bean，这个 Bean 是 MyBean 类的一个实例。然后，我们从 BeanFactory 中获取这个 Bean，并调用其 doSomething 方法，打印 "Hello, world!"。
2.2 有关ImportBeanDefinitionRegistrar的实现类的例子
这个在第8篇（Spring高手之路8——Spring Bean模块装配的艺术：@Import详解）提到过，是3.5节，大家可以回头看，这里不重复粘贴代码。
3. BeanDefinition的合并
我们前一篇讲解BeanDefinition的时候没有讲解BeanDefinition的合并，这里补充说明。
- BeanDefinition
在 Spring 中，BeanDefinition 是一个接口，它定义了 Bean 的配置信息，例如 Bean 的类名，是否是单例，依赖关系等。在 Spring 中，每一个 Bean 都对应一个 BeanDefinition 对象。
- 合并的意义
在 Spring 中，有一种特殊的 BeanDefinition，叫做子 BeanDefinition，也就是我们在 XML 配置文件中通过 parent 属性指定的那种。这种子 BeanDefinition 可以继承父 BeanDefinition 的配置信息。
合并的过程，就是把子 BeanDefinition 的配置信息和父 BeanDefinition 的配置信息合并起来，形成一个完整的配置信息。合并后的 BeanDefinition 对象包含了 Bean 创建所需要的所有信息，Spring 将使用这个完整的 BeanDefinition 来创建 Bean 实例。
- 合并的过程
Spring 在需要创建 Bean 实例的时候，会先获取对应的 BeanDefinition 对象。如果这个 BeanDefinition 是一个子 BeanDefinition，Spring 就会找到它的父 BeanDefinition，然后把两者的配置信息合并起来，形成一个完整的 BeanDefinition。
这个过程是在 DefaultListableBeanFactory 的 getMergedBeanDefinition 方法中进行的，如果大家有兴趣，可以在这个方法中设置断点，看一看具体的合并过程。
- 合并过程的流程图
我们可以通过父子Bean的方式使用这个特性，下面是一个XML配置的例子：
<bean id="parentBean" class="com.example.ParentClass" abstract="true">
<property name="commonProperty" value="commonValue" />
bean>
<bean id="childBean" parent="parentBean">
<property name="specificProperty" value="specificValue" />
bean>
在这个例子中，我们定义了两个bean，一个是 parentBean，另一个是 childBean。parentBean 是 abstract 的，表示它不会被实例化，只作为模板使用。childBean 的 parent 属性指向 parentBean，表示它继承了 parentBean 的配置。
parentBean 有一个属性 commonProperty，值为 commonValue。childBean 有一个属性 specificProperty，值为 specificValue。在Spring解析这个配置文件，生成BeanDefinition的时候，childBean 的BeanDefinition会包含两个属性：commonProperty 和 specificProperty，这就是 BeanDefinition 的合并过程。
在Java配置中，我们无法直接模拟XML配置的BeanDefinition合并过程，因为这是Spring XML配置的一项特性，配置类通常会采用Java代码的继承或组合来重用bean定义，不会涉及到配置元数据层面的BeanDefinition合并。XML配置中的BeanDefinition合并特性允许我们定义一个父Bean，然后定义一些子Bean，子Bean可以继承父Bean的一些属性。
这个特性在Java配置中并没有直接的替代品，因为Java配置通常更加依赖实例化过程中的逻辑，而不是元数据（即BeanDefinition）。在Java配置中，我们可以使用继承和组合等普通的Java特性来实现类似的结果，但这不是真正的BeanDefinition合并。因此，当我们从XML配置转换为Java配置时，通常需要手动将共享的属性复制到每个Bean的定义中。
3.1 调试验证BeanDefinition的合并
全部代码如下：
首先，创建 XML 配置文件 applicationContext.xml：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="parentBean" class="com.example.demo.bean.ParentClass" abstract="true">
<property name="commonProperty" value="commonValue" />
</bean>
<bean id="childBean" parent="parentBean" class="com.example.demo.bean.ChildClass">
<property name="specificProperty" value="specificValue" />
</bean>
</beans>
然后，创建 ParentClass 和 ChildClass，如下：
package com.example.demo.bean;
public abstract class ParentClass {
private String commonProperty;
public String getCommonProperty() {
return commonProperty;
}
public void setCommonProperty(String commonProperty) {
this.commonProperty = commonProperty;
}
}
package com.example.demo.bean;
public class ChildClass extends ParentClass {
private String specificProperty;
public String getSpecificProperty() {
return specificProperty;
}
public void setSpecificProperty(String specificProperty) {
this.specificProperty = specificProperty;
}
}
主程序如下：
package com.example.demo;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class DemoApplication {
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
DefaultListableBeanFactory factory = (DefaultListableBeanFactory) context.getBeanFactory();
// 获取childBean的原始BeanDefinition
BeanDefinition childBeanDefinition = factory.getBeanDefinition("childBean");
System.out.println("Child bean definition before merge: " + childBeanDefinition);
// 获取合并后的BeanDefinition
BeanDefinition mergedBeanDefinition = factory.getMergedBeanDefinition("childBean");
System.out.println("Merged bean definition: " + mergedBeanDefinition);
}
}
在这个示例中，我们首先加载了 applicationContext.xml 配置文件，然后获取了 childBean 的原始 BeanDefinition。然后，我们调用 getMergedBeanDefinition 方法获取了合并后的 BeanDefinition，可以在这个过程中设置断点来查看合并过程的详细情况。
运行结果：
大家可以从运行结果看到打印了Generic bean和Root bean，代表了GenericBeanDefinition 和 RootBeanDefinition。
为什么有两个不同的 BeanDefinition 类型（ GenericBeanDefinition 和 RootBeanDefinition）？
GenericBeanDefinition:
- 这是一个通用的
BeanDefinition实现类，可以配置任何类型的bean。 - 它通常用于读取
XML、注解或其他形式的配置。 - 与其它特定的
BeanDefinition相比，它是比较简单和轻量级的。 - 当使用
XML中定义bean时，通常会为该bean创建一个GenericBeanDefinition实例。
RootBeanDefinition:
- 这是一个完整的
bean定义，包含了bean的所有配置信息，如构造函数参数、属性值、方法覆盖等。 - 它通常用于合并父子
bean定义。也就是说，当一个bean定义继承另一个bean定义时，RootBeanDefinition负责持有合并后的最终配置。 - 除了
GenericBeanDefinition之外，它还包含许多与bean的实例化、依赖解析和初始化相关的内部细节。 - 在
Spring的内部工作流中，尽管开始时可以有各种BeanDefinition实现，但在容器的后期处理阶段，它们通常都会转化为RootBeanDefinition，因为在这个阶段需要一个完整和固定的bean定义来进行bean的创建。
调试点1：我们从BeanFactory中获取了子bean的原始BeanDefinition。这个BeanDefinition只表示了XML中为子 bean配置的元数据，没有与父Bean的合并，只能看到specificProperty属性。
调试点2：用getMergedBeanDefinition之后，控制台打印的 BeanDefinition 的类型变为了 RootBeanDefinition ，此时，我们从BeanFactory中获取了合并后的子Bean的BeanDefinition。由于子Bean的BeanDefinition与父Bean的BeanDefinition已合并，所以能看到一个完整的属性集，这里在propertyValues中看到两个属性键值对：commonProperty和specificProperty，这表明子Bean继承了父Bean的属性值。
注意，这个示例的目的是展示 BeanDefinition 的合并过程，因此我们直接操作了 BeanFactory。在实际的应用开发中，我们一般不会直接操作 BeanFactory。
3.2 BeanDefinition合并的目的
-
提供完整的BeanDefinition信息：在配置中，我们经常会使用父子
BeanDefinition（如通过parent属性）。子BeanDefinition可能只会定义需要改变或增加的bean属性，而父BeanDefinition则提供共享的默认定义。在这种情况下，合并操作会将父子BeanDefinition的信息合并为一个完整的BeanDefinition，用于接下来的bean创建。 -
优化性能：合并操作的结果通常会被缓存起来，因此在下次获取同样的
bean时，可以直接从缓存中获取合并后的BeanDefinition，避免了重复的合并操作，从而提高了性能。 -
解决循环依赖：在处理
bean之间的循环依赖时，需要尽早抛出已经处理（例如实例化和属性填充）的bean，这时就需要一个完整的BeanDefinition信息。因此，BeanDefinition的合并在解决循环依赖问题上也有重要作用。
简而言之，BeanDefinition的合并是为了得到一个完整、准确的BeanDefinition，以供Spring IoC容器后续的bean创建和依赖解析使用。
4. BeanDefinition的合并的源码分析
4.1 BeanDefinition合并过程时序图
4.2 BeanDefinition合并过程源码解读
这里讲一下前一篇没提到的BeanDefinition的合并，我们针对Spring 5.3.7的源码分析一下，先展示图，后面分析。
我们分析一下AbstractBeanFactory类的几个方法。
// 获取本地合并后的 BeanDefinition
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
// 从缓存中获取合并后的 BeanDefinition
RootBeanDefinition mbd = (RootBeanDefinition)this.mergedBeanDefinitions.get(beanName);
// 如果缓存中的 BeanDefinition 不为空并且未过时，则直接返回
// 否则，对 BeanDefinition 进行合并
return mbd != null && !mbd.stale ? mbd : this.getMergedBeanDefinition(beanName, this.getBeanDefinition(beanName));
}
// 获取合并后的 BeanDefinition
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd) throws BeanDefinitionStoreException {
// 直接调用 getMergedBeanDefinition 方法，将 containingBd 设为 null
return this.getMergedBeanDefinition(beanName, bd, (BeanDefinition)null);
}
// 获取合并后的 BeanDefinition
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd) throws BeanDefinitionStoreException {
synchronized(this.mergedBeanDefinitions) {
RootBeanDefinition mbd = null;
RootBeanDefinition previous = null;
// 如果没有包含的 BeanDefinition，那么从缓存中获取合并后的 BeanDefinition
if (containingBd == null) {
mbd = (RootBeanDefinition)this.mergedBeanDefinitions.get(beanName);
}
// 如果缓存中的 BeanDefinition 为空或者过时，那么创建新的 BeanDefinition 进行合并
if (mbd == null || mbd.stale) {
previous = mbd;
// 如果 bd 没有父名称，即没有继承其他的 bean
// 那么就直接 clone 这个 bd，生成一个 RootBeanDefinition
if (bd.getParentName() == null) {
if (bd instanceof RootBeanDefinition) {
mbd = ((RootBeanDefinition)bd).cloneBeanDefinition();
} else {
mbd = new RootBeanDefinition(bd);
}
} else { // 如果 bd 是一个子 BeanDefinition（即有父 BeanDefinition）
// 首先获取父 BeanDefinition
BeanDefinition pbd;
try {
String parentBeanName = this.transformedBeanName(bd.getParentName());
if (!beanName.equals(parentBeanName)) {
pbd = this.getMergedBeanDefinition(parentBeanName);
} else {
BeanFactory parent = this.getParentBeanFactory();
if (!(parent instanceof ConfigurableBeanFactory)) {
throw new NoSuchBeanDefinitionException(parentBeanName, "Parent name '" + parentBeanName + "' is equal to bean name '" + beanName + "': cannot be resolved without a ConfigurableBeanFactory parent");
}
pbd = ((ConfigurableBeanFactory)parent).getMergedBeanDefinition(parentBeanName);
}
} catch (NoSuchBeanDefinitionException var11) {
throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName, "Could not resolve parent bean definition '" + bd.getParentName() + "'", var11);
}
// 创建一个新的 RootBeanDefinition 并覆盖 bd 中的属性
// 这就完成了父子 BeanDefinition 的合并
mbd = new RootBeanDefinition(pbd);
mbd.overrideFrom(bd);
}
// 如果合并后的 BeanDefinition 没有指定作用域
// 则默认设置为 singleton
if (!StringUtils.hasLength(mbd.getScope())) {
mbd.setScope("singleton");
}
// 如果定义了父 BeanDefinition 且父 BeanDefinition 的作用域不是 singleton 但子 BeanDefinition 的作用域是 singleton
// 则将子 BeanDefinition 的作用域设置为父 BeanDefinition 的作用域
if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
mbd.setScope(containingBd.getScope());
}
// 如果不存在包含的 BeanDefinition 并且需要缓存 BeanMetadata
// 那么就将这个新创建并合并的 BeanDefinition 放入 mergedBeanDefinitions 缓存中
if (containingBd == null && this.isCacheBeanMetadata()) {
this.mergedBeanDefinitions.put(beanName, mbd);
}
}
// 如果之前存在过期的 BeanDefinition
// 那么从过期的 BeanDefinition 中拷贝相关的缓存到新的 BeanDefinition 中
if (previous != null) {
this.copyRelevantMergedBeanDefinitionCaches(previous, mbd);
}
// 返回合并后的 BeanDefinition
return mbd;
}
}
这段代码主要完成了 BeanDefinition 的合并工作。当一个 BeanDefinition 有父 BeanDefinition 时，Spring 会将子 BeanDefinition 的定义与父 BeanDefinition 的定义进行合并，生成一个新的完整的 BeanDefinition，这个过程就是 BeanDefinition 的合并。该合并的 BeanDefinition 会被缓存起来，以便下次使用。如果一个 BeanDefinition 没有父 BeanDefinition，则直接 clone 一份作为合并后的 BeanDefinition。在 Spring 的整个生命周期中，BeanDefinition 的合并可能会发生多次，每次获取 Bean 时，都会先进行 BeanDefinition 的合并。
欢迎一键三连~
有问题请留言，大家一起探讨学习
----------------------Talk is cheap, show me the code-----------------------