SpringBoot_配置文件及自动配置原理（2.2.5 version）

爱被打了一巴掌 2023-07-14 05:29 23阅读 0赞

### 文章目录 ###

*   *  1. 配置文件
     *  2. YAML语法：
     *   *  1. 基本语法
         *  2. 值的写法
         *   *  字面量：普通的值（数字，字符串，布尔）
             *  对象、Map（属性和值）（键值对）：
             *  数组（List、Set）：
     *  3. 配置文件值注入
     *   *   *  1. properties文件中文乱码
             *  2. @Value获取值和@ConfigurationProperties获取值比较
             *  3. 配置文件注入值数据校验
             *  4. @PropertySource&@ImportResource&@Bean
     *  4. 配置文件占位符
     *   *  1. 随机数
         *  2. 占位符获取之前配置的值，如果没有可以是用:指定默认值
     *  5. Profile
     *   *  1. 多Profile文件
         *  2. yml支持多文档块方式
         *  3. 激活指定profile
     *  6. 配置文件加载位置
     *  7. 外部配置加载顺序
     *  8. 自动配置原理
     *   *  1. 自动配置原理：
         *   *  1. SpringBoot启动的时候加载主配置类，开启了自动配置功能 @EnableAutoConfiguration
             *  2. @EnableAutoConfiguration 作用：
             *  3. 每一个自动配置类进行自动配置功能；
             *  4. 以HttpEncodingAutoConfiguration（Http编码自动配置）为例解释自动配置原理；
             *  5. 所有在配置文件中能配置的属性都封装在xxxxProperties类中；配置文件能配置什么就可以参照某个功能对应的这个属性类
         *  2. 细节
         *   *  1. @Conditional派生注解

## 1. 配置文件 ##

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

•application.properties

•application.yml

配置文件的作用：修改SpringBoot自动配置的默认值；SpringBoot在底层都给我们自动配置好；

YAML（YAML Ain’t Markup Language）

YAML A Markup Language：是一个标记语言

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

标记语言：

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

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

YAML：配置例子

server:
      port: 8081

XML：

## 2. YAML语法： ##

### 1. 基本语法 ###

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

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

server:
        port: 8081
        path: /hello

属性和值也是大小写敏感；

### 2. 值的写法 ###

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

k: v：字面直接来写；

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

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

name:   "zhangsan \n lisi"：
    #输出；zhangsan 换行  lisi

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

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

#### 对象、Map（属性和值）（键值对）： ####

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

对象还是k: v的方式

friends:
    		lastName: zhangsan
    		age: 20

行内写法：

friends: {
        lastName: zhangsan,age: 18}

#### 数组（List、Set）： ####

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

pets:
     - cat
     - dog
     - pig

行内写法

pets: [cat,dog,pig]

## 3. 配置文件值注入 ##

配置文件

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

javaBean：

/**
     * 将配置文件中配置的每一个属性的值，映射到这个组件中
     * @ConfigurationProperties：告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定；
     *      prefix = "person"：配置文件中哪个下面的所有属性进行一一映射
     *
     * 只有这个组件是容器中的组件，才能容器提供的@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;

我们可以导入配置文件处理器，以后编写配置就有提示了

<dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-configuration-processor</artifactId>
    	<optional>true</optional>
    </dependency>

#### 1. properties文件中文乱码 ####

根本办法时不用中文，有中文时用yaml！

#### 2. @Value获取值和@ConfigurationProperties获取值比较 ####

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

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

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

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

#### 3. 配置文件注入值数据校验 ####

@Component
    @ConfigurationProperties(prefix = "person")
    @Validated
    public class Person {
        
    
        /**
         * <bean class="Person">
         *      <property name="lastName" value="字面量/${key}从环境变量、配置文件中获取值/#{SpEL}"></property>
         * <bean/>
         */
    
       //lastName必须是邮箱格式
        @Email
        //@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;

#### 4. @PropertySource&@ImportResource&@Bean ####

