Spring Boot 配置文件启动加载顺序

前言

Spring Boot的启动加载顺序是一个涉及多个步骤和组件的过程。Spring Boot通过一系列默认设置简化了应用程序的配置，使得开发者能够快速地搭建和部署应用。为了实现这一目标，Spring Boot采用了一种分层和优先级机制来加载配置文件。

一、Spring Boot 配置文件的加载顺序

1）bootstrap.properties 或 bootstrap.yml （如果存在）

application.properties 或 application.yml

2）命令行参数

3）操作系统环境变量

4）从 RandomValuePropertySource 生成的 random.* 属性

5）由 @TestPropertySource 注解声明的属性

6）由 @SpringBootTest 注解并且 #properties 注解属性的测试属性

7）由 SpringBootApplication 注解的 exclude 属性排除的自动配置的类

8）由应用程序的 RandomValuePropertySource 生成的 random.* 属性

9）在 application.properties 或 application.yml 中使用 SpringApplication 的 setDefaultProperties 方法设置的属性

这个加载顺序是有意为此的，因为有些属性需要在后续加载的时候覆盖前面的同名属性。

这里是一个简单的例子，演示如何使用 bootstrap.properties 来配置一些在 Spring Boot 启动时需要的属性：

bootstrap.properties

java 复制代码

# bootstrap.properties
spring.application.name=myapp
spring.profiles.active=prod

或者 application.yml：

java 复制代码

# application.yml
server:
  port: 8080

命令行参数可以用于覆盖特定的属性，例如：

java 复制代码

java -jar myapp.jar --server.port=9090

二、在Spring Boot中，配置文件的加载顺序遵循以下步骤

自动加载：Spring Boot在启动时会扫描特定位置的配置文件。这些位置包括jar包内的classpath路径、当前项目的根目录以及桌面上的文件路径。Spring Boot会优先加载高优先级的配置文件，并在低优先级配置文件被加载时覆盖掉冲突的属性。
自定义配置文件：开发者可以通过spring.config.name属性指定自定义配置文件名。Spring Boot会按照以下顺序查找这些配置文件：application.和application-default.，并根据扩展名的优先级进行加载。扩展名包括：.properties、.xml、.yml、.yaml。
命令行参数：开发者可以在命令行中指定一些参数来覆盖默认的配置值。这些参数将优先于任何其他配置文件中的值生效。
环境变量：环境变量也可以用来覆盖配置文件中的属性值。这些变量在应用程序启动时自动加载，无需额外操作。
属性占位符：在配置文件中，可以使用${...}语法来引用其他属性的值。这种方式可以创建依赖关系，使得某些属性在其他属性被解析后才能确定其值。
自动配置类：Spring Boot提供了一系列的自动配置类，可以根据项目需求自动配置一些组件。开发者可以通过禁用特定的自动配置类或自定义自动配置类来覆盖默认设置。
条件注解：Spring Boot允许使用条件注解来控制特定组件的创建。例如，只有当某个属性存在或满足特定条件时，某个bean才会被创建。
外部化配置：Spring Boot支持将部分配置移动到外部属性文件中，以提高可维护性和复用性。这些外部属性文件可以包含在jar包内部、当前项目根目录或其他指定位置。

总结来说，Spring Boot的配置加载顺序遵循以下原则：优先从高优先级的源加载配置，并在低优先级源加载时覆盖冲突的属性；开发者可以通过自定义配置文件、命令行参数和环境变量来覆盖默认值；自动配置类和条件注解允许更灵活地控制组件的创建；而外部化配置则提高了应用程序的维护性和复用性。了解这个加载顺序有助于更好地管理和优化Spring Boot应用程序的配置。

关键步骤划分的Spring Boot启动加载顺序的概述：

三、启动准备阶段

装载核心启动器类：org.springframework.boot.SpringApplication。
通过构造函数创建SpringApplication实例时，进行一系列的初始化工作。

四、配置加载阶段

Spring Boot项目会按照特定的顺序加载配置文件，这些配置文件可以是application.properties或application.yml格式。

配置文件的加载顺序（优先级由高到低）：

file:./config/（项目根路径下的config文件夹）
file:./（项目根路径）
classpath:/config/（类路径下的config文件夹）
classpath:/（类路径）

外部配置文件的加载方式：

命令行参数：可以直接在启动命令后添加启动参数。
spring.config.location：用于指定配置文件的新位置。

如果多个文件有相同的key，高优先级的值会覆盖低优先级的值。

五、上下文准备阶段

准备并刷新应用上下文（Context）。
加载所有的初始化器（如从META-INF/spring.factories配置文件中加载的）。
加载所有的监听器（也是从META-INF/spring.factories配置文件中加载的）。

六、启动执行阶段

触发所有CommandLineRunner执行。
执行自定义的初始化逻辑（如果有的话）。

七、完成阶段

启动完成，等待退出。

注意

带profile的配置文件（如application-dev.yml）通常具有比不带profile的配置文件（如application.yml）更高的优先级。

代码演示，项目启动成功后执行一段初始化逻辑：

八、启动main方法中添加初始化逻辑

