Spring 生命周期详解：从初识到精通_spring生命周期七个过程总结

Spring 生命周期详解：从初识到精通

了解 Spring 生命周期对于我们更好地运用它非常重要。本篇文章力图用易懂、有趣的方式带你深入剖析 Spring 生命周期，让你成为 Spring 开发的专家。

目录

• 一、Spring 生命周期简介
  • 1.1 Spring 程序启动过程
  • 1.2 Spring Bean 的生命周期
• 二、BeanFactory 和 ApplicationContext
  • 2.1 了解 BeanFactory
  • 2.2 深入 ApplicationContext
• 三、Spring Bean 生命周期详解
  • 3.1 BeanDefinition 到 Bean 实例
  • 3.2 Bean 实例化过程
  • 3.3 依赖注入
  • 3.4 初始化回调与资源销毁
• 四、重要的 Bean 生命周期接口
  • 4.1 BeanPostProcessor
  • 4.2 BeanFactoryPostProcessor
  • 4.3 类相关接口：InitializingBean、DisposableBean 和 Aware 接口
• 五、实践案例

一、Spring 生命周期简介

要了解 Spring生命周期，我们需要分别了解 Spring 程序启动过程以及 Spring Bean的生命周期。下面开始详细介绍。

1.1 Spring 程序启动过程

Spring 程序启动主要分为这几个步骤：

1. 创建 ApplicationContext 对象
2. 读取配置文件进行解析
3. 初始化 BeanDefinition
4. 创建单例池（Singleton Bean）

1.2 Spring Bean 的生命周期

Spring Bean 生命周期可分为以下阶段：

1. BeanDefinition 到 Bean 实例
2. Bean 实例化（Instantiation）
3. 依赖注入（Dependency Injection）
4. 初始化回调与资源销毁

二、BeanFactory 和 ApplicationContext

2.1 了解 BeanFactory

BeanFactory 是 Spring 中最核心的接口，主要提供了以下功能：

1. 根据 BeanDefinition 创建 Bean 实例
2. 依赖解析与注入
3. 为 Bean 提供生命周期管理

2.2 深入 ApplicationContext

ApplicationContext 是 BeanFactory 的实现类，扩充了一些功能，如:

1. 事件发布与订阅
2. 国际化支持
3. 资源访问
4. 与 Java EE 之间的集成

三、Spring Bean 生命周期详解

3.1 BeanDefinition 到 Bean 实例

BeanDefinition 是 Bean 配置的原材料，包括了Bean 实例的各种属性和依赖关系等信息。BeanFactory 根据 BeanDefinition 来创建、注入和实例化 Bean。

1. 读取和解析配置信息：将配置文件（如 XML 文件、Java Config）转化为 BeanDefinition 对象
2. 注册到 BeanDefinitionRegistry：BeanDefinition 对象被注册到 BeanFactory 的 BeanDefinitionRegistry 中进行管理

3.2 Bean 实例化过程

Bean 实例化分为以下几个步骤：

1. 选择构造器：选择合适的构造器进行实例化
2. 实例创建：使用反射技术创建 Bean 实例
3. 属性设置：根据 BeanDefinition 中的属性信息为 Bean 实例设置属性（赋值）

3.3 依赖注入

依赖注入可以分为以下几个步骤：

1. 解析依赖关系：从 BeanDefinition 中获取到所有依赖的 Bean 名称
2. 获取依赖的 Bean 实例：根据名称从 BeanFactory 中获取依赖的 Bean 实例
3. 对目标 Bean 依赖注入：将依赖的 Bean 实例注入到目标 Bean 中

3.4 初始化回调与资源销毁

在 Bean 实例化后，Spring 提供了回调方法的支持来执行一些特定的操作。

1. 初始化回调：可以通过实现 InitializingBean 接口的 afterPropertiesSet 方法或定义 @PostConstruct 注解的方法来执行初始化操作
2. 资源销毁：可以通过实现 DisposableBean 接口的 destroy 方法或定义 @PreDestroy 注解的方法来执行销毁操作

四、重要的 Bean 生命周期接口

4.1 BeanPostProcessor

BeanPostProcessor 接口允许在 Bean 初始化的过程中执行自定义操作。它提供了两个方法：

