Spring Boot 配置文件

🔍 配置文件

1. 配置文件

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

  • application.properties

    语法结构 ：key = value

  • application.yml

    语法结构 ：key：空格 value

📜 标记语言：

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

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

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

YAML：

server:
  port: 8081

properties：

server.port=8081

2. YAML 语法

① 基本语法

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

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

server:
    port: 8081
    path: /hello

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

② 值的写法

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

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

k: v

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

    💬 例如：

    name: "zhangsan \n lisi"

    输出：

    zhangsan
lisi

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

    💬 例如：

    name: ‘zhangsan \n lisi’

    输出

    zhangsan \n lisi

Ⅱ Map（属性和值）（键值对）

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

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

💬 例如：

friends:
	lastName: zhangsan
	age: 20

行内写法：

friends: {lastName: zhangsan,age: 18}

Ⅲ 数组（List、Set）

用 - 值 表示数组中的一个元素

💬 例如：

pets:
  - cat
  - dog
  - pig

行内写法

pets: [cat,dog,pig]

3. @ConfigurationProperties 全局配置文件值注入

① 全局配置文件值注入

📜 需要导入配置文件处理器的依赖，配置文件进行绑定就会有提示

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

注入步骤：

  • 在 springboot 项目中的 resources 目录下新建一个文件 application.yml
  • 编写实体类

配置文件 yaml 格式

person:
    lastName: hello
    age: 18
    boss: false
    birth: 2017/12/12
    maps: {k1: v1,k2: 12}
    lists:
      - lisi
      - zhaoliu
    dog:
      name: 小狗
      age: 12

配置文件 properties 格式

person.last-name=张三
person.age=11
person.birth=2017/12/15
person.boss=false
person.maps.k1=v1
person.maps.k2=14
person.lists=a,b,c
person.dog.name=dog
person.dog.age=15

🚨 properties 配置文件在 IDEA 中默认 utf-8 可能会乱码，如图进行相应设置：

img

实体类：

/**
 * 将配置文件中配置的每一个属性的值，映射到这个组件中
 */
@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()方法

  • @ConfigurationProperties：告诉 SpringBoot 将本类中的所有属性和配置文件中相关的配置进行绑定；

    ⭐ 只有这个组件是容器中的组件，才能使用容器提供的 @ConfigurationProperties 功能；

  • prefix = "person"：与配置文件中哪个属性进行一一映射

② @Validated（JSR303 数据校验）

Ⅰ 概述

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

使用 @Validated 注解：表示这个 JavaBean 中的属性需要校验

@Component
@ConfigurationProperties(prefix = "person")
@Validated
public class Person {

    //lastName必须是邮箱格式
    @Email
    private String lastName;
    private Integer age;
    private Boolean boss;

    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;

Ⅱ 常见参数

@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 对象是否符合正则表达式的规则

4. @Value 值注入

@Value 值注入是 Spring 中的方式

① @Value 值注入

可以使用 @Value 注解从配置文件中手动取值或者自由赋值，支持三种方式：

  • ${key} 从环境变量、配置文件中获取值

    @Value("${person.last-name}")
private String lastName;

  • # {SpEL}

    @Value("#{11*2}")
private Integer age;

  • "字面量"

    @Value("true")
private Boolean boss;

@Component
public class Person {
    /**
     * <bean class="Person">
     *      <property name="lastName" value="字面量//"></property>
     * <bean/>
     */
    @Value("${person.last-name}")
    private String lastName;
    @Value("#{11*2}")
    private Integer age;
    @Value("true")
    private Boolean boss;

    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;

② @Value 和 @ConfigurationProperties 注入值比较

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

💡 松散绑定：比如 yml 中写的 last-name，这个和 lastName 是一样的， - 后面跟着的字母默认是大写的。这就是松散绑定。

无论配置文件是 yml 还是 properties 他们都能获取到值；

  • 如果只是在某个业务逻辑中需要获取一下配置文件中的某项值，使用 @Value；

    @RestController
public calss HelloController{
    @Value("${person.lastName}")
    private String name;
    
    @RequestMapping("/sayHello")
    public String sayHello(){
        return "Hello" + name;
    }
}

