本文分享自华为云社区《Spring高手之路11——BeanDefinition解密：构建和管理Spring Beans的基石》，作者： 砖业洋__ 。

BeanDefinition 是 Spring 中一个非常重要的概念,它包含了 Spring 容器用于创建、配置 Bean 所需的所有信息。理解 BeanDefinition 可以帮助我们深入掌握 Spring 的内部工作机制。

1. 探索 BeanDefinition

首先，让我们来对 BeanDefinition 有一个整体的认识。

1.1 官方文档对 BeanDefinition 的解读

对于理解 Spring 框架的概念和组件，Spring 的官方文档是一个非常重要的资源。关于 BeanDefinition，官方文档大意如下：

BeanDefinition 包含了大量的配置信息，这些信息可以指导 Spring 如何创建 Bean，包括 Bean 的构造函数参数，属性值，初始化方法，静态工厂方法名称等等。此外，子 BeanDefinition 还可以从父 BeanDefinition 中继承配置信息，同时也可以覆盖或添加新的配置信息。这种设计模式有效减少了冗余的配置信息，使配置更为简洁。

接下来，让我们通过一个具体的例子来更好地理解 BeanDefinition。

考虑一个简单的 Java 类，Person：

public class Person {
private String name;
private int age;
public Person() {}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// getters and setters
}

我们可以用 XML 配置或者 Java 配置的方式来定义一个 Person 类型的 Bean，同时这个 Bean 的配置信息会被封装在 BeanDefinition 中。

在 XML 配置中，一个 Person Bean 的定义可能如下：

<bean id="person" class="com.example.Person">
<constructor-arg name="name" value="John"/>
<constructor-arg name="age" value="25"/>
</bean>

在这里，BeanDefinition 的信息包括了 class 属性（全限定类名）以及构造函数参数的名称和值。

在 Java 配置中，我们可以这样定义一个 Person Bean：

@Configuration
public class AppConfig {
@Bean
public Person person() {
return new Person("John", 25);
}
}

在这个例子中，BeanDefinition 的信息包括 class 属性（全限定类名）以及构造函数参数。我们可以通过 BeanDefinition 的 getBeanClassName()方法获取到这个全限定类名。

1.2 BeanDefinition 关键方法剖析

BeanDefinition 接口定义了 Bean 的所有元信息,主要包含以下方法:

• get/setBeanClassName() - 获取/设置 Bean 的类名

• get/setScope() - 获取/设置 Bean 的作用域

• isSingleton() / isPrototype() - 判断是否单例/原型作用域

• get/setInitMethodName() - 获取/设置初始化方法名

• get/setDestroyMethodName() - 获取/设置销毁方法名

• get/setLazyInit() - 获取/设置是否延迟初始化

• get/setDependsOn() - 获取/设置依赖的 Bean

• get/setPropertyValues() - 获取/设置属性值

• get/setAutowireCandidate() - 获取/设置是否可以自动装配

• get/setPrimary() - 获取/设置是否首选的自动装配 Bean

由于 BeanDefinition 源码篇幅较长，这里就不全部贴上来，大家可以自行查看。BeanDefinition 还实现了 AttributeAccessor 接口，可以通过该接口添加自定义元数据，后面小节会举例 AttributeAccessor 的使用。

从上面可以看到，BeanDefinition 是 Spring 框架中用来描述 Bean 的元数据对象，这个元数据包含了关于 Bean 的一些基本信息，包括以下几个方面：

• Bean 的类信息： 这是 Bean 的全限定类名，即这个 Bean 实例化后的具体类型。

• Bean 的属性信息： 包括了如 Bean 的作用域（是单例还是原型）、是否为主要的 Bean（primary）、描述信息等。

• Bean 的行为特性： 例如 Bean 是否支持延迟加载，是否可以作为自动装配的候选者，以及 Bean 的初始化和销毁方法等。

• Bean 与其他 Bean 的关系： 比如说这个 Bean 所依赖的其他 Bean，以及这个 Bean 是否有父 Bean。

