SpringBoot【二】 SpringBoot 配置

标签：组件   配置文件   cti   原理   -name   prot   ssi   ring   array   

SpringBoot 配置

配置文件

SpringBoot 使用一个全局的配置文件，配置文件名称是固定的，作用是修改 SpringBoot 自动配置的默认值（底层自动配置的值），有两种方式可以使用：

• application.properties

• • 语法结构 ：key=value

• application.yaml【推荐使用】

• • 语法结构 ：key:空格value

比如可以在配置文件中修改 Tomcat 默认启动的端口号

server.port=8081

yaml

YAML是 "YAML Ain‘t a Markup Language" （YAML不是一种标记语言）的递归缩写。在开发的这种语言时，YAML 的意思其实是："Yet Another Markup Language"（仍是一种标记语言）

这种语言以数据作为中心，而不是以标记语言为重点！

1、yaml 和 xml

以前的配置文件，大多数都是使用xml来配置

• 传统 xml 配置：

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

• yaml 配置：

  server：  
  	prot: 8080
  

2、基础语法

语法要求严格

1. 空格不能省略；

2. 以缩进来控制层级关系，只要是左边对齐的一列数据都是同一个层级的；

3. 属性和值的大小写都是十分敏感的。

• 字面量：普通的值 [ 数字，布尔值，字符串 ]

  字面量直接写在后面就可以，字符串默认不用加上双引号或者单引号

  k: v
  

  注意：

  • “ ” 双引号，不会转义字符串里面的特殊字符，特殊字符会作为本身想表示的意思

    比如：name: "zhang \n san" 输出 ：zhang 换行 san

  • ‘‘ 单引号，会转义特殊字符，特殊字符最终会变成和普通字符一样输出

    比如 ：name: ‘zhang \n san’ 输出 ：zhang \n san

• 对象、Map（键值对）

  #对象、Map格式
  k:     
  	v1:    
  	v2:
  

  在下一行来写对象的属性和值的关系，注意缩进

  student:    
  	name: zhangsan   
  	age: 3
  	
  # 行内写法
  student: {name: zhangsan,age: 3}
  

• 数组（ List、set ）

  用 - 值表示数组中的一个元素,比如：

  pets: 
  	- cat 
  	- dog 
  	- pig
  	
  # 行内写法
  pets: [cat,dog,pig]
  

注入配置文件

1、yaml 配置文件注入

yaml 文件强大的地方在于，它可以给我们的实体类直接注入匹配值。

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

2. 编写一个实体类 Dog

3. 原来 Spring 中给 bean 注入属性值，通过 @Value

   @Component //注册bean到容器中
   public class Dog {
       @Value("旺财")
       private String name;
       @Value("3")
       private int age;
       ...//有参无参构造、get、set方法、toString()方法  
   }
   

4. SpringBoot 的测试类下注入 Dog 对象并输出

   @SpringBootTest
   class Springboot02ConfigApplicationTests {
   
   	@Autowired // 自动注入
   	private Dog dog;
   
      @Test
      void contextLoads() {
         System.out.println(dog); // 输出结果：Dog{name=旺财, age=3}
      }
   }
   

5. 编写一个复杂一点的实体类：Person 类

   @Component //注册 bean 到容器中
   public class Person {
       
       private String name;
       private int age;
       private boolean happy;
       private Date birth;
       private Map<String,Object> maps;
       private List<Object> lists;
       private Dog dog;
   	... //有参无参构造、get、set方法、toString()方法  
   }
   

6. 使用 yaml 配置的方式进行注入，编写 application.yml

   person:
     name: zhangsan
     age: 3
     happy: true
     birth: 2020/02/02
     maps: {k1: v1,k2: v2}
     lists:
       - code
       - music
       - dance
     dog:
       name: wangcai
       age: 3
   

7. 注入到 Person 类中

   @Component
   @ConfigurationProperties(prefix = "person")
   public class Person {
   	... // 不变
   }
   

   @ConfigurationProperties 作用：

   将配置文件中配置的每一个属性的值，映射到这个组件中，告诉 SpringBoot 将本类中的所有属性和配置文件中相关的配置进行绑定，其中参数 prefix = “person” 表示将与配置文件中的 person 下面的所有属性一一对应。

