Spring Bean的生命周期

一、Spring Bean的生命周期

        在Spring框架中，Bean的生命周期是指从创建到销毁的过程。以下是Spring Bean生命周期的主要步骤：

1. 实例化 (Instantiation)：
        Spring容器根据配置元数据（如XML或注解）调用无参构造函数或静态工厂方法来创建Bean实例。
2. 属性赋值 (Populate Properties)：
        实例化后，Spring容器使用依赖注入（DI）将属性值和依赖对象注入到Bean实例中。
3. 设置Bean名称 (Setting Bean Name)：
        如果Bean实现了BeanNameAware接口，Spring会调用setBeanName(String name)方法，传递Bean的名称。
4. 设置Bean工厂 (Setting Bean Factory)：
        如果Bean实现了BeanFactoryAware接口，Spring会调用setBeanFactory(BeanFactory beanFactory)方法，传递当前的Bean工厂。
5. 前置处理 (Pre-Initialization)：
        如果有BeanPostProcessor接口的实现类，Spring会调用postProcessBeforeInitialization(Object bean, String beanName)方法。
6. 初始化 (Initialization)：
        如果Bean实现了InitializingBean接口，Spring会调用afterPropertiesSet()方法。
        如果配置文件中有init-method属性，Spring会调用指定的方法。
7. 后置处理 (Post-Initialization)：
        如果有BeanPostProcessor接口的实现类，Spring会调用postProcessAfterInitialization(Object bean, String beanName)方法。
8. 使用阶段 (Ready for Use)：
        Bean已经完全初始化，可以被应用程序使用了。
9. 销毁 (Destruction)：
        当容器关闭时，如果Bean实现了DisposableBean接口，Spring会调用destroy()方法。
        如果配置文件中有destroy-method属性，Spring会调用指定的方法。
通过这些步骤，Spring确保每个Bean在使用之前都处于正确且可预测的状态，并在不再需要时能够正确地清理资源。

二、生命周期的示例代码

1、LifecycleDemoBean.java

import org.springframework.beans.factory.*;
import javax.annotation.*;

public class LifecycleDemoBean implements BeanNameAware, BeanFactoryAware, 
        ApplicationContextAware, InitializingBean, DisposableBean {
    
    private String name;

    // 1. 构造方法
    public LifecycleDemoBean() {
        System.out.println("1. 构造方法执行");
    }

    // 2. 属性注入
    public void setName(String name) {
        this.name = name;
        System.out.println("2. 属性注入: " + name);
    }

    // 3. Aware接口回调
    @Override
    public void setBeanName(String name) {
        System.out.println("3. BeanNameAware: " + name);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        System.out.println("3. BeanFactoryAware回调");
    }

    @Override
    public void setApplicationContext(ApplicationContext ctx) {
        System.out.println("3. ApplicationContextAware回调");
    }

    // 4. @PostConstruct
    @PostConstruct
    public void postConstruct() {
        System.out.println("4. @PostConstruct方法执行");
    }

    // 5. InitializingBean
    @Override
    public void afterPropertiesSet() {
        System.out.println("5. InitializingBean.afterPropertiesSet()");
    }

    // 6. init-method
    public void customInit() {
        System.out.println("6. 自定义init-method执行");
    }

    // 7. @PreDestroy
    @PreDestroy
    public void preDestroy() {
        System.out.println("7. @PreDestroy方法执行");
    }

    // 8. DisposableBean
    @Override
    public void destroy() {
        System.out.println("8. DisposableBean.destroy()");
    }

    // 9. destroy-method
    public void customDestroy() {
        System.out.println("9. 自定义destroy-method执行");
    }
}

2、AppConfig.java

import org.springframework.context.annotation.*;

@Configuration
public class AppConfig {
    @Bean(initMethod = "customInit", destroyMethod = "customDestroy")
    public LifecycleDemoBean demoBean() {
        LifecycleDemoBean bean = new LifecycleDemoBean();
        bean.setName("测试Bean");
        return bean;
    }
}

3、MainApp.java

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = 
            new AnnotationConfigApplicationContext(AppConfig.class);
        ctx.getBean(LifecycleDemoBean.class);
        ctx.close(); // 触发销毁
    }
}