简单上手SpringBean的整个装配过程

你好，这里是codetrend专栏“Spring6全攻略”。
典型的企业级应用程序并非仅由单个对象（在Spring术语中称为bean）组成。即使是最简单的应用程序，也会包含一些协同工作的对象，共同呈现出终端用户眼中连贯一致的应用程序形态。
以下mermaid流程图简单展示了Spring工作过程。
graph LR    A[业务类POJO] --> C[Spring容器ApplicationContext]     B[配置元数据Configuration Metadata] --> C    C --产生--> D[可执行的体系/应用程序]业务类与配置元数据相结合，使得在Spring容器ApplicationContext被创建并初始化后，得到的是一个完全配置好且可执行的体系或应用程序。
下文将从定义一系列独立的bean定义出发，进而构建出一个对象间相互协作以达成目标的完全成型的应用程序。
配置元数据 Configuration Metadata

Spring IoC 容器通过消费一种形式的配置元数据。这些配置元数据代表了您作为应用程序开发者告诉 Spring 容器如何实例化、配置和组装应用程序中的对象。
配置元数据方式如下：

• 基于 XML 格式配置
  
• 基于 Groovy 格式配置
  
• 基于Java类和注解进行配置
  

虽然配置的形式不一样，但是配置内容和api基本一样的。
以下是基于 XML 格式、Groovy 格式和 Java 类与注解的方式来配置 Spring IoC 容器的示例：

• 基于 XML 格式配置：
  

1. <beans xmlns="http://www.springframework.org/schema/beans"
2.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.        xsi:schemaLocation="http://www.springframework.org/schema/beans
4.            http://www.springframework.org/schema/beans/spring-beans.xsd">
6.     <bean id="userService" >
7.         <property name="userDao" ref="userDao"/>
8.     </bean>
10.     <bean id="userDao" />
12. </beans>

复制代码

• 基于 Groovy 格式配置：
  

1. // applicationContext.groovy
2. beans {
3.     userService(com.example.UserService) {
4.         userDao = ref('userDao')
5.     }
7.     userDao(com.example.UserDao)
8. }

复制代码

• 基于 Java 类和注解进行配置：
  

1. // AppConfig.java
2. @Configuration
3. public class AppConfig {
5.     @Bean
6.     public UserService userService() {
7.         UserService userService = new UserService();
8.         userService.setUserDao(userDao());
9.         return userService;
10.     }
12.     @Bean
13.     public UserDao userDao() {
14.         return new UserDao();
15.     }
16. }

复制代码

以上示例分别展示了利用 XML、Groovy 和 Java 类与注解的方式来配置 Spring IoC 容器。无论利用哪种配置方式，都可以定义和组装应用程序中的对象，并且相应的 API 在实现上基本一致。
这三种配置方式各有优劣，开发者可以根据项目需求和个人喜好选择合适的方式。
Ioc容器利用初体验

Ioc容器在Spring6框架中也就是各种BeanFactory的实现类来创建和管理对象。
ClassPathXmlApplicationContext就是通过读取xml配置初始化bean的一种方法。
启动类的代码如下：

1. /**
2. * 宠物测试app
3. * @author nine
4. * @since 1.0
5. */
6. public class PetApp {
7.     public static void main(String[] args) {
8.         // 创建一个类路径下的XML应用上下文，并指定配置文件
9.         ApplicationContext context = new ClassPathXmlApplicationContext("s104/services.xml", "s104/daos.xml");
10.         // 从上下文中获取名为"petStore"的bean，其类型为PetStoreServiceImpl，其中petStoreAlias是别名
11.         PetStoreService petStoreService = context.getBean("petStoreAlias", PetStoreServiceImpl.class);
12.         // 调用获取的bean的buyPet方法
13.         petStoreService.buyPet(new Pet("Tom", "Cat",1));
14.     }
15. }

复制代码

bean的配置如下：

