Spring Framework源码解析——Ordere

版权声明

本文原创作者：谷哥的小弟
作者博客地址：http://blog.csdn.net/lfdfhl

一、引言

在 Spring Framework 的扩展机制中，顺序控制（Ordering） 是一个基础而关键的设计要素。无论是 Bean 的初始化、AOP 切面的执行、事件监听器的触发，还是 Web 请求拦截器的调用，Spring 都需要一种机制来明确多个同类组件的执行优先级 。为此，Spring 提供了 org.springframework.core.Ordered 接口及围绕它构建的一整套排序基础设施。

Ordered 并非一个复杂的类，而是一个极简却极具表现力的契约接口。其背后支撑的是 Spring 对"可插拔组件模型"的深刻理解：系统应允许用户以声明式方式注入多个实现，并通过统一的排序语义控制其行为顺序。

本文将从 Ordered 接口的定义出发，深入剖析其设计意图、核心实现类（如 OrderComparator）、与注解 @Order 的集成机制、在 Spring 各子模块中的典型应用，以及排序算法的稳定性与性能特性。全文辅以关键源码解读，力求呈现 Spring 顺序控制体系的完整技术图景。

二、`Ordered` 接口定义与设计哲学

2.1 接口源码

java 复制代码

package org.springframework.core;

public interface Ordered {

    /**
     * 表示最高优先级（最先执行）的顺序值。
     * 值越小，优先级越高。
     */
    int HIGHEST_PRECEDENCE = Integer.MIN_VALUE;

    /**
     * 表示最低优先级（最后执行）的顺序值。
     */
    int LOWEST_PRECEDENCE = Integer.MAX_VALUE;

    /**
     * 返回该对象的顺序值。
     * 默认实现应返回 {@link #LOWEST_PRECEDENCE}。
     *
     * @return 顺序值，越小优先级越高
     */
    int getOrder();
}

2.2 设计哲学解析

契约极简 ：仅定义一个 getOrder() 方法，符合"接口隔离原则"；
数值语义清晰 ：使用 int 类型，支持全范围整数，MIN_VALUE 为最高优先级；
方向约定明确："值越小，优先级越高" ------ 这是 Spring 全局一致的排序语义；
默认行为可推断 ：未实现或返回 LOWEST_PRECEDENCE 的组件自动排在最后。

关键洞察 ：
Ordered 不是排序算法本身，而是提供排序依据的元数据接口 。真正的排序由 OrderComparator 等比较器完成。

三、核心支撑类：`OrderComparator`

OrderComparator 是 Spring 中对 Ordered 对象进行排序的标准比较器，其实现兼顾了类型安全、空值处理、注解支持与性能。

3.1 核心源码

java 复制代码

public class OrderComparator implements Comparator<Object> {

    public static final OrderComparator INSTANCE = new OrderComparator();

    @Override
    public int compare(@Nullable Object o1, @Nullable Object o2) {
        return doCompare(o1, o2, null);
    }

    private int doCompare(@Nullable Object o1, @Nullable Object o2, @Nullable OrderSourceProvider sourceProvider) {
        boolean p1 = (o1 instanceof PriorityOrdered);
        boolean p2 = (o2 instanceof PriorityOrdered);

        // PriorityOrdered 优先于普通 Ordered
        if (p1 && !p2) {
            return -1;
        } else if (p2 && !p1) {
            return 1;
        }

        // 获取顺序值
        int i1 = getOrder(o1, sourceProvider);
        int i2 = getOrder(o2, sourceProvider);

        // 顺序值越小，优先级越高
        return Integer.compare(i1, i2);
    }

    private int getOrder(@Nullable Object obj, @Nullable OrderSourceProvider sourceProvider) {
        if (obj != null) {
            // 1. 尝试从 OrderSourceProvider 获取（用于代理对象）
            Integer order = null;
            if (sourceProvider != null) {
                order = sourceProvider.getOrderSource(obj);
            }
            // 2. 若未提供，则检查对象自身是否实现 Ordered
            if (order == null) {
                if (obj instanceof Ordered) {
                    return ((Ordered) obj).getOrder();
                }
                // 3. 检查 @Order 注解
                order = findOrder(obj);
                if (order != null) {
                    return order;
                }
            }
            if (order != null) {
                return order;
            }
        }
        // 默认返回最低优先级
        return Ordered.LOWEST_PRECEDENCE;
    }

    @Nullable
    protected Integer findOrder(Object obj) {
        // 支持类、方法、注解上的 @Order
        return OrderUtils.getOrder(obj);
    }
}

