Spring Bean生命周期：初始化与销毁的四种方式详解-代码聚汇网

Spring Bean生命周期：初始化与销毁的四种方式详解

不靠谱的糖饼·2026-08-21·阅读 22 GEO检测（免费）

Spring Bean生命周期InitializingBeanDisposableBean

|难度：普通|阅读约 18 分钟

1. Spring Bean生命周期概述

在Spring框架中，Bean的生命周期管理是其核心功能之一。理解Bean的初始化和销毁机制，对于开发健壮的企业级应用至关重要。Spring提供了多种灵活的方式来控制Bean的创建和销毁过程，每种方式都有其适用场景和优缺点。

Bean的生命周期可以简单概括为：实例化→属性赋值→初始化→使用→销毁。其中初始化和销毁是两个开发者最常需要干预的阶段。初始化阶段通常用于完成资源加载、数据校验、连接建立等准备工作；而销毁阶段则用于释放资源、保存状态、关闭连接等清理工作。

提示：Spring容器在关闭时不会自动调用所有Bean的销毁方法，需要通过ConfigurableApplicationContext的registerShutdownHook()或close()方法显式触发。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 初始化Bean的四种核心方式

2.1 实现InitializingBean接口

InitializingBean是Spring提供的标准接口，包含一个afterPropertiesSet()方法：

java复制public class DatabaseInitializer implements InitializingBean {
    private DataSource dataSource;
    
    @Override
    public void afterPropertiesSet() throws Exception {
        // 在所有属性设置完成后执行
        try (Connection conn = dataSource.getConnection()) {
            // 初始化数据库表结构
            ScriptUtils.executeSqlScript(conn, new ClassPathResource("init.sql"));
        }
    }
    
    // setter方法...
}

这种方式的特点是：

执行时机：在所有依赖注入完成后立即调用
优点：直接实现接口，方法名明确
缺点：与Spring API强耦合，不推荐在现代Spring应用中使用

2.2 使用@PostConstruct注解

JSR-250提供的标准注解，更加推荐使用：

java复制public class CacheManager {
    private Map<String, Object> cache;
    
    @PostConstruct
    public void initCache() {
        this.cache = new ConcurrentHashMap<>();
        // 预热缓存
        loadPopularItems();
    }
    
    private void loadPopularItems() {
        // 加载热点数据...
    }
}

关键特性：

方法名可以自定义，只需添加@PostConstruct注解
执行顺序：在依赖注入之后，InitializingBean.afterPropertiesSet()之前
是当前Spring Boot应用中的首选方式

2.3 指定init-method方法

在XML配置或Java配置中指定初始化方法：

XML配置方式：

xml复制<bean id="messageService" class="com.example.MessageService" 
      init-method="startMessageBroker"/>

Java配置方式：

java复制@Bean(initMethod = "init")
public OrderService orderService() {
    return new OrderService();
}

public class OrderService {
    public void init() {
        // 初始化逻辑
    }
}

这种方式的优势：

完全解耦，不需要实现任何Spring接口
可以复用已有的初始化方法
适合整合第三方库的场景

2.4 @Bean注解的initMethod属性

在配置类中使用@Bean注解时直接指定：

java复制@Configuration
public class AppConfig {
    @Bean(initMethod = "connect")
    public FtpClient ftpClient() {
        return new FtpClient();
    }
}

public class FtpClient {
    public void connect() {
        // 建立FTP连接
    }
}

执行顺序说明：

构造函数执行
依赖注入完成
@PostConstruct方法
InitializingBean.afterPropertiesSet()
自定义init方法

3. 销毁Bean的四种核心方式

3.1 实现DisposableBean接口

与InitializingBean对应的销毁接口：

java复制public class ResourceHolder implements DisposableBean {
    private List<Connection> connections;
    
    @Override
    public void destroy() throws Exception {
        for (Connection conn : connections) {
            try {
                if (!conn.isClosed()) {
                    conn.close();
                }
            } catch (SQLException e) {
                log.error("关闭连接失败", e);
            }
        }
    }
}

注意事项：

确保在destroy()方法中处理所有异常
避免在销毁阶段抛出异常导致其他Bean无法正常销毁

3.2 使用@PreDestroy注解

JSR-250标准注解，推荐使用：

java复制public class WebSocketHandler {
    private Session session;
    
    @PreDestroy
    public void cleanup() {
        if (session != null && session.isOpen()) {
            session.close();
        }
    }
}