• Bean 的配置信息： 这包括了 Bean 的构造器参数，以及属性值等。

1.3 BeanDefinition 部分方法的实际运用

接下来用一个详细的代码示例来说明 BeanDefinition 接口中各个方法的使用，并结合实际的代码示例说明这些方法的实际含义。下面，我会针对 BeanDefinition 的几个重要方面提供代码示例。

全部代码如下：

首先，这是我们的 Java 配置类以及 Person 类的定义：

package com.example.demo.configuration;
import com.example.demo.bean.Person;
import org.springframework.context.annotation.*;
@Configuration
public class AppConfig {
@Bean(initMethod = "init", destroyMethod = "cleanup")
@Scope("singleton")
@Lazy
@Primary
@Description("A bean for person")
public Person person() {
return new Person("John", 25);
}
}
package com.example.demo.bean;
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// getters and setters
public void init() {
System.out.println("Initializing Person bean");
}
public void cleanup() {
System.out.println("Cleaning up Person bean");
}
}

下面是如何通过 BeanDefinition 获取到各个属性：

package com.example.demo;
import com.example.demo.configuration.AppConfig;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import java.util.Arrays;
public class DemoApplication {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
String personBeanName = "person";
BeanDefinition personBeanDefinition = context.getBeanFactory().getBeanDefinition(personBeanName);
// 获取Bean的类信息
System.out.println("Bean Class Name: " + context.getBean(personBeanName).getClass().getName());
// 获取Bean的属性
System.out.println("Scope: " + personBeanDefinition.getScope());
System.out.println("Is primary: " + personBeanDefinition.isPrimary());
System.out.println("Description: " + personBeanDefinition.getDescription());
// 获取Bean的行为特征
System.out.println("Is lazy init: " + personBeanDefinition.isLazyInit());
System.out.println("Init method: " + personBeanDefinition.getInitMethodName());
System.out.println("Destroy method: " + personBeanDefinition.getDestroyMethodName());
// 获取Bean的关系
System.out.println("Parent bean name: " + personBeanDefinition.getParentName());
System.out.println("Depends on: " + Arrays.toString(personBeanDefinition.getDependsOn()));
// 获取Bean的配置属性
System.out.println("Constructor argument values: " + personBeanDefinition.getConstructorArgumentValues());
System.out.println("Property values: " + personBeanDefinition.getPropertyValues());
}
}

运行结果:

这个例子包含了 BeanDefinition 的大部分方法，展示了它们的作用。请注意，在这个例子中，一些方法如 getDependsOn()、getParentName()、getConstructorArgumentValues()、getPropertyValues()的返回结果可能不会显示出任何实质内容，因为我们的 person Bean 并没有设置这些值。如果在实际应用中设置了这些值，那么这些方法将返回相应的结果。

1.4 BeanDefinition 深层信息结构梳理

在 Spring 中，BeanDefinition 包含了以下主要信息：

• Class：这是全限定类名，Spring 使用这个信息通过反射创建 Bean 实例。例如，com.example.demo.bean.Book，当 Spring 需要创建 Book bean 的实例时，它将根据这个类名通过反射创建 Book 类的实例。

• Name：这是 Bean 的名称。在应用程序中，我们通常使用这个名称来获取 Bean 的实例。例如，我们可能有一个名称为 "bookService" 的 Bean，我们可以通过 context.getBean("bookService") 来获取这个 Bean 的实例。

• Scope：这定义了 Bean 的作用域，例如 singleton 或 prototype。如果 scope 是 singleton，那么 Spring 容器将只创建一个 Bean 实例并在每次请求时返回这个实例。如果 scope 是 prototype，那么每次请求 Bean 时，Spring 容器都将创建一个新的 Bean 实例。

• Constructor arguments：这是用于实例化 Bean 的构造函数参数。例如，如果我们有一个 Book 类，它的构造函数需要一个 String 类型的参数 title，那么我们可以在 BeanDefinition 中设置 constructor arguments 来提供这个参数。