1. <beans xmlns="http://www.springframework.org/schema/beans"
2.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.        xsi:schemaLocation="http://www.springframework.org/schema/beans
4.            http://www.springframework.org/schema/beans/spring-beans.xsd">
6.     <bean id="userService" >
7.         <property name="userDao" ref="userDao"/>
8.     </bean>
10.     <bean id="userDao" />
12. </beans><beans xmlns="http://www.springframework.org/schema/beans"
13.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
14.        xsi:schemaLocation="http://www.springframework.org/schema/beans
15.            http://www.springframework.org/schema/beans/spring-beans.xsd">
17.     <bean id="userService" >
18.         <property name="userDao" ref="userDao"/>
19.     </bean>
21.     <bean id="userDao" />
23. </beans>            

复制代码

对应bean如下。其中这些bean也就是简单的业务bean。

1. @Slf4j
2. @Data
3. public class PetStoreServiceImpl implements PetStoreService {
4.     private  AccountDao accountDao;
5.     private  ItemDao itemDao;
6.     @Override
7.     public boolean buyPet(Pet pet) {
8.         log.info("buy pet: {}", pet);
9.         accountDao.store(pet);
10.         itemDao.minus(pet);
11.         return true;
12.     }
13. }
15. @Slf4j
16. public class ItemDao {
17.     public void minus(Pet pet) {
18.         log.info("minus pet num: {}", pet.getNum());
19.     }
20. }
22. @Slf4j
23. public class AccountDao {
24.     public void store(Pet pet) {
25.         log.info("增加收入: {}", pet);
26.     }
27. }

复制代码

这个过程与开发者编写工具类一样，没有任何注解、导入依靠这些配置。习惯利用springboot的开发者可能对此表示有点不习惯。
但是xml元数据配置+BeanFactory一起，就组合成了一个单独的app。运行起来就和springboot无异。
讲上述代码修改为基于Java类和注解进行配置的代码如下。

1. public class PetAppJavaConfig {
2.     public static void main(String[] args) {
3.         // 创建一个基于 Java Config 的应用上下文
4.         ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
5.         // 从上下文中获取名为"petStoreService"的bean，其类型为PetStoreService
6.         PetStoreService petStoreService = context.getBean(PetStoreService.class);
7.         // 调用获取的bean的buyPet方法
8.         petStoreService.buyPet(new Pet("Tom", "Cat", 1));
9.     }
10. }
11. @Configuration
12. class AppConfig {
13.     @Bean
14.     public PetStoreService petStoreService(AccountDao accountDao, ItemDao itemDao) {
15.         PetStoreServiceImpl petStoreService = new PetStoreServiceImpl();
16.         petStoreService.setAccountDao(accountDao);
17.         petStoreService.setItemDao(itemDao);
18.         return petStoreService;
19.     }
20.     @Bean
21.     public AccountDao accountDao() {
22.         return new AccountDao();
23.     }
24.     @Bean
25.     public ItemDao itemDao() {
26.         return new ItemDao();
27.     }
28. }

复制代码

可以看出代码简洁明了不少，代码输出结果都是一致的。

1. 11:38:11.646 [main] INFO io.yulin.learn.spring.s104.PetStoreServiceImpl -- buy pet: Pet(name=Tom, type=Cat, num=1)
2. 11:38:11.653 [main] INFO io.yulin.learn.spring.s104.AccountDao -- 增加收入: Pet(name=Tom, type=Cat, num=1)
3. 11:38:11.653 [main] INFO io.yulin.learn.spring.s104.ItemDao -- minus pet num: 1

复制代码

完备项目源码信息检察可以在gitee或者github上搜刮r0ad检察。（外链考核太严酷~木办法）
配置Bean初体验

Spring IoC容器管理一个或多个bean。这些bean是根据您提供给容器的配置元数据创建的（例如，以XML  定义的形式）。
在容器内部，bean 定义被表示为 BeanDefinition 对象，其中包含（除其他信息外）以下元数据：

