SpringBoot系列教程之Bean加載順序之錯誤使用姿勢辟謠

在網上查詢 Bean 的加載順序時，看到了大量的文章中使用@Order注解的方式來控制 bean 的加載順序，不知道寫這些的博文的同學自己有沒有實際的驗證過，本文希望通過指出這些錯誤的使用姿勢，讓觀文的小伙伴可以知道@Order的具體的應用場景

原文地址: SpringBoot系列教程之Bean加載順序之錯誤使用姿勢辟謠

I. 環境搭建

創建一個 maven 項目，pom 文件如下（具體的項目代碼，可以在文末獲取）

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.7</version>
    <relativePath/> <!-- lookup parent from update -->
</parent>

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <spring-cloud.version>Finchley.RELEASE</spring-cloud.version>
    <java.version>1.8</java.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

<build>
    <pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </pluginManagement>
</build>
<repositories>
    <repository>
        <id>spring-milestones</id>
        <name>Spring Milestones</name>
        <url>https://repo.spring.io/milestone</url>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </repository>
</repositories>

II. 錯誤姿勢

下面我們會介紹兩種典型注解的錯誤使用姿勢，一個@Order，一個@AutoConfigureOrder

I. @Order

err.case1: 類上添加 Order 注解

一種常見的錯誤觀點是在類上添加這個 Order 注解，就可以指定 bean 之間的初始化順序，order 值越小，則優先級越高，接下來我們實際測試一下，是否如此

我們創建兩個 DemoBean, 指定不同的 Order 順序

@Order(4)
@Component
public class BaseDemo1 {
    private String name = "base demo 1";

    public BaseDemo1() {
        System.out.println(name);
    }
}

@Order(3)
@Component
public class BaseDemo2 {
    private String name = "base demo 2";

    public BaseDemo2() {
        System.out.println(name);
    }
}

根據前面的觀點，orde 值小的優先級高，那么 BaseDemo2 應該先被初始化，實際測試一下，輸出如下

err.case2: 配置類中 Bean 聲明方法上添加@Order

Bean 除了上面的自動掃描之外，還有一種方式就是通過@Bean注解，下面我們演示一下在配置類中指定 bean 加載順序的錯誤 case

同樣我們新建兩個測試 bean

public class BaseDemo3 {
    private String name = "base demo 3";

    public BaseDemo3() {
        System.out.println(name);
    }
}

public class BaseDemo4 {
    private String name = "base demo 4";

    public BaseDemo4() {
        System.out.println(name);
    }
}

接下來在配置類中定義 bean

@Configuration
public class ErrorDemoAutoConf {
    @Order(2)
    @Bean
    public BaseDemo3 baseDemo3() {
        return new BaseDemo3();
    }

    @Order(1)
    @Bean
    public BaseDemo4 baseDemo4() {
        return new BaseDemo4();
    }
}

同樣的，如果@Order注解有效，那么BaseDemo4應該先被初始化

從上面的實際測試輸出可以看出，@Order 注解在上面的方式中也不生效，如果有興趣的同學可以試一下，將上面配置類中的兩個方法的順序顛倒一下，會發現BaseDemo4先加載

err.case3: @Order 注解修飾配置類

這也是一種常見的錯誤 case，認為@Order 注解是用來指定配置類的加載順序的，然而真的是這樣么?

我們創建兩個測試的配置類

@Order(1)
@Configuration
public class AConf {
    public AConf() {
        System.out.println("AConf init!");
    }
}

@Order(0)
@Configuration
public class BConf {
    public BConf() {
        System.out.println("BConf init");
    }
}

如果@Order 注解生效，那么 BConf 配置類會優先初始化，那么我們實測一下

從上面的結果可以看出，並不是 BConf 先被加載；當然這種使用姿勢，實際上和第一種錯誤 case，並沒有什么區別，配置類也是 bean，前面不生效，這里當然也不會生效

那么是不是我們的理解不對導致的呢，實際上這個@Order放在配置類上之后，是這個配置類中定義的 Bean 的優先於另一個配置類中定義的 Bean 呢？

同樣的我們測試下這種 case，我們定義三個 bean，兩個 conf

public class Demo1 {
    private String name = "conf demo bean 1";

