SpringBoot约定了配置文件，默认为 application.properties，通过该文件可以修改很多默认的配置，当然我们还可以在该配置文件内添加自定义的配置，该文件通过 key=value的形式进行配置。

1

疑惑配置提示？

当我们使用开发工具来配置时，就会出现相应的提示，这要完全要归功于 spring-configuration-metadata.json配置元数据文件，该文件内记录了配置的名称、类型、归属类等信息，如果配置类型为 枚举还可以实现 选择性配置。

SpringBoot提供了一个依赖，它的主要任务就是自动生成配置元数据，该依赖的名称为 spring-boot-configuration-processor，在打包时会在 META-INF目录生成一个名为 spring-configuration-metadata.json的文件。

2

配置方式

虽然默认使用 properties格式的配置文件，不过这种方式会导致配置的部分前缀冗余，可阅读性稍差， SpringBoot内部还支持使用 yaml方式的配置文件，只需要在 src/main/resources目录下创建一个名为 application.yml文件即可，使用配置时同样也有提供功能。

项目内可以同时存在 application.properties、 application.yml两个文件，经过测试发现， properties优先级会高一些，相同名称的配置，会将 yml内的配置覆盖掉。

3

指定配置文件

如果你的应用程序配置文件的名称不是 application，你想要进行自定义，可以通过 --spring.config.name命令行参数进行指定，如下所示：

1. java

2. -

3. jar project

4. -

5. sample

6. .

7. jar

8. --

9. spring

10. .

11. config

12. .

13. name

14. =

15. custome

注意事项：我们只需要指定配置文件的名称即可，可以使用 properties或 yaml文件格式，上面的配置会加载 src/main/resources/custome.yml或 src/main/resources/custome.properties。

通过 --spring.config.name仅仅是修改了配置文件的名称，那如果是修改配置文件所处的目录位置，我们需要怎么做呢？

SpringBoot已经给我们准备好了，通过 --spring.config.location参数就可以指定配置文件的位置，如下所示：

1. java

2. -

3. jar project

4. -

5. sample

6. .

7. jar

8. --

9. spring

10. .

11. config

12. .

13. location

14. =

15. classpath

16. :/

17. configs

18. /

19. custome

20. .

21. yml

如果一个配置文件无法满足你的需求，那你看看下面这个方式：

1. java

2. -

3. jar project

4. -

5. sample

6. .

7. jar

8. --

9. spring

10. .

11. config

12. .

13. location

14. =

15. classpath

16. :/

17. configs

18. /

19. custome

20. .

21. yml

22. ,

23. classpath

24. :/

25. configs

26. /

27. default

28. .

29. properties

注意事项：支持通过命令行参数的方式指定多个配置文件，使用英文半角 , 隔开即可。

如果你通过 spring.config.location指定的不是一个文件而是一个目录，在路径最后务必添加一个"/"结束，然后结合 spring.config.name进行组合配置文件，组合示例如下：

1. # 加载/configs/application.properties 或 /configs/application.yml（默认文件名）

2. java

3. -

4. jar project

5. -

6. sample

7. .

8. jar

9. --

10. spring

11. .

12. config

13. .

14. location

15. =

16. classpath

17. :/

18. configs

19. /

20. # 加载/configs/custome.properties 或 /configs/custome.yml

21. java

22. -

23. jar project

24. -

25. sample

26. .

27. jar

28. --

29. spring

30. .

31. config

32. .

33. location

34. =

35. classpath

36. :/

37. configs

38. /

40. --

41. spring

42. .

43. config

44. .

45. name

46. =

47. custome

注意事项： spring.config.name该配置参数默认值为 application，所以如果只是指定了 spring.config.location并为目录形式，上面示例中会自动将 spring.config.name追加到目录路径后，如果指定的 spring.config.location并非是一个目录，这里会忽略 spring.config.name的值。

4

加载顺序

SpringBoot应用程序在启动时会遵循下面的顺序进行加载配置文件：

1. 1. 类路径下的配置文件

