Spring Bean初始化三种常用方式（详细易懂版）

古城小栈2025-12-02 8:44

在Spring框架开发中，Bean的生命周期管理是核心基础知识点，而Bean初始化作为生命周期中的关键环节，负责在Bean实例创建并完成依赖注入后，执行资源加载、参数配置、缓存初始化等核心业务逻辑。本文将从"是什么-怎么用-为什么"的角度，详细拆解Spring中3种主流的Bean初始化方式，每种方式均提供完整可运行的代码示例，并补充执行顺序验证、场景对比及实战注意事项，帮助新手快速掌握并灵活运用。

核心前提：Bean初始化的触发时机------Spring容器创建Bean实例 → 完成所有属性的依赖注入（如@Autowired、构造器注入） → 执行初始化方法（本文重点） → Bean实例可用。

一、方式1：@PostConstruct注解修饰初始化方法

1.1 核心说明

@PostConstruct是JSR-250规范（Java EE标准）中定义的注解，并非Spring框架专属，因此具有良好的通用性（可跨框架使用）。该注解仅需修饰在Bean的非静态方法上（无参数、无返回值），当Spring容器完成Bean实例创建和依赖注入后，会自动调用该方法执行初始化逻辑。

依赖要求：JDK9及以上版本中，javax.annotation-api包已被移除，需手动引入依赖（Maven示例如下）；JDK8及以下版本可直接使用。

xml 复制代码 
<dependency>
    <groupId>jakarta.annotation</groupId>
    <artifactId>jakarta.annotation-api</artifactId>
    <version>2.1.1</version>
</dependency>

1.2 完整代码示例

示例包含4个核心类：依赖Bean（UserDao）、目标Bean（UserService，含@PostConstruct初始化方法）、Spring配置类（注册Bean）、测试类（启动容器验证）。

java 复制代码 
// 1. 依赖Bean：UserDao（模拟数据访问层，仅作注入示例）
public class UserDao {
    // 模拟UserDao的基础功能
    public void initDao() {
        System.out.println("UserDao实例已创建");
    }
}

// 2. 目标Bean：UserService（核心业务类，含@PostConstruct初始化方法）
import javax.annotation.PostConstruct;

public class UserService {
    // 依赖注入UserDao（通过构造器注入，Spring会自动匹配）
    private final UserDao userDao;

    // 构造器：Spring容器会通过该构造器注入UserDao实例
    public UserService(UserDao userDao) {
        this.userDao = userDao;
        System.out.println("UserService构造方法执行：已注入UserDao");
        // 注意：此处仅完成属性注入，Bean尚未初始化，不建议执行业务逻辑
    }

    // @PostConstruct修饰的初始化方法：Spring自动调用
    @PostConstruct
    public void initUserService() {
        System.out.println("@PostConstruct初始化方法执行：");
        System.out.println("  - 加载用户模块配置文件");
        System.out.println("  - 初始化用户缓存（如Redis用户信息预热）");
        System.out.println("  - 校验用户服务依赖资源（如数据库连接）");
        // 实际开发中可在此处编写核心初始化逻辑
    }

    // 模拟业务方法（验证Bean可用）
    public void getUserInfo() {
        System.out.println("执行用户查询业务：依赖UserDao完成数据获取");
    }
}

// 3. Spring配置类：SpringConfig（注解式配置，替代XML）
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration // 标识该类为Spring配置类
public class SpringConfig {
    // 注册UserDao Bean：Spring容器会管理该实例
    @Bean
    public UserDao userDao() {
        UserDao userDao = new UserDao();
        userDao.initDao(); // 可选：Dao层自身的简单初始化
        return userDao;
    }

    // 注册UserService Bean：注入UserDao依赖
    @Bean
    public UserService userService(UserDao userDao) {
        // Spring会自动将上面注册的UserDao实例传入构造器
        return new UserService(userDao);
    }
}

