SpringBoot(二)—— 配置

SpringBoot系列文章

  • Spring 注解开发
  • SpringBoot(一)——入门
  • SpringBoot(三)——日志

文章目录

    • 1. 配置文件
    • 2. YAML
      • 2.1 YAML 基本语法
    • 3. SpringBoot 属性注入
    • 3.1使用YAML进行值注入
      • 3.2 使用properties文件进行属性注入
      • 3.3 使用@Value 进行属性注入
      • 3.4 @Value 和 @ConfigurationProperties 的区别
      • 3.5 @PropertyResource 和 @ImportSource
    • 4. 配置文件占位符
    • 5. Profile
      • 5.1 多profile文件
      • 5.2 激活方式(指定配置文件)
    • 6. 配置文件加载位置
    • 7. 外部配置加载顺序
    • 8. 自动配置原理
    • 9. @Conditional的扩展注解

1. 配置文件

SpringBoot使用一个全局的配置文件,配置文件名是固定的

  • application.properties
  • application.uml

配置文件的作用:对一些默认配置进行修改
配置文件放在src/main/resources目录或者类路径/config下

2. YAML

YAML(YAML Ain’t Markup Language)。以前的配置文件大多都是用的是XXX.xml文件,SpringBoot中,也可以使用.yml文件作为配置文件。.xml文件中,大量的数据都用在了标签上面,而YAML,是以数据为中心的,比json、xml等更适合做配置文件。比如,修改端口号

  • xml:
<server> 
	<port>8081</port> 
 </server
  • YAML
server:   
	port: 8081

2.1 YAML 基本语法

  • key: value 表示一对键值对,注意冒号后面必须有空格,以空格的缩进来控制层级关系,只要是左对齐的一列数据,就是同一层级
  • 缩进时不允许使用Tab键,只允许使用空格,空格数目不重要,只要相同层级的元素左侧对其即可
  • 大小写敏感

值的写法

  • 普通值(数字、字符串、布尔、日期类型)

直接使用 key: value的形式,注意字符串不用加双引号或者单引号,当使用双引号时,可以使用转义字符,会按照转移字符的意思输出
比如name: “zhangsan\nlisi” ,输出zhangsan 换行 lisi,如果换成单引号的话,会输出zhangsan/nlisi

  • 对象、Map类型

key: value,在下一行写对象的属性和值的关系,注意缩进,比如

friends:
   name: zhangsan
   age: 20

行内写法

friends: {name: zhangsan,age: 20}
  • 数组(List、Set)
pets:
  ‐ cat
  ‐ dog
  ‐ pig

行内写法

pets: [cat,dog,pig]

3. SpringBoot 属性注入

3.1使用YAML进行值注入

person类

/*
将配置文件中配置的每一个属性的值,映射到这个组件中
  @ConfigurationProperties:告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定;
      prefix = "person":配置文件中哪个下面的所有属性进行一一映射
 
  只有这个组件是容器中的组件,才能容器提供的@ConfigurationProperties功能;
  @ConfigurationProperties(prefix = "person")默认从全局配置文件中获取值;
 */
@Component
@ConfigurationProperties(prefix="person")
public class Person {
    private String name;
    private int age;
    private Map<String,String> map;
    private List<Object> list;
    private Dog dog;
    get、set方法,toString方法
 }
 public class Dog {
    private String name;
	get、set toString方法
}

application.yml文件

person:
   name: 张三
   age: 20
   map:
     k1: s1
     k2: s2
   list:
     - wangwu
     - lisi
   dog:
     name: mm

导入配置文件处理器,以后编写配置就有提示了

<!--导入配置文件处理器,编写配置文件的时候会有提示-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

3.2 使用properties文件进行属性注入

application.properties文件

person.name=ewen
person.age=23
person.map.k1=t1
person.map.k2=t2
person.list=[张三]
person.dog.name=nn

使用application.properties文件进行属性注入,和上面使用application.yml文件使用的注解一样
注意:idea中使用的是utf-8的编码格式,而properties使用的是ASCII码,需要设置一下,settings->File Encoding
SpringBoot(二)—— 配置_第1张图片

3.3 使用@Value 进行属性注入

可以使用@Value 注解代替@ConfigurationProperties,使用方法和是spring中的一样,value中可以是值,${.properties属性文件中的属性名}
#{SpEL}(spring表达式,里面可以写具体的计算)

