集合类自定义排序和springMVC viewResolver的顺序问题

看了springMVC的dispatcherServlet的源码，有个地方不是特别明白，一路找资料，懂了 所以需要记录一下。

关于initViewResolvers方法，我们知道springMVC里有一个视图解析器的概念。同一个项目可能会需要配置多个视图解析器。对于具有REST风格的服务器更是如此。

通过对源码的查看，视图解析器在配置时，可以设置order属性，这个值关联到视图解析器的执行顺序。值越小优先级越高，可以为负数。具体原理，我会在下面详细说明。

首先我们可以看看initViewResolvers方法：

private void initViewResolvers(ApplicationContext context) {
this.viewResolvers = null;
if(this.detectAllViewResolvers) {
Map vr = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, ViewResolver.class, true, false);
if(!vr.isEmpty()) {
this.viewResolvers = new ArrayList(vr.values());
AnnotationAwareOrderComparator.sort(this.viewResolvers);
}
} else {
try {
ViewResolver vr1 = (ViewResolver)context.getBean("viewResolver", ViewResolver.class);
this.viewResolvers = Collections.singletonList(vr1);
} catch (NoSuchBeanDefinitionException var3) {
;
}
}

if(this.viewResolvers == null) {
this.viewResolvers = this.getDefaultStrategies(context, ViewResolver.class);
if(this.logger.isDebugEnabled()) {
this.logger.debug("No ViewResolvers found in servlet \'" + this.getServletName() + "\': using default");
}
}

}首先会取出 所有在ioc里注册过的viewResolver接口的实现（也就是配置的多个视图解析器），并将之放入数组中。
之后，利用AnnotationAwareOrderComparator类中sort方法进行排序，这个AnnotationAwareOrderComparator类继承了OrderComparator。而OrderComparator类通过我的研究，发现这个类在spring里运用很广泛。OrderComparator实现了Comparator接口。我们知道java集合类自定义排序正是需要实现Comparator接口。所以不难看出OrderComparator这个类是用于spring内bean排序。

public class OrderComparator implements Comparator<Object> {
public static final OrderComparator INSTANCE = new OrderComparator();

public OrderComparator() {
}

public Comparator<Object> withSourceProvider(final OrderComparator.OrderSourceProvider sourceProvider) {
return new Comparator() {
public int compare(Object o1, Object o2) {
return OrderComparator.this.doCompare(o1, o2, sourceProvider);
}
};
}

public int compare(Object o1, Object o2) {
return this.doCompare(o1, o2, (OrderComparator.OrderSourceProvider)null);
}

private int doCompare(Object o1, Object o2, OrderComparator.OrderSourceProvider sourceProvider) {
boolean p1 = o1 instanceof PriorityOrdered;
boolean p2 = o2 instanceof PriorityOrdered;
if(p1 && !p2) {
return -1;
} else if(p2 && !p1) {
return 1;
} else {
int i1 = this.getOrder(o1, sourceProvider);
int i2 = this.getOrder(o2, sourceProvider);
return i1 < i2?-1:(i1 > i2?1:0);
}
}

private int getOrder(Object obj, OrderComparator.OrderSourceProvider sourceProvider) {
Integer order = null;
if(sourceProvider != null) {
Object orderSource = sourceProvider.getOrderSource(obj);
if(orderSource != null && orderSource.getClass().isArray()) {
Object[] sources = ObjectUtils.toObjectArray(orderSource);
Object[] var6 = sources;
int var7 = sources.length;

for(int var8 = 0; var8 < var7; ++var8) {
Object source = var6[var8];
order = this.findOrder(source);
if(order != null) {
break;
}
}
} else {
order = this.findOrder(orderSource);
}
}

return order != null?order.intValue():this.getOrder(obj);
}

protected int getOrder(Object obj) {
Integer order = this.findOrder(obj);
return order != null?order.intValue():2147483647;
}

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

public Integer getPriority(Object obj) {
return null;
}

public static void sort(List<?> list) {
if(list.size() > 1) {
Collections.sort(list, INSTANCE);
}

}

public static void sort(Object[] array) {
if(array.length > 1) {
Arrays.sort(array, INSTANCE);
}

}

public static void sortIfNecessary(Object value) {
if(value instanceof Object[]) {
sort((Object[])((Object[])value));
} else if(value instanceof List) {
sort((List)value);
}

}

public interface OrderSourceProvider {
Object getOrderSource(Object var1);
}
}

它实现了compare方法，并通过findOrder方法，得到viewResolver的order属性（在配置文件里设置的order值），这里的order在spring.core包里是一个接口类，规定了order的最大值与最小值，各个viewResolver的实现类（也可以是其他bean）各自实现自己的getOrder方法。通过查看viewResolver的一些实现类，我发现若bean实现了order接口且配置bean时没设置order值，默认则是最高优先级值 -2147483648。

关于java集合类的排序再啰嗦两句。

java的集合类 collection 都会有一个sort方法，查看Collection类的源码，发现两个关键sort方法，

一个是只有一个参数的sort方法，要求返回的泛型需继承Comparable。可以重写Comparable里的compareTo方法来定义排序规则

另一个是带有两个参数的sort方法，其中第二个参数为自定义的排序器类的实例对象，这个类需要实现Comparator接口，这个排序器的用法就很多样了，支持灵活的自定义排序。