// 4. 测试类：BeanInitTest（启动Spring容器，验证初始化流程）
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class BeanInitTest {
    public static void main(String[] args) {
        // 1. 启动Spring容器（加载注解配置）
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        System.out.println("=== Spring容器启动完成 ===");
        
        // 2. 获取UserService Bean，验证其可用
        UserService userService = context.getBean(UserService.class);
        userService.getUserInfo();
        
        // 3. 关闭容器（释放资源）
        context.close();
    }
}

1.3 运行结果与解读

text 复制代码 
UserDao实例已创建
UserService构造方法执行：已注入UserDao
@PostConstruct初始化方法执行：
  - 加载用户模块配置文件
  - 初始化用户缓存（如Redis用户信息预热）
  - 校验用户服务依赖资源（如数据库连接）
=== Spring容器启动完成 ===
执行用户查询业务：依赖UserDao完成数据获取

解读：从结果可见，执行顺序为「UserDao实例创建 → UserService构造方法（注入依赖） → @PostConstruct初始化方法 → Bean可用」，完全符合Spring Bean的初始化触发时机。

二、方式2：实现InitializingBean接口（Spring原生方式）

2.1 核心说明

InitializingBean是Spring框架提供的原生接口，仅包含一个抽象方法：void afterPropertiesSet() throws Exception。当Bean实现该接口后，Spring容器在完成Bean实例创建和属性注入后，会自动调用afterPropertiesSet()方法执行初始化逻辑。

特点：与Spring框架强耦合（Bean直接依赖Spring API），但执行时机精准，无需额外配置，适合需要深度对接Spring生命周期的场景。

2.2 完整代码示例

基于方式1的基础代码修改，仅需调整UserService类（实现InitializingBean接口），其他类（UserDao、SpringConfig、测试类）保持不变。

java 复制代码 
// 目标Bean：UserService（实现InitializingBean接口）
import org.springframework.beans.factory.InitializingBean;

public class UserService implements InitializingBean {
    private final UserDao userDao;

    // 构造器注入UserDao
    public UserService(UserDao userDao) {
        this.userDao = userDao;
        System.out.println("UserService构造方法执行：已注入UserDao");
    }

    // 重写InitializingBean的afterPropertiesSet()方法：Spring自动调用
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean初始化方法（afterPropertiesSet）执行：");
        System.out.println("  - 初始化用户服务核心组件");
        System.out.println("  - 校验UserDao依赖是否正常可用");
        System.out.println("  - 加载用户权限配置");
    }

    // 模拟业务方法
    public void getUserInfo() {
        System.out.println("执行用户查询业务：依赖UserDao完成数据获取");
    }
}

2.3 运行结果与解读

text 复制代码 
UserDao实例已创建
UserService构造方法执行：已注入UserDao
InitializingBean初始化方法（afterPropertiesSet）执行：
  - 初始化用户服务核心组件
  - 校验UserDao依赖是否正常可用
  - 加载用户权限配置
=== Spring容器启动完成 ===
执行用户查询业务：依赖UserDao完成数据获取

解读：无需额外注解或配置，仅通过实现接口即可完成初始化逻辑的自动执行，适合Spring专属项目的开发场景。但需注意：若后续更换框架，该Bean需修改代码（解耦成本高）。

三、方式3：通过init-method配置自定义初始化方法

3.1 核心说明

init-method是Spring提供的"配置式"初始化方式，支持两种配置形式：① 注解配置（@Bean注解的initMethod属性）；② XML配置（传统Spring项目常用）。该方式允许开发者自定义初始化方法名（无参数、无返回值），通过配置指定后，Spring容器会在Bean依赖注入完成后调用该方法。

特点：完全解耦（不依赖任何注解或接口），灵活性最高，适合传统项目、旧代码兼容或需要自定义方法名的场景。

3.2 代码示例1：注解配置（@Bean(initMethod = "方法名")）

核心修改：UserService类中定义自定义初始化方法，SpringConfig类中通过@Bean指定initMethod属性。

java 复制代码 
// 1. 目标Bean：UserService（含自定义初始化方法）
public class UserService {
    private final UserDao userDao;