@Component
//@ConfigurationProperties(prefix="person")
public class Person {
    @Value("王五")
    private String name;
    @Value("${person.age}")// @Value("#{11 * 2}")
    private int age;
    private Map<String,String> map;
    private List<Object> list;
    private Dog dog;

3.4 @Value 和 @ConfigurationProperties 的区别

@ConfigurationProperties @Value
功能 批量注入配置文件中的值 一个一个的注入
松散绑定(松散语法) 支持 不支持
SpEL 不支持 支持
JSR303 数据校验 支持 不支持
复杂类型封装 支持 不支持
  • .yml文件和.properties文件都是使用的@ConfigurationProperties注解
  • 如果说是在某个业务逻辑中需要获取一下配置文件中的某项值,使用@Value;
  • 如果专门编写了一个javaBean来和配置文件进行映射,我们就直接使用@ConfigurationProperties;

3.5 @PropertyResource 和 @ImportSource

  • @PropertyResource
    加载指定的配置文件到环境变量中,配置文件只能是.properties文件,不能是.yml文件,就可以不用将对象的属性值写在主配置文件中了,使用@PropertyResource之后,还是需要使用@ConfigurProperties进行数据绑定。
@PropertySource(value="classpath:/person.properties")//加载指定的配置文件
@Component
@ConfigurationProperties(prefix="person")
public class Person {
	...}
  • @ImportSource
    导入Spring的配置文件,让配置文件里面的内容生效。SpringBoot里面没有Spring的配置文件,我们自己编写的配置文件,也不能自动识别,想让Spring的配置文件生效,加载进来,使用@ImportResource标注在一个配置类上
@ImportResource(locations = "classpath:/beans.xml") //让spring的配置文件生效
@SpringBootApplication
public class Springboot01Application {
	... }

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

@Configuration //指明当前类是一个配置类,用配置类代替spring中的xml配置文件
public class MyConfig {
    @Bean//将方法的的返回值添加到容器中,容器中这个组件的id就是方法名
    public HelloService helloService2(){
        System.out.println("配置类给容器添加组件");
        return new HelloService();
    }
}

4. 配置文件占位符

  • 随机数:在配置文件中,可以使用${random. }来给属性一个随机数
${random.value}、${random.int}、${random.long}
${random.int(10)}、${random.int[1024,65536]}
  • 可以使用占位符获取前面属性的值,如果没有前面的属性,可以使用:默认值,来指定默认值,不指定会报错
#name为张三随机值
person.name=张三${random.uuid} 
#为age生成一个随机数
person.age=${random.int} 
person.map.k1=t1
person.map.k2=t2
person.list=张三,李四
#获取person.hello的值,如果没有指定默认值为mm
person.dog.name=${person.hello:mm} 

5. Profile

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

5.1 多profile文件

  • xml方式
    可以创建多个配置文件,文件命名格式是:application-{profile}.properties,默认使用的是application.properties的配置
    比如,我们可以创建application-test.properties、application-dev.properties、application-prod.properties,这三个文件分别在测试、开发、生产的环境中使用。

  • yml方式
    如果使用的是yml配置文件的话,可以使用yml的多文档块,yml文件中,使用---可以将yml分成多个文档块,默认使用的是最上面的第一个文档块,下面的根据---划分为2、3、4…文档块。

5.2 激活方式(指定配置文件)

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

xml文件方式,在application.properties文件中使用 spring.profiles.active=test激活指定的配置

yml文件

#激活指定profile的配置,springboot启动的时候就会使用
server:
  port: 8081
spring: 
  profiles:
    active: prod
---
server:
  port: 8082
spring:
  profile: dev
---
server:
  port: 8083
spring:
  profiles: prod  #指定属于哪个环境

  • 命令行:
    java -jar spring-boot-02-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev
    可以直接在测试的时候,配置传入命令行参数

  • 虚拟机参数;
    -Dspring.profiles.active=dev

6. 配置文件加载位置

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

  • file:./config/ 项目根路径下的config文件夹下
  • file:./ 项目根路径下
  • classpath:/config/ 类路径下(resource下)的config文件夹下
  • classpath:/ 类路径下(resource下)
    以上是按照优先级从高到低的顺序,SpringBoot启动的时候,所有位置的配置文件都会被加载,高优先级中的配置会覆盖低优先级中的配置,并且会形成互补配置,如果高优先级中没有某项配置,而低优先级中有,就会使用低优先级的。

我们还可以通过spring.config.location来改变默认的配置文件位置
项目打包好以后,我们可以使用命令行参数的形式,启动项目的时候来指定配置文件的新位置,指定配置文件和默认加载的这些配置文件共同起作用形成互补配置;

java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=G:/application.properties 

7. 外部配置加载顺序

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

