Spring Boot自动配置_springboot自动配置

Spring boot 特性：

1、能够快速创建基于Spring的应用程序； 2、能够直接使用java main方法启动内嵌的Tomcat，Jetty服务器运行Spring boot程序，不需要部署war包文件； 3、提供约定的starter POM来简化Maven配置，让Maven的配置变得简单； 4、根据项目的Maven依赖配置，Spring boot自动配置Spring、Spring mvc等； 5、提供了程序的健康检查等功能； 6、基本可以完全不使用XML配置文件，采用注解配置。

Spring boot四大核心：

1、自动配置：针对很多Spring应用程序和常见的应用功能，Spring Boot能自动提供相关配置； 2、起步依赖：告诉Spring Boot需要什么功能，它就能引入需要的依赖库； 3、Actuator：让你能够深入运行中的应用程序，一探Spring Boot程序的内部信息； 4、命令行界面：这是Spring Boot的可选特性，主要针对Groovy语言使用。

1.1、自动配置简介

SpringBoot的自动配置就是当Spring容器启动后，一些自动配置类（只是自动配置类，并不是当前的组件配置到IOC容器中，自动配置类通过@Conditional注解来按需配置）就自动装配的IOC容器中，不需要我们手动注入，从而简化了开发，省去繁琐的配置。

一个SpringBoot工程如果想运行成功，就必须有一个主程序类，所有 Spring Boot 项目的主启动程序类上都使用了一个 @SpringBootApplication 注解，该注解是 Spring Boot 中最重要的注解之一 ，也是 Spring Boot 实现自动化配置的关键。

当我们进入@SpringBootApplication注解的源码当中，可以发现它是一个复合注解，它由@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan这三个注解组成。

• @EnableAutoConfiguration：启用 SpringBoot 的自动配置机制。
• @SpringBootConfiguration（实际是：@Configuration）：声明当前类是一个配置类，然后Spring会自动扫描到添加了@Configuration的类，并且读取其中的配置信息，允许在上下文中注册额外的 bean 或导入其他配置类，
• @ComponentScan： 扫描被@Component (@Service,@Controller)注解的 bean，注解默认会扫描启动类所在的包下所有的类 ，可以自定义不扫描某些 bean

1.2、自动配置原理

@EnableAutoConfiguration会开启SpringBoot的自动配置，并且根据你引入的依赖来生效对应的默认配置。那么问题来了：

• 这些默认配置是在哪里定义的呢？
• 为何依赖引入就会触发配置呢？

Spring Factories 机制

Spring Boot 的自动配置是基于 Spring Factories 机制实现的。
Spring Factories 机制是 Spring Boot 中的一种服务发现机制，这种扩展机制与 Java SPI 机制十分相似。Spring Boot 会自动扫描所有 Jar 包类路径下 META-INF/spring.factories 文件，并读取其中的内容，进行实例化，这种机制也是 Spring Boot Starter 的基础。

在 spring-boot-autoconfigure-xxx.jar 类路径下的 META-INF/spring.factories 中设置了 Spring Boot 自动配置的内容，其中定义了大量自动配置类，几乎涵盖了现在主流的开源框架，例如：redis、amqp、jdbc、jackson、mongodb、jpa、elasticsearch等等，如下图

SpringBoot内部对大量的第三方库或Spring内部库进行了默认配置，这些配置是否生效，取决于我们是否引入了对应库所需的依赖，如果有那么默认配置就会生效（通过@ConditionalOnBean注解实现，@ConditionalOnBean的作用是 容器中存在指定的 Bean 时才生效）。

所以，我们使用SpringBoot构建一个项目，只需要引入所需框架的依赖，配置就可以交给SpringBoot处理了。除非你不希望使用SpringBoot的默认配置，它也提供了自定义配置的入口。

1.3、自动配置加载过程

@EnableAutoConfiguration 注解 用于开启 Spring Boot 的自动配置功能， 它使用 Spring 框架提供的 @Import 注解通过
AutoConfigurationImportSelector类（选择器）给容器中导入自动配置组件。

1.3.1 @AutoConfigurationPackage注解

