本文分享自华为云社区《Spring高手之路11——BeanDefinition解密：构建和管理Spring Beans的基石》，作者： 砖业洋__ 。
BeanDefinition是Spring中一个非常重要的概念,它包含了Spring容器用于创建、配置Bean所需的所有信息。理解BeanDefinition可以帮助我们深入掌握Spring的内部工作机制。
首先，让我们来对 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()方法获取到这个全限定类名。
BeanDefinition接口定义了Bean的所有元信息,主要包含以下方法:
由于BeanDefinition源码篇幅较长，这里就不全部贴上来，大家可以自行查看。BeanDefinition还实现了AttributeAccessor接口，可以通过该接口添加自定义元数据，后面小节会举例AttributeAccessor的使用。
从上面可以看到，BeanDefinition 是 Spring 框架中用来描述 Bean 的元数据对象，这个元数据包含了关于 Bean 的一些基本信息，包括以下几个方面：
接下来用一个详细的代码示例来说明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并没有设置这些值。如果在实际应用中设置了这些值，那么这些方法将返回相应的结果。
在 Spring 中，BeanDefinition 包含了以下主要信息：
以上就是 BeanDefinition 中主要包含的信息，这些信息将会告诉 Spring 容器如何创建和配置 Bean。不同的 BeanDefinition 实现可能会有更多的配置信息。例如，RootBeanDefinition、ChildBeanDefinition、GenericBeanDefinition 等都是 BeanDefinition 接口的具体实现类，它们可能包含更多的配置选项。
让我们首先明确BeanDefinition的角色。BeanDefinition是Spring中的核心组件，它定义了bean的配置信息，包括类名、作用域、构造器参数、属性值等。下面我们来看看BeanDefinition在Spring中的设计是如何的。
通过IDEA我们可以得到如下的继承关系图：
虽然有许多接口、抽象类和扩展，我们只需要关注其中的关键部分。
在Spring中，一个bean的配置信息就是由BeanDefinition对象来保存的。根据bean配置的不同来源和方式，BeanDefinition又被分为很多种类型，我们选取其中几种讲解一下
<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实例，这个实例会保存所有的配置信息，比如类名、属性值等。
<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实例。
@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实例。
@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。
这个 BeanDefinition 对象是在 Spring 启动过程中由各种 BeanDefinitionReader 实现类读取配置并生成的。
在 Spring 中主要有三种方式来创建 BeanDefinition：
首先，我们在 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。
我们使用 @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 配置），至于其中具体的实现原理，以后再深入了解。
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的类定义。
在我们深入探讨Spring框架的过程中，我们已经了解了BeanDefinition是Spring中非常关键的一个概念。BeanDefinition的主要职责是作为一个数据对象，存储了关于如何创建、初始化、配置一个具体的Bean实例的详细信息。
特别是，BeanDefinition中包含以下主要信息：
无论我们使用哪种配置方式（XML、注解或Java配置），Spring在启动时都会解析这些配置，然后生成相应的BeanDefinition对象。这些BeanDefinition对象就像是Spring容器内部的配方，告诉Spring容器如何创建和配置各个Bean。