• 一个包限定的类名：通常是所定义的 bean 的实际实现类。
  
• Bean 行为配置元素，用于说明 bean 在容器中应如何运行（作用域、生命周期回调等）。
  
• 引用其他 bean，这些 bean 是该 bean 执行工作所需的。这些引用也称为协作者或依靠项。
  
• 其他配置设置用于设置新创建对象中的值，例如，管理连接池的 bean 中的池巨细限定或要利用的连接数。
  

1. /**
2. * 说明备案definition的例子
3. *
4. * @author nine
5. * @since 1.0
6. */
7. public class BeanDefinitionProcessDemo {
8.     public static void main(String[] args) {
9.         // ️GenericApplicationContext 是一个【干净】的容器
10.         GenericApplicationContext context = new GenericApplicationContext();
11.         // 用原始方法注册三个 bean
12.         context.registerBean("bean1", Bean1.class);
13.         // 初始化容器
14.         // 执行beanFactory后处理器, 添加bean后处理器, 初始化所有单例
15.         context.refresh();
16.         Bean1 bean = context.getBean(Bean1.class);
17.         bean.print();
18.         // 销毁容器
19.         context.close();
20.     }
21. }
23. @Slf4j
24. class Bean1 {
25.     public void print() {
26.         log.info("I am bean1");
27.     }
28. }

复制代码

通过这个代码可以发现，Bean1在调用registerBean接口后从一个普通的pojo类变成了一个bean。
org.springframework.context.support.GenericApplicationContext#registerBean为了方便利用有很多重载方法。
通过源码可以发现，普通类通过ClassDerivedBeanDefinition的构造函数转换为BeanDefinition。也就是该class通过setBeanClass成为BeanDefinition的属性beanClass。
后续通过一些列操作，自定义、名字处理、注册容器等等添加了其他的属性信息或者进行二次处理。
具体源码如下。

1. public <T> void registerBean(@Nullable String beanName, Class<T> beanClass, @Nullable Supplier<T> supplier, BeanDefinitionCustomizer... customizers) {
2.     // 创建一个 ClassDerivedBeanDefinition 对象，用于封装 Bean 的定义信息
3.     ClassDerivedBeanDefinition beanDefinition = new ClassDerivedBeanDefinition(beanClass);
5.     // 如果存在 supplier，则设置到 BeanDefinition 中
6.     if (supplier != null) {
7.         beanDefinition.setInstanceSupplier(supplier);
8.     }
10.     // 对 BeanDefinition 进行定制处理
11.     for (BeanDefinitionCustomizer customizer : customizers) {
12.         customizer.customize(beanDefinition);
13.     }
15.     // 如果指定了 beanName，则使用指定的名称，否则使用 beanClass 的名称
16.     String nameToUse = (beanName != null ? beanName : beanClass.getName());
18.     // 将封装好的 BeanDefinition 注册到容器中
19.     registerBeanDefinition(nameToUse, beanDefinition);
20. }

复制代码

bean的生命周期回调

Spring6 中 Bean 的生命周期可以通过 InitializingBean 和 DisposableBean 接口、@PostConstruct 和 @PreDestroy 注解以及配置文件中的 init-method 和 destroy-method 方法来管理。
把上面手动注入的bean的demo修改，增长实现 Bean 的初始化和烧毁回调：

1. public class BeanDefinitionProcessDemo {
2.     public static void main(String[] args) {
3.         // GenericApplicationContext 是一个干净的容器
4.         GenericApplicationContext context = new GenericApplicationContext();
5.         // 用原始方法注册 bean1，并指定初始化和销毁方法
6.         context.registerBean("bean1", Bean1.class, Bean1::new, beanDefinition -> {
7.             beanDefinition.setInitMethodName("init");
8.             beanDefinition.setDestroyMethodName("destroy");
9.         });
10.         // 初始化容器
11.         context.refresh();
12.         Bean1 bean = context.getBean(Bean1.class);
13.         bean.print();
14.         // 销毁容器
15.         context.close();
16.     }
17. }
19. @Slf4j
20. class Bean1 {
21.     public void print() {
22.         log.info("I am bean1");
23.     }
24.     public void init() {
25.         log.info("Bean1 is being initialized");
26.     }
27.     public void destroy() {
28.         log.info("Bean1 is being destroyed");
29.     }
30. }

