Spring Boot配置

1. 标记语言

以前的配置文件：xxx.xml

YAML: 以数据为中心，比json, xml更适合作配置文件，实例如下

1
2


server:
  port: 8081

XML:

1
2
3


<server>
	<port>8081</port>
</server>

2. YAML语法

(1) 基本语法

K :(空格)V — 表示一对键值对

以空格的缩进来控制层级关系，左对齐的一列数据都是同一层级

1
2
3


server: 
  port: 8080
  path: /hello

属性和值大小写敏感

(2) 值的写法

字面量：普通的值(数字，字符串，布尔)

k: v: 字面量直接来写

字符串默认不需要加上单引号或双引号

双引号：不会转义字符串里的特殊字符；特殊字符会作为本身想表示的意思

name: "zhangsan \n lisi"输出zhangsan 换行 lisi

单引号：会转义特殊字符，特殊字符最终只是一个普通的字符串

name: "zhangsan \n lisi"输出zhangsan \n lisi

对象(属性和值): 键值对

k: v: 对象还是k: v的模式

1
2
3


friends:
	lastName: zhangsan
	age: 20

行内写法：

1

friends: {lastName: zhangsan, age: 18}

数组(List, Set)

用- 值表示数组中的一个元素

1
2
3
4


pets: 
	- cat
	- dog
	- pig

行内写法

1

pets: [cat, dog, pig ]

3. 配置文件值注入

配置文件：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


server:
  port: 8081

person:
  lastName: zhangsan
  age: 18
  boss: false
  birthDay: 2017/12/12
  maps: {k1: v1, k2: 12}
  list:
    - lisi
    - zhaoliu
  dog:
    name: myDog
    age: 2

javaBean:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


/*
* 将配置文件中配置的每一个属性的值，映射到这个组件中
* @ConfigurationProperties：告诉Spring Boot将本类中的所有属性和配置文件中相关的配置进行绑定
* prefix = "person"：配置文件中哪个下面的所有属性进行一一映射
*
* 只有这个组件是容器中的组件，才能使用容器提供的@ConfigurationProperties功能
* */
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String lastName;
    private Integer age;
    private Boolean boss;
    private Date birthDay;
    private Dog dog;

    private Map<String, Object> maps;
    private List<Object> list;

我们可以导入配置文件处理器，以后配置文件进行绑定就可以有提示：

1
2
3
4
5
6


<!-- 导入配置文件处理器，配置文件进行绑定就会有提示 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

`@ConfigurationProperties`获取值和`@Value`获取值的区别

	`@ConfigurationProperties`	`@Value`
功能	批量注入配置文件中的属性	一个一个指定
松散绑定(松散语法)	支持松散语法绑定	不支持松散语法绑定
`SpEL`	不支持	支持
JSR30数据校验	支持	不支持
复杂类型封装	支持	不支持

配置文件yml和properties都可以获取值

如果只是在某个业务逻辑中，需要获取一下某个配置文件中的某项值，使用@Value

如果说，我们专门编写了一个javaBean来和配置文件进行映射，我们就直接使用@ConfigurationProperties

配置文件注入值数据校验

1
2
3
4
5
6
7


@Component
@ConfigurationProperties(prefix = "person")
@Validated
public class Person {
    // lastName必须为邮箱格式
    @Email
    private String lastName;

4. `@PropertySource`&`ImportResource`

@PropertySource：加载指定的配置文件

1
2
3
4
5
6
7
8
9


/*
* @ConfigurationProperties(prefix = "person")
* 默认从全局配置文件中获取值
* */
@PropertySource(value = {"classpath:person.properties"})
@Component
@ConfigurationProperties(prefix = "person")
//@Validated
public class Person {

@ImportResource：导入Spring的配置文件，让配置文件中的内容生效

Spring Boot里面没有Spring的配置文件，我们自己编写的配置文件，也不能自动识别；

想让Spring的配置文件生效，加载进来；

需要将@ImportResource标注在一个配置类上

1
2
3
4
5
6
7
8
9


@ImportResource(locations = {"classpath:beans.xml"})
@SpringBootApplication
public class SpringBoot01HelloworldQuickApplication {

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

}

导入Spring的配置文件，让其生效

但不希望编写Spring的配置文件

1
2
3
4
5
6
7
8


<?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 class="com.haven.springboot.sevice.HelloService" id="helloService">

