@Primary 与 @Order 详解及详细源码展示

最新推荐文章于 2025-09-25 17:39:47 发布

原创最新推荐文章于 2025-09-25 17:39:47 发布 · 923 阅读

31 ·

CC 4.0 BY-SA版权

文章标签：

#源码 #spring #注解 #学习

源码学习专栏收录该内容

118 篇文章

订阅专栏

@Primary 和 @Order 是 Spring 框架中用于控制 Bean 优先级与顺序的核心注解，分别解决“多候选 Bean 歧义”和“Bean 执行顺序”问题。以下从注解定义、源码解析、核心功能、使用场景及注意事项展开详细说明。

一、`@Primary` 详解

1. 注解定义与源码解析

@Primary 位于 org.springframework.context.annotation 包中，其源码定义如下（简化版）：

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Primary {

    /**
     * 主候选的名称（可选，默认空）
     */
    String value() default "";
}

关键特性：

标记一个 Bean 为“主候选”，当存在多个同类型 Bean 时，优先选择被 @Primary 标记的 Bean。
可作用于类（@Bean 方法或 @Component 类）或方法（@Bean 方法）。

2. 核心功能：解决多候选 Bean 的歧义

在 Spring 中，当一个接口有多个实现类（或一个类被多次声明为 Bean）时，直接使用 @Autowired 注入会因“找不到唯一匹配的 Bean”而抛出 NoUniqueBeanDefinitionException。@Primary 的核心作用是通过标记主候选，消除这种歧义。

3. 典型使用场景与示例

（1）接口多实现的场景

当一个接口有多个实现类时，通过 @Primary 标记默认使用的实现：

// 接口
public interface PaymentService {
    void pay(Double amount);
}

// 实现类 1（主候选）
@Service
@Primary // 标记为主候选
public class AlipayService implements PaymentService {
    @Override
    public void pay(Double amount) {
        System.out.println("支付宝支付：" + amount);
    }
}

// 实现类 2（非主候选）
@Service
public class WechatPayService implements PaymentService {
    @Override
    public void pay(Double amount) {
        System.out.println("微信支付：" + amount);
    }
}

// 注入时无需指定 @Qualifier，默认使用 AlipayService
@Service
public class OrderService {

    @Autowired // 自动注入 @Primary 标记的 AlipayService
    private PaymentService paymentService;

    public void createOrder(Double amount) {
        paymentService.pay(amount); // 输出：支付宝支付：100.0
    }
}

（2）`@Bean` 方法的多 Bean 场景

当 @Configuration 类中存在多个同类型的 @Bean 方法时，通过 @Primary 标记默认方法：

@Configuration
public class DataSourceConfig {

    // 主候选数据源
    @Bean
    @Primary 
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().url("jdbc:mysql://...").build();
    }

    // 非主候选数据源
    @Bean
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().url("jdbc:oracle:...").build();
    }
}

// 注入时默认使用 primaryDataSource
@Service
public class DataService {

    @Autowired 
    private DataSource dataSource; // 注入 primaryDataSource
}

（3）与 `@Qualifier` 配合使用

若需要显式指定非主候选 Bean，可结合 @Qualifier 覆盖 @Primary 的优先级：

@Service
public class OrderService {

    private final PaymentService paymentService;

    // 显式指定使用 WechatPayService（即使 AlipayService 是 @Primary）
    @Autowired
    public OrderService(@Qualifier("wechatPayService") PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void createOrder(Double amount) {
        paymentService.pay(amount); // 输出：微信支付：200.0
    }
}

二、`@Order` 详解

1. 注解定义与源码解析

@Order 位于 org.springframework.context.annotation 包中，其源码定义如下（简化版）：

@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Order {

    /**
     * 顺序值（数值越小优先级越高，默认 Integer.MAX_VALUE）
     */
    int value() default Integer.MAX_VALUE;
}

关键特性：

标记一个 Bean 的“顺序优先级”，数值越小优先级越高（如 value=1 比 value=2 优先级高）。
可作用于类（@Component、@Service 等）、方法（@Bean）或字段（依赖注入时指定顺序）。

2. 核心功能：控制 Bean 的执行顺序

@Order 主要用于以下场景：

Bean 初始化顺序：控制 @PostConstruct、InitializingBean 等初始化方法的执行顺序。
依赖注入顺序：当多个 Bean 注入到同一位置时（如 List 或数组），按 @Order 顺序排列。
事件监听顺序：控制 ApplicationListener 监听事件的触发顺序。

3. 典型使用场景与示例

（1）控制 `@PostConstruct` 初始化顺序

多个 Bean 的 @PostConstruct 方法按 @Order 顺序执行：

@Service
@Order(1) // 优先级最高（先执行）
public class InitServiceA {

    @PostConstruct
    public void init() {
        System.out.println("InitServiceA 初始化"); // 第一个执行
    }
}

@Service
@Order(2) // 优先级次之（后执行）
public class InitServiceB {

    @PostConstruct
    public void init() {
        System.out.println("InitServiceB 初始化"); // 第二个执行
    }
}

（2）控制 `List` 注入的顺序

当注入一个 List<PaymentService> 时，@Order 决定列表中 Bean 的顺序：

@Service
public class PaymentServiceManager {

    // 注入所有 PaymentService，按 @Order 顺序排列
    @Autowired 
    private List<PaymentService> paymentServices;

    public void printServices() {
        paymentServices.forEach(service -> System.out.println(service.getClass().getSimpleName()));
        // 输出顺序：AlipayService（@Order(1)）→ WechatPayService（@Order(2)）
    }
}

// 配置类：为 PaymentService 添加 @Order
@Configuration
public class PaymentConfig {

    @Bean
    @Order(1) 
    public PaymentService alipayService() {
        return new AlipayService();
    }

    @Bean
    @Order(2) 
    public PaymentService wechatPayService() {
        return new WechatPayService();
    }
}

（3）控制 `ApplicationListener` 事件触发顺序

多个 ApplicationListener 按 @Order 顺序监听事件：

@Component
@Order(1) // 先监听
public class LogListener implements ApplicationListener<ApplicationReadyEvent> {

    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        System.out.println("LogListener：应用启动完成"); // 第一个触发
    }
}

@Component
@Order(2) // 后监听
public class MetricListener implements ApplicationListener<ApplicationReadyEvent> {

    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        System.out.println("MetricListener：收集启动指标"); // 第二个触发
    }
}

三、`@Primary` 与 `@Order` 的区别与联系

特性	`@Primary`	`@Order`
核心目标	解决多候选 Bean 的歧义（选主）	控制 Bean 的执行顺序（排序）
作用范围	仅影响同类型 Bean 的注入选择	影响所有需要顺序的场景（初始化、注入、事件等）
优先级规则	主候选 > 非主候选	数值越小优先级越高（如 `@Order(1)` > `@Order(2)`）
典型场景	接口多实现、`@Bean` 多方法	初始化顺序、`List` 注入顺序、事件监听顺序