  1. 命令行参数
    所有的配置都可以在命令行上进行指定
    java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --server.port=8087 --server.context-path=/abc多个配置用空格分开; --配置项=值
  2. 来自java:comp/env的JNDI属性
  3. Java系统属性(System.getProperties())
  4. 操作系统环境变量
  5. RandomValuePropertySource配置的random.*属性值
  6. jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件
  7. jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件
  8. jar包外部的application.properties或application.yml(不带spring.profile)配置文件
  9. jar包内部的application.properties或application.yml(不带spring.profile)配置文件
    (6、7、8、9总结就是由jar包外向jar包内进行寻找; 优先加载带profile,再来加载不带profile )
  10. @Configuration注解类上的@PropertySource
  11. 通过SpringApplication.setDefaultProperties指定的默认属性

所有支持的配置加载来源,可以看官方文档

8. 自动配置原理

配置文件中可以写什么配置,怎么写?
我们可以查看官方文档配置文件能配置的属性参照

springboot启动的时候加载了主配置类,并开启了自动配置功能@EnableAutoConfiguration。

@SpringBootApplication
    @EnableAutoConfiguration

@EnableAutoConfiguration的作用:

  • 使用@Import({AutoConfigurationImportSelector.class})给容器中导入了一些组件。
  • AutoConfigurationImportSelector类中的importSelector()方法中,调用了getAutoConfigurationEntry方法

    selectImports方法中调用了getAutoConfigurationEntry方法,这个方法又调用了getCandidateConfigurations方法

  • getAutoConfigurationEntry方法中
//获取候选配置
List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
  • getCandidateConfigurations方法中,调用了SpringFactoriesLoader.loadFactoryNames()方法,扫描所有jar包类路径下 META-INF/spring.factories的文件,把扫描到的这些文件的内容包装成properties对象,从properties中获取到EnableAutoConfiguration.class(类名)对应的值,然后把它们添加在容器中。
    SpringBoot(二)—— 配置_第2张图片

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

  • 每一个自动配置类都能进行自动配置功能,有了自动配置类,免去了我们手动编写配置注入功能组件等的工作

以HttpEncodingAutoConfiguration(Http编码自动配置)为例解释自动配置原理

@Configuration( //表示这是一个配置类
    proxyBeanMethods = false
)
/**
 * 启动指定类的ConfigurationProperties功能;
 * 将配置文件中对应的值和 ServerProperties这个类绑定起来;
 * 并把 ServerProperties加入到ioc容器中
 */
@EnableConfigurationProperties({ServerProperties.class})
/**
 * 使用Spring底层@Conditional注解
 * 根据不同的条件进行判断,如果满足指定的条件,整个配置类里面的配置就会生效;
 * 判断当前应用是否是web应用,如果是,当前配置类生效
 */
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
//判断当前项目有没有这个类,CharacterEncodingFilter,SpringMVC中进行乱码解决的过滤器
@ConditionalOnClass({CharacterEncodingFilter.class})
/**
 * 判断配置文件中是否存在某个配置  server.servlet.encoding.enabled;如果不存在,判断也是成立的
 * 即使我们配置文件中不配置server.servlet.encoding.enabled=true,也是默认生效的;
 */
@ConditionalOnProperty(
    prefix = "server.servlet.encoding",
    value = {"enabled"},
    matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {
	//和springBoot中的配置文件绑定,和编码相关的配置都在Encoding这个类中
	private final Encoding properties;
	
	//只有一个有参构造器的情况下,参数默认从容器中获取
    public HttpEncodingAutoConfiguration(ServerProperties properties) {
        this.properties = properties.getServlet().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.web.servlet.server.Encoding.Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.web.servlet.server.Encoding.Type.RESPONSE));
        return filter;
    }
  1. 根据当前不同的条件判断,决定这个配置类是否生效
  2. 一但这个配置类生效;这个配置类就会给容器中添加各种组件;这些组件的属性是从对应的properties类中获取的,这些类里面的每一个属性又是和配置文件绑定的;

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

//从配置文件中获取指定的值和这个类中的属性进行绑定
@ConfigurationProperties(
    prefix = "server",
    ignoreUnknownFields = true
)
public class ServerProperties {
    private Integer port;
    private InetAddress address;

总结:

  • SpringBoot启动会加载大量的自动配置类
  • 我们看我们需要的功能有没有SpringBoot默认写好的自动配置类
  • 再来看这个自动配置类中到底配置了哪些组件;(只要我们要用的组件有,我们就不需要再来配置了)
  • 给容器中自动配置类添加组件的时候,会从properties类中获取某些属性。我们就可以在配置文件中指定这些属性的值

xxxxAutoConfigurartion:自动配置类;

xxxxProperties:封装配置文件中相关属性,里面又封装了一些对象,属性也可能在对象里

9. @Conditional的扩展注解

springBoot启动的时候,并不是把所有的自动配置类都加载到容器,必须是@Conditional指定的条件成立,才给容器中添加组件,配置类里面的所有内容才生效,这些条件就是基于spring底层的@Conditional注解实现的,springboot对这个注解进行了扩展。

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

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

参考
SpringBoot权威教程

你可能感兴趣的:(spring,boot)