I just announced the new Spring 5 modules in REST With Spring:


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:

public class Excellent implements Rating {

    public int getRating() {
        return 1;

public class Good implements Rating {

    public int getRating() {
        return 2;

public class Average implements Rating {

    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 { 
    private List<Rating> ratings;
    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 5 modules in REST With Spring:


Leave a Reply

Be the First to Comment!

Notify of