    // 构造器注入UserDao
    public UserService(UserDao userDao) {
        this.userDao = userDao;
        System.out.println("UserService构造方法执行：已注入UserDao");
    }

    // 自定义初始化方法（方法名可任意，如init、customInit等）
    public void userServiceInit() {
        System.out.println("init-method（注解配置）初始化方法执行：");
        System.out.println("  - 初始化用户模块日志组件");
        System.out.println("  - 加载用户业务规则配置");
        System.out.println("  - 初始化用户数据统计缓存");
    }

    // 模拟业务方法
    public void getUserInfo() {
        System.out.println("执行用户查询业务：依赖UserDao完成数据获取");
    }
}

// 2. Spring配置类：通过@Bean指定initMethod
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SpringConfig {
    @Bean
    public UserDao userDao() {
        UserDao userDao = new UserDao();
        userDao.initDao();
        return userDao;
    }

    // 关键：通过initMethod属性指定自定义初始化方法名（userServiceInit）
    @Bean(initMethod = "userServiceInit")
    public UserService userService(UserDao userDao) {
        return new UserService(userDao);
    }
}

运行结果（其他类不变）：

text 复制代码 
UserDao实例已创建
UserService构造方法执行：已注入UserDao
init-method（注解配置）初始化方法执行：
  - 初始化用户模块日志组件
  - 加载用户业务规则配置
  - 初始化用户数据统计缓存
=== Spring容器启动完成 ===
执行用户查询业务：依赖UserDao完成数据获取

3.3 代码示例2：XML配置（传统Spring项目）

对于使用XML配置的传统Spring项目（如SSM框架），可通过标签的init-method属性指定初始化方法。核心修改：移除注解配置，编写XML配置文件。

xml 复制代码 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    
    <bean id="userDao" class="com.example.UserDao"></bean>

    
    <bean id="userService" class="com.example.UserService" init-method="userServiceInit">
        
        <constructor-arg ref="userDao"/>
    </bean>
</beans>
java 复制代码 
// 2. 测试类（加载XML配置启动容器）
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BeanInitXmlTest {
    public static void main(String[] args) {
        // 加载XML配置文件启动Spring容器
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("=== Spring容器启动完成 ===");
        
        // 获取Bean并验证
        UserService userService = context.getBean(UserService.class);
        userService.getUserInfo();
        
        // 关闭容器
        context.close();
    }
}

运行结果与注解配置一致，适合不使用注解的传统项目场景。

四、关键补充：三种方式的执行顺序验证

若同一Bean同时使用三种初始化方式，执行顺序如何？我们通过代码验证（核心修改UserService类，同时包含三种方式）：

java 复制代码 
import org.springframework.beans.factory.InitializingBean;
import javax.annotation.PostConstruct;

public class UserService implements InitializingBean {
    private final UserDao userDao;

    public UserService(UserDao userDao) {
        this.userDao = userDao;
        System.out.println("1. UserService构造方法执行");
    }

    // 方式1：@PostConstruct
    @PostConstruct
    public void initByPostConstruct() {
        System.out.println("2. @PostConstruct初始化方法执行");
    }

    // 方式2：InitializingBean
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("3. InitializingBean（afterPropertiesSet）执行");
    }

    // 方式3：init-method自定义方法
    public void userServiceInit() {
        System.out.println("4. init-method初始化方法执行");
    }
}

SpringConfig配置：@Bean(initMethod = "userServiceInit")，运行结果：

text 复制代码 
UserDao实例已创建
1. UserService构造方法执行
2. @PostConstruct初始化方法执行
3. InitializingBean（afterPropertiesSet）执行
4. init-method初始化方法执行
=== Spring容器启动完成 ===

结论：执行顺序固定为 → @PostConstruct（1）→ InitializingBean（2）→ init-method（3）。

五、三种方式对比表（实战选型依据）