默认将主配置类( @SpringBootApplication )所在的包及其子包里面的所有组件扫描到IOC容器中。

在@AutoConfigurationPackage注解中存在一个@Import(AutoConfigurationPackages.Registrar.class)注解，自动配置包就是通过这个Registrar类的方法来完成的。

1.3.2 AutoConfigurationImportSelector 类

AutoConfigurationImportSelector 加载所有符合条件的META-INF/spring.factorie类

AutoConfigurationImportSelector 接口何时被执行?

SpringBoot 启动时会使用 ConfigurationClassParser 来解析被 @Configuration 标识的配置类, 然后再处理这个类内部被其他注解修饰的情况, 比如 @Import 注解, @ComponentScan 注解，@Bean 注解等

如果发现注解中存在 @Import(ImportSelector) 的情况下，就会创建一个相应的 ImportSelector 对象，并调用其 process 方法

process() 方法，该方法通过调用 getAutoConfigurationEntry() 方法读取 spring.factories 文件中的内容，获得自动配置类的集合，代码如下

public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
    Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector, () -> {
        return String.format("Only %s implementations are supported, got %s", AutoConfigurationImportSelector.class.getSimpleName(), deferredImportSelector.getClass().getName());
    });
    //拿到 META-INF/spring.factories中的EnableAutoConfiguration，并做排除、过滤处理
    //AutoConfigurationEntry里有需要引入配置类和排除掉的配置类，最终只要返回需要配置的配置类
    AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector)deferredImportSelector).getAutoConfigurationEntry(annotationMetadata);
    //加入缓存,List<AutoConfigurationEntry>类型
    this.autoConfigurationEntries.add(autoConfigurationEntry);
    Iterator var4 = autoConfigurationEntry.getConfigurations().iterator();
 
    while(var4.hasNext()) {
        String importClassName = (String)var4.next();
        //加入缓存，Map<String, AnnotationMetadata>类型
        this.entries.putIfAbsent(importClassName, annotationMetadata);
    }
}

getAutoConfigurationEntry() 方法通过调用 getCandidateConfigurations() 方法来获取自动配置类的完全限定名，并在经过排除、过滤等处理后，将其缓存到成员变量中，具体代码如下。

protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    } else {
        //获取注解元数据中的属性设置
        AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
        //获取自动配置类
        //通过getCandidateConfigurations得到待配置的class的类名集合,这个集合就是所有需要进行自动配置的类名，而是是否配置的关键在于META-INF/spring.factories文件中是否存在该配置信息
        List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
        //删除list 集合中重复的配置类
        configurations = this.removeDuplicates(configurations);
        //获取排除导入的配置类
        Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
        //检查是否还存在排除配置类
        this.checkExcludedClasses(configurations, exclusions);
        //删除排除的配置类
        configurations.removeAll(exclusions);
        //获取过滤器，过滤配置类
        configurations = this.getConfigurationClassFilter().filter(configurations);
        //触发自动化配置导入事件
        this.fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
    }
}

通过getCandidateConfigurations得到待配置的class的类名集合，这个集合就是所有需要进行自动配置的类名，而是是否配置的关键在于META-INF/spring.factories文件中是否存在该配置信息

在 getCandidateConfigurations() 方法中，根据 Spring Factories 机制调用 SpringFactoriesLoader 的 loadFactoryNames() 方法（后面Spring Factories 实现原理中有介绍这个方法），根据 EnableAutoConfiguration.class （自动配置接口）获取其实现类（自动配置类）的类名的集合，如下图。

 

2、Spring Factories 原理

2.1、spring.factories

spring.factories 文件本质上与 properties 文件相似，其中包含一组或多组键值对

（key=vlaue），其中，key 的取值为接口的完全限定名；value 的取值为接口实现类的完全限定名，一个接口可以设置多个实现类，不同实现类之间使用“，”隔开，例如：\

org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
org.springframework.boot.autoconfigure.condition.OnBeanCondition,\
org.springframework.boot.autoconfigure.condition.OnClassCondition,\
org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition

