Spring - 一篇文章带你理解透彻Spring Boot中Bean的生命周期！！

原创 已于 2025-08-22 12:08:03 修改 · 1.4k 阅读 · 23 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring boot #后端 #java #spring #java-ee

于 2025-08-21 19:45:54 首次发布

SpringBoot中Bean的生命周期与实践全解析

在SpringBoot的核心容器体系中，Bean作为应用上下文（ApplicationContext）的基础组件，其生命周期的管理是控制反转（IoC）与依赖注入（DI）的核心支撑。

理解Bean从创建→初始化→使用→销毁的完整流程，不仅能帮助开发者精准控制组件行为，更能在复杂场景（如资源初始化、状态维护、资源释放）中避免潜在的逻辑漏洞。

本文将从Bean生命周期的标准阶段划分入手，结合SpringBoot的具体实现机制，逐一解析各阶段的核心逻辑、扩展点及最佳实践，并辅以可运行的代码示例说明。

一、Bean生命周期的阶段概览

SpringBoot中Bean的生命周期可分为7个核心阶段，执行顺序如下：

  1. 实例化（Instantiation）：通过反射创建Bean对象（调用构造器）；
  2. 属性注入（Populate）：自动装配依赖的Bean（DI过程）；
  3. 初始化前（Aware回调）：实现Aware接口的Bean获取容器资源（如ApplicationContext、BeanName）；
  4. 初始化（Initialization）：执行自定义初始化逻辑（三种方式）；
  5. 就绪（Ready）：Bean存入容器缓存，对外提供服务；
  6. 销毁前（Pre-Destruction）：执行自定义销毁逻辑（三种方式）；
  7. 销毁（Destruction）：Bean被容器回收，资源释放。

二、各阶段详细解析与代码实现

1. 实例化：Bean对象的创建

核心逻辑：Spring容器根据BeanDefinition（Bean的元数据描述）中的类信息，通过反射调用构造器创建Bean实例。BeanDefinition包含Bean的类名、构造器参数、作用域（单例/原型）等信息，是实例化的核心依据。

代码示例（无参构造器）：

@Component // 标记为Spring管理的Bean
public class UserService {
    // 1. 实例化：Spring默认调用无参构造器
    public UserService() {
        System.out.println("1. 实例化：UserService构造器调用");
    }
}

关键说明：

  • 优先使用无参构造器（若未显式定义，编译器自动生成）；
  • 若需使用有参构造器，可通过构造器注入（@Autowired）或BeanDefinition指定构造器参数；
  • 构造器注入是Spring推荐的依赖注入方式（不可变、避免循环依赖），示例：
 @Component
 public class UserService {
     private final UserRepository userRepository;

     // 构造器注入：Spring自动装配UserRepository
     @Autowired
     public UserService(UserRepository userRepository) {
         this.userRepository = userRepository;
         System.out.println("1. 实例化：带参构造器调用（注入UserRepository）");
     }
 }

2. 属性注入：依赖的自动装配

核心逻辑：Spring根据BeanDefinition中的依赖信息（如@Autowired、@Resource注解），将依赖的Bean注入到当前Bean的属性中。注入时机在实例化之后、初始化之前。

代码示例（字段注入与setter注入）：

@Component
public class UserService {
    // 字段注入：直接标注@Autowired
    @Autowired
    private UserRepository userRepository;

    // setter注入：可选（用于打印日志）
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
        System.out.println("2. 属性注入：注入UserRepository");
    }
}

@Component // 依赖的Bean
public class UserRepository {
    public UserRepository() {
        System.out.println("UserRepository实例化");
    }
}

关键说明：

  • 字段注入：简洁但增加Bean与Spring的耦合度，不推荐用于核心组件；
  • setter注入：适用于可选依赖（可通过@Autowired(required = false)标记）；
  • 构造器注入：推荐方式（不可变、依赖明确），SpringBoot 2.2+默认支持构造器注入（无需@Autowired）。

3. 初始化前：Aware接口的回调

核心逻辑：Aware接口是Spring提供的扩展点，让Bean能主动获取容器的核心资源（如ApplicationContext、BeanName）。回调时机在属性注入之后、初始化之前。

常用Aware接口：

接口作用
BeanNameAware获取Bean在容器中的名称
ApplicationContextAware获取应用上下文（可用于动态获取其他Bean）
EnvironmentAware获取环境变量（如application.yml配置）
ResourceLoaderAware获取资源加载器（加载classpath下的文件）

