【02】Spring Boot 入门之配置文件详解

一、Spring Boot 中的配置文件

Spring Boot 使用了一个全局的配置文件,配置文件名是固定的,就叫做 application ,但是 后缀却有两种写法: 分别是 properties 和 yaml 。 例如:application.properties 、 application.yml 或者 application.yaml 。其实有很多配置 pring Boot 在底层都给我们自动配置好了,而配置文件的作用 就是修改 Spring Boot 自动配置的默认值

二、YAML 配置文件初识与使用

1、什么是 YAML

.yml 或 .yaml 是 YAML(YAML Ain't Markup Language) 语言的文件,这种文件以数据为中心,比 json、xml 等更适合做配置文件。知识拓展: YAML 的语法规范 ===> http://www.yaml.org

# YAML Ain't Markup Language 的解释

1、YAML A Markup Language ===> 是一个标记语言
2、YAML isn't Markup Language ===> 不是一个标记语言

2、标记语言对比

1、以前的配置文件大多都使用的是【xxxx.xml】文件,而 xml 大量的数据浪费在了标签的开闭上
2、YAML 文件以数据为中心,比 json、xml 等更适合做配置文件
3、各种配置文件的具体对比如下
# properties 配置文件
server.port=8080


# YAML 配置文件
server:
  port: 8080


# xml 配置文件
<server>
  <port>8080</port>
</server>

3、YAML 基本语法

# YAML 语法格式
语法格式  ===>  key:(空格)value
语法举例  ===>  port: 8080 


# YAML 语法特点
1、YAML 语法用一对键值对来表示(空格必须有),以【空格的缩进】来控制层级关系
2、只要是【左对齐】的一列数据,都是同一个层级的
3、属性和值也是大小写敏感


# YAML 语法举例如下:四个属性是同一层级,且【PORT】和【port】、【PATH】和【path】是不同属性
server:
  port: 8081
  PORT: 8082
  path: /hello
  PORT: /world

4、YAML 值的写法

# 第一种写法 ===> 字面量:普通的值(数字,字符串,布尔)
字面量格式   ===> key: value


# 注意:字面直接来写,字符串默认不用加上单引号或者双引号,加上有不同意义。具体如下:


# 加上双引号
【加上双引号】不会转义字符串里面的特殊字符,特殊字符会作为本身想表示的意思
例如  ===>  name: "zhangsan \n lisi" 
输出结果为  ===>  zhangsan 换行 lisi


# 加上单引号
【加上单引号】会转义特殊字符,特殊字符最终只是一个普通的字符串数据。
例如  ===>  name: 'zhangsan \n lisi'
输出结果为  ===>  zhangsan \n lisi


# YAML 第一种写法举例如下
name: zhangsan
age: 23
address: HangZhou
# 第二种写法:对象、Map【属性和值】【键值对】
key: value 在下一行来写对象的属性和值的关系


# 注意事项
缩进的对象还是 key: value 的方式 ===> 例如下面的 friends 对象


# YAML 第一种写法举例如下

# 对象的默认写法
friends:
  name: zhangsan
  hobby: chess


# 对象的行内写法
friends: {name: zhangsan,hobby: chess}

第三种写法: 数组(List、Set)。用【横杠+空格】来表示数组中的一个元素。 写法如下:

# 数组的默认写法
pets:
  - cat
  - dog
  - pig


# 数组的行内写法
pets: [cat,dog,pig]

三、配置文件值的注入

1、编写配置文件

先编写一个 YAML 配置文件,具体如下,那么 如何把这个配置文件里面的值注入到 Java 代码里面呢?即如何实现配置文件与实体类之间的映射?

# yamlperson 在 Java 程序中通过 @ConfigurationProperties 注解与 Java 程序绑定到一起

yamlperson:
  lastName: guo
  age: 23
  boss: false
  birth: 2018/12/3
  maps: {key1: value1,key2: value2}
  lists:
    - key1
    - key2
    - key3
  dog:
    name: milk-bottle
    age: 7

2、编写 YamlPerson 类

为了解答上述问题,我们 首先编写 YamlPerson 类。代码如下:

package edu.jgsu.bean;

// @Component 把类添加到容器中,使之成为容器中的组件,才能使用容器提供的 @ConfigurationProperties 功能
// @ConfigurationProperties 用于告诉 Spring Boot 将本类中的所有属性和配置文件中相关的配置进行绑定
// 绑定到 YAML 配置文件中的 yamlperson 对象 【prefix 的值必须小写,大写会报错】
@Component
@ConfigurationProperties(prefix = "yamlperson")
public class YamlPerson {
    // 可以使用 @Value 注解对属性赋值
    private String lastName;
    private Integer age;
    private Boolean boss;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;

    // 省略了 getXxx()/setXxx()/toString() 相关方法,使用时自己加上即可
}

class Dog {

    private String name;
    private Integer age;

    // 省略了 getXxx()/setXxx()/toString() 相关方法,使用时自己加上即可
}

3、编写 ApplicationTests 测试类

然后编写 ApplicationTests 测试类 就可以看到效果了,代码如下:

package edu.jgsu;

import edu.jgsu.bean.YamlPerson;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

// 测试类如果少了 public 修饰符,那么测试类无法使用
@RunWith(SpringRunner.class)
@SpringBootTest
public class ApplicationTests {

    @Autowired
    private YamlPerson yamlPerson;

    @Test
    public void test1() {
        System.out.println(yamlPerson);
    }

}

4、查看测试结果

运行上述的 test1() 测试方法,测试结果如下:

2020-02-02 23:25:46.436  INFO 1472 --- [           main] edu.jgsu.ApplicationTests                : Started ApplicationTests in 3.729 seconds (JVM running for 5.654)
Person{lastName='guo', age=22, boss=false, birth=Mon Dec 03 00:00:00 CST 2018, maps={key1=value1, key2=value2}, lists=[key1, key2, key3], dog=Dog{name='milk-bottle', age=7}}
2020-02-02 23:25:46.579  INFO 1472 --- [       Thread-2] o.s.w.c.s.GenericWebApplicationContext   : Closing org.springframework.web.context.support.GenericWebApplicationContext@18d604b: startup date [Sun Feb 02 23:25:43 CST 2020]; root of context hierarchy

我们还可以 导入【配置文件处理器】,以后编写配置就有提示了。pom.xml 文件中加入以下代码:

 <!-- 导入配置文件处理器,实体类在与配置文件进行绑定,在配置文件中输入值就会有提示 -->
 
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

温馨小提示:
在 YAML 文件中,lastName 和 last-name 是一样的。 在编写属性时提示 last-name 就不用大惊小怪了( ͒˃⌂˂ ͒)

5、properties 配置文件

现在来看一下上面的 YAML 配置文件在【properties 配置文件】 中的编写:

yamlperson.last-name=guo
yamlperson.age=22
yamlperson.boss=false
yamlperson.birth=2018/12/3
yamlperson.maps.key1=value1
yamlperson.maps.key2=value2
yamlperson.maps.key3=value3
yamlperson.lists=key1,key2,key3
yamlperson.dog.name=milk-bottle
yamlperson.dog.age=7
# 注意事项
有的时候属性值为中文,那么可能出现乱码


# 解决办法
在 IDEA 中点击  File | Settings | Editor | File Encodings 去配置编码为 UTF-8
然后把【转成 ASCll】的那个选项勾上即可

四、使用 @Value 注解获取值

1、@Value 注解的使用

现在,我们来看一下 配置文件和实体类进行映射的第二种姿势: 使用 @Value 注解。部分代码如下:

//@ConfigurationProperties(prefix = "yamlperson")    // 先把这个注解注释掉
//@Validated      // 该注解用于 JSR303 数据校验
@Component
public class YamlPerson {
    // 如果加了 @Email 注解,那么 lastName 必须是邮箱格式
    // @Email 这个注解来自于 JSR303 数据校验【此部分知识自行搜索一下,不是很重要】
    @Value("${yamlperson.last-name}")    // 使用 SPEL 表达式取出配置文件的值
    private String lastName;

    @Value("#{11*2}")
    private Integer age;

    @Value("true")
    private Boolean boss;
...

编写完成之后,启动测试类进行测试。 结果如下:

2020-02-03 00:30:41.800  INFO 13740 --- [           main] edu.jgsu.ApplicationTests                : Started ApplicationTests in 3.816 seconds (JVM running for 5.752)
Person{lastName='guo', age=22, boss=true, birth=null, maps=null, lists=null, dog=null}
2020-02-03 00:30:42.080  INFO 13740 --- [       Thread-2] o.s.w.c.s.GenericWebApplicationContext   : Closing org.springframework.web.context.support.GenericWebApplicationContext@3cf2ba: startup date [Mon Feb 03 00:30:38 CST 2020]; root of context hierarchy

2、@Value 注解和 @ConfigurationProperties 对比

@Value 注解 获取值和 @ConfigurationProperties 注解 获取值比较,如下表:

获取值的两种方式@ConfigurationProperties@Value
功能批量注入配置文件中的属性一个个指定
松散绑定(松散语法)支持不支持
SpEL不支持支持
JSR303数据校验支持不支持
复杂类型封装支持不支持
# 问题来了:上述两个注解都能获取到值,那么开发的时候用哪一个好呢?


1、如果说,我们只是在某个业务逻辑中需要获取一下配置文件中的某项值,使用 `@Value` 注解更好

2、如果说,我们专门编写了一个 JavaBean 来和配置文件进行映射
   我们就直接使用 `@ConfigurationProperties` 注解,这样操作起来会更方便

五、三个注解的对比

接下来比较一下 【@PropertySource】 注解、【@ImportResource】 注解和 【@Bean】 注解之间的区别。

1、@PropertySource 注解

首先介绍 【@PropertySource】 注解,这个注解的作用是 用于加载指定的配置文件,即自己定义的配置文件。例如下面的 person.properties 配置文件。 具体配置内容如下:

yamlperson.last-name=典韦
yamlperson.age=22

实体类部分代码如下:

@PropertySource(value = {"classpath:person.properties"})
@Component
@ConfigurationProperties(prefix = "yamlperson")    // prefix 的值必须小写,大写会报错
/**
 * @Author: guoshizhan
 * @Create: 2020/2/2 22:49
 * @Description: 映射自定义的 YAML 配置文件
 */
public class YamlPerson {
    private String lastName;
    private Integer age;
    ……
}

然后运行测试类测试,最终返回结果:

2020-02-03 10:27:30.260  INFO 22524 --- [           main] edu.jgsu.ApplicationTests                : Started ApplicationTests in 3.158 seconds (JVM running for 4.347)
Person{lastName='典韦', age=22, boss=null, birth=null, maps=null, lists=null, dog=null}
2020-02-03 10:27:30.415  INFO 22524 --- [       Thread-2] o.s.w.c.s.GenericWebApplicationContext   : Closing org.springframework.web.context.support.GenericWebApplicationContext@11001e5: startup date [Mon Feb 03 10:27:27 CST 2020]; root of context hierarchy

2、@ImportResource 注解

接着介绍 【@ImportResource】 注解,这个注解 用于导入 Spring 的配置文件,让配置文件里面的内容生效。 例如下面的 bean.xml 配置文件。具体配置内容如下:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="helloService" class="edu.jgsu.service.HelloService"></bean>
</beans>

然后 在测试类添加下列代码 ,测试 IOC 容器中是否有 helloService 这个对象,代码如下:

@Autowired
private ApplicationContext ioc;    // 注入 Spring 的 IOC 容器

@Test
public void test2() {
    System.out.println(ioc.containsBean("helloService"));
}

最终返回结果如下:

2020-02-03 11:02:28.466  INFO 13836 --- [           main] edu.jgsu.ApplicationTests                : Started ApplicationTests in 3.041 seconds (JVM running for 4.307)
false
2020-02-03 11:02:28.611  INFO 13836 --- [       Thread-2] o.s.w.c.s.GenericWebApplicationContext   : Closing org.springframework.web.context.support.GenericWebApplicationContext@8ff24: startup date [Mon Feb 03 11:02:25 CST 2020]; root of context hierarchy

上面的实验说明,Spring Boot 里面没有 Spring 的配置文件,我们自己编写的配置文件 bean.xml 也不能被自动识别 。想让 Spring 的配置文件生效,那么就 在 Spring Boot 启动类中加 @ImportResource 注解。 代码如下:

package edu.jgsu;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ImportResource;

@ImportResource(locations = {"classpath:bean.xml"})    // 导入 Spring 配置文件并使其生效
@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

然后 再去测试类进行测试, 最终结果如下:

2020-02-03 11:08:00.350  INFO 9568 --- [           main] edu.jgsu.ApplicationTests                : Started ApplicationTests in 3.61 seconds (JVM running for 5.002)
true
2020-02-03 11:08:00.526  INFO 9568 --- [       Thread-2] o.s.w.c.s.GenericWebApplicationContext   : Closing org.springframework.web.context.support.GenericWebApplicationContext@ed52de: startup date [Mon Feb 03 11:07:57 CST 2020]; root of context hierarchy

3、@Bean 注解

在实际开发中,我们不会自己去编写一个配置文件,然后加载进来,这样太麻烦了。接下来介绍 Spring Boot 推荐给容器中添加组件的方式:不编写 Spring 的配置文件,使用全注解的方式添加组件。这是 @Bean 注解就派上用场了。 首先,我们编写一个配置类:

package edu.jgsu.config;

import edu.jgsu.service.HelloService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author: guoshizhan
 * @Create: 2020/2/3 11:23
 * @Configuration:指明当前类是一个配置类,其作用就是来替代之前的 Spring 配置文件
 * 在 Spring 配置文件中用 <bean><bean/> 标签添加组件,而在配置类中使用使用 @Bean 给容器中添加组件
 */
@Configuration
public class MyConfig {

    // 将方法的返回值添加到容器中;容器中这个组件默认的 id 就是方法名
    @Bean
    public HelloService helloService() {
        System.out.println("配置类给 IOC 容器中添加组件了...");
        return new HelloService();
    }

}

然后 回到测试类 test2() 方法进行测试, 返回结果如下:

2020-02-03 11:31:41.352  INFO 5760 --- [           main] o.s.b.f.xml.XmlBeanDefinitionReader      : Loading XML bean definitions from class path resource [bean.xml]
配置类给 IOC 容器中添加组件了...
2020-02-03 11:31:42.229  INFO 5760 --- [           main] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/**/favicon.ico] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2020-02-03 11:31:42.466  INFO 5760 --- [           main] s.w.s.m.m.a.RequestMappingHandlerAdapter : Looking for @ControllerAdvice: org.springframework.web.context.support.GenericWebApplicationContext@ed52de: startup date [Mon Feb 03 11:31:40 CST 2020]; root of context hierarchy
2020-02-03 11:31:42.546  INFO 5760 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/hello]}" onto public java.lang.String edu.jgsu.Controller.HelloController.Hello()
2020-02-03 11:31:42.549  INFO 5760 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error]}" onto public org.springframework.http.ResponseEntity<java.util.Map<java.lang.String, java.lang.Object>> org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController.error(javax.servlet.http.HttpServletRequest)
2020-02-03 11:31:42.550  INFO 5760 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error],produces=[text/html]}" onto public org.springframework.web.servlet.ModelAndView org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController.errorHtml(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)
2020-02-03 11:31:42.577  INFO 5760 --- [           main] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/webjars/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2020-02-03 11:31:42.577  INFO 5760 --- [           main] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2020-02-03 11:31:43.369  INFO 5760 --- [           main] edu.jgsu.ApplicationTests                : Started ApplicationTests in 2.943 seconds (JVM running for 4.215)
true
2020-02-03 11:31:43.474  INFO 5760 --- [       Thread-2] o.s.w.c.s.GenericWebApplicationContext   : Closing org.springframework.web.context.support.GenericWebApplicationContext@ed52de: startup date [Mon Feb 03 11:31:40 CST 2020]; root of context hierarchy