spring.factories 文件可以将 spring-boot 项目包以外的 bean（即在 pom 文件中添加依赖中的 bean）注册到 spring-boot 项目的 spring 容器。由于@ComponentScan 注解只能扫描 spring-boot 项目包内的 bean 并注册到 spring 容器中，因此需要 @EnableAutoConfiguration 注解来注册项目包外的bean。而 spring.factories 文件，则是用来记录项目包外需要注册的bean类名

2.2 Spring Factories 实现原理

spring-core 包里定义了 SpringFactoriesLoader 类，这个类会扫描所有 Jar 包类路径下的 META-INF/spring.factories 文件，并获取指定接口的配置。在 SpringFactoriesLoader 类中定义了两个对外的方法，如下表。

以上两个方法的关键都是从指定的 ClassLoader中获取spring.factories 文件，并解析得到类名列表，具体代码如下。 loadFactories() 方法能够获取指定接口的实现类对象，具体代码如下。

public static <T> List<T> loadFactories(Class<T> factoryType, @Nullable ClassLoader classLoader) {
    // 调用loadFactoryNames获取接口的实现类
    List<String> factoryImplementationNames = loadFactoryNames(factoryType, classLoaderToUse);
    // 遍历 factoryNames 数组，创建实现类的对象
    List<T> result = new ArrayList(factoryImplementationNames.size());
    Iterator var5 = factoryImplementationNames.iterator();
    //排序
    while(var5.hasNext()) {
        String factoryImplementationName = (String)var5.next();
        result.add(instantiateFactory(factoryImplementationName, factoryType, classLoaderToUse));
    }
 
    AnnotationAwareOrderComparator.sort(result);
    return result;
}

loadFactoryNames() 方法能够根据接口获取其实现类类名的集合，具体代码如下。

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    String factoryTypeName = factoryType.getName();
    //获取自动配置类
    return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
}

loadSpringFactories() 方法能够读取该项目中所有 Jar 包类路径下 META-INF/spring.factories 文件的配置内容，并以 Map 集合的形式返回，具体代码如下。

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
    Map<String, List<String>> result = (Map)cache.get(classLoader);
    if (result != null) {
        return result;
    } else {
        HashMap result = new HashMap();
 
    try {
        //扫描所有 Jar 包类路径下的 META-INF/spring.factories 文件
        Enumeration urls = classLoader.getResources("META-INF/spring.factories");
 
        while(urls.hasMoreElements()) {
                URL url = (URL)urls.nextElement();
                UrlResource resource = new UrlResource(url);
                //将扫描到的 META-INF/spring.factories 文件中内容包装成 properties 对象
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                Iterator var6 = properties.entrySet().iterator();
 
                while(var6.hasNext()) {
                    Map.Entry<?, ?> entry = (Map.Entry)var6.next();
                    //提取 properties 对象中的 key 值
                    String factoryTypeName = ((String)entry.getKey()).trim();
                    //提取 proper 对象中的 value 值（多个类的完全限定名使用逗号连接的字符串）
                    // 使用逗号为分隔符转换为数组，数组内每个元素都是配置类的完全限定名
                    String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                    String[] var10 = factoryImplementationNames;
                    int var11 = factoryImplementationNames.length;
                    //遍历配置类数组，并将数组转换为 list 集合
                    for(int var12 = 0; var12 < var11; ++var12) {
                        String factoryImplementationName = var10[var12];
                        ((List)result.computeIfAbsent(factoryTypeName, (key) -> {
                            return new ArrayList();
                        })).add(factoryImplementationName.trim());
                    }
                }
            }
            //将 propertise 对象的 key 与由配置类组成的 List 集合一一对应存入名为 result 的 Map 中
            result.replaceAll((factoryType, implementations) -> {
                return (List)implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
            });
            cache.put(classLoader, result);
            //返回 result
            return result;
        } catch (IOException var14) {
            throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);
        }
     }
}

2.3 应用启动时ConfigurationClassPostProcessor的注册

Springboot 应用在启动时，会创建一个ApplicationContext上下文实例。如果是Web应用，该上下文实例会使用类 AnnotationConfigEmbeddedWebApplicationContext来创建；否则使用类AnnotationConfigApplicationContext来创建。