@**PropertySource**：加载指定的配置文件；SpringBoot默认从application.properties中读取属性，如果自定义的.properties文件中与application.properties中有重复属性，优先读取application.properties

/**
     * 将配置文件中配置的每一个属性的值，映射到这个组件中
     * @ConfigurationProperties：告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定；
     *      prefix = "person"：配置文件中哪个下面的所有属性进行一一映射
     *
     * 只有这个组件是容器中的组件，才能容器提供的@ConfigurationProperties功能；
     *  @ConfigurationProperties(prefix = "person")默认从全局配置文件中获取值；
     *
     */
    @PropertySource(value = {
        "classpath:person.properties"})
    @Component
    @ConfigurationProperties(prefix = "person")
    //@Validated
    public class Person {
        
    
        /**
         * <bean class="Person">
         *      <property name="lastName" value="字面量/${key}从环境变量、配置文件中获取值/#{SpEL}"></property>
         * <bean/>
         */
    
       //lastName必须是邮箱格式
       // @Email
        //@Value("${person.last-name}")
        private String lastName;
        //@Value("#{11*2}")
        private Integer age;
        //@Value("true")
        private Boolean boss;

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

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

想让Spring的配置文件生效，加载进来；@**ImportResource**标注在一个配置类上

@ImportResource(locations = {
        "classpath:beans.xml"})
    导入Spring的配置文件让其生效

不建议编写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.atguigu.springboot.service.HelloService"></bean>
    </beans>

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

1、配置类\*\*@Configuration\*\*------>Spring配置文件

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

/**
     * @Configuration：指明当前类是一个配置类；就是来替代之前的Spring配置文件
     *
     * 在配置文件中用<bean><bean/>标签添加组件
     *
     */
    @Configuration
    public class MyAppConfig {
        
    
        //将方法的返回值添加到容器中；容器中这个组件默认的id就是方法名
        @Bean
        public HelloService helloService02(){
        
            System.out.println("配置类@Bean给容器中添加组件了...");
            return new HelloService();
        }
    }

## 4. 配置文件占位符 ##

### 1. 随机数 ###

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

### 2. 占位符获取之前配置的值，如果没有可以是用:指定默认值 ###

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

## 5. Profile ##

### 1. 多Profile文件 ###

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

默认使用application.properties的配置；

### 2. yml支持多文档块方式 ###

server:
      port: 8081
    spring:
      profiles:
        active: prod
    
    ---
    server:
      port: 8083
    spring:
      profiles: dev
    
    
    ---
    
    server:
      port: 8084
    spring:
      profiles: prod  #指定属于哪个环境

### 3. 激活指定profile ###

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

2、命令行：

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

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

3、虚拟机参数；

-Dspring.profiles.active=dev

## 6. 配置文件加载位置 ##

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

– file:./config/

– file:./

– classpath:/config/

– classpath:/

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

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

多个配置用空格分开； --配置项=值

1.  来自java:comp/env的JNDI属性
2.  Java系统属性（System.getProperties()）
3.  操作系统环境变量
4.  RandomValuePropertySource配置的random.\*属性值

**由jar包外向jar包内进行寻找；**

**优先加载带profile**

**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)配置文件**

1.  @Configuration注解类上的@PropertySource
2.  通过SpringApplication.setDefaultProperties指定的默认属性

所有支持的配置加载来源；

[参考官方文档][Link 1]

## 8. 自动配置原理 ##

配置文件到底能写什么？怎么写？自动配置原理；

[配置文件能配置的属性参照][Link 2]

### 1. 自动配置原理： ###

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

/**
     *  @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
     */
    @SpringBootApplication
    public class HelloWorldMainApplication {
        
    
        public static void main(String[] args) {
        
            // Spring应用启动起来
            SpringApplication.run(HelloWorldMainApplication.class,args);
        }
    }