TIPS: 如果把配置类的方法 helloService 改为 helloService02 ,那么返回结果就为 false 了。 这个我就不贴代码了,自己修改一下,然后使用测试类进行测试即可查看到效果

六、配置文件占位符

我们先来看一份配置文件,具体配置内容如下:

yamlperson.last-name=guo${random.uuid}
yamlperson.age=${random.int}
yamlperson.boss=false
yamlperson.birth=2018/12/3
yamlperson.maps.key1=value1
yamlperson.maps.key2=value2
yamlperson.maps.key3=value3
yamlperson.lists=key1,key2,key3
yamlperson.dog.name=${yamlperson.last-name}-milk-bottle
yamlperson.dog.age=7

上述配置内容中的 ${random.uuid} 和 ${random.int} 就是 配置文件占位符。编写好配置文件之后,然后去测试类测试一下,返回的结果如下:

2020-02-03 11:50:18.934  INFO 24560 --- [           main] edu.jgsu.ApplicationTests                : Started ApplicationTests in 2.958 seconds (JVM running for 4.29)
Person{lastName='guoa1e7ef2b-0e1f-41de-a9fa-16dce9687809', age=1319770232, boss=false, birth=Mon Dec 03 00:00:00 CST 2018, maps={key1=value1, key2=value2, key3=value3}, lists=[key1, key2, key3], dog=Dog{name='guoe6b21bd7-bd07-4af5-92eb-915f435eb465-milk-bottle', age=7}}
2020-02-03 11:50:19.074  INFO 24560 --- [       Thread-2] o.s.w.c.s.GenericWebApplicationContext   : Closing org.springframework.web.context.support.GenericWebApplicationContext@19df09a: startup date [Mon Feb 03 11:50:16 CST 2020]; root of context hierarchy

