统计

随笔 - 117
文章 - 1
评论 - 1
阅读 - 8845

1. 自动配置原理初探

1.1 pom.xml

Spring-boot-dependencies:核心依赖在父工程中
我们在写或者引入springboot依赖的时候，不需要指定版本，因为有这些版本仓库

启动器

<!--启动器-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter</artifactId>
</dependency>

启动器：说白了就是Springboot的启动场景
比如spring-boot-starter-web，他就会帮我们自动导入web环境所有的依赖
springboot会将所有的功能场景，都变成一个个的启动器
我们要使用什么功能，就值需要找到对应的启动器starter

1.2 主程序

//标注这个类是一个springboot的应用
@SpringBootApplication
public class SpringbootStudyApplication {

    public static void main(String[] args) {
        //将springboot应用启动
        SpringApplication.run(SpringbootStudyApplication.class, args);
    }
}

注解

//springboot的配置
@SpringBootConfiguration

//spring配置类
@Configuration 

//说明这也是一个spring的组件
@Component	

//自动配置
@EnableAutoConfiguration

//自动配置包
@AutoConfigurationPackage 

//自动配置	
@Import(AutoConfigurationPackages.Registrar.class)

//自动配置导入选择
@Import(AutoConfigurationImportSelector.class)

//获取所有的配置
List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);

获取候选的配置：

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
  List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
                                                                       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;
}

但是**一个简单的启动类并不简单！**我们来分析一下这些注解都干了什么

1.3 @SpringBootApplication

在这里插入图片描述

作用：标注在某个类上说明这个类是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 {
    // ......
}

1.3.1 @ComponentScan

这个注解在Spring中很重要 ,它对应XML配置中的元素。
作用：自动扫描并加载符合条件的组件或者bean ，将这个bean定义加载到IOC容器中

1.3.2 @SpringBootConfiguration

作用：SpringBoot的配置类，标注在某个类上，表示这是一个SpringBoot的配置类；

我们继续进去这个注解查看

// 点进去得到下面的 @Component
@Configuration
public @interface SpringBootConfiguration {}

@Component
public @interface Configuration {}

这里的 @Configuration，说明这是一个配置类，配置类就是对应Spring的xml 配置文件；

里面的 @Component 这就说明，启动类本身也是Spring中的一个组件而已，负责启动应用！

1.2.3 @EnableAutoConfiguration

作用：开启自动配置，默认加载配置文件的位置就在META-INF/spring.factories

1.4 @EnableAutoConfiguration

@EnableAutoConfiguration ：开启自动配置功能

以前我们需要自己配置的东西，而现在SpringBoot可以自动帮我们配置；@EnableAutoConfiguration告诉SpringBoot开启自动配置功能，这样自动配置才能生效；

点进注解继续查看：
在这里插入图片描述

1.4.1 @AutoConfigurationPackage

翻译：自动配置包

@Import({Registrar.class})
//利用Registrar导入一系列组件
//将指定的一个包下的所有组件导入进来？是主程序所在的包下
public @interface AutoConfigurationPackage {
}

@import ：Spring底层注解@import ，给容器中导入一个组件
Registrar.class 作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器；

1.4.2 @Import({AutoConfigurationImportSelector.class})

给容器导入组件；

而这个注解也是一个派生注解，其中的关键功能由 @Import提供，其导入的AutoConfigurationImportSelector的selectImports()方法通过SpringFactoriesLoader.loadFactoryNames()扫描所有具有META-INF/spring.factories的jar包。spring-boot-autoconfigure-x.x.x.x.jar里就有一个这样的spring.factories文件。

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

1、这个类中有一个这样的方法

// 获得候选的配置
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;
}

2、这个方法又调用了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());
}

3、我们继续点击查看 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);
        }
    }
}

4、发现一个多次出现的文件：spring.factories，全局搜索它

spring.factories
文件里面写死了spring-boot一启动就要给容器中加载的所有配置类

我们根据源头打开spring.factories ，看到了很多自动配置的文件；这就是自动配置根源所在！
这个spring.factories文件也是一组一组的key=value的形式，其中一个key是EnableAutoConfiguration类的全类名，而它的value是一个xxxxAutoConfiguration的类名的列表，这些类名以逗号分隔，如下图所示：

在这里插入图片描述

这个@EnableAutoConfiguration注解通过@SpringBootApplication被间接的标记在了Spring Boot的启动类上。在SpringApplication.run(…)的内部就会执行selectImports()方法，找到所有JavaConfig自动配置类的全限定名对应的class，然后将所有自动配置类加载到Spring容器中。