@**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 {

@**EnableAutoConfiguration**：开启自动配置功能；

以前需要配置的东西，Spring Boot帮我们自动配置；@**EnableAutoConfiguration**告诉SpringBoot开启自动配置功能；这样自动配置才能生效；

#### 2. @EnableAutoConfiguration 作用： ####

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

@**AutoConfigurationPackage**：自动配置包

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

@**Import**(AutoConfigurationPackages.Registrar.class)：

Spring的底层注解@Import，给容器中导入一个组件；导入的组件由`AutoConfigurationPackages.Registrar.class`；

/**
     * {@link ImportBeanDefinitionRegistrar} to store the base package from the importing
     * configuration.
     */
    static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
        
    
    	@Override
    	public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        
    		register(registry, new PackageImport(metadata).getPackageName());
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70]  
**将主配置类（@SpringBootApplication标注的类）的所在包及下面所有子包里面的所有组件扫描到Spring容器；**

**@Import**(AutoConfigurationImportSelector.class)

**AutoConfigurationImportSelector**：导入哪些组件的选择器；

*  利用AutoConfigurationImportSelector给容器中导入一些组件
 *  可以查看selectImports()方法的内容；
 *  List configurations = getCandidateConfigurations(annotationMetadata, attributes);获取候选的配置

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
    			AnnotationMetadata annotationMetadata) {
        
    	...
    	List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
    	...
    }

将所有需要导入的组件以全类名的方式返回；这些组件就会被添加到容器中；

会给容器中导入非常多的自动配置类（xxxAutoConfiguration）；就是给容器中导入这个场景需要的所有组件，并配置好这些组件；

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70 1]

有了自动配置类，免去了我们手动编写配置注入功能组件等的工作；  
那从哪里找到需要自动加载类呢？

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

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
                                                                             getBeanClassLoader());
        ...
    }

protected Class<?> getSpringFactoriesLoaderFactoryClass() {
        
        return EnableAutoConfiguration.class;
    }

`SpringFactoriesLoader.loadFactoryNames()`：

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        
        String factoryTypeName = factoryType.getName();
        return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
    }
    
    private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        
        MultiValueMap<String, String> result = cache.get(classLoader);
        if (result != null) {
        
            return result;
        }
    
        try {
        
            Enumeration<URL> urls = (classLoader != null ?
                                     classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                                     ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
            result = new LinkedMultiValueMap<>();
            while (urls.hasMoreElements()) {
        
                URL url = urls.nextElement();
                UrlResource resource = new UrlResource(url);
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                for (Map.Entry<?, ?> entry : properties.entrySet()) {
        
                    String factoryTypeName = ((String) entry.getKey()).trim();
                    for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
        
                        result.add(factoryTypeName, factoryImplementationName.trim());
                    }
                }
            }
            cache.put(classLoader, result);
            return result;
        }
        catch (IOException ex) {
        
            throw new IllegalArgumentException("Unable to load factories from location [" +
                                               FACTORIES_RESOURCE_LOCATION + "]", ex);
        }
    }

`FACTORIES_RESOURCE_LOCATION`:

public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

\*\*Spring Boot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类导入到容器中，自动配置类就生效，帮我们进行自动配置工作；\*\*以前我们需要自己配置的东西，自动配置类都帮我们；

`META-INF/spring.factories`在哪里呢？  
![在这里插入图片描述][20200308163917388.png]  
![在这里插入图片描述][20200308163931921.png]

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

