Spring Bean 生命周期的执行流程详解

Spring框架以其强大的依赖注入和生命周期管理功能而闻名。理解Spring Bean的生命周期对于开发者来说至关重要，因为它可以帮助我们更好地设计和优化应用，特别是在处理复杂的依赖注入和初始化逻辑时。本文将详细介绍Spring Bean生命周期的五个主要阶段：创建前准备阶段、创建实例阶段、依赖注入阶段、容器缓存阶段和销毁实例阶段，并通过简单的示例帮助你更好地理解这一过程。

一、Spring Bean 生命周期概述

Spring Bean的生命周期是指从Bean被创建到最终被销毁的整个过程。这个过程中包含了多个步骤，每个步骤都有特定的目的和作用。以下是Spring Bean生命周期的五个主要阶段：

1. 创建前准备阶段：在创建Bean实例之前进行的准备工作。
2. 创建实例阶段：通过构造函数或工厂方法创建Bean的实例。
3. 依赖注入阶段：为Bean设置属性值并进行依赖注入。
4. 容器缓存阶段：将Bean实例注册到Spring容器中，并进行必要的后处理。
5. 销毁实例阶段：当Spring容器关闭时，调用销毁方法清理资源。

为了更好地理解这些阶段，我们将使用一个简单的示例来说明每个阶段的具体操作。假设我们有一个名为 MyBean 的类：

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class MyBean {
    private String name;

    public MyBean() {
        System.out.println("MyBean instance created.");
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("Name set to: " + name);
    }

    @PostConstruct
    public void init() {
        System.out.println("Initialization logic executed.");
    }

    @PreDestroy
    public void cleanup() {
        System.out.println("Cleanup logic executed.");
    }

    public void performTask() {
        System.out.println("Performing task with name: " + name);
    }
}

配置类

我们需要一个配置类来启动Spring应用上下文：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean(initMethod = "customInit", destroyMethod = "customCleanup")
    public MyBean myBean() {
        MyBean myBean = new MyBean();
        myBean.setName("ExampleName");
        return myBean;
    }

    public void customInit(MyBean myBean) {
        System.out.println("Custom initialization logic executed.");
    }

    public void customCleanup(MyBean myBean) {
        System.out.println("Custom cleanup logic executed.");
    }
}

主应用类

最后，编写主应用类来启动Spring应用：

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        MyBean myBean = context.getBean(MyBean.class);
        myBean.performTask();

        ((AnnotationConfigApplicationContext) context).close();
    }
}

二、详细执行流程

1. 创建前准备阶段

在创建Bean实例之前，Spring会进行一些准备工作。这包括解析Bean定义、确定Bean的作用域（如单例、原型等）以及检查是否需要进行代理等操作。

关键点：

• BeanDefinition：Spring会解析XML配置文件或注解配置，生成 BeanDefinition 对象，包含Bean的所有元数据。
• 作用域：确定Bean的作用域（如单例、原型等），并根据作用域决定是否需要缓存Bean实例。

2. 创建实例阶段

在这一步骤中，Spring容器会根据 BeanDefinition 中的信息创建Bean的实例。这通常通过反射机制实现，即通过类的构造函数或工厂方法来创建对象。

关键点：

• 构造函数：通过无参构造函数或有参构造函数创建Bean实例。
• 工厂方法：如果Bean是通过工厂方法创建的，则调用相应的工厂方法来创建实例。

public MyBean() {
    System.out.println("MyBean instance created.");
}

3. 依赖注入阶段

在这一步骤中，Spring容器会为Bean设置属性值，并进行依赖注入。依赖注入可以通过构造器注入、字段注入或Setter方法注入来实现。

关键点：

• 构造器注入：通过构造函数参数注入依赖。
• Setter注入：通过Setter方法注入依赖。
• 字段注入：通过注解直接在字段上注入依赖。

public void setName(String name) {
    this.name = name;
    System.out.println("Name set to: " + name);
}

4. 容器缓存阶段

在这一步骤中，Spring容器会将Bean实例注册到容器中，并进行必要的后处理操作。这包括调用初始化方法、注册监听器等。

关键点：

• 初始化方法：调用 @PostConstruct 注解的方法或 InitializingBean 接口的 afterPropertiesSet() 方法。
• 自定义初始化方法：通过 @Bean(initMethod = "init") 或  配置自定义的初始化方法。

@PostConstruct
public void init() {
    System.out.println("Initialization logic executed.");
}

@Bean(initMethod = "customInit")
public MyBean myBean() {
    // ...
}

public void customInit(MyBean myBean) {
    System.out.println("Custom initialization logic executed.");
}

5. 销毁实例阶段

当Spring容器关闭时，会调用Bean的销毁方法来释放资源。Spring提供了多种方式来进行销毁操作。

关键点：

• 销毁方法：调用 @PreDestroy 注解的方法或 DisposableBean 接口的 destroy() 方法。
• 自定义销毁方法：通过 @Bean(destroyMethod = "cleanup") 或  配置自定义的销毁方法。

@PreDestroy
public void cleanup() {
    System.out.println("Cleanup logic executed.");
}

@Bean(destroyMethod = "customCleanup")
public MyBean myBean() {
    // ...
}

public void customCleanup(MyBean myBean) {
    System.out.println("Custom cleanup logic executed.");
}

三、运行结果分析

运行上述代码后，控制台输出如下：

MyBean instance created.
Name set to: ExampleName
Initialization logic executed.
Custom initialization logic executed.
Performing task with name: ExampleName
Cleanup logic executed.
Custom cleanup logic executed.

解析

1. 创建前准备阶段：

   • Spring解析 AppConfig 类中的 myBean 方法，生成 BeanDefinition 对象，并确定其作用域为单例。

2. 创建实例阶段：

   • 调用 MyBean 的无参构造函数创建实例。
   • 输出：MyBean instance created.

3. 依赖注入阶段：

   • 调用 setName 方法设置 name 属性。
   • 输出：Name set to: ExampleName

4. 容器缓存阶段：

   • 调用 @PostConstruct 注解的 init 方法。
   • 输出：Initialization logic executed.
   • 调用自定义的 customInit 方法。
   • 输出：Custom initialization logic executed.

5. 销毁实例阶段：

   • 当Spring容器关闭时，首先调用 @PreDestroy 注解的 cleanup 方法。
   • 输出：Cleanup logic executed.
   • 然后调用自定义的 customCleanup 方法。
   • 输出：Custom cleanup logic executed.

四、总结

Spring Bean的生命周期是一个复杂但有序的过程，涵盖了从创建前准备到销毁实例的各个阶段。理解这些阶段及其执行顺序可以帮助开发者更好地设计和优化应用，特别是在处理复杂的依赖注入和初始化逻辑时。

关键点回顾：

1. 创建前准备阶段：解析 BeanDefinition 并确定作用域。
2. 创建实例阶段：通过构造函数或工厂方法创建Bean实例。
3. 依赖注入阶段：通过构造器、字段或Setter方法注入依赖。
4. 容器缓存阶段：调用初始化方法并将Bean实例注册到容器中。
5. 销毁实例阶段：调用销毁方法清理资源。