复制代码

通过输出可以发现，bean1的初始化和烧毁回调被调用了。

1. 15:14:23.631 [main] INFO io.yulin.learn.spring.s104.Bean1 -- Bean1 is being initialized
2. 15:14:23.669 [main] INFO io.yulin.learn.spring.s104.Bean1 -- I am bean1
3. 15:14:23.670 [main] INFO io.yulin.learn.spring.s104.Bean1 -- Bean1 is being destroyed

复制代码

把整个过程改为更熟悉的基于注解驱动开发的方式，代码如下。

1. import jakarta.annotation.PostConstruct;
2. import jakarta.annotation.PreDestroy;
3. import lombok.extern.slf4j.Slf4j;
4. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
6. /**
7. * 通过注解方式配置Bean
8. * @author nine
9. * @since 1.0
10. */
11. public class BeanDefinitionProcessAnnotationDemo {
12.     public static void main(String[] args) {
13.         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
14.         context.register(BeanAnnotation1.class);
15.         context.refresh();
17.         BeanAnnotation1 bean = context.getBean(BeanAnnotation1.class);
18.         bean.print();
19.         context.close();
20.     }
21. }
23. @Slf4j
24. class BeanAnnotation1 {
25.     public void print() {
26.         log.info("I am BeanAnnotation1");
27.     }
29.     @PostConstruct
30.     public void init() {
31.         log.info("BeanAnnotation1 is being initialized");
32.     }
34.     @PreDestroy
35.     public void destroy() {
36.         log.info("BeanAnnotation1 is being destroyed");
37.     }
38. }

复制代码

输出结果基本一致的。
通过这个转换过程可以更能清晰的发现，Spring如何从基于xml配置、Java配置、注解配置的转换。也能更加深刻体会到Spring的强大兼容性。
实例化Bean

必要利用bean就必须实例化这个类，最简单的方式就是new 一个对象。
但是在Spring6框架中提供了更多的配置来实现实例化bean。
如果利用基于XML的配置元数据，可以在元素的class属性中指定要实例化的对象的范例（或类）。
这个class属性（在BeanDefinition实例上内部是一个Class属性）通常是必需的。
利用Class属性的两种方式之一：

• 通常情况下，为了指定要构造的bean类，在容器本身通过调用其构造函数反射性地直接创建bean的情况下，类似于利用new运算符的Java代码。
  
• 在较不常见的情况下，为了指定包含静态工厂方法的实际类，容器调用该类上的静态工厂方法来创建bean。从调用静态工厂方法返回的对象范例可以是相同的类，也可以是完全差别的类。
  

构造器实例化bean

当通过构造函数方式创建一个bean时，所有普通类都可以被Spring利用并与之兼容。
也就是说，正在开发的类不必要实现任何特定的接口或以特定方式编码。只需指定bean类即可。
然而，根据为该特定bean利用的IoC范例，可能必要一个默认（空）构造函数。
Spring IoC容器可以管理险些任何希望它管理的类。它不范围于管理真正的JavaBeans。
大多数Spring用户更喜欢具有仅默认（无参数）构造函数。
Spring容器还可以管理非bean的类。例如，如果必要利用不符合JavaBean规范的传统连接池，Spring也可以进行管理。
下面通过一个例子说明基于构造器实例化bean的例子。