不管是以上两种情况中的哪一种，相应的上下文类实例在创建时都会创建一个AnnotatedBeanDefinitionReader实例用于读取注解方式的Bean定义，而在创建这个AnnotatedBeanDefinitionReader实例的过程中，它注册了一个 ConfigurationClassPostProcessor Bean定义到容器，这是一个BeanFactoryPostProcessor,更明确地讲,它是一个BeanDefinitionRegistryPostProcessor。

ConfigurationClassPostProcessor被设计用来发现所有的配置类和相关的Bean定义并注册到容器，它在所有BeanFactoryPostProcessor中具备最高执行优先级，因为其他BeanFactoryPostProcessor需要基于注册了Bean定义工作

在springboot启动过程中，具体的来讲，是在以下位置被完成自动配置

SpringApplication.run()
=> refreshContext()
    => AbstractApplicationContext.refresh()
    => invokeBeanFactoryPostProcessors()
        => ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry()
        => processConfigBeanDefinitions()
            => ConfigurationClassParser.parse()
            => processDeferredImportSelectors()
                => AutoConfigurationImportSelector.selectImports()
 

在启动时把实现类org.springframework.boot.autoconfigure.EnableAutoConfiguration定义了哪些类是自动配置类，使用属性org.springframework.boot.autoconfigure.AutoConfigurationImportFilter定义了哪些自动配置导入过滤器会被应用，缺省情况下，只有一个过滤器会被应用，那就是OnClassCondition

AutoConfigurationImportSelector.selectImports()在执行时 :

1.从spring-autoconfigure-metadata.properties属性文件中提取自动配置元数据AutoConfigurationMetadata;

spring-boot-autoconfigure jar包的文件结构
├─META-INF
│      spring-autoconfigure-metadata.properties
│      spring.factories
│
└─org
    └─springframework
        └─boot
            └─autoconfigure

2.获取spring.factories属性文件中属性org.springframework.boot.autoconfigure.EnableAutoConfiguration定义的所有配置类作为候选配置类;

3.然后，获取spring.factories属性文件中属性org.springframework.boot.autoconfigure.AutoConfigurationImportFilter定义的过滤器，缺省是一个 : org.springframework.boot.autoconfigure.condition.OnClassCondition

4.对所有的候选配置类在自动配置元数据上 应用 所发现的过滤器，其实缺省情况下就一个，就是 OnClassCondition，也就是利用每个候选配置类上的注解 @ConditionalOnClass ， 来看这个候选配置类是否需要被应用。

selectImports()会返回所有需要被应用的配置类(注解@ConditionalOnClass条件被满足)，ConfigurationClassPostProcessor.postProcessBeanFactory()会将识别这些配置类中定义的bean并将它们注册到容器

整个流程如下图所示

2.4、自动配置的生效和修改

spring.factories 文件中的所有自动配置类（xxxAutoConfiguration），都是必须在一定的条件下才会作为组件添加到容器中，配置的内容才会生效。这些限制条件在 Spring Boot 中以 @Conditional 派生注解的形式体现，如下表。

下面我们以
ServletWebServerFactoryAutoConfiguration 为例，介绍 Spring Boot 自动配置是如何生效的。

ServletWebServerFactoryAutoConfiguration 代码如下。

@Configuration(   //表示这是一个配置类，与 xml 配置文件等价，也可以给容器中添加组件
        proxyBeanMethods = false
)
@AutoConfigureOrder(-2147483648)
@ConditionalOnClass({ServletRequest.class})//判断当前项目有没有 ServletRequest 这个类
@ConditionalOnWebApplication(// 判断当前应用是否是 web 应用，如果是，当前配置类生效 
type = Type.SERVLET
)
@EnableConfigurationProperties({ServerProperties.class})
//启动指定类的属性配置（ConfigurationProperties）功能；将配置文件中对应的值和 ServerProperties 绑定起来；并把 ServerProperties 加入到ioc容器中
@Import({ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class, EmbeddedTomcat.class, EmbeddedJetty.class, EmbeddedUndertow.class})
public class ServletWebServerFactoryAutoConfiguration {
    public ServletWebServerFactoryAutoConfiguration() {
    }
 