2. 2. 类路径内config子目录的配置文件

3. 3. 当前项目根目录下的配置文件

4. 4. 当前项目根目录下config子目录的配置文件

示例项目配置文件存放结构如下所示：

1. .

2. project

3. -

4. sample

5. ├──

6. config

7. │

9. ├──

10. application

11. .

12. yml

13. （

14. 4

15. ）

16. │

18. └──

19. src

20. /

21. main

22. /

23. resources

24. |

26. │

28. ├──

29. application

30. .

31. yml

32. （

33. 1

34. ）

35. |

37. │

39. └──

40. config

41. |

43. |

45. │

47. ├──

48. application

49. .

50. yml

51. （

52. 2

53. ）

54. ├──

55. application

56. .

57. yml

58. （

59. 3

60. ）

启动时加载配置文件顺序：1 > 2 > 3 > 4

src/main/resources下的配置文件在项目编译时，会放在 target/classes下。

5

优先级覆盖

SpringBoot配置文件存在一个特性，优先级较高的配置加载顺序比较靠后， 相同名称的配置 优先级较高的会 覆盖掉 优先级较低的内容。

为了更好地解释这一点，我们根据对应的加载顺序分别创建一个 application.yml配置文件，来验证根据优先级的不同是否存在覆盖问题，如下图所示：

在上面四个配置文件中都有一个名为 name的配置，而红色字体标注的内容就是每个配置文件 name的配置内容，下面我们来启动项目测试下输出内容。

6

运行测试

在测试之前我们让启动类实现 CommandLineRunner接口，如下所示：

1. @SpringBootApplication

2. public

4. class

6. LoadOrderOfConfigFilesApplication

8. implements

10. CommandLineRunner

12. {

14. public

16. static

18. void

19. main

20. (

21. String

22. []

23. args

24. )

26. {

28. SpringApplication

29. .

30. run

31. (

32. LoadOrderOfConfigFilesApplication

33. .

34. class

35. ,

36. args

37. );

39. }

41. @Value

42. (

43. "${name}"

44. )

46. private

48. String

49. name

50. ;

52. @Override

54. public

56. void

57. run

58. (

59. String

60. ...

61. args

62. )

64. throws

66. Exception

68. {

70. System

71. .

72. out

73. .

74. println

75. (

76. "配置名称："

78. +

79. name

80. );

82. }

83. }

项目启动后通过 run方法进行打印 ${name}配置的内容。

测试一：顺序覆盖

保留上面四个对应加载顺序的配置文件，启动项目，控制台输出内容：

1. 配置名称：

2. project

3. /

4. config

期望与实际输出是符合的，项目根下的 config目录是 最后加载的，所以它的 优先级相对其他三个来说是 最高的，覆盖顺序为：4 > 3 > 2 > 1。

测试二：跨顺序覆盖

上一个测试点我们对每一个加载顺序都对应添加了一个配置文件，那如果我们只有两个 project/config、 classes/config两个目录的配置文件，是否按照优先级进行覆盖呢？

删除另外两个，只保留 project/config、 classes/config两个位置的配置文件，启动项目控制台输出如下所示：

1. 配置名称：

2. project

3. /

4. config

同样是输出了优先级最高的 project/config配置文件的内容，覆盖顺序为：4 > 1

测试三：单顺序加载

平时在项目开发中一般都是将 application.yml配置文件放在 src/main/resources目录下，然而根据上面的加载顺序来看，我们可以将配置文件放置在任意一处，启动时都会进行加载。

仅保留 classes/config位置的配置文件，启动项目控制台输出内容如下所示：

1. 配置名称：

2. classes

3. /

4. config

IDEA对 SpringBoot的支持真的很强大， classes/config下的配置文件同样提供了 关键字提醒功能。

7

总结

了解配置文件的加载顺序，才能得心应手的进行配置覆盖，完全控制在不同环境下使用不同的配置内容，要记住 classes/application.yml优先级最低， project/config/application.yml优先级最高。