• Properties：这些是需要注入到 Bean 的属性值。例如，我们可能有一个 Book 类，它有一个 title 属性，我们可以在 BeanDefinition 中设置 properties 来提供这个属性的值。这些值也可以通过 <property> 标签或 @Value 注解在配置文件或类中注入。

• Autowiring Mode：这是自动装配的模式。如果设置为 byType，那么 Spring 容器将自动装配 Bean 的属性，它将查找容器中与属性类型相匹配的 Bean 并注入。如果设置为 byName，那么容器将查找容器中名称与属性名相匹配的 Bean 并注入。还有一个选项是 constructor，它指的是通过 Bean 构造函数的参数类型来自动装配依赖。

• Lazy Initialization：如果设置为 true，Bean 将在首次请求时创建，而不是在应用启动时。这可以提高应用的启动速度，但可能会在首次请求 Bean 时引入一些延迟。

• Initialization Method and Destroy Method：这些是 Bean 的初始化和销毁方法。例如，我们可能有一个 BookService 类，它有一个名为 init 的初始化方法和一个名为 cleanup 的销毁方法，我们可以在 BeanDefinition 中设置这两个方法，那么 Spring 容器将在创建 Bean 后调用 init 方法，而在销毁 Bean 之前调用 cleanup 方法。

• Dependency beans：这些是 Bean 的依赖关系。例如，我们可能有一个 BookService Bean，它依赖于一个 BookRepository Bean，那么我们可以在 BookService 的 BeanDefinition 中设置 dependency beans 为 "bookRepository"，那么在创建 BookService Bean 之前，Spring 容器将首先创建 BookRepository Bean。

以上就是 BeanDefinition 中主要包含的信息，这些信息将会告诉 Spring 容器如何创建和配置 Bean。不同的 BeanDefinition 实现可能会有更多的配置信息。例如，RootBeanDefinition、ChildBeanDefinition、GenericBeanDefinition 等都是 BeanDefinition 接口的具体实现类，它们可能包含更多的配置选项。

2. BeanDefinition 构造体系解析

让我们首先明确 BeanDefinition 的角色。BeanDefinition 是 Spring 中的核心组件，它定义了 bean 的配置信息，包括类名、作用域、构造器参数、属性值等。下面我们来看看 BeanDefinition 在 Spring 中的设计是如何的。

通过 IDEA 我们可以得到如下的继承关系图：

虽然有许多接口、抽象类和扩展，我们只需要关注其中的关键部分。

2.1 BeanDefinition 的类型及其应用

在 Spring 中，一个 bean 的配置信息就是由 BeanDefinition 对象来保存的。根据 bean 配置的不同来源和方式，BeanDefinition 又被分为很多种类型，我们选取其中几种讲解一下

• RootBeanDefinition：当我们在 XML 配置文件中定义一个 bean 时，Spring 会为这个 bean 创建一个 RootBeanDefinition 对象，这个对象包含了所有用于创建 bean 的信息，如 bean 的类名、属性值等。例如：

<bean id="exampleBean" class="com.example.ExampleBean">
<property name="stringProperty" value="stringValue"/>
</bean>

这段 XML 配置中定义了一个名为"exampleBean"的 bean，它的类是"com.example.ExampleBean"，并且有一个名为"stringProperty"的属性值是"stringValue"。当 Spring 读取这段配置时，会创建一个 RootBeanDefinition 对象来保存这个 bean 的所有配置信息。

总结：在 XML 文件中定义一个 bean 时，Spring 就会创建一个 RootBeanDefinition 实例，这个实例会保存所有的配置信息，比如类名、属性值等。

• ChildBeanDefinition：当我们需要让一个 bean 继承另一个 bean 的配置时，可以使用 ChildBeanDefinition。例如：

<bean id="parentBean" class="com.example.ParentBean">
<property name="stringProperty" value="stringValue"/>
</bean>
<bean id="childBean" parent="parentBean">
<property name="anotherStringProperty" value="anotherStringValue"/>
</bean>