占位符获取的是原先配置好了的值,如果没有配置,可以是用 ": " 来指定默认值。 例如以下配置:

# 以下配置并没有 yamlperson.hello 这个属性,所以它会使用 world 这个被指定的值
# 所以最终输出结果为 ===> world-java

yamlperson.hello=${yamlperson.hello:world}-java

那么,如果我把上述的配置修改成下面这样,结果又是怎样呢?

# 以下配置既没有 hello 属性,也没有指定默认值
# 那么最终输出结果为 ===> ${yamlperson.hello}-java

yamlperson.hello=${yamlperson.hello}-java

以下是常用随机数代码:

${random.value}

${random.int}

${random.long}

${random.int(10)}

${random.int[1024,65536]}

七、配置文件之 Profile

Profile 是 Spring 对 不同环境提供不同配置功能 的支持,可以通过 激活、指定参数 等方式来快速切换环境。

1、properties 中的 Profile 编写

我们在编写 主配置文件 application.properties 的时候,文件名可以是 application-{profile}.properties/yml。具体的示例配置如下:

# application.properties
# 该配置文件时默认的配置文件
# 系统启动时默认就会加载该配置文件

server.port=8080
# application-dev.properties
# dev 表示开发环境,所以该配置文件应在开发环境下激活

server.port=8081
# application-test.properties
# test 表示测试环境,所以该配置文件应在测试环境下激活

