2 - Spring Boot与配置文件

一、配置文件

1、Spring Boot使用一个全局的配置文件，配置文件名是固定的。

• application.properties
• application.yml

2、配置文件的作用：

• 修改SpringBoot自动配置的默认值。
• SpringBoot在底层都给我们自动配置好。

3、YAML（YAML Ain’t Markup Language）

• YAML A Markup Language：是一个标记语言
• YAML isn’t Markup Language：不是一个标记语言；

4、标记语言：

• 以前的配置文件，大多都使用的是 xxxx.xml文件；

• YAML：以数据为中心，比json、xml等更适合做配置文件

• YAML配置实例

  server:
    	port: 8080
  

• XML配置实例

  <server>
  	<port>8080</port>
  </server> 
  

二、YAML语法

1、基本语法

• k:(空格)v：表示一对键值对（空格必须有）

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

• 属性和值也是大小写严格控制的。

server:
	port: 8080
	path: /url

2、值的写法

• 字面量：普通的值（数字，字符串，布尔）

  • k:(空格)v：字面直接来写。

• 字符串默认不用加上单引号或者双引号。

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

  ​ name: “zhangsan \n lisi”：输出；zhangsan 换行 lisi

• ‘’：单引号，会转义特殊字符，特殊字符终只是一个普通的字符串数据。

  name: ‘zhangsan \n lisi’：输出；zhangsan \n lisi

• 对象、Map（属性和值）（键值对）

  • k:(空格)v：在下一行来写对象的属性和值的关系，注意缩进。

  • 对象还是以k:(空格)v的方式

    friends:
    	name: zhangsan
    	age: 20
    

• 行内写法：

  friends: {name: zhangsan,age: 20}
  

• 数组（List、Set）

  • 用 -(空格)值表示数组中的一个元素

    pets:
    - cat
    - dog
    - pig
    

• 行内写法：

  pets: [cat,dog,pig]
  

3、YAML配置文件注入

• 配置文件

  person:
    lastName: zhangsan
    age: 20
    boss: false
    birth: 2017/12/12
    maps: {k1: v1,k2: v2}
    lists:
    - lisi
    - wangwu
    dog:
      name: 小狗
      age: 2
  

• 对应的JavaBean

  /**
   *将配置文件中配置的每一个属性的，映射到这个组件中
   * @ConfigurationProperties：告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定
   * prefix = "person"：配置文件中哪个下面的所有属性进行一一映射
   * @ConfigurationProperties(prefix = "person")默认是从全局配置文件中获取值
   * @Component只有这个组件是容器中的组件，才能使用容器提供的@ConfigurationProperties功能
   */
  @Component
  @ConfigurationProperties(prefix = "person")
  public class Person {
      private String lastName;
      private Integer age;
      private Boolean boss;
      private Date birth;
      private Map<String,Object> maps;
      private List<Object> lists;
      private Dog dog;
    	//同时要生成get、set方法和toString方法
  }
  

• 可以导入一个配置文件处理器，以后编写配置就有提示

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

• 测试

  /**
   * springboot单元测试
   * 可以在测试期间很方便的类似编码一样进行自动注入到容器的功能
   */
  @SpringBootTest
  class SpringBoot02ConfigApplicationTests {
      @Autowired
      Person person;
      @Test
      void contextLoads() {
          System.out.println(person);
      }
  }
  

4、properties配置文件注入

• 配置文件

  #配置person
  #idea的properties配置文件是utf-8
  person.last-name=张三
  person.age=18
  person.birth=2017/12/15
  person.boss=false
  person.maps.k1=v1
  person.maps.k2=v2
  person.lists=a,b,c
  person.dog.name=小绵羊
  person.dog.age=15
  

• properties配置文件在idea中默认utf-8可能会乱码

  • 解决：file—>settings—>搜索File Encodings—>选择UTF-8—>勾选Transparent native-to-ascii conversion

5、@Value获取值和@ConfigurationProperties获取值的比较

• @Value获取值

  @Component
  //@ConfigurationProperties(prefix = "person")
  public class Person {
      /**
       * <bean class="Person">
       *      <property name="lastName" value="字面量/${key}从环境变量、配置文件中取值/#{SpEL}"/>
       * </bean>
       */
      @Value("${person.lastName}")
      private String lastName;
      @Value("#{11*2}")
      private Integer age;
      @Value("true")
      private Boolean boss;
  }
  

• 松散绑定（松散语法）：使用-或者_表示后面的首字母大写(例如：person.last-name=张三)

• SpEL：spring表达式语言（如：@Value("#{11*2}")会计算出来再赋值）

• 区别如下：

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

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

6、配置文件注入值数据校验

/**
 * @Validated是做数据校验
 */
@Component
@ConfigurationProperties(prefix = "person")
@Validated
public class Person {
    //必须是邮箱格式
    @Email
    private String lastName;
}

7、@PropertySource&@ImportResource&@Bean

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

  • 在resources下新建一个文件：person.properties

    person.lastName=张三
    person.age=18
    person.birth=2017/12/15
    person.boss=false
    person.maps.k1=v1
    person.maps.k2=v2
    person.lists=a,b,c
    person.dog.name=小绵羊
    person.dog.age=15
    

