SpringBoot配置

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数据校验 支持 不支持
    复杂类型封装 支持 不支持

    配置文件ymlproperties都可以获取值

    如果只是在某个业务逻辑中,需要获取一下某个配置文件中的某项值,使用@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推荐给容器中添加组件的方式: 推荐使用全注解方式

  1. 配置类===Spring配置文件
  2. 使用@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

自动配置原理

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

  2. @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类都是容器中的一个组件,都加入到容器中,用他们做自动配置。

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

  4. 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类中获取的,而这些类里面的每一个属性又是和配置文件绑定的。

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

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

精髓

  1. SpringBoot启动会加载大量的配置类

  2. 我们看我们的功能有没有SpringBoot默认写好的自动配置类;

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

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

    xxxAutoConfiguration:自动配置类,给容器中添加组件

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

9. 细节

1. @Conditional派生注解

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

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

通过

1
debug=true

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

分为Positive matchesNegative matches

Kommentare