前言

为了 Spring Boot 能够更好地生成配置元数据文件,我们可以在创建项目时添加 Spring Configuartion Processor 依赖,或者在创建好项目后的 pom.xml 文件中手动添加。添加该依赖后,我们在编写配置时就会有属性提示,大大降低编写错误。

  1. <dependency>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-configuration-processor</artifactId>
  4. <optional>true</optional>
  5. </dependency>

application.properties

自定义属性

application.properties 配置文件是创建项目后就自带的,如果我们要自定义属性,可以在其中直接配置,配置过程如下:

  1. application.properties 中添加我们要自定义的配置;
  1. cunyu.id=1024
  2. cunyu.name=村雨遥
  3. cunyu.website=https://cunyu1943.github.io
  1. 创建实体类来映射我们配置的属性;
  1. package com.cunyu.pojo;
  2. import lombok.AllArgsConstructor;
  3. import lombok.Data;
  4. import lombok.NoArgsConstructor;
  5. import org.springframework.boot.context.properties.ConfigurationProperties;
  6. import org.springframework.stereotype.Component;
  7. /**
  8. * @author : cunyu
  9. * @version : 1.0
  10. * @className : CunyuProperties
  11. * @date : 2020/7/29 13:34
  12. * @description : TODO
  13. */
  14. @Component
  15. @ConfigurationProperties(prefix = "cunyu")
  16. @Data
  17. @NoArgsConstructor
  18. @AllArgsConstructor
  19. public class CunyuProperties {
  20. private int id;
  21. private String name;
  22. private String website;
  23. }
  1. 定义 Controller 来注入测试;
  1. package com.cunyu.controller;
  2. import com.cunyu.pojo.CunyuProperties;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.web.bind.annotation.GetMapping;
  7. import org.springframework.web.bind.annotation.RequestMapping;
  8. import org.springframework.web.bind.annotation.RestController;
  9. /**
  10. * @author : cunyu
  11. * @version : 1.0
  12. * @className : CunyuPropertiesController
  13. * @date : 2020/7/29 13:37
  14. * @description : TODO
  15. */
  16. @RestController
  17. @RequestMapping("/cunyu")
  18. public class CunyuPropertiesController {
  19. private static final Logger logger = LoggerFactory.getLogger(CunyuPropertiesController.class);
  20. @Autowired
  21. CunyuProperties cunyuProperties;
  22. @GetMapping("/profile")
  23. public String cunyuProfile(){
  24. logger.info("---------------");
  25. logger.info(cunyuProperties.toString());
  26. logger.info("---------------");
  27. return cunyuProperties.toString();
  28. }
  29. }
  1. 打开网页测试,打开 1,同时观察控制台,显示如下内容则说明属性注入成功;

SpringBoot 配置详解 - 图1

SpringBoot 配置详解 - 图2

多环境配置

实际开发过程中,常常需要多个环境(如 开发、测试、生产等),而不同环境的配置都不一样,此时配置方法如下;

  1. 创建不同环境对应的配置文件,配置文件名为 application-{profile}.properties{profile} 为我们自定义环境,如下:

开发环境:application-dev.properties

  1. server.servlet.context-path=/dev

测试环境:application-test.properties

  1. server.servlet.context-path=/test

生产环境:application-prod.properties

  1. server.servlet.context-path=/prod
  1. 然后在 application.properties 中加入激活的环境,此时就会激活对应环境的配置;
  1. # {profile} 对应上述的 dev、test、prod
  2. spring.profiles.active={profile}

之所以要分为多个环境的配置,主要是方便在不同环境中开发的需求,比如我们要开发新功能,那此时就可以激活开发配置文件的相关设置,等待我们开发完成之后,然后再切换到测试环境进行测试。而经过严格的测试之后,我们就可以将新推出的功能上线到生产环境中。纵观整个开发流程,我们既完成了新功能的开发,也没有影响到用户对现有系统的使用,所以现在大家基本都是基于这种模式来进行业务开发。

自定义配置文件

