Spring Boot与配置文件

1、配置文件

1.1 文件类型

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

• application.properties
• application.yml

配置文件的作用：修改Spring Boot自动配置的默认值（Spring Boot在底层都给我们自动配置好）

YAML(YAML Ain’t a Markup Language)

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

标记语言

• 以前的配置文件，大多都使用XML文件
• YAML以数据为中心，比JSON，XML等更适合做配置文件

例子

YAML

server:
  port: 8081

XML

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

2、YAML语法

2.1 基本语法

key:(空格)value表示一对键值对

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

属性和值也是大小写敏感

2.2 值的写法

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

key: value字面直接来写

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

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

  name: “Hello \n World”，输出：Hello 换行 World

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

  name: ‘Hello \n World’，输出：Hello \n World

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

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

对象还是key: value的方式

friends:
	name: Tom
	age: 20

行内写法

friends: (name: Tom,age 20)

数组（List、Set）

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

pets:
	- cat
	- dog
	- pig

行内写法

pets: [cat, dog, pig]

2.3 配置文件值注入

配置文件application.yml

person:
  name: MysteryGuest
  age: 21
  birth: 1999/01/09
  map: {k1: v1, k2: v2}
  list:
    - China
    - Hubei
  pet:
    name: niuniu
    age: 5

• @ConfigurationProperties的方式

javaBean

/**
 * 将配置文件中配置的每一个属性的值，映射到这个数组中
 * @ConfigurationProperties: 告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定
 * prefix = "person": 配置文件中哪个下面的所有属性进行一一映射
 *
 * 只有这个组件是容器中的组件，才能使用容器提供的@ConfigurationProperties功能
 */
@Component
@ConfigurationProperties(prefix = "person")
public class Person {

    private String name;
    private Integer age;
    private Date birth;
    private Map<String, Object> map;
    private List<Object> list;
    private Pet pet;

    // getter() and setter()

    @Override
    public String toString() {...}
}

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

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

• @Value的方式

@Component
public class Person {

    // 另一种方式，Spring的底层注解
    /**
     * 类似以前
     * <bean class="Person">
     *     <property name="name" value="MysteryGuest"></property>
     * </bean>
     * <bean>标签相当于@Compoent
     * <property>标签中的value相当于@Value
     * value的参数可以是字面量、${key}从环境变量或配置文件获取值、#{SpEL}
     */
    @Value("${person.name}")
    private String name;
    @Value("#{11*2}")
    private Integer age;
    private Date birth;
    private Map<String, Object> map;
    private List<Object> list;
    private Pet pet;

    // getter() and setter()

    @Override
    public String toString() {...}
}

2.4 @Value获取值和@ConfigurationProperties获取值比较

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

属性名匹配规则（Relaxed binding，松散绑定）

• person.firstName：使用标准方式

• person.first-name：大写用-

• person.first_name：大写用_

• PERSON_FIRST_NAEM：

  推荐系统属性使用这种写法

配置文件（yml和properties）都能获取值

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

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

2.5 配置文件注入值校验

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

    @Email // @value不支持
    private String name;
    private Integer age;
    private Date birth;
    private Map<String, Object> map;
    private List<Object> list;
    private Pet pet;

    // getter() and setter()

    @Override
    public String toString() {...}
}

3、@PropertySource和@ImportResource

@PropertySource用来加载指定的配置文件

@PropertySource(value = {"classpath:person.properties"})
@Component
@ConfigurationProperties(prefix = "person")
public class Person {...}

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

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

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

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

3.1 Spring Boot推荐给容器中添加组件的方式

不来编写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.initializr.service.HelloService"></bean>
</beans>

@Bean既可以标记在类上，也可以作为元注解

推荐使用全注解的方式

• 配置类-------Spring配置文件
• 使用@Bean给容器中添加组件

/**
 * @Configuration指明当前类是一个配置类，就是来替代之前的Spring配置文件
 *
 * 以前在配置文件中用<bean></bean>标签添加组件
 */
@Configuration
public class MyAppConfig {

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

4、配置文件占位符

4.1 随机数

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

4.2 占位符获取之前配置的值，如果之前没有配置值，可以使用默认值

person.name=MysticalGuest${random.uuid}
person.age=${random.int}
person.birth=1999/01/09
person.map.k1=v1
person.map.k2=v2
person.list=[a, b, c]
person.pet.name=${person.hello:hello}${person.name}'s dog
# 如果文件中没有定义person.hello，那么取后面的hello值
person.pet.age=6

5、Profile

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

5.1 多Profile文件

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

默认使用application.properties/yml的配置

5.2 yml支持多文档块方式

server:
  port: 8081
spring:
  profiles:
    active: dev
---
server:
  port: 8084
spring:
  profiles: dev
---
server:
  port: 8085
  spring:
    profiles: prod

5.3 激活指定profile

• 指定激活开发环境配置

spring.profiles.active=dev

• 编辑运行配置参数

  --spring.profiles.active=dev

• 命令行

  打包后运行项目，切换端口，配置传入命令行参数

  $ java -jar target/myproject-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev
  

• 虚拟机参数

  -Dspring.profiles.active=dev

6、配置文件加载位置

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

• file: ./config/ file为当前项目目录

• file: ./

• classpath: /config/

• classpath: /

• 以上是按照优先级从高到低的顺序，所有位置的文件都会被加载，高优先
  级配置内容会覆盖低优先级配置内容；Spring Boot会从这4个位置全部加载主配置文件，互补配置

• 我们也可以通过配置spring.config.location来改变默认配置