这段 XML 配置中，"childBean"继承了"parentBean"的所有配置，同时还添加了一个新的属性"anotherStringProperty"。当 Spring 读取这段配置时，会首先为"parentBean"创建一个 RootBeanDefinition 对象，然后为"childBean"创建一个 ChildBeanDefinition 对象，这个对象会引用"parentBean"的 BeanDefinition。

总结：如果有一个 bean，并且想创建一个新的 bean，这个新的 bean 需要继承原有 bean 的所有配置，但又要添加或修改一些配置信息，Spring 就会创建一个 ChildBeanDefinition 实例。

• GenericBeanDefinition：这是一种通用的 BeanDefinition，可以根据需要转化为 RootBeanDefinition 或者 ChildBeanDefinition。例如，在一个配置类中使用 @Bean 注解定义了一个 bean：

@Configuration
public class AppConfig {
@Bean
public MyComponent myComponent() {
return new MyComponent();
}
}

在这段代码中，我们定义了一个名为"myComponent"的 bean，它的类是"MyComponent"。当 Spring 解析这个配置类时，会为 myComponent()方法创建一个 GenericBeanDefinition 对象。这个 GenericBeanDefinition 对象会保存方法的名字（这也是 bean 的名字）、返回类型，以及任何需要的构造函数参数或属性。在这个例子中，我们没有定义任何参数或属性，所以 GenericBeanDefinition 对象只包含了基本的信息。这个 GenericBeanDefinition 对象之后可以被 Spring 容器用于生成 bean 的实例。

总结：在 Java 配置类中使用 @Bean 注解定义一个 bean 时，Spring 就会创建一个 GenericBeanDefinition 实例。

• AnnotatedBeanDefinition：当我们在代码中使用注解（如 @Component, @Service, @Repository 等）来定义 bean 时，Spring 会创建一个 AnnotatedBeanDefinition 接口的实例。例如：

@Component("myComponent")
public class MyComponent {
// some fields and methods
}

在这段代码中，我们定义了一个名为"myComponent"的 bean，它的类是"MyComponent"，并且这个类上有一个 @Component 注解。当 Spring 解析这个类时，会创建一个 AnnotatedBeanDefinition 对象。这个 AnnotatedBeanDefinition 对象会保存类名（这也是 bean 的名字）、类的类型，以及类上的所有注解信息。在这个例子中，AnnotatedBeanDefinition 实例会包含 @Component 注解及其所有元数据。这个 AnnotatedBeanDefinition 实例之后可以被 Spring 容器用于生成 bean 的实例，同时 Spring 还可以使用存储在 AnnotatedBeanDefinition 中的注解信息来进行进一步的处理，如 AOP 代理、事务管理等。

总结：在类上使用注解（如 @Component, @Service, @Repository 等）来定义一个 bean 时，Spring 会创建一个实现了 AnnotatedBeanDefinition 接口的实例，如 AnnotatedGenericBeanDefinition 或 ScannedGenericBeanDefinition。这个实例会保存类名、类的类型，以及类上的所有注解信息。

GenericBeanDefinition 和 AnnotatedBeanDefinition 的主要区别在于，AnnotatedBeanDefinition 保存了类上的注解信息，而 GenericBeanDefinition 没有。这就使得 Spring 能够在运行时读取和处理这些注解，提供更丰富的功能。

在大多数情况下，我们并不需要关心 Spring 为 bean 创建的是哪一种 BeanDefinition。Spring 会自动管理这些 BeanDefinition，并根据它们的类型以及它们所包含的信息来创建和配置 bean。

2.2 生成 BeanDefinition 的原理剖析

这个 BeanDefinition 对象是在 Spring 启动过程中由各种 BeanDefinitionReader 实现类读取配置并生成的。

在 Spring 中主要有三种方式来创建 BeanDefinition：

• XML 配置方式：

首先，我们在 XML 文件中定义了一个 bean：

<bean id="bookService" class="com.example.demo.service.BookService">
<property name="bookRepository" ref="bookRepository"/>
</bean>
<bean id="bookRepository" class="com.example.demo.repository.BookRepository"/>