3.2 关键特性分析

3.2.1 分层优先级：`PriorityOrdered`

Spring 定义了一个标记接口 PriorityOrdered：

java 复制代码

public interface PriorityOrdered extends Ordered {
}

语义：实现 PriorityOrdered 的组件总是优先于 仅实现 Ordered 的组件；
用途：确保核心基础设施（如配置加载器）在用户自定义组件之前执行。

排序规则总结：

PriorityOrdered 实例优先；

同一类中，按 getOrder() 升序排列（值小者先）；

未实现 Ordered 或无 @Order 注解者，视为 LOWEST_PRECEDENCE。

3.2.2 注解支持：`@Order`

OrderComparator 通过 OrderUtils.getOrder(obj) 支持 @Order 注解：

java 复制代码

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
public @interface Order {
    int value() default Ordered.LOWEST_PRECEDENCE;
}

适用目标：类、方法、字段；
查找逻辑 （OrderUtils.getOrder）：
- 优先查找目标类上的 @Order；
- 若为代理对象（如 AOP），尝试从原始类或目标方法获取；
- 支持元注解（meta-annotation）继承。

示例：

java 复制代码

@Order(100)
public class MyBeanPostProcessor implements BeanPostProcessor {}

3.2.3 代理对象处理：`OrderSourceProvider`

在 AOP 场景中，实际对象可能是 CGLIB/JDK 动态代理。OrderSourceProvider 允许从代理中提取原始顺序信息：

java 复制代码

public interface OrderSourceProvider {
    @Nullable
    Integer getOrderSource(Object obj);
}

典型实现 ：AspectJProxyUtils 在创建切面代理时提供顺序源；
目的：确保 @Order 在切面上的声明能被正确识别。

四、排序算法的稳定性与性能

4.1 稳定性（Stability）

OrderComparator 不保证稳定排序（即相同顺序值的对象相对位置可能改变）；
但在 Spring 实际使用中（如 AnnotationAwareOrderComparator），通常结合 System.identityHashCode() 作为次要比较键，实现伪稳定排序：

java 复制代码

// 在 AnnotationAwareOrderComparator 中
if (orderDiff == 0) {
    orderDiff = Boolean.compare(c1Instance, c2Instance);
    if (orderDiff == 0) {
        orderDiff = Integer.compare(System.identityHashCode(c1), System.identityHashCode(c2));
    }
}

意义：避免因 JVM 对象地址变化导致执行顺序随机波动，提升可预测性。

4.2 性能特性

时间复杂度 ：O(1) 获取顺序值，整体排序为 O(n log n)；
无反射开销 ：@Order 注解在启动时通过 AnnotatedElementUtils 缓存，运行时直接读取；
零分配 ：比较器为单例（INSTANCE），避免重复创建。

五、在 Spring 各模块中的典型应用

5.1 Bean 生命周期：`BeanPostProcessor`

java 复制代码

// AbstractBeanFactory.java
List<BeanPostProcessor> currentRegisteredBeanPostProcessors = ...;
// 排序
sortPostProcessors(currentRegisteredBeanPostProcessors);

排序器 ：AnnotationAwareOrderComparator.INSTANCE
影响：决定 postProcessBeforeInitialization / postProcessAfterInitialization 的调用顺序；
典型场景 ：AutowiredAnnotationBeanPostProcessor（处理 @Autowired）需在自定义 BPP 之前执行。

5.2 AOP 切面执行顺序

java 复制代码

// AspectJAdvisorFactory
List<Advisor> advisors = ...;
advisors.sort(new AspectJPrecedenceComparator());

虽然 AOP 有专用比较器，但其内部仍依赖 Ordered 和 @Order；
规则：@Order 值小的切面在外层 （先执行 @Before，后执行 @After）。

记忆口诀 ：

"Order 小，套在外；先进后出，环绕中间。"

5.3 事件监听：`ApplicationListener`

java 复制代码

// SimpleApplicationEventMulticaster
listenerBeans.values().stream()
    .sorted(OrderComparator.INSTANCE)
    .forEach(listener -> listener.onApplicationEvent(event));

决定事件监听器的触发顺序；
应用场景：日志监听器（低优先级）应在业务监听器之后执行。

5.4 Web 拦截器：`HandlerInterceptor`

java 复制代码

// HandlerExecutionChain
this.interceptorList.sort(AnnotationAwareOrderComparator.INSTANCE);

控制 preHandle / postHandle / afterCompletion 的调用栈顺序；
实践建议：认证拦截器（高优先级）应在日志拦截器（低优先级）之前。