8. 标注 @ConfigurationProperties 注解后，IDEA 提示报红（但是不影响程序运行），SpringBoot 配置注解处理器没有找到，查看文档，找到一个依赖

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

9. 测试类中测试

   @SpringBootTest
   class Springboot02ConfigApplicationTests {
   
      @Autowired
      private Person person;
   
      @Test
      void contextLoads() {
         System.out.println(person);
      }
   

10. 输出 Person 对象，属性值和 yaml 注入的相同，说明所有值全部注入成功

    Person{name=‘zhangsan‘, age=3, happy=true,birth=Sun Feb 02 00:00:00 GMT+08:00 2020,maps={k1=v1, k2=v2}, lists=[code, music, dance],dog=Dog{name=‘wangcai‘, age=3}}
    

注意：当配置文件的 key 值和属性的值设置的不一样时，结果输出为 null，注入失败。

配置文件占位符：配置文件可以编写占位符生成随机数

person:
 name: zhangsan${random.uuid} # 随机uuid
 age: ${random.int}  # 随机int
 happy: true
 birth: 2020/02/02
 maps: {k1: v1,k2: v2}
 lists:
   - code
   - music
   - dance
 dog:
   name: ${person.hello:other}_wangcai
   age: 3

2、properties 配置文件注入（加载指定的配置文件）

properties 配置文件在写中文的时候，会有乱码，需要去 IDEA 中（settings --> FileEncodings）设置编码格式为UTF-8。

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

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

1. 在 resources 目录下新建一个 person.properties 文件

   name=lisi
   

2. 然后在 Person 类中指定加载 person.properties 文件

   @Component
   // 加载指定的配置文件
   @PropertySource(value = "classpath:application.properties")
   public class Person {	//直接使用@value  
       
       // @Value("男")  // 字面量 
       // @Value("#{9*2}")  // #{SPEL} Spring表达式
       @Value("${name}") // spring EL表达式取出配置文件的值
       private String name;
       private int age;
       ...
   }
   

3. 测试输出，Person 对象中只有 name 属性被赋值为 lisi，其他都为 null，说明配置文件绑定成功。

   Person{name=‘lisi‘, age=null, happy=null, birth=null, maps=null, lists=null, dog=null}
   

注意：@Value 使用起来并不友好，因为我们需要为每个属性单独注解赋值，比较麻烦

3、两种方式对比

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

2. 松散绑定：比如 yml 中写的 last-name，和实体类中的 lastName 一样， - 后面跟着的字母默认是大写的。

3. JSR303 数据校验 ， 可以在字段上增加一层过滤器验证，可以保证数据的合法性

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

结论：

• 配置 yml 和配置 properties 都可以获取到值 ， 强烈推荐 yml；

• 如果在某个业务中，只需要获取配置文件中的某个值，可以使用一下 @value；

• 如果专门编写了一个 JavaBean 来和配置文件进行一一映射，使用 yaml 和 @configurationProperties。

JSR303 数据校验

Springboot 中可以用 @validated 来校验数据，如果数据异常则会统一抛出异常，方便异常中心统一处理。使用数据校验，可以保证数据的正确性。

在 Person 类中加入注解让 name 只能支持 Email 格式；

@Component
@ConfigurationProperties(prefix = "person")
@Validated // 数据校验
public class Person {

    @Email(message = "邮箱格式错误") //name必须是邮箱格式
    private String name;
	...
}

运行结果：default message [不是一个合法的电子邮件地址];

常见参数：

@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 对象是否符合正则表达式的规则
.......等等除此以外，我们还可以自定义一些数据校验规则

多环境切换

profile 是 Spring 对不同环境提供不同配置功能的支持，可以通过激活不同的环境版本，实现快速切换环境。

1、多配置文件

在主配置文件编写的时候，文件名可以是 application-{profile}.properties/yml , 用来指定多个环境版本

例如：

• application-test.properties 代表测试环境配置
• application-dev.properties 代表开发环境配置

但是 Springboot 并不会直接启动这些配置文件，它默认使用 application.properties主配置文件，需要通过一个配置来选择需要激活的环境：

#比如在配置文件中指定使用dev环境，我们可以通过设置不同的端口号进行测试；
#我们启动SpringBoot，就可以看到已经切换到dev下的配置了；
spring.profiles.active=dev

2、yaml 的多文档块

和 properties 配置文件中一样，但是使用 yml 去实现不需要创建多个配置文件，更加方便。

server:  
	port: 8081
	
#选择要激活那个环境块
spring:  
	profiles:    
		active: prod
		
---
server:  
	port: 8083
spring:  
	profiles: dev #配置环境的名称

---
server:  
	port: 8084
spring:  
	profiles: prod  #配置环境的名称

注意：如果 yml 和 properties 同时都配置了端口，并且没有激活其他环境，默认会使用 properties 配置文件。

配置文件加载位置

官方文档说明，外部配置文件位置有：

1. file:./config/

2. file:./

3. classpath:./config/

4. classpath:./

SpringBoot 启动会扫描以下位置的 application.properties 或者 application.yml 文件作为 SpringBoot 的默认配置文件，优先级由高到底，高优先级的配置会覆盖低优先级的配置：

优先级1：项目路径(file)下的config文件夹配置文件
优先级2：项目路径下配置文件
优先级3：资源路径(classpath)下的config文件夹配置文件
优先级4：资源路径下配置文件

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

指定位置加载配置文件：

可以通过 spring.config.location 来改变默认的配置文件位置，项目打包好以后，可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置，这种情况，一般是后期运维做的多，相同配置，外部指定的配置文件优先级最高

java -jar spring-boot-config.jar --spring.config.location=F:/application.properties

自动配置原理

关注两种文件：

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

• xxxProperties ：默认属性类，封装配置文件中相关属性，和配置文件绑定，这样就可以使用自定义的配置

原理分析：

以 HttpEncodingAutoConfiguration（Http编码自动配置）和 ServerProperties 为例：

// 表示这是一个配置类，和以前编写的配置文件一样，也可以给容器中添加组件
@Configuration(proxyBeanMethods = false)

// 自动配置属性：ServerProperties
	//进入这个ServerProperties查看，将配置文件中对应的值和ServerProperties绑定起来；
    //并把ServerProperties加入到ioc容器中
@EnableConfigurationProperties(ServerProperties.class)

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

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

//判断配置文件中是否存在某个配置：server.servlet.encoding
    //如果不存在，判断也是成立的
    //即使我们配置文件中不配置 server.servlet.encoding=true，也是默认生效的；
@ConditionalOnProperty(prefix = "server.servlet.encoding", value = "enabled", matchIfMissing = true)
public class HttpEncodingAutoConfiguration {

   //它已经和SpringBoot的配置文件映射了
   private final Encoding properties;

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

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

//从配置文件中获取指定的值和 bean 的属性进行绑定
@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties {
    ...
}

总结：

根据当前不同的条件判断，决定这个配置类是否生效；一旦这个配置类生效，这个配置类就会给容器中添加各种组件；这些组件的属性是从对应的 properties 类中获取的，这些类里面的每一个属性又是和配置文件绑定的；

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

精髓：

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

@Conditional

自动配置类必须在一定的条件下才能生效，主要原因是每个自动配置类上都添加了 @Conditional 的派生注解。

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

问题：如何知道哪些自动配置类生效？

通过启用 debug=true 属性，来让控制台打印自动配置报告，这样知道哪些自动配置类生效

#开启springboot的调试类
debug=true

输出日志中将配置类分为三种：

• Positive matches:（自动配置类启用的：正匹配）

• Negative matches:（没有启动，没有匹配成功的自动配置类：负匹配）

• Unconditional classes: （没有条件的类）

SpringBoot【二】 SpringBoot 配置

标签：组件   配置文件   cti   原理   -name   prot   ssi   ring   array   

原文地址：https://www.cnblogs.com/Songzw/p/13269448.html