在这种情况下，当 Spring 启动的时候，XmlBeanDefinitionReader 会读取这个 XML 文件，解析其中的 <bean> 元素，并为每一个 <bean> 元素创建一个 BeanDefinition 对象。

简单描述为：由 XmlBeanDefinitionReader 读取 XML 文件，解析<bean>元素并生成 BeanDefinition。

• 注解配置方式：

我们在类上使用 @Component, @Service, @Repository 等注解来定义 bean，例如：

@Repository
public class BookRepository {
// ... repository methods
}
@Service
public class BookService {
private final BookRepository bookRepository;


public BookService(BookRepository bookRepository) {
this.bookRepository = bookRepository;
}


// ... service methods
}

在这种情况下，当 Spring 启动的时候，ClassPathBeanDefinitionScanner 会扫描指定的包路径，找到所有带有特定注解的类，并为这些类创建 BeanDefinition 对象。这种方式下生成的 BeanDefinition 通常是 ScannedGenericBeanDefinition 类型。

简单描述为：由 ClassPathBeanDefinitionScanner 扫描指定包路径下的带注解的类，并生成 BeanDefinition。

• Java 配置方式：

我们使用 @Configuration 和 @Bean 注解来定义配置类和 bean，例如：

@Configuration
public class AppConfig {
@Bean
public BookRepository bookRepository() {
return new BookRepository();
}
@Bean
public BookService bookService(BookRepository bookRepository) {
return new BookService(bookRepository);
}
}

在这种情况下，当 Spring 启动的时候，ConfigurationClassPostProcessor 就会处理这些配置类，并交给 ConfigurationClassParser 来解析。对于配置类中每一个标记了 @Bean 的方法，都会创建一个 BeanDefinition 对象。这种方式下生成的 BeanDefinition 通常是 ConfigurationClassBeanDefinition 类型。

简单描述为：由 ConfigurationClassPostProcessor 处理标记了 @Configuration 的类，解析其中的 @Bean 方法并生成 BeanDefinition。

总的来说，不论我们选择 XML 配置、注解配置还是 Java 配置方式，Spring 启动时都会解析这些配置，并生成对应的 BeanDefinition 对象，以此来指导 Spring 容器如何创建和管理 Bean 实例。

这些内容可能比较抽象和复杂，但对于初学者来说，只需要理解：BeanDefinition 是 Spring 用来存储 Bean 配置信息的对象，它是在 Spring 启动过程中由 BeanDefinitionReader 读取配置生成的，具体的生成方式取决于使用的配置方式（XML、注解或者 Java 配置），至于其中具体的实现原理，以后再深入了解。

2.3 AttributeAccessor 实战：属性操作利器

AttributeAccessor 是 Spring 框架中的一个重要接口，它提供了一种灵活的方式来附加额外的元数据到 Spring 的核心组件。在 Spring 中，包括 BeanDefinition 在内的许多重要类都实现了 AttributeAccessor 接口，这样就可以动态地添加和获取这些组件的额外属性。这样做的一个显著好处是，开发人员可以在不改变原有类定义的情况下，灵活地管理这些组件的额外信息。

让我们来看一个例子，全部代码如下：

先创建一个 Book 对象

class Book {
private String title;
private String author;
public Book() {}
public Book(String title, String author) {
this.title = title;
this.author = author;
}
// getter 和 setter 省略...
}

主程序：

package com.example.demo;
import com.example.demo.bean.Book;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.RootBeanDefinition;
public class DemoApplication {
public static void main(String[] args) {
// 创建一个BeanDefinition, BeanDefinition是AttributeAccessor的子接口
BeanDefinition bd = new RootBeanDefinition(Book.class);
// 设置属性
bd.setAttribute("bookAttr", "a value");
// 检查和获取属性
if(bd.hasAttribute("bookAttr")) {
System.out.println("bookAttr: " + bd.getAttribute("bookAttr"));
// 移除属性
bd.removeAttribute("bookAttr");
System.out.println("bookAttr: " + bd.getAttribute("bookAttr"));
}
}
}