server.port=8082
# application-prod.properties
# prod 表示生产【线上】环境,所以该配置文件应在生产【线上】环境下激活

server.port=8083

TIPS: 上面那么多配置文件,该使用哪一个呢?Spring Boot 默认会使用 application.properties 的配置

2、激活 Profile 的方式

第一种激活方式:通过【properties 文件】激活指定 Profile

# 因为 Spring Boot 默认会使用 application.properties 的配置
# 所以在 application.properties 配置文件中激活指定的配置,具体操作如下


server.port=8080
# 激活 dev 环境
spring.profiles.active=dev


# 注意:在激活完成后,那么端口就不是 8080 了,而是 dev 的端口 8081

第二种激活方式:命令行中激活指定

# 对已经打成了 jar 包的文件,我们可以在命令行中再次激活 Profile

java -jar spring-boot-02-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev

也可以直接在测试的时候,在配置中传入命令行参数。 如下图:

第三种激活方式:虚拟机参数激活指定

# 虚拟机参数激活指定

-Dspring.profiles.active=dev

3、YAML 中的 Profile 编写

YAML 配置文件支持多文档块方式激活指定 Profile,比 properties 更简单。 使用 三根小短线 即可将 YAML 文件分成几个文档块。具体示例配置如下:

server:
  port: 8080