初始化方式 执行顺序 核心优势 潜在缺点 适用场景
@PostConstruct注解 1（最先） 1. 基于JSR-250规范，跨框架通用；2. 低耦合（不依赖Spring）；3. 使用简单（仅需注解） JDK9+需手动引入jakarta.annotation-api依赖 绝大多数注解式开发场景（如Spring Boot项目），追求框架解耦
实现InitializingBean接口 2（中间） 1. Spring原生支持，执行时机精准；2. 无需额外配置（仅实现接口） 1. 与Spring强耦合；2. 代码侵入性高（Bean需实现特定接口） 需要深度对接Spring生命周期，或Spring专属项目
init-method配置（注解/XML） 3（最后） 1. 完全解耦（无注解/接口依赖）；2. 灵活性最高（自定义方法名）；3. 支持XML/注解双配置 1. 注解配置需手动指定方法名（易写错）；2. XML配置较繁琐 1. 传统XML配置项目；2. 旧代码兼容；3. 需自定义初始化方法名的场景

六、实战注意事项（避坑指南）

  • 初始化方法需满足：无参数、无返回值，且不能是静态方法（static修饰会导致Spring无法调用）。

  • @PostConstruct依赖问题：JDK9及以上版本需引入jakarta.annotation-api依赖，否则会报"找不到@PostConstruct注解"错误。

  • 避免在构造器中执行初始化逻辑：构造器仅负责属性注入，此时Bean尚未完全创建，若执行业务逻辑可能导致依赖未就绪（如NullPointerException）。

  • init-method方法名匹配：注解配置（@Bean(initMethod)）或XML配置时，方法名需与Bean中的自定义方法名完全一致（大小写敏感），否则Spring无法识别。

  • 多初始化方式共存：实际开发中不建议同一Bean同时使用多种方式（易造成逻辑混乱），优先选择一种符合项目技术栈的方式即可。

七、总结

本文详细讲解了Spring Bean初始化的三种核心方式，结合完整代码示例、执行顺序验证、场景对比及避坑指南，可总结为：

  1. 优先选择：@PostConstruct注解（通用性强、低耦合，适合Spring Boot等注解式项目）；

  2. 特殊场景：实现InitializingBean接口（Spring专属项目，需精准对接生命周期）；

  3. 兼容场景：init-method配置（传统XML项目、旧代码兼容，完全解耦）。

掌握这三种方式的核心逻辑和适用场景，能帮助你在实际开发中灵活处理Bean的初始化需求，避免踩坑。若需进一步学习Bean的销毁方式（如@PreDestroy、DisposableBean接口、destroy-method配置），可留言补充~

相关推荐
小小码农一只1 小时前
Spring WebFlux与响应式编程：构建高效的异步Web应用
java·前端·spring·spring webflux
Dest1ny-安全1 小时前
CTF 及网络安全相关平台汇总表
java·运维·服务器·python·安全·web安全
2401_837088501 小时前
Redis List 的消息队列
数据库·redis·缓存
j***12151 小时前
Spring容器初始化扩展点：ApplicationContextInitializer
java·后端·spring
s***P9821 小时前
【Sql Server】随机查询一条表记录，并重重温回顾下自定义函数的封装和使用
数据库·性能优化
懒惰蜗牛1 小时前
Day65 | Java网络编程之TCP/IP协议
java·网络·tcp/ip·网络编程·osi七层模型·tcp/ip四层模型
k***82511 小时前
Spring注解
java·后端·spring
豆奶特浓61 小时前
谢飞机迎战金融风控面试：从Spring WebFlux、Elasticsearch到AI模型，他能扛住吗？
java·elasticsearch·微服务·ai·面试·spring webflux·金融风控
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03BongoCat - 跨平台键盘猫动画工具04安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）05Linux下V2Ray安装配置指南06本地部署阿里最新开源的Z-Image07【保姆级教程】免费使用Gemini3的5种方法！免翻墙/国内直连0846个Nano-banana 精选提示词，持续更新中09Labelme从安装到标注：零基础完整指南10Gemini 3.0 Pro Preview 实测报告