16 分钟 读完 (大约 2427 个字)  0次访问

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

    配置文件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推荐给容器中添加组件的方式： 推荐使用全注解方式

  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 matches和Negative matches

#

喜欢这篇文章？打赏一下作者吧

评论

×