spring:
  profiles:
    active: test    # 激活 test 环境

---
server:
  port: 8081
spring:
  profiles: dev     # 指定属于哪个环境的配置【dev 开发环境】

---
server:
  port: 8082
spring:
  profiles: test    # 指定属于哪个环境的配置【test 测试环境】

---
server:
  port: 8083
spring:
  profiles: prod    # 指定属于哪个环境的配置【prod 生产环境】

八、配置文件加载位置

1、内部配置文件加载顺序

Spring Boot 启动会扫描以下位置的 application.properties 或者 application.yml 文件作为 Spring Boot 的默认配置文件 。那么 Spring Boot 是从哪里去找这些配置文件呢?现在告诉你,它从下面四个位置去找:

# 项目根目录下的 config 文件夹里的配置文件
file:./config/


# 项目根目录下的配置文件
file:./


# 类路径下的 config 文件夹下的配置文件,即 resources/config 文件夹下的配置文件
classpath:/config/


# 类路径下的配置文件,即 resources 文件夹下的配置文件
classpath:/

以上是 按照优先级【从高到低】 的顺序排序,Spring Boot 默认会从上述四个位置加载所有的主配置文件,即上述所有位置的文件都会被加载,高优先级配置内容会覆盖低优先级配置内容,而且还会【互补配置】。


我们还可以通过 spring.config.location 来改变默认的配置文件位置。项目打包好以后,我们可以使用命令行参数的形式,启动项目的时候来指定配置文件的新位置;指定配置文件和默认加载的这些配置文件共同起作用形成互补配置。 例如下面代码,加载了 G 盘的配置文件:

