03、SpringBoot配置

配置文件

SpringBoot使用一个全局的配置文件。同等目录下，properties优先级高于yml。

• application.properties。语法结构 ：key=value。
• application.yml。语法结构 ：key: value。

配置文件的作用 ：修改SpringBoot自动配置的默认值，因为SpringBoot在底层都给我们自动配置好了。

配置文件放在src/main/resources目录或者类路径/config下。

yaml

概述

yaml是YAML（YAML Ain't Markup Language）语言的文件，以数据为中心，比json、xml等更适合做配置文件。其后缀名一般为yaml或者yml。

• 参考语法规范：http://www.yaml.org/

全局配置文件的可以对一些默认配置值进行修改：

YAML：配置例子

server:
  port: 8081

XML：

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

yaml语法

YAML基本语法：

• 使用缩进表示层级关系。

• 缩进时不允许使用Tab键，只允许使用空格。

• 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可 。

• 大小写敏感。

YAML 支持的三种数据结构：

• 对象：键值对的集合。

• 数组：一组按次序排列的值 。

• 字面量：单个的、不可再分的值。

  • 数字、字符串、布尔、日期

  • 字符串

    • 默认不使用引号

    • 可以使用单引号或者双引号，单引号会转义特殊字符

      ""：双引号；不会转义字符串里面的特殊字符；特殊字符会作为本身想表示的意思，如：name: "zhangsan lisi"，输出：zhangsan 换行 lisi

      ​ ''：单引号；会转义特殊字符，特殊字符最终只是一个普通的字符串数据，如name: ‘zhangsan lisi’，输出：zhangsan lisi。

    • 字符串可以写成多行，从第二行开始，必须有一个单空格缩进。换行符会被转为空格。

文档：多个文档用 - - - 隔开。

注意：Spring Boot使用 snakeyaml 解析yml文件，

snakeyaml 参考语法：https://bitbucket.org/asomov/snakeyaml/wiki/Documentation#markdown-header-yaml-syntax 。

# k=v
# 注入到我们的配置类中
name: coydone
# 对象
student:
 name: coydone
 age: 18
# 行内写法
student: {name: coydone,age: 18}
# 数组
pets:
 - cat
 - dog
 - pig
pets: [cat,dog,pig]

配置文件值注入

1、在springboot项目中的resources目录下新建一个文件application.yml。

person:
  name: coydone
  age: 18
  happy: false
  birth: 2020/5/7
  maps: {k1: v1,k2: v2}
  lists:
    - code
    - music
    - girl
  dog:
    name: 旺财
    age: 3

2、编写一个实体类 Dog

package com.coydone.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component //注册bean到容器中
//我们原来是通过@Value给bean注入属性值的！
public class Dog {
    @Value("旺财")
    private String name;
    @Value("3")
    private Integer age;
    //省略有参无参构造，getter和setter方法、tostring方法
}

3、在SpringBoot的测试类下注入Dog输出

@SpringBootTest
class DemoApplicationTests {
    @Autowired //将狗狗自动注入进来
    Dog dog;
    @Test
    public void contextLoads() {
        System.out.println(dog); //打印看下狗狗对象
    }
}

4、再编写一个复杂一点的实体类：Person 类

package com.coydone.pojo;

import java.util.Date;
import java.util.List;
import java.util.Map;

public class Person {
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;
   //省略有参无参构造，getter和setter方法、tostring方法
}

5、将yaml中对应的person对象的值注入到Person类中

/*
@ConfigurationProperties作用：
将配置文件中配置的每一个属性的值，映射到这个组件中；
告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定
参数 prefix = “person” : 将配置文件中的person下面的所有属性一一对应
*/
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;
}

6、IDEA 提示，springboot配置注解处理器没有找到，可以添加依赖解决。

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

7、测试类中测试

@SpringBootTest
class DemoApplicationTests {
    @Autowired
    Person person; //将person自动注入进来
    @Test
    public void contextLoads() {
        System.out.println(person); //打印person信息
    }
}

properties文件注入

