java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Spring Bean生命周期

深度解析Spring Bean生命周期的各个阶段

作者：猿究院-陆昱泽

本文将详细梳理Spring Bean生命周期的各个阶段,并通过代码示例展示每个关键节点,本文结合实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧

概述

Spring Bean的生命周期是Spring框架的核心概念之一，理解Bean从创建到销毁的整个过程对于开发高质量的Spring应用程序至关重要。本文将详细梳理Spring Bean生命周期的各个阶段，并通过代码示例展示每个关键节点。

Spring Bean生命周期阶段

1. 实例化阶段

Spring容器通过构造函数或工厂方法创建Bean实例

public class ExampleBean {
    public ExampleBean() {
        System.out.println("1. Bean实例化 - 构造函数执行");
    }
}

2. 属性赋值阶段

Spring容器注入Bean的属性和依赖

public class ExampleBean {
    private String name;
    private AnotherBean anotherBean;
    // Setter方法用于属性注入
    public void setName(String name) {
        System.out.println("2. 属性注入 - name: " + name);
        this.name = name;
    }
    public void setAnotherBean(AnotherBean anotherBean) {
        System.out.println("2. 依赖注入 - anotherBean");
        this.anotherBean = anotherBean;
    }
}

3. Aware接口回调阶段

Bean实现Aware接口获取容器资源

public class ExampleBean implements BeanNameAware, BeanFactoryAware, ApplicationContextAware {
    @Override
    public void setBeanName(String name) {
        System.out.println("3. BeanNameAware - Bean名称: " + name);
    }
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("3. BeanFactoryAware - BeanFactory注入");
    }
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("3. ApplicationContextAware - ApplicationContext注入");
    }
}

4. BeanPostProcessor前置处理

BeanPostProcessor的postProcessBeforeInitialization方法

@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof ExampleBean) {
            System.out.println("4. BeanPostProcessor前置处理 - " + beanName);
        }
        return bean;
    }
}

5. 初始化阶段

@PostConstruct注解方法

public class ExampleBean {
    @PostConstruct
    public void postConstruct() {
        System.out.println("5.1 @PostConstruct方法执行");
    }
}

InitializingBean接口

public class ExampleBean implements InitializingBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("5.2 InitializingBean.afterPropertiesSet()执行");
    }
}

自定义init方法

public class ExampleBean {
    public void customInit() {
        System.out.println("5.3 自定义init方法执行");
    }
}
// 配置类中指定init方法
@Configuration
public class AppConfig {
    @Bean(initMethod = "customInit")
    public ExampleBean exampleBean() {
        return new ExampleBean();
    }
}

6. BeanPostProcessor后置处理

BeanPostProcessor的postProcessAfterInitialization方法

@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof ExampleBean) {
            System.out.println("6. BeanPostProcessor后置处理 - " + beanName);
        }
        return bean;
    }
}

7. Bean使用阶段

Bean完全初始化，可供应用程序使用

@Service
public class BusinessService {
    private final ExampleBean exampleBean;
    public BusinessService(ExampleBean exampleBean) {
        this.exampleBean = exampleBean;
    }
    public void doBusiness() {
        System.out.println("7. Bean使用阶段 - 执行业务逻辑");
    }
}

8. 销毁阶段

@PreDestroy注解方法

public class ExampleBean {
    @PreDestroy
    public void preDestroy() {
        System.out.println("8.1 @PreDestroy方法执行");
    }
}

DisposableBean接口

public class ExampleBean implements DisposableBean {
    @Override
    public void destroy() throws Exception {
        System.out.println("8.2 DisposableBean.destroy()执行");
    }
}

自定义destroy方法

public class ExampleBean {
    public void customDestroy() {
        System.out.println("8.3 自定义destroy方法执行");
    }
}
// 配置类中指定destroy方法
@Configuration
public class AppConfig {
    @Bean(destroyMethod = "customDestroy")
    public ExampleBean exampleBean() {
        return new ExampleBean();
    }
}