  • 如果我们专门编写了一个 JavaBean 来和配置文件进行映射，就直接使用@ConfigurationProperties

5. @PropertySource 指定配置文件值注入

@ConfigurationProperties(prefix = "person") 默认从全局配置文件中获取值，如果所有的配置全写在全局配置文件中，那么这个文件就太大了。我们可以自定义配置文件使用 @PropertySource 加载指定的配置文件

比如我们在 resources 目录下新建一个 person.properties 文件

@PropertySource(value = {"classpath:person.properties"})
@Component
public class Person {
    private String lastName;
    private Integer age;
    private Boolean boss;

6. @ImportResource / @Bean

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

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

@ImportResource 标注在一个配置类上可以让 Spring 的配置文件生效并加载进来；

@ImportResource(locations = {"classpath:beans.xml"})
@SpringBootApplication

Spring 的配置文件 beans.xml（示例：我们创建一个 service.HelloService.java 文件）

<?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.smallbeef.springboot.service.HelloService"></bean>
</beans>

🌎 显然，这样给容器中添加组件的方法比较麻烦，SpringBoot 推荐给容器中添加组件的方式：使用全注解的方式：

  • 创建一个 config.MyAppConfig.java 配置类

    img

  • ⭐ 使用@Bean 给容器中添加组件

    @Configuration 表示此类是 Spring 的配置类（替代原来的 Spring 配置文件）

    /**
 * @Configuration：指明当前类是一个配置类；就是来替代之前的Spring配置文件
 */
@Configuration
public class MyAppConfig {

    //将方法的返回值添加到容器中；容器中这个组件默认的 id 就是方法名
    @Bean
    public HelloService helloService02(){
        System.out.println("配置类 @Bean 给容器中添加组件了...");
        return new HelloService();
    }
}

7. 配置文件占位符

① 随机数

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

  • ${random.value}
  • ${random.int}
  • ${random.long}
  • ${random.int(10)}
  • ${random.int[1024,65536]}

② 占位符获取之前配置的值

person.last-name = 张三${random.uuid}
person.age = ${random.int}
# 在 person.last-name 后面 添加 _dog 字符
person.dog.name=${person.last-name}_dog

如果没有可以是用 : 指定默认值

person.last-name=张三${random.uuid}
# person.dog.name = hello_dog
person.dog.name=${person.hello:hello}_dog

8. Profile 多环境切换

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

① 多配置文件

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

比如：application-dev.properties 、application-prod.properties

默认使用 application.properties 的配置

② 激活指定环境

  • ⭐ 在配置文件中指定

    spring.profiles.active=dev

  • 命令行：

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

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

  • 虚拟机参数；

    -Dspring.profiles.active=dev

    img

③ yml 支持多文档块方式

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

server: 
  port: 8081 # 默认端口
#选择要激活那个环境块
spring:
  profiles:
  	# 激活
    active: prod # 使用 prod 环境，8084端口

---
server:
  port: 8083
spring:
  profiles: dev # 配置环境的名称


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

9. 配置文件加载位置

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

  • file:./config/ 项目路径下的 config 文件夹配置文件

  • file:./ 项目路径下配置文件

  • classpath:/config/ 资源路径下的 config 文件夹配置文件

  • classpath:/ 资源路径下配置文件

优先级由高到底，高优先级的配置会覆盖低优先级的配置；

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

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

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

比如我们项目打包后后我们指定配置文件的新位置为 E:/application.properties

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

10. 自动配置原理

配置文件到底能写什么？怎么写？配置文件能配置的属性参照

① 自动配置原理 ⭐

Ⅰ 加载主配置类，开启自动配置功能

⭐ @SpringBootApplication（Spring Boot应用）：标注在某个类上说明这个类是 SpringBoot 的主程序类，SpringBoot 就应该运行这个类的 main 方法来启动 SpringBoot 应用；

📑 该注解源码如下：

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {

底层由三个注解实现：

  • @SpringBootConfiguration
  • @EnableAutoConfiguration
  • @ComponentScan

⭐ 自动配置第 1 步：SpringBoot 启动的时候加载主配置类（由 @SpringBootConfiguration 标识），并开启了自动配置功能 @EnableAutoConfiguration

Ⅱ 导入组件（自动配置类）

@EnableAutoConfiguration：开启自动配置功能。

以前我们需要配置的东西，Spring Boot 帮我们自动配置；

@EnableAutoConfiguration告诉 SpringBoot 开启自动配置功能，这样自动配置才能生效；

📑 该注解的源码如下：

@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {

  • ⭐ @AutoConfigurationPackage：自动配置包，将主配置类（@SpringBootApplication标注的类）的所在包及下面所有子包里面的所有组件扫描到 Spring 容器中

    📑 该注解的源码如下：

    @Import({Registrar.class})
public @interface AutoConfigurationPackage {
}

    • @Import({Registrar.class})：@import是 Spring 中的底层注解，给容器中导入一个组件

    • Registrar.class 作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到 Spring 容器 ；

  • ⭐ @Import({AutoConfigurationImportSelector.class})：给容器中导入组件。

    AutoConfigurationImportSelector：自动配置导入选择器。将所有需要导入的组件以全类名的方式返回；这些组件就会被添加到容器中。说白了就是导入组件

    那么它会导入哪些组件的选择器呢？📑 我们点击去这个类 AutoConfigurationImportSelector 看源码：

    这个类中有一个这样的方法：

    // 获得候选的配置
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    // 这里的 getSpringFactoriesLoaderFactoryClass() 方法
    // 返回的就是启动自动导入配置文件的注解类；EnableAutoConfiguration
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
    Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
    return configurations;
}

    这个方法又调用了 SpringFactoriesLoader 类的静态方法，我们进入SpringFactoriesLoader 类 loadFactoryNames() 方法：

    public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
    String factoryClassName = factoryClass.getName();
    // 这里它又调用了 loadSpringFactories 方法
    return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}

