【技术累积】【点】【java】【25】Orderd
基础概念
Orderd是spring core中定义的一个接口，使用它以及相关的Comparator和@Order注解，可以实现对元素的排序。
@Order
直接先说下@Order注解吧，使用场景较多。
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
@Documented
public @interface Order {
/**
* The order value.
* <p>Default is {@link Ordered#LOWEST_PRECEDENCE}.
* @see Ordered#getOrder()
*/
int value() default Ordered.LOWEST_PRECEDENCE;
}
Type，Method，Field都可以被注解；
一般来说，属性被注解顺序是为了序列化的便利，类被注解是功能或逻辑上的要求（比如拦截器的前后顺序）
Orderd接口
上面代码中的Ordered.LOWEST_PRECEDENCE出现在Orderd接口定义中
public interface Ordered {
/**
* Useful constant for the highest precedence value.
* @see java.lang.Integer#MIN_VALUE
*/
int HIGHEST_PRECEDENCE = Integer.MIN_VALUE;
/**
* Useful constant for the lowest precedence value.
* @see java.lang.Integer#MAX_VALUE
*/
int LOWEST_PRECEDENCE = Integer.MAX_VALUE;
/**
* Get the order value of this object.
* <p>Higher values are interpreted as lower priority. As a consequence,
* the object with the lowest value has the highest priority (somewhat
* analogous to Servlet {@code load-on-startup} values).
* <p>Same order values will result in arbitrary sort positions for the
* affected objects.
* @return the order value
* @see #HIGHEST_PRECEDENCE
* @see #LOWEST_PRECEDENCE
*/
int getOrder();
}
可以看到，低优先级是Integer的最大值，也就是说，数值越大，优先级越低（数值可以为负），可以理解为顺序（第一个被服务的优先级高，取第一个的一为优先级数值）
Order的两种设置方法
- 注解@Order(30)
- 实现Orderd接口
private static final class StubOrdered implements Ordered {
private final int order;
public StubOrdered(int order) {
this.order = order;
}
@Override
public int getOrder() {
return this.order;
}
}
作者：兴浩
链接：https://www.jianshu.com/p/8442d21222ef
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。
后面看下Comparator的源码就知道：
- 一个是Priority的有判断，会先去比较；
boolean p1 = (o1 instanceof PriorityOrdered);
boolean p2 = (o2 instanceof PriorityOrdered);
if (p1 && !p2) {
return -1;
}
else if (p2 && !p1) {
return 1;
}
- 另一个是实现接口后，如果没有指定sourceProvider，会调用getOrder方法去比较数值
// Direct evaluation instead of Integer.compareTo to avoid unnecessary object creation.
int i1 = getOrder(o1, sourceProvider);
int i2 = getOrder(o2, sourceProvider);
return (i1 < i2) ? -1 : (i1 > i2) ? 1 : 0;
OrderUtils
spring提供了OrderUtils来获取Class的Order信息
public class OrderUtilsTests {
@Test
public void getSimpleOrder() {
assertEquals(Integer.valueOf(50), OrderUtils.getOrder(SimpleOrder.class, null));
}
@Test
public void getPriorityOrder() {
assertEquals(Integer.valueOf(55), OrderUtils.getOrder(SimplePriority.class, null));
}
@Order(50)
private static class SimpleOrder {}
@Priority(55)
private static class SimplePriority {}
}
作者：兴浩
链接：https://www.jianshu.com/p/8442d21222ef
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。
@Priority的优先级会相比于Order高一些，其他没有区别，后面Comparator有影响。
OrderComparator
比较两个对象的排列顺序
private final OrderComparator comparator = new OrderComparator();
@Test
public void compareOrderedInstancesBefore() {
assertEquals(-1, this.comparator.compare(
new StubOrdered(100), new StubOrdered(2000)));
}
@Test
public void compareOrderedInstancesSame() {
assertEquals(0, this.comparator.compare(
new StubOrdered(100), new StubOrdered(100)));
}
@Test
public void compareOrderedInstancesAfter() {
assertEquals(1, this.comparator.compare(
new StubOrdered(982300), new StubOrdered(100)));
}
private static final class StubOrdered implements Ordered {
private final int order;
public StubOrdered(int order) {
this.order = order;
}
@Override
public int getOrder() {
return this.order;
}
}
作者：兴浩
链接：https://www.jianshu.com/p/8442d21222ef
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。
AnnotationAwareOrderComparator
AnnotationAwareOrderComparator继承自OrderComparator
其可以同时处理对象实现Ordered接口或@Order注解
其提供了静态方法sort,可以对List进行排序
@Test
public void sortInstances() {
List<Object> list = new ArrayList<>();
list.add(new B());
list.add(new A());
AnnotationAwareOrderComparator.sort(list);
assertTrue(list.get(0) instanceof A);
assertTrue(list.get(1) instanceof B);
}
@Order(1)
private static class A {
}
@Order(2)
private static class B {
}
作者：兴浩
链接：https://www.jianshu.com/p/8442d21222ef
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。
Bean注册顺序
Demo2Config的对象将会先于Demo1Config初始化注册
注意点:其构造函数的初始化并不生效
@Configuration
@Order(2)
public class Demo1Config {
public Demo1Config()
{
System.out.println("Demo1Config");
}
@Bean
public Demo1Service demo1Service(){
System.out.println("demo1config 加载了");
return new Demo1Service();
}
}
@Configuration
@Order(1)
public class Demo2Config {
public Demo2Config()
{
System.out.println("Demo2Config");
}
@Bean
public Demo2Service demo2Service(){
System.out.println("demo2config 加载了");
return new Demo2Service();
}
}
public class Main {
public static void main(String[] args) {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext("core.annotation.order2");
}
}
输出的结果信息:
Demo1Config
Demo2Config
demo2config 加载了
demo1config 加载了
作者：兴浩
链接：https://www.jianshu.com/p/8442d21222ef
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。