# 执行 jar 包时,加载 G 盘自定义的配置文件

java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=G:/application.properties

2、外部配置文件加载顺序

Spring Boot 也可以从外部加载配置,所有支持的配置如下【详情可参考 官方文档】:

在上图的配置中,加载优先级从高到低,高优先级的配置覆盖低优先级的配置,所有的配置会形成【互补配置】。 常见的配置如下 (已按照加载顺序列出):

# 注意:加了【重要】关键字的配置需重点关注

# 01、命令行参数【重要】
     所有的配置都可以在命令行上进行指定,多个配置【用空格分开】
     命令行配置的格式  ===> --配置项=值。示例配置如下:
     java -jar spring-boot-config-02-0.0.1-SNAPSHOT.jar --server.port=8087  --server.context-path=/abc


# 02、来自 java:comp/env 的 JNDI 属性
# 03、Java 系统属性(System.getProperties())
# 04、操作系统环境变量
# 05、RandomValuePropertySource 配置的 random.* 属性值


# 注意:配置文件查找顺序:由 jar 包外向 jar 包内进行寻找;优先加载带 profile,然后再来加载不带 profile

# 06、jar包外部的 application-{profile}.properties 或 application.yml(带spring.profile)配置文件【重要】
# 07、jar包内部的 application-{profile}.properties 或 application.yml(带spring.profile)配置文件【重要】
# 08、jar包外部的 application.properties 或 application.yml(不带spring.profile)配置文件【重要】
# 09、jar包内部的 application.properties 或 application.yml(不带spring.profile)配置文件【重要】
# 10、@Configuration 注解类上的 @PropertySource
# 11、通过 SpringApplication.setDefaultProperties 指定的默认属性

九、配置文件的自动配置原理

1、自动配置原理初探

Spring Boot 中的配置文件到底能写什么?该怎么写?又自动帮我们配置好了什么? 针对这些问题,那么接下来就来聊一聊这个 自动配置原理。如果需要了解更多详情,请参考 官方文档


Spring Boot 在启动的时候加载主配置类,并开启了自动配置的功能,这主要归功于 @EnableAutoConfiguration 这个注解,它利用 EnableAutoConfigurationImportSelector 类给容器中导入一些组件, 可以查看 selectImports() 方法 的内容,获取到的 候选配置以 List 集合 返回。大致过程如下:

// 1、调用 SpringFactoriesLoader.loadFactoryNames() 去扫描所有 jar 包类路径

// 2、然后把类路径的 META-INF/spring.factories 文件里的内容进行扫描

// 3、把扫描到的这些文件的内容包装成 properties 对象

// 4、从 properties 中获取到 EnableAutoConfiguration.class 类(类名)对应的值

// 5、最后把他们添加在容器中


// 获取候选配置的方法
List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);

Spring Boot 在项目启动的过程中,它会把类路径下 META-INF/spring.factories 这个文件 里面配置的 所有 EnableAutoConfiguration 的值 加入到了容器中。具体如下 (当前的 Spring Boot 版本为 2.0.1.RELEASE 版本):

# 所有的自动配置类【Spring Boot 2.0.1.RELEASE 版本】

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.cloud.CloudAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
org.springframework.boot.autoconfigure.elasticsearch.jest.JestAutoConfiguration,\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,\
org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,\
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,\
org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,\
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,\
org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,\
org.springframework.boot.autoconfigure.mobile.DeviceResolverAutoConfiguration,\
org.springframework.boot.autoconfigure.mobile.DeviceDelegatingViewResolverAutoConfiguration,\
org.springframework.boot.autoconfigure.mobile.SitePreferenceAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
org.springframework.boot.autoconfigure.reactor.ReactorAutoConfiguration,\
org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.SecurityFilterAutoConfiguration,\
org.springframework.boot.autoconfigure.security.FallbackWebSecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.OAuth2AutoConfiguration,\
org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
org.springframework.boot.autoconfigure.social.SocialWebAutoConfiguration,\
org.springframework.boot.autoconfigure.social.FacebookAutoConfiguration,\
org.springframework.boot.autoconfigure.social.LinkedInAutoConfiguration,\
org.springframework.boot.autoconfigure.social.TwitterAutoConfiguration,\
org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,\
org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.web.HttpEncodingAutoConfiguration,\
org.springframework.boot.autoconfigure.web.HttpMessageConvertersAutoConfiguration,\
org.springframework.boot.autoconfigure.web.MultipartAutoConfiguration,\
org.springframework.boot.autoconfigure.web.ServerPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.web.WebClientAutoConfiguration,\
org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.WebSocketAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.WebSocketMessagingAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration

每一个这样的 【xxxAutoConfiguration 类】 都是容器中的一个组件,都会被加入到容器中,用他们来做自动配置。那么每一个自动配置类是如何进行自动配置功能呢? 接着往下看!

2、自动配置示例

现在以 HttpEncodingAutoConfiguration(Http编码自动配置) 为例来解释 自动配置原理。 具体如下:

// 表示这是一个配置类,以前编写的配置文件一样,也可以给容器中添加组件
@Configuration

// 启动指定类的 ConfigurationProperties 功能,将配置文件中对应的值和 HttpEncodingProperties 绑定起来
// 并把 HttpEncodingProperties 加入到 IOC 容器中
@EnableConfigurationProperties(HttpEncodingProperties.class);

// @ConditionalOnWebApplication 注解用于判断当前应用是否为 web 应用,如果是,当前配置类生效
// 该注解的底层是 @Conditional 注解,可以根据不同的条件来判断是否需要生效
// 如果满足指定的条件,整个配置类里面的配置就会生效
@ConditionalOnWebApplication

// 判断当前项目有没有 CharacterEncodingFilter 这个类,该类在 Spring MVC 中是用来解决乱码的过滤器
@ConditionalOnClass(CharacterEncodingFilter.class);

// 判断配置文件中是否存在某个配置【spring.http.encoding.enabled】,如果不存在,判断也是成立的
// 即使我们配置文件中不配置 pring.http.encoding.enabled=true,也是默认生效的
@ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true)
public class HttpEncodingAutoConfiguration {
  
    // 它已经和 Spring Boot 的配置文件映射了
    private final HttpEncodingProperties properties;
  
    // 只有一个有参构造器的情况下,参数的值就会从容器中拿
    public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {
        this.properties = properties;
    }
  
    @Bean   // 给容器中添加一个组件,这个组件的某些值需要从 properties 中获取
    @ConditionalOnMissingBean(CharacterEncodingFilter.class) // 判断容器没有这个组件【没有才能生效】
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
        filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
        return filter;
    }
    ……
}

根据当前不同的条件判断,决定这个配置类是否生效。一但这个配置类生效,这个配置类就会给容器中添加各种组件,这些组件的属性是从对应的 properties 类中获取的,这些类里面的每一个属性又是和配置文件绑定的。所有在配置文件中能配置的属性都是在【xxxxProperties 类】中封装着,配置文件能配置什么就可以参照某个功能对应的这个属性类。 属性类示例代码如下:

// 从配置文件中获取指定的值和 bean 的属性进行绑定
@ConfigurationProperties(prefix = "spring.http.encoding")
public class HttpEncodingProperties {

   public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

3、自动配置的精髓

1、Spring Boot 启动会加载大量的自动配置类

2、查看我们需要的功能有没有 Spring Boot 默认写好的自动配置类

3、我们再来看这个自动配置类中到底配置了哪些组件【只要我们要用的组件有,我们就不需要再来配置了】

4、给容器中的自动配置类添加组件的时候,会从 properties 类中获取属性。我们就可以在配置文件中指定这些属性的值

5、xxxxAutoConfigurartion ===> 这种类就是自动配置类,用于给容器中添加组件

6、xxxxProperties ===> 这种类用于封装配置文件中相关属性

4、@Conditional 派生注解

@Conditional 注解 是 Spring 的底层注解,它的作用:必须是 @Conditional 指定的条件成立,才给容器中添加组件,配置配里面的所有内容才能生效。 它有许多的派生注解,具体如下:

@Conditional扩展注解作用(判断是否满足当前指定条件)
@ConditionalOnJava系统的 Java 版本是否符合要求
@ConditionalOnBean容器中存在指定 Bean
@ConditionalOnMissingBean容器中不存在指定 Bean
@ConditionalOnExpression满足 SpEL 表达式指定
@ConditionalOnClass系统中有指定的类
@ConditionalOnMissingClass系统中没有指定的类
@ConditionalOnSingleCandidate容器中只有一个指定的Bean,或者这个 Bean 是首选 Bean
@ConditionalOnProperty系统中指定的属性是否有指定的值
@ConditionalOnResource类路径下是否存在指定资源文件
@ConditionalOnWebApplication当前是 web 环境
@ConditionalOnNotWebApplication当前不是 web 环境
@ConditionalOnJndiJNDI 存在指定项

自动配置类必须在一定的条件下才能生效,如果条件不满足,那么在 Spring Boot 启动过程中是不会进行自动配置的。 现在随便点进某一个自动配置类**【如下面的 AOP 自动配置类】**,然后查看这个类生效所需要的条件:

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.boot.autoconfigure.aop;

@Configuration

// 如果没有导入 @ConditionalOnClass 注解里面的字节码文件,也就是相关 jar 包,那么自动配置类是无法生效的
// 这就是生效的条件 ===> 即各种 @Conditional 注解
@ConditionalOnClass({EnableAspectJAutoProxy.class, Aspect.class, 
                    Advice.class, AnnotatedElement.class})
@ConditionalOnProperty(prefix = "spring.aop", name = {"auto"}, 
                       havingValue = "true", matchIfMissing = true)
public class AopAutoConfiguration {
    public AopAutoConfiguration() {
    }