    @Bean //给容器中添加一个组件，这个组件的某些值需要从properties中获取
    public ServletWebServerFactoryCustomizer servletWebServerFactoryCustomizer(ServerProperties serverProperties, ObjectProvider<WebListenerRegistrar> webListenerRegistrars) {
        return new ServletWebServerFactoryCustomizer(serverProperties, (List) webListenerRegistrars.orderedStream().collect(Collectors.toList()));
    }
 
    @Bean
    @ConditionalOnClass(
            name = {"org.apache.catalina.startup.Tomcat"}
    )
    public TomcatServletWebServerFactoryCustomizer tomcatServletWebServerFactoryCustomizer(ServerProperties serverProperties) {
        return new TomcatServletWebServerFactoryCustomizer(serverProperties);
    }
 
    @Bean
    @ConditionalOnMissingFilterBean({ForwardedHeaderFilter.class})
    @ConditionalOnProperty(
            value = {"server.forward-headers-strategy"},
            havingValue = "framework"
    )
    public FilterRegistrationBean<ForwardedHeaderFilter> forwardedHeaderFilter() {
        ForwardedHeaderFilter filter = new ForwardedHeaderFilter();
        FilterRegistrationBean<ForwardedHeaderFilter> registration = new FilterRegistrationBean(filter, new ServletRegistrationBean[0]);
        registration.setDispatcherTypes(DispatcherType.REQUEST, new DispatcherType[]{DispatcherType.ASYNC, DispatcherType.ERROR});
        registration.setOrder(-2147483648);
        return registration;
    }
 
    public static class BeanPostProcessorsRegistrar implements ImportBeanDefinitionRegistrar, BeanFactoryAware {
        private ConfigurableListableBeanFactory beanFactory;
 
        public BeanPostProcessorsRegistrar() {
        }
 
        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
            if (beanFactory instanceof ConfigurableListableBeanFactory) {
                this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
            }
 
        }
 
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
            if (this.beanFactory != null) {
                this.registerSyntheticBeanIfMissing(registry, "webServerFactoryCustomizerBeanPostProcessor", WebServerFactoryCustomizerBeanPostProcessor.class, WebServerFactoryCustomizerBeanPostProcessor::new);
                this.registerSyntheticBeanIfMissing(registry, "errorPageRegistrarBeanPostProcessor", ErrorPageRegistrarBeanPostProcessor.class, ErrorPageRegistrarBeanPostProcessor::new);
            }
        }
 
        private <T> void registerSyntheticBeanIfMissing(BeanDefinitionRegistry registry, String name, Class<T> beanClass, Supplier<T> instanceSupplier) {
            if (ObjectUtils.isEmpty(this.beanFactory.getBeanNamesForType(beanClass, true, false))) {
                RootBeanDefinition beanDefinition = new RootBeanDefinition(beanClass, instanceSupplier);
                beanDefinition.setSynthetic(true);
                registry.registerBeanDefinition(name, beanDefinition);
            }
 
        }
    }
}

该类使用了以下注解：

• @Configuration：用于定义一个配置类，可用于替换 Spring 中的 xml 配置文件；
• @Bean：被 @Configuration 注解的类内部，可以包含有一个或多个被 @Bean 注解的方法，用于构建一个 Bean，并添加到 Spring 容器中；该注解与 spring 配置文件中 等价，方法名与 的 id 或 name 属性等价，方法返回值与 class 属性等价；
• @EnableConfigurationProperties(ServerProperties.class).他的意思是启动指定类的
  ConfigurationProperties功能；将配置文件中对应的值和 ServerProperties 绑定起来；并把
  ServerProperties 加入到 IOC 容器中。

除了 @Configuration 和 @Bean 注解外，该类还使用 5 个 @Conditional 衍生注解：

