Spring7指南（三）之Bean的生命周期

项目工程完整地址：https://github.com/YiyiCoding/Spring7Guides

Bean的单例说明

• 多例Bean（ @Scope(“prototype”) ）每次都由IOC容器New一个新对象，此处之外跟容器没有太多的联系性

• 单例才具有生命周期的概念

• 单例有懒加载的概念：需要时才由IOC容器创建Bean

  只要在类上面或@Bean 上注解 @Lazy 即可

Bean的生命周期

1. 实例化（Instantiation）→
2. 属性填充（Populate）→
3. 前置初始化（BeanPostProcessor.postProcessBeforeInitialization）→
4. 初始化（Initialization）→
5. 后置初始化（BeanPostProcessor.postProcessAfterInitialization）→
6. 就绪（Ready）：【在容器中可用】 →
7. 销毁前处理（DestructionAwareBeanPostProcessor）→
8. 销毁（Destruction）

【今天Spring7包含的知识点】：

• @Lazy

• Bean的生命周期

• 构造函数注入

  public UserService2(OrderService orderService) {
     this.orderService = orderService;
  }
  

• 需适配 Jakarta EE 9+

  implementation("jakarta.annotation:jakarta.annotation-api:3.0.0")
  

• @PostConstruct

• @PreDestroy

• InitializingBean

• DisposableBean

代码开始

• 新增依赖，Spring7 要求 Jakarta EE 9+

implementation("jakarta.annotation:jakarta.annotation-api:3.0.0")

• UserService2，采用构造函数注入

@Service
public class UserService2 {
    private final OrderService orderService;

    public UserService2(OrderService orderService) {
        this.orderService = orderService;
    }
    public void test(){
        System.out.println(orderService.demo());
    }
}

Bean的生命周期代码 LifecycleBean：

package com.yiyi.coding.spring.ioc.bean;

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

@Component
public class LifecycleBean implements InitializingBean, DisposableBean {

    // 步骤1：实例化（无代码，容器自动执行）
    public LifecycleBean() {
        System.out.println("【1. 实例化】创建Bean实例");
    }

    // 步骤2：属性填充（模拟注入，实际可通过配置注入）
    private String name;
    public void setName(String name) {
        this.name = name;
        System.out.println("【2. 属性填充】设置属性name=" + name);
    }

    // 步骤3：BeanPostProcessor前置处理（需自定义实现）
    // 步骤4：初始化
    @PostConstruct
    public void postConstruct() {
        System.out.println("【4.1 初始化】@PostConstruct");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("【4.2 初始化】InitializingBean#afterPropertiesSet");
    }

    public void initMethod() {
        System.out.println("【4.3 初始化】自定义init-method");
    }

    // 步骤5：BeanPostProcessor后置处理（需自定义实现）
    // 步骤6：就绪（可用）
    public void doBusiness() {
        System.out.println("【6. 就绪】Bean执行业务逻辑");
    }

    // 步骤7：销毁前处理（需自定义DestructionAwareBeanPostProcessor）
    // 步骤8：销毁
    @PreDestroy
    public void preDestroy() {
        System.out.println("【8.1 销毁】@PreDestroy");
    }

    @Override
    public void destroy() {
        System.out.println("【8.2 销毁】DisposableBean#destroy");
    }

    public void destroyMethod() {
        System.out.println("【8.3 销毁】自定义destroy-method");
    }

    public String getName() {
        return name;
    }
}

运行 main函数的测试情况：LifecycleBean 中的某些方法未完全执行，有些需进行配置，如 initMethod()等，本次略过。

package com.yiyi.coding.spring.ioc;// 测试类
import com.yiyi.coding.spring.ioc.bean.LifecycleBean;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;

@ComponentScan("com.yiyi.coding.spring.ioc")
public class LifecycleTest {
    static void main() {
        // 启动容器
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(LifecycleTest.class);
        LifecycleBean bean = context.getBean(LifecycleBean.class);
        bean.setName("test"); // 手动触发属性填充（模拟容器注入）
        bean.doBusiness();
        // 关闭容器（触发销毁）
        context.close();
    }
}

以下生命周期的钩子已经足够使用。

【1. 实例化】创建Bean实例
【4.1 初始化】@PostConstruct
【4.2 初始化】InitializingBean#afterPropertiesSet
【2. 属性填充】设置属性name=test
【6. 就绪】Bean执行业务逻辑
【8.1 销毁】@PreDestroy
【8.2 销毁】DisposableBean#destroys