六、高级扩展：`AnnotationAwareOrderComparator`

这是 OrderComparator 的增强版，显式支持 @Order 和 @Priority（JSR-330）注解，是 Spring Boot 和 Spring Framework 的默认排序器。

java 复制代码

public class AnnotationAwareOrderComparator extends OrderComparator {

    public static final AnnotationAwareOrderComparator INSTANCE = 
        new AnnotationAwareOrderComparator();

    @Override
    @Nullable
    protected Integer findOrder(Object obj) {
        // 1. 查找 @Order
        Integer order = OrderUtils.getOrder(obj);
        if (order != null) {
            return order;
        }
        // 2. 查找 javax.annotation.Priority
        return OrderUtils.getPriority(obj);
    }
}

@Priority 支持：兼容 Java EE / Jakarta EE 标准；
使用场景 ：ApplicationContext 初始化、@Bean 方法排序等。

七、常见误区与最佳实践

7.1 常见误区

误区	说明	正确理解
"`@Order` 值越大越先执行"	混淆了"优先级"与"顺序值"	值越小，优先级越高
"未标注 `@Order` 的 Bean 顺序随机"	忽略了默认 `LOWEST_PRECEDENCE`	所有未排序组件排在最后，相对顺序由注册顺序或哈希决定
"`Ordered` 可用于控制 Bean 创建顺序"	混淆了 Bean 实例化与后处理器执行	`Ordered` 控制的是同类组件的回调顺序，而非 Bean 本身的创建

7.2 最佳实践

明确使用 PriorityOrdered：对基础设施组件（如配置加载器）实现此接口；
合理分配 @Order 值 ：使用常量或枚举避免魔法数字，如：
java 复制代码
```
public interface OrderConstants {
    int AUTH = 100;
    int LOGGING = 1000;
}
```
避免过度依赖顺序：组件间应尽量解耦，顺序仅用于必要场景（如安全、事务）；
测试顺序敏感逻辑：通过单元测试验证多组件协作的正确性。

八、总结

Ordered 接口及其配套体系是 Spring 框架扩展性与可组合性的重要基石。其设计体现了以下核心思想：

契约极简，语义清晰 ：通过单一 int 值表达优先级；
分层优先级模型 ：PriorityOrdered > Ordered > 无序；
声明式与编程式并存 ：支持接口实现与 @Order 注解；
深度集成 Spring 生态：贯穿 Beans、AOP、Context、Web 等模块；
性能与稳定性兼顾：缓存注解、伪稳定排序、单例比较器。

维度	关键结论
排序语义	值越小，优先级越高
优先级层级	`PriorityOrdered` > `Ordered` > 默认
注解支持	`@Order` 和 `@Priority` 均被支持
典型应用	BPP、AOP、事件监听、拦截器
稳定性	通过 identity hash 实现伪稳定

最终建议 ：

当你需要控制多个同类 Spring 组件的执行顺序时，优先使用 @Order 注解 ；若需更高优先级或动态顺序，再考虑实现 Ordered 或 PriorityOrdered 接口。理解 Ordered 体系的工作原理，是构建可维护、可预测的 Spring 应用的关键。

Spring Framework源码解析——Ordere

版权声明

一、引言

二、Ordered 接口定义与设计哲学

2.1 接口源码

2.2 设计哲学解析

三、核心支撑类：OrderComparator

3.1 核心源码

3.2 关键特性分析

3.2.1 分层优先级：PriorityOrdered

3.2.2 注解支持：@Order

3.2.3 代理对象处理：OrderSourceProvider

四、排序算法的稳定性与性能

4.1 稳定性（Stability）

4.2 性能特性

五、在 Spring 各模块中的典型应用

5.1 Bean 生命周期：BeanPostProcessor

5.2 AOP 切面执行顺序

5.3 事件监听：ApplicationListener

5.4 Web 拦截器：HandlerInterceptor

六、高级扩展：AnnotationAwareOrderComparator

七、常见误区与最佳实践

7.1 常见误区

7.2 最佳实践

八、总结

二、`Ordered` 接口定义与设计哲学

三、核心支撑类：`OrderComparator`

3.2.1 分层优先级：`PriorityOrdered`

3.2.2 注解支持：`@Order`

3.2.3 代理对象处理：`OrderSourceProvider`

5.1 Bean 生命周期：`BeanPostProcessor`

5.3 事件监听：`ApplicationListener`

5.4 Web 拦截器：`HandlerInterceptor`

六、高级扩展：`AnnotationAwareOrderComparator`