自动配置真正实现是从classpath中搜寻所有的META-INF/spring.factories配置文件，并将其中对应的 org.springframework.boot.autoconfigure. 包下的配置项，通过反射实例化为对应标注了 @Configuration的JavaConfig形式的IOC容器配置类，然后将这些都汇总成为一个实例并加载到IOC容器中。

1.5 自动配置生效

每一个XxxxAutoConfiguration自动配置类都是在某些条件之下才会生效的，这些条件的限制在Spring Boot中以注解的形式体现，常见的条件注解有如下几项：

@ConditionalOnBean：当容器里有指定的bean的条件下。

@ConditionalOnMissingBean：当容器里不存在指定bean的条件下。

@ConditionalOnClass：当类路径下有指定类的条件下。

@ConditionalOnMissingClass：当类路径下不存在指定类的条件下。

@ConditionalOnProperty：指定的属性是否有指定的值，比如@ConditionalOnProperties(prefix=”xxx.xxx”, value=”enable”, matchIfMissing=true)，代表当xxx.xxx为enable时条件的布尔值为true，如果没有设置的情况下也为true。

1.6 例子

以ServletWebServerFactoryAutoConfiguration配置类为例，解释一下全局配置文件中的属性如何生效，比如：server.port=8081，是如何生效的（当然不配置也会有默认值，这个默认值来自于org.apache.catalina.startup.Tomcat）。
$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q8aVQTyn-1657777327519)(C:\Users\GuoSheng\AppData\Roaming\Typora\typora-user-images\image-20210414204347147.png)]$

在ServletWebServerFactoryAutoConfiguration类上，有一个@EnableConfigurationProperties注解：开启配置属性，而它后面的参数是一个ServerProperties类，这就是约定大于配置的最终落地点。

1.7 结论

springboot 所有的自动配置都是在启动的时候扫描并加载，扫描了spring.properties配置文件，所有的自动配置类都在这里面，但是不定生效，因为要判断条件是否成立，只要导入了对应的start，就有对应的启动器，有了启动器我们自动装配就会生效，然后就配置成功

步骤：

SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值
将这些值作为自动配置类导入容器，自动配置类就生效，帮我们进行自动配置工作；
以前需要我们配置的文件，springboot帮我们配置了！
整个J2EE的整体解决方案和自动配置都在springboot-autoconfigure的jar包中；
它会给容器中导入非常多的自动配置类（xxxAutoConfiguration）@Bean, 就是给容器中导入这个场景需要的所有组件，并配置好这些组件 @Configuration；
有了自动配置类，免去了我们手动编写配置注入功能组件等的工作；

SpringApplication

我们最初以为就是运行了一个main方法，没想到却开启了一个服务；

@SpringBootApplication
public class SpringbootApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootApplication.class, args);
    }
}

SpringApplication.run分析

分析该方法主要分两部分，一部分是SpringApplication的实例化，二是run方法的执行；

SpringApplication

这个类主要做了以下四件事情：

1、推断应用的类型是普通的项目还是Web项目

2、查找并加载所有可用初始化器，设置到initializers属性中

3、找出所有的应用程序监听器，设置到listeners属性中

4、推断并设置main方法的定义类，找到运行的主类

查看构造器：

public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
    // ......
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    this.setInitializers(this.getSpringFactoriesInstances();
    this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
    this.mainApplicationClass = this.deduceMainApplicationClass();
}

关于springboot，谈谈你的理解：

springboot的自动装配
run()：
① 判断当前项目是普通项目还是web项目
② 推断并设置main方法的定义类，找到运行的主类
③ run方法里面有一些监听器，这些监听器是全局存在的，它的作用是获取上下文处理一些bean，所有的bean无论是加载还是生产初始化多存在。

2. Springboot配置文件

2.1 配置文件

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

application.properties
- 语法结构：key=value

server.port=8081

application.yaml
- 语法结构：key:空格value

server:
  port: 8081

2.2 yaml概述

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

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

以前的配置文件，大多数都是使用xml来配置；比如一个简单的端口配置，我们来对比下yaml和xml

传统xml配置：

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

yaml配置：

server：
  prot: 8080

yaml基础语法

说明：语法要求严格！

1、空格不能省略

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

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

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

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

k: v

注意：

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

比如：name: “kuang \n shen” 输出：kuang 换行 shen
‘’ 单引号：会转义特殊字符，特殊字符最终会变成和普通字符一样输出

比如：name: ‘kuang \n shen’ 输出：kuang \n shen

对象、Map（键值对）

#对象、Map格式
key: 
    value1:
    value2:

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

student:
    name: qinjiang
    age: 3

行内写法

student: {name: qinjiang,age: 3}

数组（ List、set ）

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

pets:
 - cat
 - dog
 - pig

行内写法

pets: [cat,dog,pig]