# 配置person的值  默认ASCII码
person.name=张三
person.age=18
person.happy=false
person.birth=2017/11/11
person.maps.k1=v1
person.maps.k2=v2
person.lists=a,b,c
person.dog.name=dog
person.dog.age=5

properties文件乱码问题

@Value获取值和@ConfigurationProperties获取值比较

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

1、@ConfigurationProperties只需要写一次即可 ， @Value则需要每个字段都添加。

2、松散绑定：这个什么意思呢? 比如我的yml中写的last-name，这个和lastName是一样的， - 后面跟着的字母默认是大写的。这就是松散绑定。

3、JSR303数据校验 ， 这个就是我们可以在字段是增加一层过滤器验证 ， 可以保证数据的合法性。

4、复杂类型封装，yml中可以封装对象 ， 使用value就不支持。

结论：

• 配置文件 yml 还是 properties 它们都能获取到值；
• 如果我们只是在某个业务逻辑中需要获取一下配置文件中的某项值，使用@Value；
• 如果我们专门编写了一个javaBean来和配置文件进行映射，我们就直接使用@ConfigurationProperties。

配置文件值校验

@Component
@ConfigurationProperties(prefix = "person")
@Validated //数据校验
public class Person {
   //name必须是邮箱格式
    @Email
    //@Value("${person.name}")
    private String name;
    //@Value("#{11*2}")
    private Integer age;
    //@Value("true")
    private Boolean happy;
}

JSR303数据校验常见参数

@NotNull(message="名字不能为空")
private String userName;
@Max(value=120,message="年龄最大不能查过120")
private int age;
@Email(message="邮箱格式错误")
private String email;

空检查
@Null       验证对象是否为null
@NotNull    验证对象是否不为null, 无法查检长度为0的字符串
@NotBlank   检查约束字符串是不是Null还有被Trim的长度是否大于0,只对字符串,且会去掉前后空格.
@NotEmpty   检查约束元素是否为NULL或者是EMPTY.
    
Booelan检查
@AssertTrue     验证 Boolean 对象是否为 true  
@AssertFalse    验证 Boolean 对象是否为 false  
    
长度检查
@Size(min=, max=) 验证对象（Array,Collection,Map,String）长度是否在给定的范围之内  
@Length(min=, max=) string is between min and max included.

日期检查
@Past       验证 Date 和 Calendar 对象是否在当前时间之前  
@Future     验证 Date 和 Calendar 对象是否在当前时间之后  
@Pattern    验证 String 对象是否符合正则表达式的规则

.......等等
除此以外，我们还可以自定义一些数据校验规则

加载指定的配置文件

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

@configurationProperties：默认从全局配置文件中获取值；

1、我们去在resources目录下新建一个person.properties文件

name=coydone

2、然后在我们的代码中指定加载person.properties文件

@PropertySource(value = "classpath:person.properties")
@Component //注册bean
public class Person {
    @Value("${name}")
    private String name;
    //......  
}

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

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

想让Spring的配置文件生效，加载进来；@ImportResource标注在一个配置类上。

//导入Spring的配置文件让其生效
@ImportResource(locations = {"classpath:beans.xml"})

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

1、配置类@Configuration——>Spring配置文件

2、使用@Bean给容器中添加组件

配置文件占位符

RandomvaluePropertySource：配置文件中可以使用随机数。

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

属性配置占位符

app.name=MyApp
app.description=${app.name} is a Spring Boot application

• 可以在配置文件中引用前面配置过的属性（优先级前面配置过的这里都能用）。
• ${app.name:默认值}来指定找不到属性时的默认值

# 随机的uuid
person.name=张三${random.uuid}
person.age=${random.int}
person.dog.name=${person.name}_dog
#匹配person.hello的值，如果没有就取hello
person.dog.name=${person.hello:hello}_dog

Profile

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

多Profile文件

我们在主配置文件编写的时候，文件名可以是 application-{profile}.properties/yml，默认使用application.properties 的配置。

yml支持多文档块方式

spring:
  profiles:
    active: dev #profiles.active:激活指定配置
#三个短横线分割多个peofile区（文档块）    
---
server:
  port: 8083
spring:
  profiles: dev

---

server:
  port: 8080
