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

上一篇博文介绍了@Order注解的常见错误理解，它并不能指定 bean 的加载顺序，那么问题来了，若是我须要指定 bean 的加载顺序，那应该怎么办呢？

本文将介绍几种可行的方式来控制 bean 之间的加载顺序

• 构造方法依赖
• @DependOn 注解
• BeanPostProcessor 扩展

原文: 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 的加载顺序

II. 其余

0. 项目

• SpringBoot系列教程之Bean加载顺序之错误使用姿式辟谣
• 工程：github.com/liuyueyi/sp…
• 项目: github.com/liuyueyi/sp…

1. 一灰灰 Blog

尽信书则不如，以上内容，纯属一家之言，因我的能力有限，不免有疏漏和错误之处，如发现 bug 或者有更好的建议，欢迎批评指正，不吝感激

下面一灰灰的我的博客，记录全部学习和工做中的博文，欢迎你们前去逛逛

• 一灰灰 Blog 我的博客 blog.hhui.top
• 一灰灰 Blog-Spring 专题博客 spring.hhui.top