  项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置，指定配置文件和默认加载的主配置文件

$ java -jar target/myproject-0.0.1-SNAPSHOT.jar --spring.config.location=D:/application.properties

以便运维的时候修改某些配置

7、外部配置加载顺序

Spring Boot支持多种外部配置方式，也可以从以下位置加载配置，优先级从高到底，高优先级的配置覆盖第优先级的配置，所有的配置会形成互补配置

这些方式优先级如下，可以参阅官方文档

1. 命令行参数

$ java -jar target/myproject-0.0.1-SNAPSHOT.jar --server.port=8089 --server.context-path=/initcmd

2. 来自 java: comp/env的JNDI属性

3. Java系统属性( System getProperties() )

4. 操作系统环境变量

5. RandomValuePropertySource配置的Random.*属性值

6. jar包外部的application-{profile}.properties或application.yml（带spring.profile）配置文件

   由jar包外向jar包内进行寻找，优先加载带profile

7. jar包内部的application-{profile}-properties或application.yml（spring profile)配置文件

8. jar包外部的application.properties或applcation.yml（不带spring.profile）配置文件

9. jar包内部的application.properties或application.yml（不带spring.profile）配置文件

10. @Configuration注解类上的@PropertySource

11. 通过SpringApplication.setDefaultProperties指定的默认属性

8、自动配置原理

配置依据官方文档

• Spring Boot启动的时候加载主配置类，开启了自动配置功能@EnableAuto Configuratio

• @EnableAutoConfiguration作用

  • 利用EnableAutoConfigurationlmportSelector给容器中导入一些组件?
    可以查看selectImports()方法的内容
  • List configurations = getCandidateConfigurations(annotation Metadata, attributes)获取候选的配置
  • SpringFactorfesLoader.loadFactoryNames()
    扫描所有jar包类路径下 META-INF/ spring.factories
    把扫描到的这些文件的内容包装成properties对象
    从properties中获取到EnableAutoconfiguration.class类（类名）对应的值，然后把他们添加在器中
  • 将类路径下 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.CloudAutoConfiguration,\
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.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
...
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
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.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.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.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
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.mobile.DeviceResolverAutoConfiguration,\
org.springframework.boot.autoconfigure.mobile.DeviceDelegatingViewResolverAutoConfiguration,\
org.springframework.boot.autoconfigure.mobile.SitePreferenceAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
org.springframework.boot.autoconfigure.reactor.ReactorAutoConfiguration,\
org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.SecurityFilterAutoConfiguration,\
org.springframework.boot.autoconfigure.security.FallbackWebSecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.OAuth2AutoConfiguration,\
org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
org.springframework.boot.autoconfigure.social.SocialWebAutoConfiguration,\
org.springframework.boot.autoconfigure.social.FacebookAutoConfiguration,\
org.springframework.boot.autoconfigure.social.LinkedInAutoConfiguration,\
org.springframework.boot.autoconfigure.social.TwitterAutoConfiguration,\
org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
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.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.web.HttpEncodingAutoConfiguration,\
org.springframework.boot.autoconfigure.web.HttpMessageConvertersAutoConfiguration,\
org.springframework.boot.autoconfigure.web.MultipartAutoConfiguration,\
org.springframework.boot.autoconfigure.web.ServerPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.web.WebClientAutoConfiguration,\
org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.WebSocketAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.WebSocketMessagingAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration

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

• 每一个自动配置类进行自动配置功能

8.1 以HttpEncodingAutoConfiguration为例解释自动配置原理

@Configuration
@EnableConfigurationProperties({HttpEncodingProperties.class})
@ConditionalOnWebApplication
@ConditionalOnClass({CharacterEncodingFilter.class})
@ConditionalOnProperty(
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {
    // 已经和Spring Boot的配置文件映射了
    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;
    }
    ...
}

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

• @EnableConfigurationProperties启用指定类ConfigurationProperties功能，将配置文件中对应的值和HttpEncodingProperties绑定起来；并把HttpEncodingProperties加入到ioc容器中，就可以用了

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

@ConfigurationProperties(
    prefix = "spring.http.encoding"
)
public class HttpEncodingProperties {
    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
  ...
}

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

• @ConditionalOnWebApplication是Spring底层@Conditional注解，根据不同条件，如果满足指定的条件，整个配置类里面的配置就会生效；

  这个注解是判断当前应用是否是web应用，如果是，当前配置类生效

• @ConditionalOnClass判断当前项目有没有指定类CharacterEncodingFilter.class

• CharacterEncodingFilter.class是SpringMVC中进行乱码解决的过滤器，以前都是配置在web.xml中的

• @ConditionalOnProperty判断配置文件中是否存在某个配置spring.http.encoding.enabled，如果不存在，判断也是成立的

  即使我们配置文件中不配置spring.http.encoding.enabled=true，也是默认生效的

一句话解释这个配置类，根据当前不同的条件，决定这个配置类是否生效？

一旦这个配置类生效，这个配置类就会给容器中添加各种组件，这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的

8.2 Spring Boot精髓

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

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

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

8.3 细节

在HttpEncodingAutoConfiguration配置里中

@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;
}

方法上也有一个注解，判断容器中是否配置了这个组件，如果没有则生效，进行配置

• @Conditional派生注解

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

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

虽然自动配置类很多，但大多都需要一定条件才会生效

之前解析过程中，虽然加载了很多自动配置类，但不是所有的都生效

• 现在重要的是我们怎么知道哪些配置类生效了

我们可以启用debug属性

# 开启Spring的debug，默认false
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)
   ...
Unconditional classes:
----------------------

    org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration
    ...

• Positive matches：自动配置类启用的
  Negative matches：没有启动，没有匹配成功的自动配置类

9、更多精彩

更多精彩，访问我的个人博客吧！