    我们继续点击查看 loadSpringFactories 方法：

    private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    // 获得classLoader ， 我们返回可以看到这里得到的就是EnableAutoConfiguration标注的类本身
    MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
    if (result != null) {
        return result;
    } else {
        try {
            //去获取一个资源 "META-INF/spring.factories"
            Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
            LinkedMultiValueMap result = new LinkedMultiValueMap();

            //将读取到的资源遍历，封装成为一个Properties
            while(urls.hasMoreElements()) {
                URL url = (URL)urls.nextElement();
                UrlResource resource = new UrlResource(url);
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                Iterator var6 = properties.entrySet().iterator();

                while(var6.hasNext()) {
                    Entry<?, ?> entry = (Entry)var6.next();
                    String factoryClassName = ((String)entry.getKey()).trim();
                    String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                    int var10 = var9.length;

                    for(int var11 = 0; var11 < var10; ++var11) {
                        String factoryName = var9[var11];
                        result.add(factoryClassName, factoryName.trim());
                    }
                }
            }

            cache.put(classLoader, result);
            return result;
        } catch (IOException var13) {
            throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
        }
    }
}

    ⭐ 在上面这段源码中，我们发现了一个多次出现的文件 spring.factories，在 External Libraries 中找到它：

    image-20220602163107661

    其中包含了很多自动配置的文件（自动配置类 xxxAutoConfiguration），这就是自动配置的根源所在！

    image-20220602163134062

    我们在上面的自动配置类随便找一个打开看看，比如 ：WebMvcAutoConfiguration

    image-20220602163158203

    可以看到这些一个个的都是JavaConfig 配置类，而且都注入了一些 Bean。

    ⭐ 自动配置第 2 步：利用 AutoConfigurationImportSelector 给容器中导入一些组件：

    • 扫描所有 jar 包类路径下 META-INF/spring.factories

    • 把扫描到的这些文件的内容包装成 properties 对象

    • 从 properties 中获取到 EnableAutoConfiguration.class 类（类名）对应的值，然后把他们添加在容器中

    总结来说，就是利用 SpringFactoriesLoader.loadFactoryNames() 将类路径下 META-INF/spring.factories 里面配置的所有 EnableAutoConfiguration 的值加入到了容器中。每一个这样的 xxxAutoConfiguration 自动配置类都是容器中的一个组件，都加入到容器中，用他们来做自动配置；

Ⅲ 举例分析自动配置原理

📑 以 HttpEncodingAutoConfiguration（Http 编码自动配置）为例解释自动配置原理：

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

// 启动指定类的ConfigurationProperties功能；
// 将配置文件中对应的值和 HttpEncodingProperties 绑定起来；
// 并把HttpEncodingProperties加入到ioc容器中
@EnableConfigurationProperties(HttpEncodingProperties.class)  

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

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

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

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

    📑 比如 HttpEncodingProperties：

    //从配置文件中获取指定的值和 bean 的属性进行绑定
@ConfigurationProperties(prefix = "spring.http.encoding")  
public class HttpEncodingProperties {

   public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    我们去配置文件里面试试前缀，看看提示：

    image-20220602163221992

⭐ 精髓：

  • SpringBoot 启动会加载大量的自动配置类

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

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

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

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

  • 给容器中自动配置类添加组件的时候，会从 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存在指定项

那么多的自动配置类，必须在一定的条件下才能生效；也就是说，我们加载了这么多的配置类，但不是所有的都生效了。

❓ 我们怎么知道哪些自动配置类生效？

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

#开启springboot的调试类
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)

   AopAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required classes 'org.aspectj.lang.annotation.Aspect', 'org.aspectj.lang.reflect.Advice' (OnClassCondition)

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

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

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

posted @ 2022-06-07 20:38  Maple~  阅读(1423)  评论(0)  编辑  收藏  举报