SpringBoot Bean中如何指定初始化順序的若干姿勢

SpringBoot Bean中如何指定初始化順序的若干姿勢，很多新手對此不是很清楚，為了幫助大家解決這個難題，下面小編將為大家詳細講解，有這方面需求的人可以來學習下，希望你能有所收獲。

I. 環境搭建

我們的測試項目和上一篇博文公用一個項目環境，當然也可以建一個全新的測試項目，對應的配置如下：（文末有源碼地址）

<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. 初始化順序指定

1. 構造方法依賴

這種可以說是最簡單也是最常見的使用姿勢，但是在使用時，需要注意循環依賴等問題

我們知道 bean 的注入方式之中，有一個就是通過構造方法來注入，借助這種方式，我們可以解決有優先級要求的 bean 之間的初始化順序

比如我們創建兩個 Bean，要求 CDemo2 在 CDemo1 之前被初始化，那么我們的可用方式

@Component
public class CDemo1 {

    private String name = "cdemo 1";

    public CDemo1(CDemo2 cDemo2) {
        System.out.println(name);
    }
}

@Component
public class CDemo2 {

    private String name = "cdemo 1";

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

實測輸出結果如下，和我們預期一致

雖然這種方式比較直觀簡單，但是有幾個限制

• 需要有注入關系，如 CDemo2 通過構造方法注入到 CDemo1 中，如果需要指定兩個沒有注入關系的 bean 之間優先級，則不太合適（比如我希望某個 bean 在所有其他的 Bean 初始化之前執行）

• 循環依賴問題，如過上面的 CDemo2 的構造方法有一個 CDemo1 參數，那么循環依賴產生，應用無法啟動

另外一個需要注意的點是，在構造方法中，不應有復雜耗時的邏輯，會拖慢應用的啟動時間

2. @DependOn 注解

這是一個專用于解決 bean 的依賴問題，當一個 bean 需要在另一個 bean 初始化之后再初始化時，可以使用這個注解

使用方式也比較簡單了，下面是一個簡單的實例 case

@DependsOn("rightDemo2")
@Component
public class RightDemo1 {
    private String name = "right demo 1";

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

@Component
public class RightDemo2 {
    private String name = "right demo 2";

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

上面的注解放在 RightDemo1 上，表示RightDemo1的初始化依賴于rightDemo2這個 bean

在使用這個注解的時候，有一點需要特別注意，它能控制 bean 的實例化順序，但是 bean 的初始化操作（如構造 bean 實例之后，調用@PostConstruct注解的初始化方法）順序則不能保證，比如我們下面的一個實例，可以說明這個問題

@DependsOn("rightDemo2")
@Component
public class RightDemo1 {
    private String name = "right demo 1";

    @Autowired
    private RightDemo2 rightDemo2;

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

    @PostConstruct
    public void init() {
        System.out.println(name + " _init");
    }
}

@Component
public class RightDemo2 {
    private String name = "right demo 2";

    @Autowired
    private RightDemo1 rightDemo1;

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

    @PostConstruct
    public void init() {
        System.out.println(name + " _init");
    }
}

注意上面的代碼，雖然說有循環依賴，但是通過@Autowired注解方式注入的，所以不會導致應用啟動失敗，我們先看一下輸出結果

有意思的地方來了，我們通過@DependsOn注解來確保在創建RightDemo1之前，先得創建RightDemo2；

所以從構造方法的輸出可以知道，先實例 RightDemo2, 然后實例 RightDemo1；

然后從初始化方法的輸出可以知道，在上面這個場景中，雖然 RightDemo2 這個 bean 創建了，但是它的初始化代碼在后面執行

題外話： 有興趣的同學可以試一下把上面測試代碼中的@Autowired的依賴注入刪除，即兩個 bean 沒有相互注入依賴，再執行時，會發現輸出順序又不一樣

3. BeanPostProcessor

最后再介紹一種非典型的使用方式，如非必要，請不要用這種方式來控制 bean 的加載順序

先創建兩個測試 bean

@Component
public class HDemo1 {
    private String name = "h demo 1";

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

@Component
public class HDemo2 {
    private String name = "h demo 2";

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

我們希望 HDemo2 在 HDemo1 之前被加載，借助 BeanPostProcessor，我們可以按照下面的方式來實現

@Component
public class DemoBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter implements BeanFactoryAware {
    private ConfigurableListableBeanFactory beanFactory;
    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
            throw new IllegalArgumentException(
                    "AutowiredAnnotationBeanPostProcessor requires a ConfigurableListableBeanFactory: " + beanFactory);
        }
        this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
    }

    @Override
    @Nullable
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        // 在bean實例化之前做某些操作
        if ("HDemo1".equals(beanName)) {
            HDemo2 demo2 = beanFactory.getBean(HDemo2.class);
        }
        return null;
    }
}

請將目標集中在postProcessBeforeInstantiation，這個方法在某個 bean 的實例化之前，會被調用，這就給了我們控制 bean 加載順序的機會

看到這種騷操作，是不是有點蠢蠢欲動，比如我有個 bean，希望在應用啟動之后，其他的 bean 實例化之前就被加載，用這種方式是不是也可以實現呢?

下面是一個簡單的實例 demo，重寫DemoBeanPostProcessor的postProcessAfterInstantiation方法，在 application 創建之后，就加載我們的 FDemo 這個 bean

@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
    if ("application".equals(beanName)) {
        beanFactory.getBean(FDemo.class);
    }

    return true;
}


@DependsOn("HDemo")
@Component
public class FDemo {
    private String name = "F demo";

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

@Component
public class HDemo {
    private String name = "H demo";

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

從下圖輸出可以看出，HDemo, FDemo的實例化順序放在了最前面了

4. 小結

在小結之前，先指出一下，一個完整的 bean 創建，在本文中區分了兩塊順序

• 實例化 （調用構造方法）

• 初始化 （注入依賴屬性，調用@PostConstruct方法）

主要介紹了三種方式來控制 bean 的加載順序，分別是

• 通過構造方法依賴的方式，來控制有依賴關系的 bean 之間初始化順序，但是需要注意循環依賴的問題

• @DependsOn注解，來控制 bean 之間的實例順序，需要注意的是 bean 的初始化方法調用順序無法保證

• BeanPostProcessor 方式，來手動控制 bean 的加載順序

看完上述內容是否對您有幫助呢？如果還想對相關知識有進一步的了解或閱讀更多相關文章，請關注億速云行業資訊頻道，感謝您對億速云的支持。