1. import lombok.extern.slf4j.Slf4j;
2. import org.springframework.context.ApplicationContext;
3. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
4. import org.springframework.context.annotation.Bean;
5. import org.springframework.context.annotation.Configuration;
7. /**
8. * SpringBean创建demo
9. *
10. * @author nine
11. * @since 1.0
12. */
13. public class SpringBeanCreateDemo {
15.     public static void main(String[] args) {
16.         // 创建一个基于 Java Config 的应用上下文
17.         ApplicationContext context = new AnnotationConfigApplicationContext(AppCreateConfig.class);
18.         // 从上下文中获取名bean，其类型为PetStoreService
19.         MyClass bean = context.getBean(MyClass.class);
20.         // 调用获取的bean的方法
21.         bean.hello("jack");
22.     }
23. }
25. @Configuration
26. @Slf4j
27. class AppCreateConfig {
28.     @Bean
29.     public MyClass exampleBean() {
30.         return new MyClass("exampleConstructorArg");
31.     }
32. }
34. @Slf4j
35. class MyClass {
36.     public MyClass(String constructorArg) {
37.         log.info(constructorArg);
38.     }
40.     public void hello(String name) {
41.         log.info("hello " + name);
42.     }
43. }

复制代码

输出结果如下。可以看到MyClass类被正确初始化和被IoC容器管理。

1. 09:44:57.211 [main] INFO io.yulin.learn.spring.s104.MyClass -- exampleConstructorArg
2. 09:44:57.262 [main] INFO io.yulin.learn.spring.s104.MyClass -- hello jack

复制代码

静态工厂方法实例化bean

在定义利用静态工厂方法创建的bean时，利用class属性指定包含静态工厂方法的类，并利用名为factory-method的属性指定工厂方法本身的名称。
应该能够调用这个方法（带有可选参数，如后面所述），并返回一个活动对象，随后将其视为通过构造函数创建的对象。
如许一个bean定义的用途之一是在遗留代码中调用静态工厂。

1. import lombok.extern.slf4j.Slf4j;
2. import org.springframework.context.ApplicationContext;
3. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
4. import org.springframework.context.annotation.Bean;
5. import org.springframework.context.annotation.Configuration;
7. /**
8. * SpringBean创建demo
9. *
10. * @author nine
11. * @since 1.0
12. */
13. public class SpringBeanFactoryMethodCreateDemo {
15.     public static void main(String[] args) {
16.         // 创建一个基于 Java Config 的应用上下文
17.         ApplicationContext context = new AnnotationConfigApplicationContext(AppFactoryConfig.class);
18.         // 从上下文中获取名bean，其类型为PetStoreService
19.         AppFactoryConfig.MyBean bean = context.getBean(AppFactoryConfig.MyBean.class);
20.         // 调用获取的bean的方法
21.         bean.hello();
22.     }
23. }
25. @Slf4j
26. @Configuration
27. class AppFactoryConfig {
29.     @Bean
30.     public MyBean myBean() {
31.         // 调用带有可选参数的静态工厂方法创建 bean
32.         return MyBeanFactory.createBean("Tom");
33.     }
35.     static class MyBean {
36.         private String name;
38.         public MyBean(String name) {
39.             this.name = name;
40.         }
42.         public void hello() {
43.             log.info("Hello, " + name);
44.         }
45.     }
47.     static class MyBeanFactory {
48.         public static MyBean createBean(String parameter) {
49.             return new MyBean(parameter);
50.         }
51.     }
52. }

复制代码

通过实例工厂方法实例化bean

类似于通过静态工厂方法进行实例化，利用实例工厂方法进行实例化会调用容器中现有 bean 的非静态方法来创建一个新的 bean。
要利用这种机制，将class属性留空，在factory-bean属性中指定当前（或父级或祖先）容器中包含要被调用以创建对象的实例方法的 bean 的名称。
利用factory-method属性设置工厂方法本身的名称。
这个例子是基于java config来实现的。
可以发现MyBean通过现著名为MyBeanFactory的bean来创建的。