    public Demo1() {
        System.out.println(name);
    }
}

public class Demo2 {
    private String name = "conf demo bean 2";

    public Demo2() {
        System.out.println(name);
    }
}

public class Demo3 {
    private String name = "conf demo bean 3";

    public Demo3() {
        System.out.println(name);
    }
}

然后我們將 Demo1, Demo3 放在一個配置中，Demo2 放在另外一個配置中

@Order(2)
@Configuration
public class AConf1 {
    @Bean
    public Demo1 demo1() {
        return new Demo1();
    }

    @Bean
    public Demo3 demo3() {
        return new Demo3();
    }
}

@Order(1)
@Configuration
public class BConf1 {

    @Bean
    public Demo2 demo2() {
        return new Demo2();
    }
}

如果@Order 注解實際上控制的是配置類中 Bean 的加載順序，那么 BConf1 中的 Bean 應該優先加載，也就是說 Demo2 會優先於 Demo1, Demo3，實際測試一下，輸出如

上面的輸出結果和我們預期的並不一樣，所以@Order注解來決定配置類的順序也是不對的

2. @AutoConfigureOrder

從命名來看，這個注解是用來指定配置類的順序的，然而對於這個注解的錯誤使用也是非常多的，而大多的錯誤使用在於沒有真正的了解到它的使用場景

接下來我們來演示一下錯誤的使用 case

在工程內新建兩個配置類，直接使用注解

@Configuration
@AutoConfigureOrder(1)
public class AConf2 {
    public AConf2() {
        System.out.println("A Conf2 init!");
    }
}

@Configuration
@AutoConfigureOrder(-1)
public class BConf2 {
    public BConf2() {
        System.out.println("B conf2 init!");
    }
}

當注解生效時，BConf 會優先級加載

從輸出結果來看，和我們預期的不一樣；那么這個注解是不是作用於配置類中的 Bean 的順序，而不是配置類本身呢？

同樣的我們設計一個 case 驗證一下

public class DemoA {
    private String name = "conf demo bean A";

    public DemoA() {
        System.out.println(name);
    }
}

public class DemoB {
    private String name = "conf demo bean B";

    public DemoB() {
        System.out.println(name);
    }
}

public class DemoC {
    private String name = "conf demo bean C";

    public DemoC() {
        System.out.println(name);
    }
}

對應的配置類

@Configuration
@AutoConfigureOrder(1)
public class AConf3 {
    @Bean
    public DemoA demoA() {
        return new DemoA();
    }

    @Bean
    public DemoC demoC() {
        return new DemoC();
    }
}

@Configuration
@AutoConfigureOrder(-1)
public class BConf3 {

    @Bean
    public DemoB demoB() {
        return new DemoB();
    }
}

如果 DemoB 后被加載，則說明上面的觀點是錯誤的，實測結果如下

所以問題來了，@AutoConfigureOrder這個注解並不能指定配置類的順序，還叫這個名，干啥？存粹是誤導人不是!!!

接下來我們看一下@Order和@AutoConfigureOrder的正確使用方式

III. 使用說明

1. @Order

先看一下這個注解的官方注釋

{@code @Order} defines the sort order for an annotated component.
Since Spring 4.0, annotation-based ordering is supported for many
kinds of components in Spring, even for collection injection where the order values
of the target components are taken into account (either from their target class or
from their {@code @Bean} method). While such order values may influence priorities
at injection points, please be aware that they do not influence singleton startup
order which is an orthogonal concern determined by dependency relationships and
{@code @DependsOn} declarations (influencing a runtime-determined dependency graph).

最開始 Order 注解用於切面的優先級指定；在 4.0 之后對它的功能進行了增強，支持集合的注入時，指定集合中 bean 的順序

並且特別指出了，它對於但實例的 bean 之間的順序，沒有任何影響；這句話根據我們上面的測試也可以驗證

接下來我們需要看一下通過@Order 注解來注入集合時，指定順序的場景

首先我們定義兩個 Bean 實現同一個接口，並添加上@Order注解

public interface IBean {
}

@Order(2)
@Component
public class AnoBean1 implements IBean {

    private String name = "ano order bean 1";

    public AnoBean1() {
        System.out.println(name);
    }
}