    @Configuration
    @EnableAspectJAutoProxy(proxyTargetClass = true)
    @ConditionalOnProperty(prefix = "spring.aop", name = {"proxy-target-class"}, 
                           havingValue = "true", matchIfMissing = true)
    public static class CglibAutoProxyConfiguration {
        public CglibAutoProxyConfiguration() {
        }
    }

    @Configuration
    @EnableAspectJAutoProxy(proxyTargetClass = false)
    @ConditionalOnProperty(prefix = "spring.aop", name = {"proxy-target-class"}, 
                           havingValue = "false", matchIfMissing = false)
    public static class JdkDynamicAutoProxyConfiguration {
        public JdkDynamicAutoProxyConfiguration() {
        }
    }
}

5、自动配置报告

那么我们怎么知道哪些自动配置类生效了,哪些没有生效呢? 我们可以 在主配置文件中通过启用 debug=true 属性,来让控制台打印自动配置报告, 这样我们就可以很方便的知道自动配置类是否生效了。示例如下:

# 先在主配置文件中加入下列配置,表示自动配置报告

debug=true

然后 运行 Spring Boot 主程序,就可看到控制台的自动配置报告, 部分输出结果如下:

2020-02-04 12:05:38.905 DEBUG 25984 --- [           main] ConditionEvaluationReportLoggingListener : 

============================
CONDITIONS EVALUATION REPORT
============================

Positive matches:
-----------------

   CodecsAutoConfiguration matched:
      - @ConditionalOnClass found required class 'org.springframework.http.codec.CodecConfigurer'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition)

   CodecsAutoConfiguration.JacksonCodecConfiguration matched:
      - @ConditionalOnClass found required class 'com.fasterxml.jackson.databind.ObjectMapper'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition)

   CodecsAutoConfiguration.JacksonCodecConfiguration#jacksonCodecCustomizer matched:
      - @ConditionalOnBean (types: com.fasterxml.jackson.databind.ObjectMapper; SearchStrategy: all) found bean 'jacksonObjectMapper' (OnBeanCondition)

   DispatcherServletAutoConfiguration matched:
      - @ConditionalOnClass found required class 'org.springframework.web.servlet.DispatcherServlet'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition)
      - found ConfigurableWebEnvironment (OnWebApplicationCondition)
.
.
.

Negative matches:
-----------------

   ActiveMQAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required classes 'javax.jms.ConnectionFactory', 'org.apache.activemq.ActiveMQConnectionFactory' (OnClassCondition)

   AopAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required classes 'org.aspectj.lang.annotation.Aspect', 'org.aspectj.lang.reflect.Advice', 'org.aspectj.weaver.AnnotatedElement' (OnClassCondition)

   ArtemisAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required classes 'javax.jms.ConnectionFactory', 'org.apache.activemq.artemis.jms.client.ActiveMQConnectionFactory' (OnClassCondition)

   BatchAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required classes 'org.springframework.batch.core.launch.JobLauncher', 'org.springframework.jdbc.core.JdbcOperations' (OnClassCondition)
...

TIPS: 到此为止, Spring Boot 的配置 学习就结束了。记得常回来温习,巩固知识~~~

  • 文章作者:root
  • 创建时间:2020-02-26 22:10:54
  • 更新时间:2022-01-06 22:10:54
  • 版权声明:本文为博主原创文章,未经博主允许不得转载!
请 在 评 论 区 留 言 哦 ~~~
1024