华为云服务器Spring高手之路11——BeanDefinition解密:构建和管理Spring Beans的基石_云淘科技

  BeanDefinitionSpring中一个非常重要的概念,它包含了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的定义可能如下:


    
    

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

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

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

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

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的使用。

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

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

Bean 的属性信息: 包括了如 Bean 的作用域(是单例还是原型)、是否为主要的 Beanprimary)、描述信息等。

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 的作用域,例如 singletonprototype。如果 scopesingleton,那么 Spring 容器将只创建一个 Bean 实例并在每次请求时返回这个实例。如果 scopeprototype,那么每次请求 Bean 时,Spring 容器都将创建一个新的 Bean 实例。

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

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

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

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

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

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

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

2. BeanDefinition构造体系解析

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

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

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

2.1 BeanDefinition的类型及其应用

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

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


    

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

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

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


    



    

  这段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接口的实例,如AnnotatedGenericBeanDefinitionScannedGenericBeanDefinition。这个实例会保存类名、类的类型,以及类上的所有注解信息。

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

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

2.2 生成BeanDefinition的原理剖析

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

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

XML 配置方式:

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


    



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

简单描述为:由XmlBeanDefinitionReader读取XML文件,解析元素并生成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 实例。

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

2.3 AttributeAccessor实战:属性操作利器

  AttributeAccessorSpring框架中的一个重要接口,它提供了一种灵活的方式来附加额外的元数据到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类的实例。RootBeanDefinitionBeanDefinition的实现,而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 对象,按照其中的元数据(如 scopelazy 初始化、初始化和销毁方法等)来创建和管理 bean实例。这些元数据并不会直接附加到 bean实例上,而是存储在 BeanDefinition 对象中,由 Spring 容器来管理和使用。

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

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

3. BeanDefinition回顾及总结

  在我们深入探讨Spring框架的过程中,我们已经了解了BeanDefinitionSpring中非常关键的一个概念。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

欢迎一键三连~

有问题请留言,大家一起探讨学习

———————-Talk is cheap, show me the code———————–文章来源:华为云社区