Spring Boot Bean生命周期详解

12/8/25About 8 min

1. 简介

Spring Boot作为当前最流行的Java企业级开发框架之一，其核心功能之一就是依赖注入（DI）和控制反转（IoC）。Bean作为Spring容器中管理的核心对象，其生命周期的管理是Spring框架的基础。了解Bean的生命周期对于深入理解Spring Boot的工作原理、进行性能优化以及排查问题都具有重要意义。

本文将详细解析Spring Boot中Bean的完整生命周期，包括从Bean的定义、实例化、初始化到销毁的各个阶段，并结合源码分析和可视化图表进行说明。

2. 架构原理与源码分析

2.1 Bean生命周期概述

Spring Boot中Bean的生命周期主要包括以下几个阶段：

Bean定义阶段：Spring容器加载配置文件或扫描注解，解析出Bean的定义信息
Bean实例化阶段：根据Bean定义创建Bean实例
属性赋值阶段：为Bean的属性注入依赖
初始化阶段：执行各种初始化回调方法
Bean使用阶段：Bean可以被应用程序使用
销毁阶段：容器关闭时执行销毁回调方法

2.2 详细流程与源码分析

2.2.1 Bean定义阶段

Bean定义阶段主要由BeanDefinitionReader和BeanDefinitionScanner负责，它们从XML配置文件或注解中解析出Bean的定义信息，并注册到BeanDefinitionRegistry中。

// Bean定义信息存储在BeanDefinition中
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
    // Bean定义的各种属性和方法
}

2.2.2 Bean实例化阶段

当容器需要一个Bean时，会调用BeanFactory的getBean()方法，该方法会触发Bean的实例化过程。实例化主要由InstantiationStrategy接口负责，默认实现是SimpleInstantiationStrategy和CglibSubclassingInstantiationStrategy。

// BeanFactory接口定义了获取Bean的方法
public interface BeanFactory {
    Object getBean(String name) throws BeansException;
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    // 其他方法
}

2.2.3 属性赋值阶段

实例化完成后，Spring容器会为Bean的属性注入依赖。这个过程主要由BeanWrapper接口负责，它包装了Bean实例并提供了属性访问的方法。

// BeanWrapper接口定义了属性访问的方法
public interface BeanWrapper extends ConfigurablePropertyAccessor {
    Object getWrappedInstance();
    Class<?> getWrappedClass();
    // 其他方法
}

2.2.4 初始化阶段

属性赋值完成后，Spring容器会执行Bean的初始化方法。初始化阶段包括以下几个步骤：

执行BeanNameAware的setBeanName()方法
执行BeanClassLoaderAware的setBeanClassLoader()方法
执行BeanFactoryAware的setBeanFactory()方法
执行ApplicationContextAware的setApplicationContext()方法
执行BeanPostProcessor的postProcessBeforeInitialization()方法
执行InitializingBean的afterPropertiesSet()方法
执行自定义的初始化方法（通过@PostConstruct注解或XML配置的init-method）
执行BeanPostProcessor的postProcessAfterInitialization()方法

// InitializingBean接口定义了初始化方法
public interface InitializingBean {
    void afterPropertiesSet() throws Exception;
}

// BeanPostProcessor接口定义了初始化前后的处理器方法
public interface BeanPostProcessor {
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}

2.2.5 Bean使用阶段

初始化完成后，Bean就可以被应用程序使用了。此时的Bean是完全初始化和配置好的，可以正常提供服务。

2.2.6 销毁阶段

当Spring容器关闭时，会执行Bean的销毁方法。销毁阶段包括以下几个步骤：

执行DisposableBean的destroy()方法
执行自定义的销毁方法（通过@PreDestroy注解或XML配置的destroy-method）

// DisposableBean接口定义了销毁方法
public interface DisposableBean {
    void destroy() throws Exception;
}

3. 生命周期流程图

下面是Spring Boot中Bean的完整生命周期流程图：

4. 使用场景

了解Bean的生命周期对于以下场景非常有用：

资源管理：在Bean初始化时获取资源（如数据库连接、文件句柄等），在销毁时释放资源
缓存初始化：在Bean初始化时加载缓存数据，提高系统性能
依赖检查：在Bean初始化阶段检查必要的依赖是否已正确注入
配置验证：在Bean初始化阶段验证配置参数的有效性
AOP代理：通过BeanPostProcessor实现AOP代理功能

5. 代码示例

下面是一个展示Bean生命周期各个阶段的代码示例：

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class LifecycleBean implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean {

    private String name;

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

    public void setName(String name) {
        this.name = name;
        System.out.println("2. 属性赋值执行: name = " + name);
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("3. BeanNameAware.setBeanName()执行: " + name);
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("4. BeanClassLoaderAware.setBeanClassLoader()执行");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("5. BeanFactoryAware.setBeanFactory()执行");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("6. ApplicationContextAware.setApplicationContext()执行");
    }

    @PostConstruct
    public void postConstruct() {
        System.out.println("7. @PostConstruct注解方法执行");
    }

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

    public void customInit() {
        System.out.println("9. 自定义init方法执行");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println("10. @PreDestroy注解方法执行");
    }

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

    public void customDestroy() {
        System.out.println("12. 自定义destroy方法执行");
    }

    public void doSomething() {
        System.out.println("Bean使用中: name = " + name);
    }
}

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("TestBean");
        return bean;
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);
        LifecycleBean bean = context.getBean(LifecycleBean.class);
        bean.doSomething();
        context.close();
    }
}

运行上述代码，控制台输出如下：

1. Bean构造方法执行
2. 属性赋值执行: name = TestBean
3. BeanNameAware.setBeanName()执行: lifecycleBean
4. BeanClassLoaderAware.setBeanClassLoader()执行
5. BeanFactoryAware.setBeanFactory()执行
6. ApplicationContextAware.setApplicationContext()执行
7. @PostConstruct注解方法执行
8. InitializingBean.afterPropertiesSet()执行
9. 自定义init方法执行
Bean使用中: name = TestBean
10. @PreDestroy注解方法执行
11. DisposableBean.destroy()执行
12. 自定义destroy方法执行

6. 性能优化建议

延迟初始化：对于不常用的Bean，可以使用@Lazy注解或XML配置的lazy-init="true"进行延迟初始化，减少应用启动时间。
原型Bean的使用：原型Bean每次获取都会创建新实例，避免使用过多原型Bean导致内存占用过高。
BeanPostProcessor的优化：BeanPostProcessor会对所有Bean生效，避免在其中执行耗时操作，必要时可以通过@Order注解指定执行顺序。
资源管理：确保在Bean销毁阶段正确释放资源，避免内存泄漏。
减少初始化逻辑：将耗时的初始化逻辑移到异步方法中执行，提高应用启动速度。