1. postProcessBeforeInitialization：在 Bean 初始化前调用，例如在调用 InitializingBean 的 afterPropertiesSet 方法之前
2. postProcessAfterInitialization：在 Bean 初始化后调用，例如在调用 @PostConstruct 注解的方法之后

实现此接口，你可以在 Bean 的生命周期中，通过实现类插入定制的动作。

4.2 InstantiationAwareBeanPostProcessor

InstantiationAwareBean_postProcessor 接口继承自 BeanPostProcessor，提供在 Bean 实例化之前进行扩展操作的能力。

1. postProcessBeforeInstantiation：在实例化 Bean 之前调用，例如在选择合适的构造器之前
2. postProcessAfterInstantiation：在实例化 Bean 之后调用，例如在属性设置之前

4.3 SmartInstantiationAwareBeanPostProcessor

SmartInstantiationAwareBeanPostProcessor 继承自 InstantiationAwareBeanPostProcessor，提供对简单类型字段的候选者的选择。

1. determineCandidateConstructors：提供了自定义选择构造器的能力
2. getEarlyBeanReference：有助于解决循环依赖问题

五、实践案例

假设我们有一个简单的 Spring 应用，目标是了解 Bean 生命周期的各个阶段。

5.1 创建简单的 Spring 应用

以下是一个简单的 Spring 配置和示例 Bean：

@Configuration
public class AppConfig {
    @Bean
    public UserService userService() {
    return new UserService```java
    new UserService();
    }
}

@Component
public class UserService {
    @Autowired
    private OrderService orderService;

    public UserService() {
        System.out.println("UserService: 构造方法");
    }

    @PostConstruct
    public void init() {
        System.out.println("UserService: 初始化");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("UserService: 销毁");
    }
}

@Component
public class OrderService {
    public OrderService() {
        System.out.println("OrderService: 构造方法");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

上面的代码定义了一个简单的 Spring 配置类 AppConfig，其中包含一个 userService Bean。UserService 有一个对 OrderService 的依赖。这两个 Bean 包含了一些生命周期相关的方法（构造方法、初始化和销毁）。

5.2 分析 Bean 生命周期

现在我们来分析整个 Bean 生命周期，看看在不同阶段输出的内容。启动 Spring 应用，将看到如下输出：

OrderService: 构造方法
UserService: 构造方法
UserService: 初始化
1
2
3

首先，OrderService 的构造方法被调用，接着是 UserService 的构造方法。最后，UserService 的初始化方法被调用。接下来，我们以 UserService 为例，看看在生命周期的各个阶段都发生了什么：

1. 读取和解析配置信息：Spring 从配置类中读取配置信息，并解析为 BeanDefinition 对象
2. 注册到 BeanDefinitionRegistry：BeanDefinition 对象被注册到 BeanFactory 中
3. 选择合适的构造器：Spring 根据提供的构造方法和依赖关系，查找并选择合适的构造器来实例化 Bean
4. 实例化 Bean：通过构造器实例化 Bean，在这里 UserService 和 OrderService 的构造方法被调用
5. 设置 Bean 属性：Spring 根据配置信息设置 Bean 的属性，这里 UserService 的 OrderService 属性被自动装配
6. 初始化 Bean：执行初始化方法，这里 UserService 的 init 方法被调用（@PostConstruct 注解标记的）
7. Bean 放入容器：实例化好的 Bean 被放入 Spring IoC 容器并被管理
8. 销毁 Bean：应用停止时，执行销毁方法（@PreDestroy 注解标记的）

从上述分析中，我们可以看到 Bean 生命周期的多个阶段，并了解 Spring 如何实例化、装配和管理 Bean。为了更深入了解 Bean 生命周期，我们可以通过在 UserService 中实现 InitializingBean 和 DisposableBean 接口，并重写接口方法来观察输出结果。

@Component
public class UserService implements InitializingBean, DisposableBean {
    // ...其他代码

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("UserService: afterPropertiesSet");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("UserService: DisposableBean 销毁方法");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

再次运行应用，我们将看到如下输出：

OrderService: 构造方法
UserService: 构造方法
UserService: 初始化
UserService: afterPropertiesSet
1
2
3
4

这次，除了 @PostConstruct 注解的方法，UserService 初始化阶段还包括调用 afterPropertiesSet 方法。

六、总结

在本文中，我们首先介绍了 Spring Bean 的生命周期，并学习了 Bean 生命周期中的各个阶段。