代码示例（实现BeanNameAware与ApplicationContextAware）：

@Component
public class UserService implements BeanNameAware, ApplicationContextAware {
    private String beanName;
    private ApplicationContext applicationContext;

    // 3. BeanNameAware回调：获取Bean名称
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("3. BeanNameAware：beanName=" + name);
    }

    // 4. ApplicationContextAware回调：获取应用上下文
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
        System.out.println("4. ApplicationContextAware：获取ApplicationContext");
    }
}

注意事项：

  • 尽量避免过度依赖Aware接口（增加耦合度），仅在必须获取容器资源时使用（如动态获取Bean）；
  • 若需读取配置文件，优先使用@Value或@ConfigurationProperties，而非EnvironmentAware。

4. 初始化：自定义初始化逻辑

核心逻辑：初始化阶段用于执行自定义准备工作（如初始化缓存、连接数据库）。Spring提供三种初始化方式，执行顺序固定：
@PostConstruct → InitializingBean → 自定义init-method。

4.1 @PostConstruct注解（推荐）

@PostConstruct是JSR-250规范的注解（标准Java注解），标注在方法上，Spring会在属性注入完成后调用该方法。

代码示例：

@Component
public class UserService {
    @PostConstruct
    public void initByPostConstruct() {
        System.out.println("5. @PostConstruct：初始化缓存、校验属性");
        // 示例：初始化Redis缓存连接
        // redisTemplate.opsForValue().set("key", "value");
    }
}
4.2 InitializingBean接口

Spring提供的接口，需实现afterPropertiesSet()方法，执行时机在@PostConstruct之后。

代码示例：

@Component
public class UserService implements InitializingBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("6. InitializingBean：校验属性合法性");
        // 示例：校验数据库连接配置是否存在
        // if (dbUrl == null) throw new IllegalArgumentException("dbUrl未配置");
    }
}
4.3 自定义init-method

通过@Bean注解的init-method属性指定初始化方法（或XML中init-method配置），执行时机在InitializingBean之后。

代码示例：

@Configuration // 配置类
public class AppConfig {
    // 指定init-method为customInit
    @Bean(initMethod = "customInit")
    public UserService userService() {
        return new UserService();
    }
}

public class UserService {
    public void customInit() {
        System.out.println("7. 自定义init-method：初始化数据库连接池");
    }
}
初始化阶段最佳实践
  1. 优先使用@PostConstruct：标准注解，无框架耦合；
  2. 避免复杂逻辑：初始化方法应专注于资源准备（如连接池、缓存），而非业务逻辑；
  3. 校验属性合法性：确保必要配置项存在（如dbUrl、redisHost），避免运行时错误。

5. 就绪：Bean进入可用状态

核心逻辑：初始化完成后，Bean会被存入容器缓存（单例Bean存入singletonObjects三级缓存），此时Bean对外提供服务。

代码示例（获取可用Bean）：

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        // 启动SpringBoot应用，获取ApplicationContext
        ApplicationContext context = SpringApplication.run(Application.class, args);
        
        // 从容器中获取UserService（已就绪）
        UserService userService = context.getBean(UserService.class);
        System.out.println("8. 就绪：UserService可用，hashCode=" + userService.hashCode());
    }
}

6. 销毁：资源的释放与清理

核心逻辑：销毁阶段用于执行资源释放操作（如关闭数据库连接、停止线程池）。仅单例Bean会被Spring容器管理销毁；原型Bean（prototype）的销毁由调用者负责。

Spring提供三种销毁方式，执行顺序固定：
@PreDestroy → DisposableBean → 自定义destroy-method。

6.1 @PreDestroy注解（推荐）

@PreDestroy是JSR-250规范的注解，标注在方法上，Spring会在容器关闭前调用该方法。

代码示例：

@Component
public class UserService {
    @PreDestroy
    public void destroyByPreDestroy() {
        System.out.println("9. @PreDestroy：释放数据库连接池");
        // 示例：关闭Hikari连接池
        // dataSource.close();
    }
}
6.2 DisposableBean接口

Spring提供的接口，需实现destroy()方法，执行时机在@PreDestroy之后。

代码示例：

@Component
public class UserService implements DisposableBean {
    @Override
    public void destroy() throws Exception {
        System.out.println("10. DisposableBean：停止线程池");
        // 示例：关闭线程池
        // executorService.shutdown();
    }
}
6.3 自定义destroy-method