• JavaBean

  /**
   * 将配置文件中配置的每一个属性的，映射到这个组件中
   * @ConfigurationProperties：告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定
   * prefix = "person"：配置文件中哪个对象下面的所有属性进行一一映射
   * @ConfigurationProperties(prefix = "person")默认是从全局配置文件中获取值
   * @Component只有这个组件是容器中的组件，才能使用容器提供的@ConfigurationProperties功能
   */
  @Component
  @ConfigurationProperties(prefix = "person")
  @PropertySource(value = {"classpath:person.properties"})
  public class Person {
      private String lastName;
      private Integer age;
      private Boolean boss;
      private Date birth;
      private Map<String,Object> maps;
      private List<Object> lists;
      private Dog dog;
  }
  

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

  • 在SpringBoot里面没有Spring的配置文件，自己编写的配置文件，也不能自动识别。

  • 若需要让Spring的配置文件加载生效，需要将@ImportResource标注在一个配置类上。

    /**
     * @SpringBootApplication来标注一个主程序类，说明这是一个Spring Boot应用
     * @ImportResource(locations导入spring的配置文件让其生效，多个配置文件用“,”号隔开
     */
    @SpringBootApplication
    @ImportResource(locations = {"classpath:applicationContext.xml"})
    public class HelloWorldMainApplication {
        public static void main(String[] args) {
            //启动spring应用，两个参数，主程序类的.class和main中的可变参数
            SpringApplication.run(HelloWorldMainApplication.class,args);
        }
    }
    

• 以前编写的Spring的配置文件

  <?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 id="helloService" class="com.itan.springboot.service.HelloService"></bean>
  </beans>
  

• SpringBoot推荐给容器中添加组件的方式： 推荐使用全注解的方式，不需要再编写配置文件了，也不需要将@ImportResource标注在一个配置类上。

  1、配置类@Configuration：标识是一个配置类

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

  /**
   * @Configuration：指明当前类是一个配置类，替代spring配置文件中的<bean/>标签添加组件
   */
  @Configuration
  public class MyAppConfig {
      //@Bean将方法的返回值添加到容器中，容器中这个组件默认的id就是当前标注的方法名
      @Bean
      public HelloService helloService(){
          return new HelloService();
      }
  }
  

  3、测试

  @Autowired
  ApplicationContext ioc;
  @Test
  public void helloService(){
      boolean b = ioc.containsBean("helloService");
      System.out.println(b);
  }
  

8、配置文件占位符

• 随机数：获取一个随机数值

  person.age=${random.int}
  ${random.int(10)}、${random.int[1024,65536]}、${random.long}
  

• 占位符获取之前配置的值，如果不存在，可以使用” : “指定默认值

  person.lastName=张三${random.uuid}
  person.age=${random.value}
  person.birth=2017/12/15
  person.boss=false
  person.maps.k1=v1
  person.maps.k2=v2
  person.lists=a,b,c
  person.dog.name=${person.hello:hello}_小绵羊
  person.dog.age=15
  

9、Profile

• 多Profile文件

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

  默认使用的是application.properties的配置

• yml支持多文档块方式：不用写多个配置文件

  server:
      port: 8081
  #激活dev配置
  spring:
      profiles:
      active: dev
  ---
  server:
         port: 8082
  spring:
      profiles: dev
  
  ---
  server:
         port: 8083
  spring:
      profiles: prod	#指定属于哪个环境
  

• 激活指定的profile

  1、在配置文件中指定 ：spring.profiles.active=dev，激活的是application-dev.properties

  2、打包后使用命令行激活指定的profile

  ​ java -jar spring-boot-02-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev

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

  ​ Configurations—>Program arguments中输入：–spring.profiles.active=dev

  3、虚拟机参数：

  ​ Configurations—>VM options中输入：-Dspring.profiles.active=dev

10、配置文件加载位置

• springboot启动会扫描一下位置的application.properties或者application.yml文件作为Spring Boot的默认配置文件

  • 当前项目下的config文件夹下的配置文件
  • 当前项目下的配置文件
  • 当前项目下src/main/resources/config下的配置文件
  • 当前项目下src/main/resources下的配置文件

• 加载优先级由高到低，高优先级会覆盖低优先级的配置。

• Spring Boot会从这四个位置全部加载主配置文件，形成互补。

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

  • 项目打包后，使用命令行参数的形式，启动项目的时候来指定配置文件的新位置，指定配置文件和默认加载的这些配置文件共同起作用形成互补配置。
  • java -jar 项目打包的jar名 --spring.config.location=配置文件路径（G:/application.properties）

11、外部配置文件

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

1. 命令行参数：所有的配置都可以在命令行上进行指定，多个配置用空格分开；–配置项=值

   java -jar 项目打包后的jar全名 --server.port=8080 --server.servlet.context-path=/abc

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

3. Java系统属性（System.getProperties()）

4. 操作系统环境变量

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

   优先加载带porfile

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指定的默认属性

12、自动配置原理

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

• @EnableAutoConfiguration 作用：

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

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

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

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

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

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

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

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

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

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

总结精髓：

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

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

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

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

xxxxAutoConfigurartion：自动配置类；

给容器中添加组件

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

13、自动配置的细节

• @Conditional派生注解（Spring注解版原生的@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存在指定项

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

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

  debug=true
  server.port=8080