I just announced the new Spring Boot 2 material, coming in REST With Spring:

>> CHECK OUT THE COURSE

1. Overview

In this tutorial, we’re going to learn about Spring’s @Order annotation. The @Order annotation defines the sorting order of an annotated component or bean.

It has an optional value argument which determines the order of the component; the default value is Ordered.LOWEST_PRECEDENCE. This marks that the component has the lowest priority among all other ordered components.

Similarly, the value Ordered.HIGHEST_PRECEDENCE can be used for overriding the highest priority among components.

2. When to Use @Order

Before Spring 4.0, the @Order annotation was used only for the AspectJ execution order. It means the highest order advice will run first.

Since Spring 4.0, it supports the ordering of injected components to a collection. As a result, Spring will inject the auto-wired beans of the same type based on their order value.

Let’s explore it with a quick example.

3. How to Use @Order

First of all, let’s set up our project with the relevant interface and classes.

3.1. Interface Creation

Let’s create the Rating interface that determines the rating of a product:

public interface Rating {
    int getRating();
}

3.2. Components Creation

Finally, let’s create three components that define the ratings of some products:

@Component
@Order(1)
public class Excellent implements Rating {

    @Override
    public int getRating() {
        return 1;
    }
}

@Component
@Order(2)
public class Good implements Rating {

    @Override
    public int getRating() {
        return 2;
    }
}

@Component
@Order(Ordered.LOWEST_PRECEDENCE)
public class Average implements Rating {

    @Override
    public int getRating() {
        return 3;
    }
}

Note that the Average class has the lowest priority because of its overridden value.

4. Testing Our Example

Up until now, we’ve created all the required components and the interface to test the @Order annotation. Now, let’s test it to confirm that it works as expected:

public class RatingRetrieverUnitTest { 
    
    @Autowired
    private List<Rating> ratings;
    
    @Test
    public void givenOrder_whenInjected_thenByOrderValue() {
        assertThat(ratings.get(0).getRating(), is(equalTo(1)));
        assertThat(ratings.get(1).getRating(), is(equalTo(2)));
        assertThat(ratings.get(2).getRating(), is(equalTo(3)));
    }
}

5. Conclusion

We’ve learned about the @Order annotation in this quick article. We can find the application of @Order in various use cases – where the ordering of the auto-wired components matter. One example is the Spring’s request filters.

Due to its influence on injection precedence, it may seem like it might influence the singleton startup order also. But in contrast, the dependency relationships and @DependsOn declarations determine the singleton startup order.

All examples mentioned in this tutorial can be found over on Github.

I just announced the new Spring Boot 2 material, coming in REST With Spring:

>> CHECK OUT THE LESSONS