修改SpringBoot的默认端口号

配置文件中添加，端口号的参数，就可以切换端口；

server:
 port: 8082

2.3 yaml注入配置文件

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

2.3.1 原始的给实体对象赋值

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

2、编写一个实体类 User；

@Component  //注册bean到容器中,使得这个类可以被扫描到
public class Dog {
    private String name;
    private Integer age;
    
    //有参无参构造、get、set方法、toString()方法  
}

3、思考，我们原来是如何给bean注入属性值的！@Value，给User类测试一下：

@Component //注册bean
public class Dog {
    @Value("阿黄")
    private String name;
    @Value("18")
    private Integer age;
}

4、在SpringBoot的测试类下注入user输出一下；

@SpringBootTest
class DemoApplicationTests {

    @Autowired //将狗狗自动注入进来
    Dog dog;

    @Test
    public void contextLoads() {
        System.out.println(dog); //打印看下狗狗对象
    }

}

2.3.2 通过yaml文件赋值

1、我们在编写一个复杂一点的实体类：Person 类


@Component //注册bean到容器中
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;
    
    //有参无参构造、get、set方法、toString()方法  
}

2、我们来使用yaml配置的方式进行注入，大家写的时候注意区别和优势，我们编写一个yaml配置！

person:
  name: qinjiang
  age: 3
  happy: false
  birth: 2000/01/01
  maps: {k1: v1,k2: v2}
  lists:
   - code
   - girl
   - music
  dog:
    name: 旺财
    age: 1

3、我们刚才已经把person这个对象的所有值都写好了，我们现在来注入到我们的类中！

/*
@ConfigurationProperties作用：
将配置文件中配置的每一个属性的值，映射到这个组件中；
告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定
参数 prefix = “person” : 将配置文件中的person下面的所有属性一一对应
*/
@Component //注册bean
@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;
}

在这里插入图片描述

4、IDEA 提示，springboot配置注解处理器没有找到，让我们看文档，我们可以查看文档，找到一个依赖！

在这里插入图片描述

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

5、确认以上配置都OK之后，我们去测试类中测试一下：

@SpringBootTest
class DemoApplicationTests {

    @Autowired
    Person person; //将person自动注入进来

    @Test
    public void contextLoads() {
        System.out.println(person); //打印person信息
    }

}

结果：所有值全部注入成功！

yaml配置注入到实体类完全OK！

2.4 加载指定的配置文件

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

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

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

注意在使用之前要去setting把字符集调整为UTF-8否则会乱码(在后面的回顾properties配置中有具体写到)

name=guoshuai

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

@PropertySource(value = "classpath:person.properties")
@Component //注册bean
public class Person {

    @Value("${name}")//有点像jsp了哦，EL表达式
    private String name;

    ......  
}

在这里插入图片描述

3.再次输出测试一下：指定配置文件绑定成功！

2.5 配置文件占位符

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

person:
    name: qinjiang${random.uuid} # 随机uuid
    age: ${random.int}  # 随机int
    happy: false
    birth: 2000/01/01
    maps: {k1: v1,k2: v2}
    lists:
      - code
      - girl
      - music
    dog:
      name: ${person.hello:other}_旺财
      age: 1

2.6 回顾properties配置

我们上面采用的yaml方法都是最简单的方式，开发中最常用的；也是springboot所推荐的！那我们来唠唠其他的实现方式，道理都是相同的；写还是那样写；配置文件除了yml还有我们之前常用的properties 。

【注意】properties配置文件在写中文的时候，会有乱码，我们需要去IDEA中设置编码格式为UTF-8；

settings–>FileEncodings 中配置：

2.7 Properties和Yaml的对比小结

@Value这个使用起来并不友好！我们需要为每个属性单独注解赋值，比较麻烦；我们来看个功能对比图

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

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

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

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

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

结论

配置yaml和配置properties都可以获取到值，但是强烈推荐 yaml；
如果我们在某个业务中，只需要获取配置文件中的某个值，可以使用一下 @value；
如果说，我们专门编写了一个JavaBean来和配置文件进行一一映射，就直接@configurationProperties，不要犹豫！

3. JSR303数据校验及多环境切换

3.1 JSR303

JSR303数据校验是用来校验输入内容的

Springboot中可以用@validated来校验数据，如果数据异常则会统一抛出异常，方便异常中心统一处理。我们这里来写个注解让我们的name只能支持Email格式；

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

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

如果没有@Email注解，需要在pom.xml文件中添加依赖：

        <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>

使用数据校验，可以保证数据的正确性

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

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

3.2 多环境切换

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

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

例如：

application-test.properties 代表测试环境配置

application-dev.properties 代表开发环境配置