    </bean>
</beans>

SpringBoot推荐给容器中添加组件的方式： 推荐使用全注解方式

配置类===Spring配置文件
使用@Bean给容器中添加组件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


/*
* @Configuration：告诉Spring Boot这是一个配置类
* 就是来替代之前Spring的配置文件
*
* 之前在Spring配置文件中用 <bean></bean> 标签添加组件
* */
@Configuration
public class MyAppConfig {

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

}

5. 配置文件占位符

(1) 随机数

1
2


${random.value}, ${random.int}, ${random.long}
${random.int(10)}, ${random.int[1024, 65536]}

(2) 占位符获取之前配置的值，如果没有可以使用`:`指定默认值

1
2
3
4
5
6
7
8
9


person.last-name=张三${random.uuid}
person.age=${random.int}
person.birth-day=2017/12/15
person.boss=false
person.maps.k1=v1
person.maps.k2=14
person.list=a,b,c
person.dog.name=${person.hello:hello}_dog
person.dog.age=15

6. Profile

(1) 多Profile文件

我们在主配置文件编写时，文件名可以是application-{profile}.properties/yml

默认使用application.properties的配置

(2)激活指定profile

在配置文件中指定spring.profiles.active=dev
命令行
1

--spring.profiles.active=dev
Edit Configuration—>Program arguments

(3) yml多文档块

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


server:
  port: 8081
spring:
  profiles:
    active: prod
---

server:
  port: 8083
spring:
  profiles: dev

---

server:
  port: 8084
spring:
  profiles: prod #指定属于那个环境

7. 配置文件加载位置

优先级由高到低，高优先级会覆盖低优先级的配置：

./config/
./
./src/main/resources/config/
./src/main/resources/

SpringBoot会从这四个位置全部加载主配置文件：互补配置

可以通过spring.config.location来改变默认的配置文件的位置

项目打包好后，可以使用命令行参数--spring.config.location=?的形式，启动项目的时候来指定配置文件的新位置；指定配置文件和默认加载的配置文件共同起作用，形成互补配置

8. 自动配置原理

配置文件能配置的属性参照

https://docs.spring.io/spring-boot/docs/2.1.8.RELEASE/reference/html/common-application-properties.html

自动配置原理

SpringBoot启动时加载主配置类，开启了自动配置功能@EnableAutoConfiguration

@EnableAutoConfiguration原理

利用AutoConfigurationImportSelector给容器中导入一些组件
查看AutoConfigurationImportSelector中的selectImports()方法

1
2


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

1
2


// getCandidateConfigurations()
List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());

1
2
3
4


SpringFactoriesLoader.loadFactoryNames()
// 扫描所有jar包类路径下的	META-INF/spring.factories
// 把扫描到的文件的内容包装成properties对象
// 从properties获取到EnableAutoConfiguration.class的类名对应的值，然后把他们添加在容器中

将类路径下 META-INF/spring.factories里面配置的所有EnableAutoConfiguration的值加到了容器中

每一个这样的 xxxAutoConfiguration类都是容器中的一个组件，都加入到容器中，用他们做自动配置。

每一个自动配置类进行自动配置功能

HttpEncodingAutoConfiguration(HTTP编码自动配置)为例，介绍自动配置原理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


@Configuration	// 表示是一个配置类，可以给容器中添加组件
@EnableConfigurationProperties({HttpProperties.class})	// 启用指定类的ConfigurationProperties功能；将配置文件中对应的值和HttpProperties绑定起来，并把HttpProperties加入到ioc容器中

@ConditionalOnWebApplication(
    type = Type.SERVLET
)	// Spring底层@Conditional注解，根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效；
// 判断当前应用是否是web应用，如果是，则当前配置类生效；

// 判断当前项目有没有这个类
// CharacterEncodingFilter：SpringMVC中进行乱码解决的过滤器
@ConditionalOnClass({CharacterEncodingFilter.class})

// 判断配置文件中是否存在某个配置 spring.http.encoding;如果不存在，判断也是成立的
// 即使配置文件中不配置spring.http.encoding=enabled，也是默认生效的
@ConditionalOnProperty(
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {
    // 他已经和SpringBoot的配置文件映射了
    private final Encoding properties;

    // 只有一个有参构造器的情况下，参数的值会从容器中拿
    public HttpEncodingAutoConfiguration(HttpProperties properties) {
        this.properties = properties.getEncoding();
    }

    @Bean	// 给容器中添加一个组件，这个组件的某些值需要从properties中获取
    @ConditionalOnMissingBean
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
  filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));
	 	 filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE));
        return filter;
    }

根据当前不同的条件判断，决定这个配置类是否生效。

一旦配置类生效，这个配置类就会个容器中添加各种组件，这些组件是从对应的properties类中获取的，而这些类里面的每一个属性又是和配置文件绑定的。

所有在配置文件中能配置的属性，都是在xxxProperties类中封装着；配置文件能配置什么，就可以参照某个功能对应的属性类

1
2
3
4


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

精髓

SpringBoot启动会加载大量的配置类
我们看我们的功能有没有SpringBoot默认写好的自动配置类；
再看这个自动配置类中到底配置了哪些组件（只要我们要用的组件有，我们就不需要再来配置）
给容器中自动配置类添加组件时，会从propertie中获取某些属性，我们就可以在配置文件中指定这些属性的值

xxxAutoConfiguration：自动配置类，给容器中添加组件

xxxProperties：封装配置文件中相关属性

9. 细节

1. @Conditional派生注解

作用：必须是@Conditional指定的条件成立，才给容器中添加组件，配置类里面的所有内容才生效

自动配置类必须在一定的条件下才能生效

通过

1

debug=true

让控制台打印自动配置报告，这样我们就可以很方便地知道哪些自动配置类生效

分为Positive matches和Negative matches

Spring Boot配置#

1. 标记语言#

2. YAML语法#

(1) 基本语法#

(2) 值的写法#

3. 配置文件值注入#

@ConfigurationProperties获取值和@Value获取值的区别#

配置文件注入值数据校验#

4. @PropertySource&ImportResource#

5. 配置文件占位符#

(1) 随机数#

(2) 占位符获取之前配置的值，如果没有可以使用:指定默认值#

6. Profile#

(1) 多Profile文件#

(2)激活指定profile#

(3) yml多文档块#

7. 配置文件加载位置#

8. 自动配置原理#

配置文件能配置的属性参照#

自动配置原理#

精髓#

9. 细节#

1. @Conditional派生注解#