通过@Bean注解的destroy-method属性指定销毁方法（或XML中destroy-method配置），执行时机在DisposableBean之后。

代码示例：

@Configuration
public class AppConfig {
    // 指定destroy-method为customDestroy
    @Bean(destroyMethod = "customDestroy")
    public UserService userService() {
        return new UserService();
    }
}

public class UserService {
    public void customDestroy() {
        System.out.println("11. 自定义destroy-method：清空临时文件");
    }
}
销毁阶段最佳实践
  1. 优先使用@PreDestroy：标准注解，无框架耦合；
  2. 释放资源要彻底：确保数据库连接池、文件流、线程池等资源被正确关闭，避免内存泄漏；
  3. 单例Bean专属：原型Bean的销毁需调用者手动处理（如context.getBean("prototypeBean").destroy()）。

三、完整生命周期示例：整合所有阶段

以下示例整合了Bean生命周期的所有阶段，运行后可清晰看到执行顺序：

@Component
public class UserService implements BeanNameAware, ApplicationContextAware, InitializingBean, DisposableBean {
    @Autowired
    private UserRepository userRepository;

    private String beanName;
    private ApplicationContext applicationContext;

    // 1. 实例化：构造器
    public UserService() {
        System.out.println("1. 实例化：UserService构造器调用");
    }

    // 2. 属性注入：setter（可选，用于日志）
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
        System.out.println("2. 属性注入：注入UserRepository");
    }

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

    // 4. ApplicationContextAware回调
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
        System.out.println("4. ApplicationContextAware：获取ApplicationContext");
    }

    // 5. @PostConstruct初始化
    @PostConstruct
    public void postConstruct() {
        System.out.println("5. @PostConstruct：初始化缓存");
    }

    // 6. InitializingBean初始化
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("6. InitializingBean：校验属性");
    }

    // 7. @PreDestroy销毁
    @PreDestroy
    public void preDestroy() {
        System.out.println("9. @PreDestroy：释放连接池");
    }

    // 8. DisposableBean销毁
    @Override
    public void destroy() throws Exception {
        System.out.println("10. DisposableBean：停止线程池");
    }
}

// 启动类
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        System.out.println("=== SpringBoot应用启动 ===");
        ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);
        
        System.out.println("=== Bean就绪，开始使用 ===");
        UserService userService = context.getBean(UserService.class);
        
        System.out.println("=== 关闭容器 ===");
        context.close(); // 触发销毁逻辑
    }
}

运行输出结果（关键顺序）

=== SpringBoot应用启动 ===
1. 实例化：UserService构造器调用2. 属性注入：注入UserRepository
3. BeanNameAware：beanName=userService
4. ApplicationContextAware：获取ApplicationContext
5. @PostConstruct：初始化缓存
6. InitializingBean：校验属性
=== Bean就绪，开始使用 ===
=== 关闭容器 ===
9. @PreDestroy：释放连接池
10. DisposableBean：停止线程池

四、常见问题与注意事项

1. 循环依赖的处理

Spring能处理单例Bean的循环依赖（通过三级缓存singletonFactories），但无法处理构造器注入的循环依赖（构造器参数需依赖的Bean未创建）。解决方式：

  • 将构造器注入改为字段注入或setter注入；
  • 使用@Lazy注解延迟加载依赖（仅在首次使用时创建Bean）。

2. JDK版本对@PostConstruct的影响

JDK 9及以上版本移除了javax.annotation包（包含@PostConstruct/@PreDestroy），需手动添加依赖：

<dependency>
    <groupId>javax.annotation</groupId>
    <artifactId>javax.annotation-api</artifactId>
    <version>1.3.2</version>
</dependency>

3. 单例与原型Bean的生命周期差异

特性单例Bean（Singleton）原型Bean（Prototype）
实例数量容器中仅一个实例每次获取创建新实例
生命周期管理容器全程管理（创建→销毁）仅创建阶段由容器管理，销毁由调用者负责
销毁方法调用容器自动调用需手动调用

五、总结

SpringBoot中Bean的生命周期是容器管理组件的核心逻辑，理解各阶段的扩展点（如@PostConstruct、InitializingBean）如何构造器注入、优先使用标准注解等等，能帮助开发者：

  • 精准控制组件的初始化与销毁逻辑；
  • 避免资源泄漏与循环依赖问题；
  • 提升应用的稳定性与可维护性。

在实际开发中，应优先使用标准注解（如@PostConstruct）减少框架耦合，避免过度依赖Aware接口，并通过构造器注入保证依赖的不可变性。