1. import org.springframework.context.annotation.Bean;
2. import org.springframework.context.annotation.Configuration;
4. @Configuration
5. public class AppBeanCreateConfig {
6.     @Bean
7.     public MyBeanFactory myBeanFactory() {
8.         return new MyBeanFactory();
9.     }
11.     @Bean
12.     public MyBean myBean(MyBeanFactory myBeanFactory) {
13.         // 调用实例工厂方法创建 bean
14.         return myBeanFactory.createBean("optionalParameter");
15.     }
17.     static class MyBean {
18.         private String name;
20.         public MyBean(String name) {
21.             this.name = name;
22.         }
24.         public void hello() {
25.             System.out.println("Hello, " + name);
26.         }
27.     }
29.     static class MyBeanFactory {
30.         public MyBean createBean(String parameter) {
31.             return new MyBean(parameter);
32.         }
33.     }
34. }

复制代码

确定Bean的运行时范例

确定Spring框架中一个特定bean的运行时范例确实必要思量到多种复杂情况。
在bean元数据定义中指定的类只是一个初始类引用，可能与声明的工厂方法结合，或者是一个可能导致bean具有差别运行时范例的FactoryBean类，或者在实例级工厂方法的情况下根本没有设置（这是通过指定的工厂-bean 名称来剖析的）。
此外，AOP署理可能会用基于接口的署理包装一个bean实例，只袒露目标bean的实际范例（仅袒露其实现的接口）。
查找特定bean的实际运行时范例的推荐方法是利用BeanFactory.getType调用指定的bean名称。
这思量了上述所有情况，并返回BeanFactory.getBean调用将为相同的bean名称返回的对象范例。
以上面的通过实例工厂方法实例化bean为例说明利用BeanFactory.getType。

1. import lombok.extern.slf4j.Slf4j;
2. import org.junit.jupiter.api.Test;
3. import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
4. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
6. @Slf4j
7. public class BeanRunTimeTypeTest {
9.     @Test
10.     public void test() {
11.         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppBeanCreateConfig.class);
12.         // 获取 BeanFactory 实例
13.         ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
14.         // 使用 BeanFactory.getType 方法获取特定 bean 的运行时类型
15.         Class<?> beanType = beanFactory.getType("myBean");
16.         log.info("The runtime type of 'myBean' is: " + beanType.getName());
17.         // 使用 BeanFactory.getBean 方法获取特定 bean 的实例对象
18.         AppBeanCreateConfig.MyBean myBeanInstance = (AppBeanCreateConfig.MyBean) beanFactory.getBean("myBean");
19.         myBeanInstance.hello();
20.         // 关闭应用上下文
21.         context.close();
22.     }
23. }

复制代码

输出结果如下。可以看到实例工厂方法没有设置class，但是运行时范例为MyBean。

1. 10:51:25.111 [main] INFO io.yulin.learn.spring.s104.BeanRunTimeTypeTest -- The runtime type of 'myBean' is: io.yulin.learn.spring.s104.AppBeanCreateConfig$MyBean
2. Hello, optionalParameter

复制代码

BeanFactory.getType()一些常见用途：

• 范例检查：通过调用 getType() 方法，可以获取特定 bean 的实际范例，并根据这些范例信息执行相应的操作。这对于在运行时进行范例检查和验证非常有用。
  
• 动态处理：在某些情况下，您可能必要根据 bean 的范例来动态地决定如何处理该 bean。通过 getType() 方法可以获取 bean 的范例信息，并根据必要执行相应的处理逻辑。
  
• 条件化配置：在 Spring 应用程序中，有时根据 bean 的范例来进行条件化的配置会很有用。通过 getType() 方法可以获取 bean 的范例，从而根据差别的范例执行差别的配置。
  
• 自定义逻辑：某些情况下，可能必要根据 bean 的范例来编写特定的业务逻辑。通过 getType() 方法可以获取 bean 的准确范例信息，并在代码中编写相应的逻辑。
  

关于作者

来自全栈程序员nine的探索与实践，持续迭代中。
接待关注或者点个小红心~

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。