spring:
  profiles: default  #表示未指定时的默认位置

激活指定profile

1、在配置文件中指定 spring.profiles.active=dev

2、命令行：

java -jar 项目名.jar --spring.profiles.active=dev

可以直接在测试的时候，配置传入命令行参数。

IDEA中设置：

3、虚拟机参数： -Dspring.profiles.active=dev

配置文件加载位置

spring boot 启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文件：

• file:./config/：项目名/config/application.properties
• file:./：项目名/application.properties
• classpath:/config/ ：rescources/config/application.properties
• classpath:/ ：rescources/application.properties

以上是按照优先级从高到低的顺序，所有位置的文件都会被加载，高优先级配置内容会覆盖低优先级配置内容。

我们也可以通过配置spring.config.location来改变默认配置。

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

java -jar 项目名.jar --spring.config.location=G:/application.properties

外部配置加载顺序

Spring Boot 支持多种外部配置方式

这些方式优先级如下：https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#boot-features-external-config

SpringBoot也可以从以下位置加载配置，优先级从高到低。高优先级配置会覆盖低优先级配置，所有的配置会形成互补配置。

1、命令行参数

java -jar 项目名.jar --server.port=8087 --server.context-path=/abc，多个配置用空格分开，--配置项=值。

2、来自java:comp/env的 JNDI 属性。

3、java系统属性（System.getProperties()）。

4、操作系统环境变量。

5、RandomValuePropertySource配置的random.*属性值。

由jar包外向jar包内进行寻找；优先加载带profile

6、jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件

7、jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件

再来加载不带profile

8、jar包外部的application.properties或application.yml(不带spring.profile)配置文件

9、jar包内部的application.properties或application.yml(不带spring.profile)配置文件

10、@Configuration注解类上的@PropertySource。

11、通过SpringApplication.setDefaultProperties指定的默认属性。

自动配置原理

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

1、SpringBoot启动的时候，加载主配置类，开启了自动配置功能@EnableAutoConfiguration。

2、@EnableAutoConfiguration作用：

• 利用EnableAutoConfigurationImportSelector给容器中导入一些组件；

• 可以查看selectImports()方法的内容；

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

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

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

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

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

4、以HttpEncodingAutoConfiguration（Http编码自动配置）为例解释自动配置原理；

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

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

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

@ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true)  
//判断配置文件中是否存在某个配置  spring.http.encoding.enabled；如果不存在，判断也是成立的
//即使我们配置文件中不配置pring.http.encoding.enabled=true，也是默认生效的；
public class HttpEncodingAutoConfiguration {
  
  	//他已经和SpringBoot的配置文件映射了
  	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类中获取的，这些类里面的每一个属性又是和配置文件绑定的。

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

@ConfigurationProperties(prefix = "spring.http.encoding")  //从配置文件中获取指定的值和bean的属性进行绑定
public class HttpEncodingProperties {
   public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
}

精髓：

1）、SpringBoot启动会加载大量的自动配置类

2）、我们看我们需要的功能有没有SpringBoot默认写好的自动配置类；

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

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

xxxxAutoConfigurartion：自动配置类；给容器中添加组件。

xxxxProperties：属性配置类；封装配置文件中相关属性；

yml/properties文件中能配置的值就来源于[属性配置类] 。

@Conditional派生注解

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

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

SpringBoot的debug模式

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

我们怎么知道哪些自动配置类生效？ --debug=true查看详细的自动配置报告。

#开启SpringBoot的debug模式
debug: true

我们可以通过启用 debug=true属性；来让控制台打印自动配置报告，这样我们就可以很方便的知道哪些自动配置类生效；

=========================
AUTO-CONFIGURATION REPORT（自动配置报告）
=========================

Positive matches:（自动配置类启用的）
-----------------

   DispatcherServletAutoConfiguration matched:
      - @ConditionalOnClass found required class 'org.springframework.web.servlet.DispatcherServlet'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition)
      - @ConditionalOnWebApplication (required) found StandardServletEnvironment (OnWebApplicationCondition)
        
    
Negative matches:（没有启动，没有匹配成功的自动配置类）
-----------------

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