完整示例代码

1. 定义Bean类

import org.springframework.beans.factory.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
public class LifecycleBean implements BeanNameAware, BeanFactoryAware, 
        ApplicationContextAware, InitializingBean, DisposableBean {
    private String name;
    private AnotherBean anotherBean;
    public LifecycleBean() {
        System.out.println("1. 构造函数执行 - Bean实例化");
    }
    public void setName(String name) {
        System.out.println("2. 属性注入 - name: " + name);
        this.name = name;
    }
    public void setAnotherBean(AnotherBean anotherBean) {
        System.out.println("2. 依赖注入 - anotherBean");
        this.anotherBean = anotherBean;
    }
    @Override
    public void setBeanName(String name) {
        System.out.println("3. BeanNameAware - Bean名称: " + name);
    }
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("3. BeanFactoryAware - BeanFactory注入");
    }
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("3. ApplicationContextAware - ApplicationContext注入");
    }
    @PostConstruct
    public void postConstruct() {
        System.out.println("5.1 @PostConstruct方法执行");
    }
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("5.2 InitializingBean.afterPropertiesSet()执行");
    }
    public void customInit() {
        System.out.println("5.3 自定义init方法执行");
    }
    public void doSomething() {
        System.out.println("7. Bean使用阶段 - 执行业务方法");
    }
    @PreDestroy
    public void preDestroy() {
        System.out.println("8.1 @PreDestroy方法执行");
    }
    @Override
    public void destroy() throws Exception {
        System.out.println("8.2 DisposableBean.destroy()执行");
    }
    public void customDestroy() {
        System.out.println("8.3 自定义destroy方法执行");
    }
}

2. 配置BeanPostProcessor

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
@Component
public class CustomBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof LifecycleBean) {
            System.out.println("4. BeanPostProcessor前置处理 - " + beanName);
        }
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof LifecycleBean) {
            System.out.println("6. BeanPostProcessor后置处理 - " + beanName);
        }
        return bean;
    }
}

3. 配置类

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
    @Bean(initMethod = "customInit", destroyMethod = "customDestroy")
    public LifecycleBean lifecycleBean() {
        LifecycleBean bean = new LifecycleBean();
        bean.setName("示例Bean");
        return bean;
    }
    @Bean
    public AnotherBean anotherBean() {
        return new AnotherBean();
    }
}

4. 测试类

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class LifecycleTest {
    public static void main(String[] args) {
        System.out.println("Spring容器启动...");
        AnnotationConfigApplicationContext context = 
            new AnnotationConfigApplicationContext(AppConfig.class);
        System.out.println("\n获取Bean并执行业务方法...");
        LifecycleBean bean = context.getBean(LifecycleBean.class);
        bean.doSomething();
        System.out.println("\nSpring容器关闭...");
        context.close();
        System.out.println("程序结束");
    }
}

生命周期流程图

Bean生命周期完整流程：
1. 实例化 → 2. 属性赋值 → 3. Aware接口回调 → 4. BeanPostProcessor前置处理 →
5. 初始化(@PostConstruct → InitializingBean → 自定义init) → 6. BeanPostProcessor后置处理 →
7. Bean就绪可用 → 8. 销毁(@PreDestroy → DisposableBean → 自定义destroy)

总结

Spring Bean的生命周期是一个复杂但有序的过程，理解每个阶段的执行顺序和用途对于：

  1. 调试和问题排查：能够快速定位Bean初始化相关的问题
  2. 扩展功能：通过BeanPostProcessor等机制扩展Spring功能
  3. 资源管理：正确管理数据库连接、线程池等资源
  4. 性能优化：合理使用各种初始化机制提升应用性能

到此这篇关于Spring Bean生命周期全面解析的文章就介绍到这了,更多相关Spring Bean生命周期内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文