Autowiring should support ordered collection driven by Order annotation or Ordered interface [SPR-5574]

[spring-projects-issues]

Roman Pichlík opened SPR-5574 and commented

Let suppose that there are beans of a given type T and these beans are marked by interface Ordered or annotation Order. It does make really sense to preserve their order according to Ordered/Order marker if they are collected. See following code for illustration.

@Component
@Order(value=1)
public class BusinessServiceA implements BusinessService{}

@Component
@Order(value=2)
public class BusinessServiceB implements BusinessService{}

@Component
public class ServiceRegistry {
@Autowired
public List<BusinessService> services;
}

assertThat(services.get(0).getClass(), is(BusinessServiceA.class));
assertThat(services.get(1).getClass(), is(BusinessServiceB.class));

---

Issue Links:

• Allow to define autowired collections and array elements order [SPR-6253] #10921 Allow to define autowired collections and array elements order ("is duplicated by")
• Document common use cases for @Order vs @Priority vs @DependsOn [SPR-16213] #20761 Document common use cases for @Order vs @Priority vs @DependsOn

Referenced from: commits 4a9af23

15 votes, 15 watchers

[spring-projects-issues]

David Erickson commented

Would love to see this implemented, have run into use cases needing this!!

[spring-projects-issues]

Martin Frey commented

Here is a version that I have implemented at the time I needed that feature in an ExtendedBeanFactory:

@Override
protected Object doResolveDependency(DependencyDescriptor descriptor,
          Class<?> type, String beanName, Set<String> autowiredBeanNames,
          TypeConverter typeConverter) throws BeansException {
     Object result = super.doResolveDependency(descriptor, type, beanName,
               autowiredBeanNames, typeConverter);
     if (result != null && descriptor.getField() != null) {
          if (descriptor.getField().isAnnotationPresent(OrderedWired.class)) {
               if (type.isArray()) {
                        Object[] resultArray = (Object[]) result;
                        if (log.isDebugEnabled()) {
                                 log.debug("Sorting results for {}.{}", descriptor
                                                   .getField().getDeclaringClass(), descriptor
                                                   .getDependencyName());
                        }
                        Arrays.sort(resultArray,
                                          AnnotationAwareOrderComparator.INSTANCE);
                        return resultArray;
               } else if (List.class.isAssignableFrom(type)) {
                        List<?> resultList = (List<?>) super.doResolveDependency(
                                          descriptor, type, beanName, autowiredBeanNames,
                                          typeConverter);
                        if (log.isDebugEnabled()) {
                                 log.debug("Sorting results for {}.{}", descriptor
                                                   .getField().getDeclaringClass(), descriptor
                                                   .getDependencyName());
                        }
                        Collections.sort(resultList,
                                          AnnotationAwareOrderComparator.INSTANCE);
                        return resultList;
               }
          }
     }
     return result;
}

And this would be wired like this at the moment:

@Autowired
@OrderedWired
private List<DataInitializer> dataInitializers;

[spring-projects-issues]

Juergen Hoeller commented

Finally implemented as a core feature for 4.0: However, not in the BeanFactory's resolveDependency itself but rather in AutowiredAnnotationBeanPostProcessor, in order to limit its applicability to @Autowired/@Inject. Programmatic callers of resolveDependency can call AnnotationAwareOrderComparator.sortIfNecessary(...) as they see fit.

Juergen

[spring-projects-issues]

Ittai Zeidman commented

@Juergen,
Any chance this will be backported to 3.2.x?

[spring-projects-issues]

Juergen Hoeller commented

I'm afraid not, since 3.2.x is in maintenance mode already... with the upcoming 3.2.7 being the last planned release in that line, just fixing a few remaining bugs.

That said, is there anything preventing you from upgrading to the 4.0 line? The upcoming 4.0.1 fixes all known regressions from 3.2.x, so it should be a very smooth upgrade... as long as the minimal system requirements are met (see https://github.com/spring-projects/spring-framework/wiki/Migrating-from-earlier-versions-of-the-spring-framework).

Juergen

[spring-projects-issues]

Martin Frey commented

As this will not be backported i add here the steps i took to implement it in an ExtendedBeanFactory for 3.2 at the time. (Upgrading from Spring 3.2 to 4.0 was a breeze by the way! 1h of work. Thanks for that :) )