在Spring Boot的main入口启动方法中，执行SpringApplication.run(OrderApplication.class, args)是可以返回ApplicationContext对象的，我们可以从ApplicationContext中获取指定的bean对象，执行初始化逻辑。

java 复制代码

@SpringBootApplication(scanBasePackages = {"com.xx.service"})
public class OrderApplication {

    public static void main(String[] args){
        //启动的run方法
        ApplicationContext context =  SpringApplication.run(OrderApplication.class, args);

        //启动执行操作：从context中获取指定的bean，调度初始化逻辑
        OrderService orderService = (OrderService)context.getBean("OrderServiceImpl");
        orderService.preLoadCache();
    }

}

初始化逻辑：

java 复制代码

@Service
public class OrderServiceImpl implements OrderService {
    @Override
    public void preLoadCache(){
        System.out.println("应用启动完成：开始执行缓存预加载操作");
    }
}

九、实现ApplicationRunner或CommandLineRunner接口

在Spring Boot框架中，给我们提供了ApplicationRunner和CommandLineRunner接口来帮助我们解决项目启动后的初始化资源操作。

如果有多个ApplicationRunner、CommandLineRunner的实现类，可以通过@Order注解进行排序，参数值小的先执行。

实现CommandLineRunner接口：

java 复制代码

@Order(1)
@Component
@Slf4j
public class CommandLineRunnerImpl implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("应用启动完成，开始执行CommandLineRunner方法完成资源初始化");
    }
}

实现ApplicationRunner接口：

java 复制代码

@Order(2)
@Component
@Slf4j
public class ApplicationRunnerImpl implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("应用启动完成，开始执行ApplicationRunner方法完成资源初始化");
    }
}

源码分析：

在SpringApplication的run方法中，有这么一段核心代码

java 复制代码

public ConfigurableApplicationContext run(String... args) {
        long startTime = System.nanoTime();
        DefaultBootstrapContext bootstrapContext = this.createBootstrapContext();
        ConfigurableApplicationContext context = null;
        this.configureHeadlessProperty();
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        listeners.starting(bootstrapContext, this.mainApplicationClass);

        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, bootstrapContext, applicationArguments);
            this.configureIgnoreBeanInfo(environment);
            Banner printedBanner = this.printBanner(environment);
            context = this.createApplicationContext();
            context.setApplicationStartup(this.applicationStartup);
            this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
            this.refreshContext(context);
            this.afterRefresh(context, applicationArguments);
            Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), timeTakenToStartup);
            }

            listeners.started(context, timeTakenToStartup);
            this.callRunners(context, applicationArguments);
        } catch (Throwable var12) {
            this.handleRunFailure(context, var12, listeners);
            throw new IllegalStateException(var12);
        }

        try {
            Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
            listeners.ready(context, timeTakenToReady);
            return context;
        } catch (Throwable var11) {
            this.handleRunFailure(context, var11, (SpringApplicationRunListeners)null);
            throw new IllegalStateException(var11);
        }
    }

十、ApplicationListener监听启动完成事件

通过源码，我们发现在Spring Boot启动过程中，框架内部定义了很多事件SpringApplicationEvent，用来通知SpringApplicationRunListeners监听器，以针对各种事件执行对应的逻辑处理。而Spring Boot启动完成的事件对应的是ApplicationStartedEvent，我们可以通过自定义监听器来监听ApplicationStartedEvent事件，然后执行初始化资源的相关操作。

java 复制代码

@Component
class StartedEventListener implements ApplicationListener<ApplicationStartedEvent> {
    @Override
    public void onApplicationEvent(ApplicationStartedEvent event) {
        System.out.println("应用启动完成，通知监听器执行缓存预加载操作");
    }
}

总结

Spring Boot支持两种类型的配置文件：application.properties和application.yml。当同一个目录下同时存在这两种类型的配置文件时，application.properties会优先加载，但两种文件会进行互补配置。即，如果同一配置项在两个配置文件中都进行了设置，那么application.properties中的配置会覆盖application.yml中的配置。

除了上述默认的配置文件加载位置外，Spring Boot还支持多种外部配置方式，它们的优先级从高到低如下：

1）命令行参数：通过java -jar命令启动应用时，可以在命令后附加--配置项=值的形式来指定配置。

2）来自java:comp/env的JNDI属性。

3）Java系统属性（System.getProperties()）。

4）操作系统环境变量。

5）RandomValuePropertySource配置的random.*属性值：用于生成随机值。

6）jar包外部的带profile的配置文件（如application-{profile}.properties或application-{profile}.yml）。

7）jar包内部的带profile的配置文件。

8）jar包外部的不带profile的配置文件（如application.properties或application.yml）。

9）jar包内部的不带profile的配置文件。

（由jar包外向jar包内进行寻找，优先加载带profile的，再加载不带profile的。）

10）@Configuration注解类上的@PropertySource。

11）通过SpringApplication.setDefaultProperties指定的默认属性。

另外，可以通过spring.config.location属性来改变默认的配置文件位置。

在项目打包后，可以使用命令行参数的形式来指定配置文件的新位置，指定的配置文件和默认加载的配置文件会共同起作用，形成互补配置。

当使用多环境配置时（如开发、测试、生产环境），可以通过激活不同的profiles来加载对应的配置文件。