在这个例子中，我们创建了一个 RootBeanDefinition 实例来描述如何创建一个 Book 类的实例。RootBeanDefinition 是 BeanDefinition 的实现，而 BeanDefinition 实现了 AttributeAccessor 接口，因此 RootBeanDefinition 也就继承了 AttributeAccessor 的方法。

有人可能会疑问，Book 并没有 bookAttr 这个成员变量，这是怎么赋值的？

在 Spring 框架中，AttributeAccessor 接口定义的方法是为了附加、获取和移除与某个对象（例如 RootBeanDefinition）相关联的元数据，而不是操作对象（例如 Book）本身的字段。

所以，在 RootBeanDefinition 实例上调用 setAttribute("bookAttr", "a value")方法时，其实并不是在 Book 实例上设置一个名为 bookAttr 的字段。而是在 RootBeanDefinition 实例上附加了一个元数据，元数据的键是"bookAttr"，值是"a value"。

后续使用 getAttribute("bookAttr")方法时，它将返回之前设置的元数据值"a value"，而不是尝试访问 Book 类的 bookAttr 字段（实际上 Book 类并没有 bookAttr 字段）。

简单来说，这些元数据是附加在 RootBeanDefinition 对象上的，而不是附加在由 RootBeanDefinition 对象描述的 Book 实例上的。

运行结果：

总结：

BeanDefinition 是实现了 AttributeAccessor 接口的一个重要的类，BeanDefinition 对象是 Spring 框架用来存储 bean 配置信息的数据结构。当我们在配置类中使用 @Bean、@Scope、@Lazy 等注解定义一个 bean 时，Spring 会为这个 bean 创建一个 BeanDefinition 对象，并将这些注解的元数据附加到这个 BeanDefinition 对象上。

当 Spring 容器在后续需要创建 bean 实例时，它会查看这个 BeanDefinition 对象，按照其中的元数据（如 scope、lazy 初始化、初始化和销毁方法等）来创建和管理 bean 实例。这些元数据并不会直接附加到 bean 实例上，而是存储在 BeanDefinition 对象中，由 Spring 容器来管理和使用。

所以，当我们在 main 方法中从 ApplicationContext 获取 BeanDefinition 并打印其属性时，我们实际上是在查看 Spring 框架用来管理 bean 的内部数据结构，而不是直接查看 bean 实例本身的状态。

这种方法的好处是，它将这些额外的元数据与 bean 实例本身分离，这样就可以在不修改 bean 类的情况下灵活地改变这些元数据，而且 AttributeAccessor 可以在同一个 JVM 进程中的不同线程间共享数据。这也是为什么我们可以通过修改配置文件或注解来改变 bean 的范围、是否是懒加载等，而不需要修改 bean 的类定义。

3. BeanDefinition 回顾及总结

在我们深入探讨 Spring 框架的过程中，我们已经了解了 BeanDefinition 是 Spring 中非常关键的一个概念。BeanDefinition 的主要职责是作为一个数据对象，存储了关于如何创建、初始化、配置一个具体的 Bean 实例的详细信息。

特别是，BeanDefinition 中包含以下主要信息：

• 完全限定的类名，以便 Spring 容器通过反射创建 Bean 实例。

• Bean 的名称和别名，用于在应用中引用和查找 Bean。

• Bean 的作用域，如单例或原型，决定了 Spring 如何管理 Bean 实例的生命周期。

• 构造函数参数和属性值，用于实例化 Bean 和依赖注入。

• 自动装配模式，指示 Spring 如何自动注入依赖。

• 初始化和销毁方法，让 Spring 知道在 Bean 生命周期的特定时刻如何执行自定义逻辑。

• Bean 的依赖关系，告诉 Spring 在创建当前 Bean 之前需要先创建哪些 Bean。

无论我们使用哪种配置方式（XML、注解或 Java 配置），Spring 在启动时都会解析这些配置，然后生成相应的 BeanDefinition 对象。这些 BeanDefinition 对象就像是 Spring 容器内部的配方，告诉 Spring 容器如何创建和配置各个 Bean。

点击关注，第一时间了解华为云新鲜技术~