-> I removed the OrderedWired Annotation in this code, so arrays and collections are always sorted.

1. create ExtendedBeanFactory:

    public class ExtendedBeanFactory extends DefaultListableBeanFactory {
        private static final Logger log = LoggerFactory.getLogger(ExtendedBeanFactory.class);

        public ExtendedBeanFactory() {
            super();
        }

        public ExtendedBeanFactory(BeanFactory parentBeanFactory) {
            super(parentBeanFactory);
        }

        @Override
        protected Object doResolveDependency(DependencyDescriptor descriptor, Class<?> type, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {
            Object result = super.doResolveDependency(descriptor, type, beanName, autowiredBeanNames, typeConverter);
            if (result != null) {
                if (type.isArray()) {
                    Object[] resultArray = (Object[]) result;
                    if (log.isDebugEnabled()) {
                        log.debug("Sorting results for {}.{}", descriptor.getField().getDeclaringClass(), //$NON-NLS-1$
                                descriptor.getDependencyName());
                    }
                    Arrays.sort(resultArray, AnnotationAwareOrderComparator.INSTANCE);
                    return resultArray;
                } else if (List.class.isAssignableFrom(type)) {
                    List<?> resultList = (List<?>) super.doResolveDependency(descriptor, type, beanName, autowiredBeanNames,
                            typeConverter);
                    if (log.isDebugEnabled()) {
                        log.debug("Sorting results for {}.{}", descriptor.getField().getDeclaringClass(), //$NON-NLS-1$
                                descriptor.getDependencyName());
                    }
                    Collections.sort(resultList, AnnotationAwareOrderComparator.INSTANCE);
                    return resultList;
                }
            }
            return result;
        }
    }

2. create ExtendedXmlWebApplicationContext:

    public class ExtendedXmlWebApplicationContext extends XmlWebApplicationContext {

        @Override
        protected DefaultListableBeanFactory createBeanFactory() {
            return new ExtendedBeanFactory(getInternalParentBeanFactory());
        }

    }

3. create ExtendedDispatcherServlet

    public class ExtendedDispatcherServlet extends DispatcherServlet {

        public ExtendedDispatcherServlet() {
            super();
            setContextClass(ExtendedXmlWebApplicationContext.class);
        }

        public ExtendedDispatcherServlet(WebApplicationContext webApplicationContext) {
            super(webApplicationContext);
            setContextClass(ExtendedXmlWebApplicationContext.class);
        }

    }

4. declare it in web.xml

<context-param>
    <param-name>contextClass</param-name>
    <param-value>org.....ExtendedXmlWebApplicationContext</param-value>
</context-param>
<servlet>
    <servlet-name>appServlet</servlet-name>
    <servlet-class>org.....ExtendedDispatcherServlet</servlet-class>
</servlet>

For test integration this was a bit more tricky as i needed to override the AbstractDelegatingSmartContextLoader. If this code is desired I can post this too.

As said, upgrading to 4.0 was a simple excercise, so if you can upgrade i would go for that solution.

[spring-projects-issues]

Donnchadh O Donnabhain commented

Anybody using Spring WebFlow would be blocked from upgrading to Spring 4.0 until SWF 2.3.3, which includes SWF-1600, is released.

[spring-projects-issues]

sorin commented

If I want to sort a list of beans of type A for example, I don't think it's enough to implement Ordered interface, I move to 4.0.0 but the getOrder method it's not call, I have to declare bean of type BeanPostProcessor in order to be call getOrder method from OrderComparator class.

I's normal this behavior ?

thanks
Sorin

[spring-projects-issues]

Stéphane Nicoll commented

Hi,

This issue has been closed. If you have a question, please raise it on StackOverflow with the #spring tag. What you are describing should work out-of-the box: both Ordered implementations and annotated class with @Order are used to order the collection to auto wire.

Thanks.