/** * Sort advisors based on ordering. Subclasses may choose to override this * method to customize the sorting strategy. * @param advisors the source List of Advisors * @return the sorted List of Advisors * @see org.springframework.core.Ordered * @see org.springframework.core.annotation.Order * @see org.springframework.core.annotation.AnnotationAwareOrderComparator */ protected List<Advisor> sortAdvisors(List<Advisor> advisors) { AnnotationAwareOrderComparator.sort(advisors); return advisors; }
/** * Sort the given array or List with a default AnnotationAwareOrderComparator, * if necessary. Simply skips sorting when given any other value. * <p>Optimized to skip sorting for lists with size 0 or 1, * in order to avoid unnecessary array extraction. * @param value the array or List to sort * @see java.util.Arrays#sort(Object[], java.util.Comparator) */ public static void sortIfNecessary(Object value) { if (value instanceof Object[]) { sort((Object[]) value); } else if (value instanceof List) { sort((List<?>) value); } }
/** * Constructor with an {@link ReactiveAdapterRegistry} instance. * @param viewResolvers the view resolver to use * @param contentTypeResolver to determine the requested content type * @param registry for adaptation to reactive types */ public ViewResolutionResultHandler(List<ViewResolver> viewResolvers, RequestedContentTypeResolver contentTypeResolver, ReactiveAdapterRegistry registry) { super(contentTypeResolver, registry); this.viewResolvers.addAll(viewResolvers); AnnotationAwareOrderComparator.sort(this.viewResolvers); }
/** * Set the request interceptors that this accessor should use. * <p>The interceptors will get sorted according to their order * once the {@link ClientHttpRequestFactory} will be built. * @see #getRequestFactory() * @see AnnotationAwareOrderComparator */ public void setInterceptors(List<ClientHttpRequestInterceptor> interceptors) { // Take getInterceptors() List as-is when passed in here if (this.interceptors != interceptors) { this.interceptors.clear(); this.interceptors.addAll(interceptors); AnnotationAwareOrderComparator.sort(this.interceptors); } }
@Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { this.beanFactory = beanFactory; Map<String, EventListenerFactory> beans = beanFactory.getBeansOfType(EventListenerFactory.class, false, false); List<EventListenerFactory> factories = new ArrayList<>(beans.values()); AnnotationAwareOrderComparator.sort(factories); this.eventListenerFactories = factories; }
protected void initStrategies(ApplicationContext context) { Map<String, HandlerMapping> mappingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors( context, HandlerMapping.class, true, false); ArrayList<HandlerMapping> mappings = new ArrayList<>(mappingBeans.values()); AnnotationAwareOrderComparator.sort(mappings); this.handlerMappings = Collections.unmodifiableList(mappings); Map<String, HandlerAdapter> adapterBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors( context, HandlerAdapter.class, true, false); this.handlerAdapters = new ArrayList<>(adapterBeans.values()); AnnotationAwareOrderComparator.sort(this.handlerAdapters); Map<String, HandlerResultHandler> beans = BeanFactoryUtils.beansOfTypeIncludingAncestors( context, HandlerResultHandler.class, true, false); this.resultHandlers = new ArrayList<>(beans.values()); AnnotationAwareOrderComparator.sort(this.resultHandlers); }
private void detectResourceHandlers(ApplicationContext context) { Map<String, SimpleUrlHandlerMapping> beans = context.getBeansOfType(SimpleUrlHandlerMapping.class); List<SimpleUrlHandlerMapping> mappings = new ArrayList<>(beans.values()); AnnotationAwareOrderComparator.sort(mappings); mappings.forEach(mapping -> mapping.getHandlerMap().forEach((pattern, handler) -> { if (handler instanceof ResourceWebHandler) { ResourceWebHandler resourceHandler = (ResourceWebHandler) handler; this.handlerMap.put(pattern, resourceHandler); } })); if (this.handlerMap.isEmpty()) { logger.trace("No resource handling mappings found"); } }
private static List<HandlerMapping> initHandlerMappings(ApplicationContext applicationContext) { Map<String, HandlerMapping> beans = BeanFactoryUtils.beansOfTypeIncludingAncestors( applicationContext, HandlerMapping.class, true, false); if (!beans.isEmpty()) { List<HandlerMapping> mappings = new ArrayList<>(beans.values()); AnnotationAwareOrderComparator.sort(mappings); return Collections.unmodifiableList(mappings); } return Collections.unmodifiableList(initFallback(applicationContext)); }
protected void detectResourceHandlers(ApplicationContext appContext) { Map<String, SimpleUrlHandlerMapping> beans = appContext.getBeansOfType(SimpleUrlHandlerMapping.class); List<SimpleUrlHandlerMapping> mappings = new ArrayList<>(beans.values()); AnnotationAwareOrderComparator.sort(mappings); for (SimpleUrlHandlerMapping mapping : mappings) { for (String pattern : mapping.getHandlerMap().keySet()) { Object handler = mapping.getHandlerMap().get(pattern); if (handler instanceof ResourceHttpRequestHandler) { ResourceHttpRequestHandler resourceHandler = (ResourceHttpRequestHandler) handler; this.handlerMap.put(pattern, resourceHandler); } } } if (this.handlerMap.isEmpty()) { logger.trace("No resource handling mappings found"); } }
private void initControllerAdviceCache() { ApplicationContext context = getApplicationContext(); if (context == null) { return; } if (logger.isTraceEnabled()) { logger.trace("Looking for @MessageExceptionHandler mappings: " + context); } List<ControllerAdviceBean> beans = ControllerAdviceBean.findAnnotatedBeans(context); AnnotationAwareOrderComparator.sort(beans); initMessagingAdviceCache(MessagingControllerAdviceBean.createFromList(beans)); }
/** * Add all {@link Advisor Advisors} from the supplied {@link MetadataAwareAspectInstanceFactory} * to the current chain. Exposes any special purpose {@link Advisor Advisors} if needed. * @see AspectJProxyUtils#makeAdvisorChainAspectJCapableIfNecessary(List) */ private void addAdvisorsFromAspectInstanceFactory(MetadataAwareAspectInstanceFactory instanceFactory) { List<Advisor> advisors = this.aspectFactory.getAdvisors(instanceFactory); Class<?> targetClass = getTargetClass(); Assert.state(targetClass != null, "Unresolvable target class"); advisors = AopUtils.findAdvisorsThatCanApply(advisors, targetClass); AspectJProxyUtils.makeAdvisorChainAspectJCapableIfNecessary(advisors); AnnotationAwareOrderComparator.sort(advisors); addAdvisors(advisors); }
@Test public void sortClasses() { List<Object> list = new ArrayList<>(); list.add(B.class); list.add(A.class); AnnotationAwareOrderComparator.sort(list); assertEquals(A.class, list.get(0)); assertEquals(B.class, list.get(1)); }
@Test public void sortClassesWithSubclass() { List<Object> list = new ArrayList<>(); list.add(B.class); list.add(C.class); AnnotationAwareOrderComparator.sort(list); assertEquals(C.class, list.get(0)); assertEquals(B.class, list.get(1)); }
@Test public void sortWithNulls() { List<Object> list = new ArrayList<>(); list.add(null); list.add(B.class); list.add(null); list.add(A.class); AnnotationAwareOrderComparator.sort(list); assertEquals(A.class, list.get(0)); assertEquals(B.class, list.get(1)); assertNull(list.get(2)); assertNull(list.get(3)); }
@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); }
@Test public void sortInstancesWithOrderAndPriority() { List<Object> list = new ArrayList<>(); list.add(new B()); list.add(new A2()); AnnotationAwareOrderComparator.sort(list); assertTrue(list.get(0) instanceof A2); assertTrue(list.get(1) instanceof B); }
@Test public void sortInstancesWithPriority() { List<Object> list = new ArrayList<>(); list.add(new B2()); list.add(new A2()); AnnotationAwareOrderComparator.sort(list); assertTrue(list.get(0) instanceof A2); assertTrue(list.get(1) instanceof B2); }
@Test public void sortInstancesWithSubclass() { List<Object> list = new ArrayList<>(); list.add(new B()); list.add(new C()); AnnotationAwareOrderComparator.sort(list); assertTrue(list.get(0) instanceof C); assertTrue(list.get(1) instanceof B); }
@Test public void testInterfaceProxiesCanBeOrderedThroughAnnotations() { Object proxy1 = new ProxyFactory(new A()).getProxy(); Object proxy2 = new ProxyFactory(new B()).getProxy(); List<Object> list = new ArrayList<>(2); list.add(proxy1); list.add(proxy2); AnnotationAwareOrderComparator.sort(list); assertSame(proxy2, list.get(0)); assertSame(proxy1, list.get(1)); }
@Test public void testTargetClassProxiesCanBeOrderedThroughAnnotations() { ProxyFactory pf1 = new ProxyFactory(new A()); pf1.setProxyTargetClass(true); ProxyFactory pf2 = new ProxyFactory(new B()); pf2.setProxyTargetClass(true); Object proxy1 = pf1.getProxy(); Object proxy2 = pf2.getProxy(); List<Object> list = new ArrayList<>(2); list.add(proxy1); list.add(proxy2); AnnotationAwareOrderComparator.sort(list); assertSame(proxy2, list.get(0)); assertSame(proxy1, list.get(1)); }