深入剖析Spring Boot依赖注入顺序：从原理到实战

引言

"为什么我的Bean注入是null？"、"@PostConstruct方法里调用其他Bean为什么会失败？"------这些问题你是否遇到过？究其根源，往往是对Spring Boot中依赖注入的顺序理解不够深入。

Spring Boot的依赖注入（Dependency Injection, DI）远不止是加一个@Autowired注解那么简单。它背后是一套严谨的容器启动生命周期。理解这个顺序，不仅能让你避免低级错误，更能让你设计出更优雅、健壮的应用。今天，我们就来彻底揭开这层神秘面纱。

一、核心概念：两个"顺序"的区别

在深入之前，我们必须理清一个关键点：谈论"顺序"时，通常指两个方面：

1. Bean的创建与实例化顺序：Spring IoC容器中，哪个Bean先被创建，哪个后被创建。
2. 单个Bean的生命周期顺序：一个Bean从被容器识别到完全初始化，所经历的一系列步骤。

后者是前者的基础，也是本文的重点。

二、Bean的完整生命周期与注入时机

下图清晰地展示了一个Bean从无到有所经历的完整生命周期，特别是依赖注入发生的关键位置：

让我们来详细解读图中的每一个关键步骤。

1. Bean定义加载（Definition Loading）

在容器刷新阶段，Spring会先解析所有配置，将Bean"蓝图"注册到工厂。这是通过BeanFactoryPostProcessor完成的，其中最核心的是ConfigurationClassPostProcessor。

• 它负责：

  • 扫描@ComponentScan指定的包，识别@Component, @Service, @Controller, @Repository等注解的类。
  • 解析@Configuration类中的@Bean方法。
  • 处理@Import和@PropertySource等注解。

💡 关键 ：此时只是注册了Bean的定义（BeanDefinition），Bean的实例还未创建，依赖也远未注入。

2. [实例化]（Instantiation）

当Spring开始创建Bean实例时（通常是应用启动时，针对单例和非懒加载的Bean），第一步就是调用Bean的构造方法。

@Component
public class ExampleBean {
    
    // 第1步：静态字段/静态块（JVM级别，最早执行）
    private static final String STATIC_FIELD = "static";
    static {
        System.out.println("1. 静态块执行");
    }
    
    // 第2步：实例字段初始化（Java对象初始化）
    private String instanceField = "instance";
    {
        System.out.println("2. 实例初始化块执行");
    }
    
    // 第3步：构造器执行（此时依赖注入还未开始）
    public ExampleBean() {
        System.out.println("3. 构造器执行");
        // 此时@Autowired字段都是null，@Value字段都是默认值
    }
}
AI写代码java
运行

⚠️ 警告 ：在构造方法中，不要尝试调用依赖的其他Bean的方法，因为依赖注入尚未发生，这些引用仍然是null。

3. 依赖注入（Dependency Injection）

@Component
public class ExampleBean {
    
    // 第4步：字段注入（@Autowired, @Value, @Resource等）
    @Value("${config.value}")
    private String configValue;  // 此时注入配置值
    
    @Autowired
    private OtherService otherService;  // 此时注入依赖Bean
    
    // 第5步：Setter方法注入（如果有的话）
    private AnotherService anotherService;
    
    @Autowired
    public void setAnotherService(AnotherService anotherService) {
        System.out.println("5. Setter注入执行");
        this.anotherService = anotherService;
    }
}
AI写代码java
运行

4、初始化后阶段

@Component
public class ExampleBean implements InitializingBean {
    
    // 第6步：@PostConstruct方法执行
    @PostConstruct
    public void postConstruct() {
        System.out.println("6. @PostConstruct方法执行");
        // 所有依赖注入已完成，可以安全使用注入的字段
    }
    
    // 第7步：InitializingBean接口方法
    @Override
    public void afterPropertiesSet() {
        System.out.println("7. InitializingBean.afterPropertiesSet执行");
    }
    
    // 第8步：自定义init方法（如果有配置）
    public void customInit() {
        System.out.println("8. 自定义init方法执行");
    }
}
AI写代码java
运行

5、完整的顺序示例

@Component
public class CompleteExample {
    
    // 阶段1：实例化
    private static final String STATIC = "static";
    static {
        System.out.println("1. 静态块");
    }
    
    private String instanceField = "instance";
    {
        System.out.println("2. 实例初始化块");
    }
    
    public CompleteExample() {
        System.out.println("3. 构造器 - configValue: " + configValue); // null
    }
    
    // 阶段2：依赖注入
    @Value("${example.value:default}")
    private String configValue;
    
    @Autowired
    private DependencyService dependency;
    
    @Autowired
    public void setDependency(DependencyService dep) {
        System.out.println("4. Setter注入 - configValue: " + configValue); // 已注入
    }
    
    // 阶段3：初始化后
    @PostConstruct
    public void init() {
        System.out.println("5. @PostConstruct - configValue: " + configValue); // 正确值
        System.out.println("5. @PostConstruct - dependency: " + dependency); // 已注入
    }
}
AI写代码java
运行

6、各种注入方式的顺序比较

注入方式	执行时机	推荐度	特点
构造器注入	第3步	★★★★★	强依赖，不可变，推荐
字段注入	第4步	★★★☆☆	简单但不可变
Setter注入	第5步	★★★★☆	可选依赖，可变
@PostConstruct	第6步	★★★★★	初始化逻辑

总结

依赖注入顺序：

1. 静态初始化（JVM级别）
2. 实例字段初始化（Java对象初始化）
3. 构造器执行
4. 字段注入（@Autowired, @Value）
5. Setter方法注入
6. @PostConstruct方法
7. InitializingBean接口
8. 自定义init方法