PriorityOrdered和Ordered学习

简介

在Spring框架中，Ordered和PriorityOrdered接口用于确定Bean的排序。它们通常用于那些需要按照特定顺序执行的操作，比如事件监听器、初始化回调、拦截器等。理解这两个接口的差异对于正确配置Spring应用是非常重要的。

Ordered

public interface Ordered {

	/**
	 * 最小排序号
	 */
	int HIGHEST_PRECEDENCE = Integer.MIN_VALUE;

	/**
	 * 最大排序号
	 */
	int LOWEST_PRECEDENCE = Integer.MAX_VALUE;


	/**
	 * 获取排序号，数字越小，优先级也越高
	 */
	int getOrder();

}

PriorityOrdered

public interface PriorityOrdered extends Ordered {
}

在实际应用中，如果你需要更精细地控制Bean的初始化顺序，特别是当涉及到一些需要提前执行的操作时，你可能会需要使用PriorityOrdered

总结

• Ordered和PriorityOrdered都用于Bean的排序。
• PriorityOrdered是Ordered的一个扩展，提供了更早的排序阶段。
• 实现PriorityOrdered的Bean会比仅实现Ordered的Bean更早地被排序。
• 在大多数情况下，Ordered可能就足够了，但如果你需要更精细的控制，那么PriorityOrdered可能是一个更好的选择。

在编写Spring代码时，要谨慎使用这些接口，确保不会引入不必要的复杂性或性能问题。同时，也要考虑到其他可能影响Bean生命周期和初始化顺序的因素。

@Order

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

	/**
	 * 默认最小值
	 */
	int value() default Ordered.LOWEST_PRECEDENCE;

}

OrderComparator

在Spring框架中，OrderComparator类是一个用于比较实现了Ordered或PriorityOrdered接口的对象的比较器（Comparator）。这个类的作用是帮助Spring容器或用户代码根据这些接口中定义的顺序对Bean进行排序。

OrderComparator的主要职责是：

• 检查对象是否实现了Ordered或PriorityOrdered接口。
• 如果是，则根据getOrder()方法返回的值来比较这些对象的顺序。
• 如果不是，或者两个对象的顺序相同，则可能使用默认的排序机制（例如，根据对象的自然顺序或根据它们的hashCode）。

OrderComparator通常用于Spring容器内部的Bean排序，特别是在处理事件监听器、初始化回调、AOP拦截器等方面。由于Spring允许用户自定义Bean的初始化顺序，因此OrderComparator在确保这些顺序得到正确遵守方面起着关键作用。

使用OrderComparator的一个常见场景是在Spring的AOP框架中，其中拦截器（Interceptor）可能需要按照特定的顺序执行。通过实现Ordered或PriorityOrdered接口，并定义相应的顺序，开发者可以精确地控制这些拦截器的执行顺序。

值得注意的是，OrderComparator仅用于比较实现了特定接口的对象。对于没有实现这些接口的对象，它可能无法提供有意义的比较结果。因此，在使用OrderComparator时，应确保所有需要排序的对象都实现了正确的接口。

最后，虽然OrderComparator在Spring内部广泛使用，但开发者也可以在自己的代码中使用它来对实现了Ordered或PriorityOrdered接口的对象进行排序。这提供了更大的灵活性，使得开发者能够根据业务逻辑自定义对象的排序顺序。

源码

public class OrderComparator implements Comparator<Object> {
	@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) {
		//如果是PriorityOrdered类型 优先排序
		boolean p1 = (o1 instanceof PriorityOrdered);
		boolean p2 = (o2 instanceof PriorityOrdered);
		if (p1 && !p2) {
			return -1;
		}
		else if (p2 && !p1) {
			return 1;
		}

		//否则 判断是Ordered类型 获取order数字，比较大小
		int i1 = getOrder(o1, sourceProvider);
		int i2 = getOrder(o2, sourceProvider);
		return Integer.compare(i1, i2);
	}
	
	private int getOrder(@Nullable Object obj, @Nullable OrderSourceProvider sourceProvider) {
		Integer order = null;
		if (obj != null && sourceProvider != null) {
			Object orderSource = sourceProvider.getOrderSource(obj);
			if (orderSource != null) {
				if (orderSource.getClass().isArray()) {
					for (Object source : ObjectUtils.toObjectArray(orderSource)) {
						order = findOrder(source);
						if (order != null) {
							break;
						}
					}
				}
				else {
					order = findOrder(orderSource);
				}
			}
		}
		return (order != null ? order : getOrder(obj));
	}

	@Nullable
	protected Integer findOrder(Object obj) {
		return (obj instanceof Ordered ? ((Ordered) obj).getOrder() : null);
	}

}