执行顺序：

@PreDestroy方法
DisposableBean.destroy()
自定义destroy方法

3.3 指定destroy-method方法

与init-method对应的销毁配置：

XML配置：

xml复制<bean id="fileProcessor" class="com.example.FileProcessor"
      destroy-method="releaseResources"/>

Java配置：

java复制@Bean(destroyMethod = "shutdown")
public ThreadPoolTaskExecutor taskExecutor() {
    // 创建线程池...
}

3.4 @Bean注解的destroyMethod属性

java复制@Bean(destroyMethod = "disconnect")
public ChatServer chatServer() {
    return new ChatServer();
}

public class ChatServer {
    public void disconnect() {
        // 断开所有客户端连接
    }
}

特殊值说明：

设置destroyMethod=""可以禁用默认推断的关闭方法
对于DataSource等常见组件，Spring会自动推断close()或shutdown()方法

4. 初始化与销毁的执行顺序与陷阱

4.1 完整生命周期执行顺序

构造函数执行
依赖注入(setter/字段注入)
BeanPostProcessor.postProcessBeforeInitialization()
@PostConstruct方法
InitializingBean.afterPropertiesSet()
自定义init方法
BeanPostProcessor.postProcessAfterInitialization()
Bean准备就绪，可供使用
容器关闭时@PreDestroy方法
DisposableBean.destroy()
自定义destroy方法

4.2 常见问题排查

问题1：初始化方法未执行

检查Bean是否被Spring管理（是否有@Component等注解）
确认@PostConstruct是否被正确导入（javax.annotation）
查看是否有BeanPostProcessor拦截了初始化过程

问题2：销毁方法未执行

确保调用了context.registerShutdownHook()或close()
检查destroy方法是否可访问（非private）
确认没有其他异常导致容器异常终止

问题3：循环依赖中的初始化顺序

java复制@Component
public class ServiceA {
    @Autowired
    private ServiceB serviceB;
    
    @PostConstruct
    public void init() {
        // 可能依赖ServiceB的初始化状态
    }
}

@Component
public class ServiceB {
    @Autowired 
    private ServiceA serviceA;
    
    @PostConstruct
    public void init() {
        // 可能依赖ServiceA的初始化状态
    }
}

解决方案：

重构设计，避免循环依赖
使用@DependsOn明确指定依赖顺序
将初始化逻辑移到使用方法中（懒加载）

5. 高级应用场景

5.1 组合使用多种初始化方式

java复制public class ComplexService implements InitializingBean {
    @PostConstruct
    public void postConstruct() {
        // 第一阶段初始化
    }
    
    @Override
    public void afterPropertiesSet() {
        // 第二阶段初始化
    }
    
    @Bean(initMethod = "finalSetup")
    public void finalSetup() {
        // 最终配置
    }
}

执行顺序保证：

@PostConstruct
afterPropertiesSet()
finalSetup()

5.2 使用BeanPostProcessor全局处理

实现BeanPostProcessor接口可以对所有Bean的初始化过程进行拦截：

java复制@Component
public class TimingBeanPostProcessor 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;
    }
}

5.3 针对原型(prototype)Bean的特殊处理

对于scope="prototype"的Bean：

初始化方法每次创建新实例时都会调用
销毁方法不会被自动调用，需要手动管理
可以通过实现DisposableBean并手动调用destroy()方法

java复制@Scope("prototype")
@Component
public class PrototypeBean implements DisposableBean {
    @Override
    public void destroy() {
        // 需要手动触发
    }
}

// 使用方
public class Client {
    @Autowired
    private ApplicationContext context;
    
    public void process() {
        PrototypeBean bean = context.getBean(PrototypeBean.class);
        try {
            // 使用bean...
        } finally {
            ((DisposableBean) bean).destroy();
        }
    }
}

5.4 使用SmartInitializingSingleton处理单例初始化

在所有单例Bean初始化完成后执行：

java复制@Component
public class CacheWarmupper implements SmartInitializingSingleton {
    @Autowired
    private List<CacheableService> services;
    
    @Override
    public void afterSingletonsInstantiated() {
        services.forEach(CacheableService::warmupCache);
    }
}

这个接口特别适合：

缓存预热
应用启动后的数据校验
依赖所有其他Bean的初始化任务