面试官：Spring 如何控制 Bean 的加载顺序？

在大多数情况下，我们不需要手动控制 Bean 的加载顺序，因为 Spring 的 IoC 容器足够智能。

核心原则：依赖驱动加载

Spring IoC 容器会构建一个依赖关系图（Dependency Graph）。如果 Bean A 依赖于 Bean B（例如，A 的构造函数需要一个 B 类型的参数），Spring 会保证在创建 Bean A 之前，Bean B 已经被完全创建和初始化好了。

@Service
public class ServiceA {
    private final ServiceB serviceB;

    // 因为 ServiceA 在构造时需要 ServiceB，
    // Spring 保证 serviceB 会先被创建。
    @Autowired
    public ServiceA(ServiceB serviceB) {
        this.serviceB = serviceB;
        System.out.println("ServiceA 初始化了，此时 ServiceB 已经可用。");
    }
}

@Service
public class ServiceB {
    public ServiceB() {
        System.out.println("ServiceB 初始化了。");
    }
}

// 输出结果：
// ServiceB 初始化了。
// ServiceA 初始化了，此时 ServiceB 已经可用。

但是，在某些特殊场景下，这种隐式的依赖关系可能不存在，我们需要强制一个特定的初始化顺序。这时就需要手动控制。

手动控制 Bean 加载顺序的方法

以下是几种常用的手动控制方法。

方法 1：使用 @DependsOn (最直接、最明确)

@DependsOn 注解可以直接声明一个 Bean 在初始化之前，必须先初始化另一个Bean。这用于处理没有直接依赖关系（即 A 类中没有 B 类的字段引用），但存在逻辑上或“副作用”上的依赖（比如 B 必须先初始化数据库表，A 才能去操作它）。

场景：一个 DatabaseInitializer 负责创建数据库表，而一个 DataImporter 负责向这些表中导入数据。DataImporter 并没有直接注入 DatabaseInitializer，但它依赖于 DatabaseInitializer 的工作先完成。

// Bean A: 数据导入器
@Component
@DependsOn("databaseInitializer") // <-- 关键点
public class DataImporter {
    public DataImporter() {
        System.out.println("DataImporter: 开始导入数据...（此时数据库表一定已创建）");
        // ...导入逻辑...
    }
}

// Bean B: 数据库初始化器
@Component("databaseInitializer") // 注意Bean的名字
public class DatabaseInitializer {
    public DatabaseInitializer() {
        System.out.println("DatabaseInitializer: 正在创建数据库表结构...");
        // ...建表逻辑...
    }
}

输出顺序保证是：

1. DatabaseInitializer: 正在创建数据库表结构...
2. DataImporter: 开始导入数据...（此时数据库表一定已创建）

@DependsOn 可以接受一个字符串数组，来依赖多个 Bean：@DependsOn({"beanA", "beanB"})。

方法 2：使用 @EventListener 监听容器事件（适用于后处理逻辑）

有时候，你需要的不是“在另一个 Bean 之前加载”，而是“在所有 Bean 都加载完毕之后，再执行某些逻辑”。这对于缓存预热、启动后执行一次性任务等场景非常有用。

你可以通过监听 ContextRefreshedEvent 来实现。这个事件会在 Spring 容器完成所有 Bean 的初始化和配置后发布。

场景：在应用启动后，需要将数据库中的热门商品预加载到 Redis 缓存中。

@Component
public class CacheWarmer {

    private final ProductService productService;
    private final RedisTemplate<String, Object> redisTemplate;

    public CacheWarmer(ProductService productService, RedisTemplate<String, Object> redisTemplate) {
        this.productService = productService;
        this.redisTemplate = redisTemplate;
    }

    @EventListener(ContextRefreshedEvent.class) // <-- 关键点
    public void onApplicationEvent() {
        System.out.println("容器已启动完毕，开始预热缓存...");
        // 此时，productService 和 redisTemplate 肯定已经准备就绪
        List<Product> hotProducts = productService.findHotProducts();
        redisTemplate.opsForValue().set("hot_products", hotProducts);
        System.out.println("缓存预热完成！");
    }
}

这种方式保证了你的逻辑在整个应用程序准备就绪后才执行，是一种非常安全和解耦的顺序控制。

方法 3：在 Spring Boot 中使用 @AutoConfigureAfter / @AutoConfigureBefore

这两种注解是 Spring Boot 自动配置模块专用的。它们用来控制**配置类（@Configuration）**之间的加载顺序，而不是普通的 Component Bean。

当你编写自己的 starter 或自动配置时，这个方法至关重要。

场景：你的自动配置 MyDataSourceAutoConfiguration 必须在 Spring Boot 的 DataSourceAutoConfiguration 之后执行，以确保数据源已经存在。

@Configuration
@AutoConfigureAfter(DataSourceAutoConfiguration.class) // <-- 关键点
public class MyCustomConfiguration {
    
    @Bean
    public MyService myService(DataSource dataSource) {
        // 因为有 @AutoConfigureAfter，这里的 dataSource 肯定已经被
        // DataSourceAutoConfiguration 配置好了。
        return new MyService(dataSource);
    }
}

一个常见的误区：@Order

@Order 注解或 Ordered 接口完全不能控制 Bean 的加载（初始化）顺序！

这是一个非常非常常见的误解。

@Order 的作用是对集合中的元素进行排序。当你将多个相同接口的实现注入到一个 List 中时，@Order 用来决定它们在这个 List 中的顺序。

例子：你有多个过滤器 Filter，你想控制它们的执行顺序。

@Component
@Order(1) // 序号小的优先
class LoggingFilter implements Filter { ... }

@Component
@Order(2)
class SecurityFilter implements Filter { ... }

@Service
public class MyProcessor {
    @Autowired
    private List<Filter> filters; // 注入一个Filter的List

    public void process() {
        // 因为 @Order，可以保证 LoggingFilter 在 SecurityFilter 之前执行
        filters.forEach(Filter::doFilter);
    }
}

在这个例子中，@Order 决定了 filters 列表中的元素顺序，但它不影响 LoggingFilter 和 SecurityFilter 这两个 Bean 本身的初始化顺序。它们的初始化顺序仍然由 Spring 的依赖图决定。

总结

最佳实践：

1. 95% 的情况，请使用构造函数注入来表达依赖关系，让 Spring 自动管理加载顺序。这是最干净、最可靠的方式。
2. 当你确实需要处理没有直接引用的逻辑依赖时（如初始化任务），@DependsOn 是你的首选工具。
3. 当你需要在整个应用启动完成后执行代码时，@EventListener(ContextRefreshedEvent.class) 是最优雅的方案。
4. 永远不要试图用 @Order 去控制 Bean 的加载顺序。