但是Springboot并不会直接启动这些配置文件，它默认使用application.properties主配置文件；

我们需要通过一个配置来选择需要激活的环境：

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

3.3 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配置文件的！

配置文件加载位置

外部加载配置文件的方式十分多，我们选择最常用的即可，在开发的资源文件中进行配置！

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

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

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

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

我们在最低级的配置文件中设置一个项目访问路径的配置来测试互补问题；

#配置项目的访问路径
server.servlet.context-path=/guo

3.4 拓展，运维小技巧

指定位置加载配置文件

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

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

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

4. 自动配置原理

配置文件到底能写什么？怎么写？

SpringBoot官方文档中有大量的配置，我们无法全部记住

4.1 分析自动配置原理

我们以**HttpEncodingAutoConfiguration（Http编码自动配置）**为例解释自动配置原理；

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

//启动指定类的ConfigurationProperties功能；
//进入这个HttpProperties查看，将配置文件中对应的值和HttpProperties绑定起来；
//并把HttpProperties加入到ioc容器中
@EnableConfigurationProperties({HttpProperties.class}) 

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

//判断当前项目有没有这个类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 Encoding properties;
    //只有一个有参构造器的情况下，参数的值就会从容器中拿
    public HttpEncodingAutoConfiguration(HttpProperties properties) {
        this.properties = properties.getEncoding();
    }
    
    //给容器中添加一个组件，这个组件的某些值需要从properties中获取
    @Bean
    @ConditionalOnMissingBean //判断容器没有这个组件？
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
        filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE));
        return filter;
    }
    //。。。。。。。
}

一句话总结：根据当前不同的条件判断，决定这个配置类是否生效！

一但这个配置类生效；这个配置类就会给容器中添加各种组件；
这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的；
这样就可以形成我们的配置文件可以动态的修改springboot的内容。
所有在配置文件中能配置的属性都是在xxxxProperties类中封装着；
配置文件能配置什么就可以参照某个功能对应的这个属性类

通俗理解：把我们原先需要在bean中手打的属性（property）封装成了一个类，然后通过yaml文件进行自动注入，而我们也可以在application.yaml文件中对这些property进行赋值。

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

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

4.2 精髓

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

XXXXAutoConfiguration：自动配置类:给容器添加组件，这些组件要赋值就需要绑定一个XXXXProperties类
XXXXProperties：里面封装配置文件中相关属性；

怎么去修改这些属性呢：说白了就是SpringBoot配置，---->.yaml、.properties这些文件

4.3 了解：@Conditional

了解完自动装配的原理后，我们来关注一个细节问题，*自动配置类必须在一定的条件下才能生效；

@Conditional派生注解（Spring注解版原生的@Conditional作用）

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

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

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

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

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

#开启springboot的调试类
debug=true

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

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

Unconditional classes: （没有条件的类）

【演示：查看输出的日志】

posted on 2022-07-15 14:58 JAVA开发区阅读(35) 评论(0) 编辑收藏举报来源

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· SpringBoot笔记之SpringBoot概述

· SpringBoot笔记之模板引擎

· SpringBoot 教程

· SpringBoot

· SpringBoot笔记

阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· 阿里巴巴 QwQ-32B真的超越了 DeepSeek R-1吗？
· 【译】Visual Studio 中新的强大生产力特性
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
· 【设计模式】告别冗长if-else语句：使用策略模式优化代码结构

公告

昵称： JAVA开发区
园龄： 2年11个月
粉丝： 0
关注： 0
+加关注

导航

统计

SpringBoot自动配置

1. 自动配置原理初探

1.1 pom.xml

1.2 主程序

1.3 @SpringBootApplication

1.3.1 @ComponentScan

1.3.2 @SpringBootConfiguration

1.2.3 @EnableAutoConfiguration

1.4 @EnableAutoConfiguration

1.4.1 @AutoConfigurationPackage

1.4.2 @Import({AutoConfigurationImportSelector.class})

1.5 自动配置生效

1.6 例子

1.7 结论

2. Springboot配置文件

2.1 配置文件

2.2 yaml概述

2.3 yaml注入配置文件

2.3.1 原始的给实体对象赋值

2.3.2 通过yaml文件赋值

2.4 加载指定的配置文件

2.5 配置文件占位符

2.6 回顾properties配置

2.7 Properties和Yaml的对比小结

3. JSR303数据校验及多环境切换

3.1 JSR303

3.2 多环境切换

3.3 yaml的多文档块

3.4 拓展，运维小技巧

4. 自动配置原理

4.1 分析自动配置原理

4.2 精髓

4.3 了解：@Conditional

搜索

常用链接

我的标签

随笔分类

随笔档案

阅读排行榜

最新评论