# Auto Configure
    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
    org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
    org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
    org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
    org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
    org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
    org.springframework.boot.autoconfigure.cloud.CloudServiceConnectorsAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
    org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
    org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveRestClientAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
    org.springframework.boot.autoconfigure.elasticsearch.jest.JestAutoConfiguration,\
    org.springframework.boot.autoconfigure.elasticsearch.rest.RestClientAutoConfiguration,\
    org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
    org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
    org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
    org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,\
    org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,\
    org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,\
    org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,\
    org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration,\
    org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration,\
    org.springframework.boot.autoconfigure.influx.InfluxDbAutoConfiguration,\
    org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,\
    org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,\
    org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
    org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
    org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
    org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\
    org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\
    org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
    org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
    org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
    org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
    org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration,\
    org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
    org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,\
    org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,\
    org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,\
    org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,\
    org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,\
    org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
    org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
    org.springframework.boot.autoconfigure.mongo.MongoReactiveAutoConfiguration,\
    org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
    org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
    org.springframework.boot.autoconfigure.quartz.QuartzAutoConfiguration,\
    org.springframework.boot.autoconfigure.rsocket.RSocketMessagingAutoConfiguration,\
    org.springframework.boot.autoconfigure.rsocket.RSocketRequesterAutoConfiguration,\
    org.springframework.boot.autoconfigure.rsocket.RSocketServerAutoConfiguration,\
    org.springframework.boot.autoconfigure.rsocket.RSocketStrategiesAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.servlet.SecurityFilterAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.reactive.ReactiveSecurityAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.reactive.ReactiveUserDetailsServiceAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.rsocket.RSocketSecurityAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.saml2.Saml2RelyingPartyAutoConfiguration,\
    org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
    org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.oauth2.client.servlet.OAuth2ClientAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.oauth2.client.reactive.ReactiveOAuth2ClientAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.oauth2.resource.servlet.OAuth2ResourceServerAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.oauth2.resource.reactive.ReactiveOAuth2ResourceServerAutoConfiguration,\
    org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
    org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration,\
    org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration,\
    org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
    org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
    org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
    org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.error.ErrorWebFluxAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.function.client.ClientHttpConnectorAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
    org.springframework.boot.autoconfigure.websocket.reactive.WebSocketReactiveAutoConfiguration,\
    org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration,\
    org.springframework.boot.autoconfigure.websocket.servlet.WebSocketMessagingAutoConfiguration,\
    org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration,\
    org.springframework.boot.autoconfigure.webservices.client.WebServiceTemplateAutoConfiguration

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

#### 3. 每一个自动配置类进行自动配置功能； ####

#### 4. 以HttpEncodingAutoConfiguration（Http编码自动配置）为例解释自动配置原理； ####

//表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件
    @Configuration(proxyBeanMethods = false)
    //启动指定类的ConfigurationProperties功能；将配置文件中对应的值和HttpProperties绑定起来；并把HttpProperties加入到ioc容器中
    @EnableConfigurationProperties(HttpProperties.class)
    //Spring底层@Conditional注解，根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效；    
    //判断当前应用是否是web应用，如果是，当前配置类生效
    @ConditionalOnWebApplication(type = ConditionalOnWebApplication.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 HttpProperties.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(Type.REQUEST));
    		filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
    		return filter;
    	}
    
    	...
    }

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

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

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

**精髓：**

**1）SpringBoot启动会加载大量的自动配置类**

**2）看需要的功能有没有SpringBoot默认写好的自动配置类；**

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

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

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

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

### 2. 细节 ###

#### 1. @Conditional派生注解 ####

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

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

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

怎么知道哪些自动配置类生效?

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

============================
    CONDITIONS EVALUATION REPORT
    ============================
    
    //自动配置类启动的
    Positive matches:
    -----------------
    
       AopAutoConfiguration matched:
          - @ConditionalOnProperty (spring.aop.auto=true) matched (OnPropertyCondition)
              
       ...
            
    //自动配置类未启动的
    Negative matches:
    -----------------
    
       ActiveMQAutoConfiguration:
          Did not match:
             - @ConditionalOnClass did not find required class 'javax.jms.ConnectionFactory' (OnClassCondition)
    	...

[Link 1]: https://docs.spring.io/spring-boot/docs/1.5.9.RELEASE/reference/htmlsingle/#boot-features-external-config
[Link 2]: https://docs.spring.io/spring-boot/docs/1.5.9.RELEASE/reference/htmlsingle/#common-application-properties
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70]: /images/20230529/ae4e6b40e4b84ee4beda238582e1a2f7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70 1]: /images/20230529/8a87e4e638284bfd9a1676d7f0328780.png
[20200308163917388.png]: /images/20230529/1a6aaa14854946098bca219019673f36.png
[20200308163931921.png]: /images/20230529/fd615a3ae393447db1b2a7d56aea68c2.png