最后：Bean的生命周期是Spring的基础知识点，任何博文都抵不过自己动手实操，建议结合本文代码示例实际运行，观察各阶段的执行顺序，加深理解。

深入理解Spring Boot生命周期
weixin_53840353的博客
04-19 2477
Spring Boot扫描项目中的注解，解析@Component@Service等注解，以及通过@Import导入的配置。Spring Boot生命周期的理解并不是一朝一夕能完成的。它要求开发者不断实践、探索和学习。通过深入了解各个生命周期阶段，开发者可以更加精准地控制应用的行为，提高开发效率，并确保应用稳定可靠地运行。本文只是对Spring Boot生命周期的一个初步介绍，但希望它能作为一个起点，帮助你开始在实践中更深入地理解和应用这些概念，从而构建更加强大和优雅的Spring Boot应用。
《滚雪球学SpringBoot》· 高质量专栏介绍，你值得拥有！
热门推荐
**My Coding Family**
07-08 1万+
《滚雪球学SpringBoot》 并不是普通的技术讲解合集，它是专为开发者精心设计的系统化学习路径。通过不断“滚动学习”，我们将带领你从基础入门到高阶应用，从理解每一行代码到设计和优化大规模分布式系统，最终帮助你成长为一位精通 spring架构 的工程师。
Spring Bean 实例化的基本流程
rqz__的博客
04-17 680
Spring Bean 可以是任何的 Java 类实例，其实例化方式可以通过 Spring 配置进行定义，配置方式可以是 XML、Java 注解或者 Java 代码方式。Spring 提供了丰富的功能支持，例如依赖注入（Dependency Injection）、切面编程（Aspect-oriented Programming）、事务处理等。通过这些功能，Spring Bean 可以更好地实现应用程序的松耦合设计和方便测试驱动开发等特性。
Spring Boot 中 Bean 的生命周期详解
qq_68883928的博客
04-11 1530
通过@Component@Service等注解定义或通过 XML 配置、Java 配置类 () 定义@Component@Override// 初始化逻辑@Override// 销毁逻辑Spring Boot 中 Bean 的生命周期是一个精心设计的过程，提供了多个扩展点供开发者干预。理解这些阶段和扩展点，能够帮助我们更好地控制组件的行为，构建更加健壮的应用。在实际开发中，应根据具体需求选择合适的干预方式，同时注意避免常见的陷阱和性能问题。
兄弟你来阐述一下Spring框架中Bean的生命周期？【云图智联】
06-10 345
1.Bean的生命周期 关于Bean的生命周期，如果我们不谈这个Spring的话，实际上很多人都会想到New，通过 New 对象的形式来实现对 Bean的实例化操作，而在我们不再使用 Bean 了之后，这时候我们的 Java 就会对这个指定的 Bean 来进行垃圾回收了。 但是对于Spring来说，Bean的生命周期可能就比较让人头疼了，毕竟 Spring 这么复杂，而且里面的对 Bean 管理的非常的有逻辑了，每一层都有每一层的步骤。 如果现在我们去百度上面去搜索所有的关于Spring的Bea...
springboot学习:bean生命周期
卫卫的博客
10-26 2772
1、bean 生命周期 bean创建—初始化—销毁 构造(对象创建)： 单实例：在容器启动的时候创建对象; 多实例：在每次获取的时候创建对象； 初始化： 对象创建完成，并赋值好，调用初始化方法 销毁： 单实例，容器关闭的时候； 多实例：容器不会管理bean，容器调用销毁方法 2、自定义初始化方法和销毁方法 2.1、通过@Bean指定初始化方法(initMethod)和销毁方法(destroyM...
SpringBoot Bean的生命周期
朗朗繁星的博客
09-17 4860
一般情况下，我们只是关心如何正确地将Bean装配到容器中，并不关心Ioc容器是如何装配和销毁Bean的过程。但是恰恰有时候，我们需要自定义初始化或销毁Bean的过程，以满足一些“特殊的”需求。比如，数据源在关闭的时候调用其close方法，这是项目开发过程中很常见的需求。 Bean的生命周期大致可以分为4个部分： 1. Bean的定义 2. Bean的初始化 3. Bean的生存期 4. Bean的销毁 Bean的定义 资源定位的过程。 如使用@ComponentScan定义的扫描路径去找@Com
SpringBoot中bean的生命周期
zhangjianfzf的博客
05-03 1478
Bean 生命周期管理是 Spring Boot 中的关键功能之一。它负责管理应用程序中的 Java 对象，这些对象被称为 Beans。Spring Boot 通过创建、配置、初始化和销毁这些 Beans 来确保应用程序的正常运行。这个功能的目的是提供一种灵活的方式，使开发人员能够轻松地管理对象的生命周期，从而实现高效的依赖注入和组件化开发。1、实例化：在 Spring 容器启动时，Spring 会创建配置中定义的所有 Bean。这是通过 Java 类的构造函数或工厂方法来完成的。
Springboot bean生命周期
q_2540638774的博客
06-10 854
生命周期 Bean的生命周期的过程，它大致分为Bean定义、Bean的初始化、Bean 的生存期和Bean的销毁4个部分。其中Bean定义过程大致如下： Spring通过我们的配置，如@ComponentScan 定义的扫描路径去找到带有 @Component的类，这个过程就是一个资源定位的过程。 一旦找到了资源，那么它就开始解析，并且将定义的信息保存起来。注意，此时还没有初始化Bean,也就没有Bean的实例，它有的仅仅是Bean的定义。 然后就会把Bean定义发布到SpringIoC容器中。此时，
springboot bean生命周期
zjshuster的博客
08-10 1900
springboot 生命周期
springboot-bean生命周期
zhouping118的博客
08-04 2064
1.spring bean生命周期 2.Aware接口 2.1.作用 一个标记，标记在spring容器初始化时需要获取上下文中当前的一些运行环境； 2.2.常用接口 ApplicationContextAware：获取ApplicationContext spring上下文； ApplicationEventPublisherAware：获取ApplicationEventPublisher事件发布器； BeanClassLoaderAware：获取当前的ClassLoader类加载器； BeanFac
SpringBoot Bean的生命周期demo.zip
09-17
一般情况下，我们只是关心如何正确地将Bean装配到容器中，并不关心Ioc容器是如何装配和销毁Bean的过程。但是恰恰有时候，我们需要自定义初始化或销毁Bean的过程，以满足一些“特殊的”需求。比如，数据源在关闭的时候调用其close方法，这是项目开发过程中很常见的需求。
spring-core-5.1.8中英文对照文档下载与使用
从应用场景来看，这份文档适用于多个层面的开发工作：初学者可通过它逐步理解Spring的核心概念如Bean生命周期、资源加载机制（Resource体系）、Environment抽象等；中级开发者可用其排查配置问题、理解自动装配规则...
扎实基础！深入理解Spring框架，解锁Java开发新境界
2501_91832086的博客
08-13 471
摘要：Spring框架是Java企业级开发的核心技术，通过控制反转(IoC)和依赖注入(DI)实现松耦合，提供面向切面编程(AOP)处理横切关注点。其轻量级设计、强大的容器管理和丰富的功能支持（如Spring MVC、事务管理、Security）大大简化了开发。学习重点包括IoC容器、DI实践、AOP实现、MVC框架及事务管理。建议通过实际项目逐步掌握核心概念，理解Bean生命周期和代理机制。系统学习Spring是提升Java工程能力的关键，为掌握SpringBoot等现代框架奠定基础。
Spring的注解 @Component 和 @Service 的不同？
最新发布
**My Coding Family**
10-18 806
🏆本文收录于《滚雪球学Spring Boot》，专门攻坚指数提升，2025 年国内最系统+最强（更新中）。    本专栏致力打造最硬核 Spring Boot 从零基础到进阶系列学习内容，🚀均为全网独家首发，打造精品专栏，专栏持续更新中…欢迎大家订阅持续学习。 如果想快速定位学习，可以看这篇【SpringBoot教程导航帖】,你想学习的都被收集在内，快速投入学习！！两不误。
【SpringSecurity】详细核心类与过滤器流程讲解和封装通用组件实战
xiaoxualg的博客
03-20 1485
Spring Security 是一个功能强大且高度可定制的认证和访问控制框架，是保护基于 Spring 的应用程序的标准工具。它是一个专注于为 Java 应用程序提供认证和授权的框架，实际上它是 Spring 生态系统中负责安全方面的重要成员。认证回答了"你是谁？"的问题，是确认用户身份的过程。核心工作流程：授权回答了"你能做什么？"的问题，是确定用户是否有权执行特定操作的过程。核心工作流程：表示当前通过认证的用户，通常包含用户标识（如用户名）和授予的权限。表示授予用户的特定权限，通常分为：Spring
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值