Bean生命周期

Bean生命周期定义了Bean从创建到销毁的完整过程，理解生命周期有助于在合适的时机执行自定义逻辑。

四个核心阶段

实例化 → 属性赋值 → 初始化 → 销毁

完整生命周期流程

1. 实例化（调用构造器）
       ↓
2. 属性赋值（依赖注入）
       ↓
3. 处理Aware接口
   - BeanNameAware.setBeanName()
   - BeanFactoryAware.setBeanFactory()
   - ApplicationContextAware.setApplicationContext()
       ↓
4. BeanPostProcessor.postProcessBeforeInitialization()
       ↓
5. 执行初始化方法
   - @PostConstruct
   - InitializingBean.afterPropertiesSet()
   - init-method
       ↓
6. BeanPostProcessor.postProcessAfterInitialization()
       ↓
7. Bean就绪，可使用
       ↓
8. 容器关闭，执行销毁方法
   - @PreDestroy
   - DisposableBean.destroy()
   - destroy-method

代码示例

定义Bean

@Component
public class LifecycleBean implements BeanNameAware, InitializingBean, DisposableBean {

    private String beanName;

    // 1. 实例化
    public LifecycleBean() {
        System.out.println("1. 构造器执行");
    }

    // 2. 属性赋值
    @Autowired
    private UserService userService;

    // 3. BeanNameAware
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("2. BeanNameAware: " + name);
    }

    // 4. @PostConstruct（第一个初始化方法）
    @PostConstruct
    public void postConstruct() {
        System.out.println("3. @PostConstruct");
    }

    // 5. InitializingBean（第二个初始化方法）
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("4. InitializingBean.afterPropertiesSet()");
    }

    // 6. 自定义init-method（第三个初始化方法）
    public void customInit() {
        System.out.println("5. customInit");
    }

    // 7. @PreDestroy（第一个销毁方法）
    @PreDestroy
    public void preDestroy() {
        System.out.println("6. @PreDestroy");
    }

    // 8. DisposableBean（第二个销毁方法）
    @Override
    public void destroy() throws Exception {
        System.out.println("7. DisposableBean.destroy()");
    }

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

BeanPostProcessor

@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("初始化前处理: " + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("初始化后处理: " + beanName);
        return bean;
    }
}

初始化方法执行顺序

销毁方法执行顺序

XML配置

<bean id="lifecycleBean"
      class="com.example.LifecycleBean"
      init-method="customInit"
      destroy-method="customDestroy"/>

@Bean配置

@Bean(initMethod = "customInit", destroyMethod = "customDestroy")
public LifecycleBean lifecycleBean() {
    return new LifecycleBean();
}

Aware接口一览

要点总结

1. 生命周期四阶段：实例化、属性赋值、初始化、销毁
2. 初始化顺序：@PostConstruct → InitializingBean → init-method
3. 销毁顺序：@PreDestroy → DisposableBean → destroy-method
4. BeanPostProcessor在初始化前后执行，常用于AOP代理创建
5. 推荐使用注解方式（@PostConstruct/@PreDestroy）更简洁