SpringBoot系列教程之Bean之指定初始化順序的若干姿式

時間 2020-05-13

標籤 springboot 系列教程 bean 指定初始化順序若干欄目 Spring 简体版

原文原文鏈接

上一篇博文介紹了@Order註解的常見錯誤理解，它並不能指定 bean 的加載順序，那麼問題來了，若是我須要指定 bean 的加載順序，那應該怎麼辦呢？java

本文將介紹幾種可行的方式來控制 bean 之間的加載順序git

構造方法依賴
@DependOn 註解
BeanPostProcessor 擴展

原文: SpringBoot系列教程之Bean之指定初始化順序的若干姿式

I. 環境搭建

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

<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. 構造方法依賴

這種能夠說是最簡單也是最多見的使用姿式，可是在使用時，須要注意循環依賴等問題web

咱們知道 bean 的注入方式之中，有一個就是經過構造方法來注入，藉助這種方式，咱們能夠解決有優先級要求的 bean 之間的初始化順序spring

好比咱們建立兩個 Bean，要求 CDemo2 在 CDemo1 以前被初始化，那麼咱們的可用方式app

@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);
    }
}

實測輸出結果以下，和咱們預期一致maven

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

須要有注入關係，如 CDemo2 經過構造方法注入到 CDemo1 中，若是須要指定兩個沒有注入關係的 bean 之間優先級，則不太合適（好比我但願某個 bean 在全部其餘的 Bean 初始化以前執行）
循環依賴問題，如過上面的 CDemo2 的構造方法有一個 CDemo1 參數，那麼循環依賴產生，應用沒法啓動

另一個須要注意的點是，在構造方法中，不該有複雜耗時的邏輯，會拖慢應用的啓動時間spring-boot

2. @DependOn 註解

這是一個專用於解決 bean 的依賴問題，當一個 bean 須要在另外一個 bean 初始化以後再初始化時，可使用這個註解post

使用方式也比較簡單了，下面是一個簡單的實例 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的實例化順序放在了最前面了