@Order(1)
@Component
public class AnoBean2 implements IBean {

    private String name = "ano order bean 2";

    public AnoBean2() {
        System.out.println(name);
    }
}

然后再一個測試 bean 中，注入IBean的列表，我們需要測試這個列表中的 Bean 的順序是否和我們定義的@Order規則一致

@Component
public class AnoTestBean {

    public AnoTestBean(List<IBean> anoBeanList) {
        for (IBean bean : anoBeanList) {
            System.out.println("in ano testBean: " + bean.getClass().getName());
        }
    }
}

根據我們的預期, anoBeanList 集合中，anoBean2 應該在前面

根據上面的輸出，也可以看出列表中的順序和我們預期的一致，並且 AnoOrderBean1與 AnoOrderBean2 的加載順序和注解沒有關系

2. @AutoConfigureOrder

這個注解用來指定配置文件的加載順序，然而前面的測試中並沒有生效，那么正確的使用姿勢是怎樣的呢？

@AutoConfigureOrder適用於外部依賴的包中 AutoConfig 的順序，而不能用來指定本包內的順序

為了驗證上面的說法，我們再次新建兩個工程，並指定自動配置類的順序

工程一配置如下：

@AutoConfigureOrder(1)
@Configuration
@ComponentScan(value = {"com.git.hui.boot.order.addition"})
public class AdditionOrderConf {
    public AdditionOrderConf() {
        System.out.println("additionOrderConf init!!!");
    }
}

注意自動配置類如要被正確加載，需要在工程的 /META-INF/spring.factories文件中定義

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.git.hui.boot.order.addition.AdditionOrderConf

工程二的配置如下:

@Configuration
@AutoConfigureOrder(-1)
@ComponentScan("com.git.hui.boot.order.addition2")
public class AdditionOrderConf2 {

    public AdditionOrderConf2() {
        System.out.println("additionOrderConf2 init!!!");
    }
}

然后我們在項目內部添加一個配置

@AutoConfigureOrder(10)
@Configuration
public class OrderConf {
    public OrderConf() {
        System.out.println("inner order conf init!!!");
    }
}

因為注解適用於外部依賴包中的自動配置類的順序，所以上面三個配置類中，正確的話 AdditionOrderConf2 在 AdditionOrderConf1 之前；而 OrderConf 並不會收到注解的影響，默認環境下，內部定義的配置類會優於外部依賴，從下面的輸出也可以佐證我們說明（當然為了驗證確實如次，還應該調整下兩個外部工程配置類的順序，並觀察下加載順序是否隨之改變，我們這里省略掉了）

IV. 小結

本篇主要介紹了網上對@Order和@AutoConfigureOrder常見的錯誤使用姿勢，並給出了正確的使用 case。

下面用簡單的幾句話介紹一下正確的姿勢

• @Order注解不能指定 bean 的加載順序，它適用於 AOP 的優先級，以及將多個 Bean 注入到集合時，這些 bean 在集合中的順序
• @AutoConfigureOrder指定外部依賴的 AutoConfig 的加載順序（即定義在/META-INF/spring.factories文件中的配置 bean 優先級)，在當前工程中使用這個注解並沒有什么鳥用
• 同樣的 @AutoConfigureBefore和 @AutoConfigureAfter這兩個注解的適用范圍和@AutoConfigureOrder一樣

0. 項目

• 工程：https://github.com/liuyueyi/spring-boot-demo
• 源碼模塊: - https://github.com/liuyueyi/spring-boot-demo/blob/master/spring-boot/008-beanorder - https://github.com/liuyueyi/spring-boot-demo/blob/master/spring-boot/008-beanorder-addition - https://github.com/liuyueyi/spring-boot-demo/blob/master/spring-boot/008-beanorder-addition2

1. 一灰灰 Blog

盡信書則不如，以上內容，純屬一家之言，因個人能力有限，難免有疏漏和錯誤之處，如發現 bug 或者有更好的建議，歡迎批評指正，不吝感激

下面一灰灰的個人博客，記錄所有學習和工作中的博文，歡迎大家前去逛逛

• 一灰灰 Blog 個人博客 https://blog.hhui.top
• 一灰灰 Blog-Spring 專題博客 http://spring.hhui.top