假如我们不想用项目自带的 application.properties 配置环境,那我们也可以自定义我们需要的配置。但该如何配置呢?接下来我们就来看看 ~

  1. 首先创建一个自定义配置文件 my.properties,文件名可以自定义,但是后缀要保持一致,然后在其中加入我们自定义配置的属性;
  1. my.id=1024
  2. my.name=村雨遥
  3. my.website=https://cunyu1943.github.io
  1. 定义实体类,用于映射自定义配置文件中的内容;
  1. package com.cunyu.pojo;
  2. import lombok.AllArgsConstructor;
  3. import lombok.Data;
  4. import lombok.NoArgsConstructor;
  5. import org.springframework.boot.context.properties.ConfigurationProperties;
  6. import org.springframework.context.annotation.PropertySource;
  7. import org.springframework.stereotype.Component;
  8. /**
  9. * @author : cunyu
  10. * @version : 1.0
  11. * @className : MyProperties
  12. * @date : 2020/7/29 14:05
  13. * @description : TODO
  14. */
  15. @Component
  16. @PropertySource("classpath:my.properties")
  17. @ConfigurationProperties(prefix = "my")
  18. @Data
  19. @NoArgsConstructor
  20. @AllArgsConstructor
  21. public class MyProperties {
  22. private int id;
  23. private String name;
  24. private String website;
  25. }
  1. 定义 Controller 来注入测试
  1. package com.cunyu.controller;
  2. import com.cunyu.pojo.MyProperties;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.web.bind.annotation.GetMapping;
  7. import org.springframework.web.bind.annotation.RequestMapping;
  8. import org.springframework.web.bind.annotation.RestController;
  9. /**
  10. * @author : cunyu
  11. * @version : 1.0
  12. * @className : MyPropertiesController
  13. * @date : 2020/7/29 14:07
  14. * @description : TODO
  15. */
  16. @RestController
  17. @RequestMapping("/my")
  18. public class MyPropertiesController {
  19. private static final Logger logger = LoggerFactory.getLogger(MyPropertiesController.class);
  20. @Autowired
  21. MyProperties myProperties;
  22. @GetMapping("/profile")
  23. public String myProfile() {
  24. logger.info("=============");
  25. logger.info(myProperties.toString());
  26. logger.info("=============");
  27. return myProperties.toString();
  28. }
  29. }
  1. 打开网页测试,打开 http://localhost:8080/my/profile,同时观察控制台,显示如下内容则说明属性注入成功;

SpringBoot 配置详解 - 图3

SpringBoot 配置详解 - 图4

注意

application.propertiesmy.properties 会优先加载 application.properties

.yml 和 .properties

一般来说,使用 IDEA 创建一个 Spring Boot 项目时,默认都会生成一个 application.properties 的配置文件。该配置文件是用来 修改 Spring Boot 自动配置的默认值。 但有的朋友会更倾向于使用 application.yml,那么问题来了,这两种格式到底有啥区别呢?

开始比较之前,我们先来看看各自的实例:

  • .properties 格式
  1. server.port=8081
  2. spring.datasource.type=org.apache.tomcat.jdbc.pool.DataSource
  3. spring.datasource.url=jdbc:mysql://aliyuncs.com:3306/database?useUnicode=true&zeroDateTimeBehavior=convertToNull&autoReconnect=true
  4. spring.datasource.username=root
  5. spring.datasource.password=******
  6. spring.datasource.driver-class-name=com.mysql.jdbc.Driver
  • .yml 格式
  1. server:
  2. port: 8082
  3. spring:
  4. datasource:
  5. name: test
  6. url: jdbc:mysql://127.0.0.1:3306/database
  7. username: root
  8. password: ******
  9. type: com.alibaba.druid.pool.DruidDataSource
  10. driver-class-name: com.mysql.jdbc.Driver

从上面的实例我们可以发现,两者的区别主要有以下几点:

  1. 语法结构
  • .properties 格式使用的是 键值对形式(key=value),而 .yml 格式则使用的是 树状结构(key: value)
  • .properties 格式通过 . 来连接,= 来赋值,结构上比较直接,而 .yml 格式则使用 : 来分层,结构上呈现树状结构,层次感明显,而且赋值时 : 的后边必须 接着一个空格再赋值
  1. 执行先后顺序

如果一个工程中同时存在两种格式的文件,那么会 优先加载 **.yml** 文件,然后再加载 **.properties**,而且后加载的 **.properties** 会覆盖之前加载的 **.yml** 文件

此外,.yml 配置时需要注意以下几点:

  1. 缩进必须用空格,不能用 Tab
  2. @PropertySource 注解不能加载 yml 文件

总结

以上就是关于 Spring Boot 中的配置相关内容了。本文主要介绍了 Spring Boot 项目自带的配置文件的相关信息,同时也介绍了如果我们想要满足自己需求如何进行自定义配置。最后,则是对 .yml.properties 不同格式的配置文件的区别进行解释。