• @ConditionalOnClass({ServletRequest.class})：判断当前项目是否存在 ServletRequest 这个类，若存在，则该配置类生效。
• @ConditionalOnWebApplication(type = Type.SERVLET)：判断当前应用是否是 Web 应用，如果是的话，当前配置类生效。
• @ConditionalOnClass(name = {"org.apache.catalina.startup.Tomcat"})：判断是否存在 Tomcat 类，若存在则该方法生效。
• @ConditionalOnMissingFilterBean({ForwardedHeaderFilter.class})：判断容器中是否有 ForwardedHeaderFilter 这个过滤器，若不存在则该方法生效。
• @ConditionalOnProperty(value = {"server.forward-headers-strategy"},havingValue = "framework")：判断配置文件中是否存在 server.forward-headers-strategy = framework，若不存在则该方法生效。

ServerProperties

ServletWebServerFactoryAutoConfiguration 类还使用了一个 @EnableConfigurationProperties 注解，通过该注解导入了一个 ServerProperties 类，其部分源码如下。

@ConfigurationProperties(
    prefix = "server",
    ignoreUnknownFields = true
)
public class ServerProperties {
    private Integer port;
    private InetAddress address;
    @NestedConfigurationProperty
    private final ErrorProperties error = new ErrorProperties();
    private ServerProperties.ForwardHeadersStrategy forwardHeadersStrategy;
    private String serverHeader;
    private DataSize maxHttpHeaderSize = DataSize.ofKilobytes(8L);
    private Shutdown shutdown;
    @NestedConfigurationProperty
    private Ssl ssl;
    @NestedConfigurationProperty
    private final Compression compression;
    @NestedConfigurationProperty
    private final Http2 http2;
    private final ServerProperties.Servlet servlet;
    private final ServerProperties.Tomcat tomcat;
    private final ServerProperties.Jetty jetty;
    private final ServerProperties.Netty netty;
    private final ServerProperties.Undertow undertow;
 
    public ServerProperties() {
        this.shutdown = Shutdown.IMMEDIATE;
        this.compression = new Compression();
        this.http2 = new Http2();
        this.servlet = new ServerProperties.Servlet();
        this.tomcat = new ServerProperties.Tomcat();
        this.jetty = new ServerProperties.Jetty();
        this.netty = new ServerProperties.Netty();
        this.undertow = new ServerProperties.Undertow();
    }
    ....
}

我们看到，
ServletWebServerFactoryAutoConfiguration 使用了一个 @EnableConfigurationProperties 注解，而 ServerProperties 类上则使用了一个 @ConfigurationProperties 注解。这其实是 Spring Boot 自动配置机制中的通用用法。 Spring Boot 中为我们提供了大量的自动配置类 XxxAutoConfiguration 以及 XxxProperties，每个自动配置类 XxxAutoConfiguration 都使用了 @EnableConfigurationProperties 注解，而每个 XxxProperties 上都使用 @ConfigurationProperties 注解。

@ConfigurationProperties 注解的作用，是将这个类的所有属性与配置文件中相关的配置进行绑定，以便于获取或修改配置，但是 @ConfigurationProperties 功能是由容器提供的，被它注解的类必须是容器中的一个组件，否则该功能就无法使用。而 @EnableConfigurationProperties 注解的作用正是将指定的类以组件的形式注入到 IOC 容器中，并开启其 @ConfigurationProperties 功能。因此，@ConfigurationProperties + @EnableConfigurationProperties 组合使用，便可以为 XxxProperties 类实现配置绑定功能。

自动配置类 XxxAutoConfiguration 负责使用 XxxProperties 中属性进行自动配置，而 XxxProperties 则负责将自动配置属性与配置文件的相关配置进行绑定，以便于用户通过配置文件修改默认的自动配置。也就是说，真正“限制”我们可以在配置文件中配置哪些属性的类就是这些 XxxxProperties 类，它与配置文件中定义的 prefix 关键字开头的一组属性是唯一对应的。

注意：XxxAutoConfiguration 与 XxxProperties 并不是一一对应的，大多数情况都是多对多的关系，即一个 XxxAutoConfiguration 可以同时使用多个 XxxProperties 中的属性，一个 XxxProperties 类中属性也可以被多个 XxxAutoConfiguration 使用。