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

更新时间：2025年09月23日 09:30:07 作者：猿究院-陆昱泽

本文将详细梳理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的生命周期是一个复杂但有序的过程，理解每个阶段的执行顺序和用途对于：

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

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

您可能感兴趣的文章:

深入理解Java中的克隆
想必大家对克隆都有耳闻，世界上第一只克隆羊多莉就是利用细胞核移植技术将哺乳动物的成年体细胞培育出新个体，甚为神奇。其实在Java中也存在克隆的概念，即实现对象的复制。本文将尝试介绍一些关于Java中的克隆和一些深入的问题，希望可以帮助大家更好地了解克隆。
2016-08-08
Java并发编程：volatile关键字详细解析
这篇文章主要介绍了Java并发编程：volatile关键字详细解析，对学习volatile关键字有一定的认识，有需要的可以了解一下。
2016-11-11
Maven在Windows中的配置以及IDE中的项目创建实例
下面小编就为大家带来一篇Maven在Windows中的配置以及IDE中的项目创建实例。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-09-09
Gradle的使用教程详解
Gradle它使用一种基于Groovy的特定领域语言(DSL)来声明项目设置，目前也增加了基于Kotlin语言的kotlin-based DSL，抛弃了基于XML的各种繁琐配置，下面通过本文给大家介绍Gradle的使用教程，感兴趣的朋友一起看看吧
2020-09-09
Java实现快速排序算法(Quicktsort)
这篇文章主要介绍了Java实现快速排序算法(Quicktsort)，有需要的朋友可以参考一下
2013-12-12
java排序去重示例分享
这篇文章主要介绍了java排序去重示例，对String strs = "ZZZ BBB AAA OOO ZZZ AAA ZZZ"计算出现个数，排序去重,需要的朋友可以参考下
2014-02-02
Netty启动流程注册多路复用源码解析
这篇文章主要介绍了Netty启动流程注册多路复用源码分析，继续分析channel是如何注册到selector中的，有需要的朋友可以借鉴参考下，希望能够有所帮助
2022-03-03
基于Java代码实现支付充值的通用流程
本文给大家分享一段java核心代码实现支付充值的通用流程，非常不错，具有参考借鉴价值，感兴趣的朋友一起看看吧
2016-05-05
修改jar包package目录结构操作方法
这篇文章主要介绍了修改jar包package目录结构操作方法，本文给大家介绍的非常详细，具有一定的参考借鉴价值 ,需要的朋友可以参考下
2019-07-07
SpringBoot集成FastDFS依赖实现文件上传的示例
这篇文章主要介绍了SpringBoot集成FastDFS依赖实现文件上传,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2021-05-05