SpringBoot文档

一、Spring Boot 入门

1、Hello World探究

1、POM文件

1、父项目

<parent>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-parent</artifactId>
   <version>2.0.5.RELEASE</version>
   <relativePath /> <!-- lookup parent from repository -->
</parent>
他的父项目是
<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.0.5.RELEASE</version>
        <relativePath>../../spring-boot-dependencies</relativePath>
</parent>
他来真正管理Spring Boot 应用里面的所有依赖版本：

Spring Boot 版本仲裁中心：

以后我们导入依赖默认是不需要写版本：（没有在dependencies里面管理的依赖自然需要写版本号）

2、启动器

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

spring-boot-starter-web: Spring Boot 场景启动器帮我们导入了Web模块正常运行所依赖的组件；

Spring Boot 将所有相关场景都抽取出来，做成一个个的starters(启动器)，只需要在项目里面引入这些starters相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器

2、主程序类、注入口类

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

@SpringBootApplication :Spring Boot 应用标注在某个类上说明这个类是SpringBoot的主配置类，

SpringBoot就应该运行这个类的main方法来启动SpringBoot应用；

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
      @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
      @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

@SpringBootConfiguration:Spring Boot 的配置类；

标注在某个类上，表示这是一个Spring Boot 的配置类；

@Configuration：配置类上来标注这个注解；

配置类-------配置文件：配置类也是容器中的一个组件；@Component

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

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

告诉Spring Boot 开启自动配置功能；这样自动配置才能生效；

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

@AutoConfigurationPackage：自动配置包

@Import(AutoConfigurationPackages.Registrar.class)；

spring的底层注解@import,给容器中导入一个组件；导入的组件由

AutoConfigurationPackages.Registrar.class

==将主配置类（@SpringBootApplication标注的类）的所在包及下面所有子包里面的所有组件扫描到Spring容器；==

@Import(AutoConfigurationImportSelector.class)

给容器中导入组件？

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

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

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

有了自动配置类，免去了我们手动编写配置注入功能组件等的工作；

SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class,classLoader);

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

J2EE的整体整合解决方案和自动配置都在spring-boot-autoconfigure-2.0.5.RELEASE.jar；

2、使用Spring Initializer快速创建SpringBoot项目

IDE都支持使用Spring的项目创建向导快速创建一个Spring Boot项目；

选择我们需要的模块；向导会联网创建Spring Boot 项目；

默认生成的Spring Boot项目；

• 主程序已经生成好了，我们只需要我们自己的逻辑

• resources文件夹中目录结构

  • static:保存所有的静态资源；js css images ;

  • templates:保存所有的模板页面；（Spring Boot 默认jar包使用嵌入式的Tomcat,默认不支持jsp页面）；可以使用引擎模板（Freemarker、thymeleaf）;

  • application.properties:Spring Boot 应用的配置文件；可以修改一些默认配置；

二、 配置文件

1、配置文件

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

• application.properties

• application.yml

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

YAML(YAML Ain't Markup language)

YAML A Markup Language ;是一个标记语言；

YAML isn't Markup Language; 不是一个标记语言 ；

标记语言：

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

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

YAML:配置例子

server:
  port: 8090

XML:

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

2、YAML语法

1、基本语法

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

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

server:
  port: 8090
  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 :20}

数组（List、Set）

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

pets:
    -cat
    -dog
    -pig

行内写法

pets：{cat，dog，pig}

3、配置文件值注入

配置文件

person:
    lastName: zhangsan
    age: 18
    boss: false
    birth: 2018/10/4
    maps: {k1: v1, k2: 12}
    lists:
      -lisi
      -zhaoliu
    dog:
      name: 小狗
      age: 2

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配置文件在idea中默认UTF-8可能会乱码

2、@value获取值和@ConfigurationProperties获取值比较

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

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

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

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

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

@Component
@ConfigurationProperties(prefix = "person")
@Validated
public class Person {
    /*
    * <bean class="Persion">
    *     <property name ="lastName" value="字面量/${key}从环境变量，配置文件中获取值/#{SpEl}"</property>
    * </bean>
    * */
//    @Value("${person.last-name}")
    @Email
    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

@PropertySoure:加载指定的配置文件

/*
*将配置文件中配置的每一个属性的值，映射到这个组件中
*@ConfigurationProperties：告诉springBoot将本类中的所有属性和配置文件中相关配置进行绑定；
*       prefix = "person"配置文件中哪个下面的所有属性进行一一映射
*       默认从全局配置文件中获取值；
* 只有这个组件是容器中的组件，才能使用容器提供的@ConfigurationProperties功能；
*/
@Component
@ConfigurationProperties(prefix = "person")
@PropertySource(value = {"classpath:person.properties"})
//@Validated
public class Person {
    /*
    * <bean class="Persion">
    *     <property name ="lastName" value="字面量/${key}从环境变量，配置文件中获取值/#{SpEl}"</property>
    * </bean>
    * */
//    @Value("${person.last-name}")
    @Email
    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="org.wl.springboot.service.HelloService"></bean>
</beans>

SpringBoot 推荐给容器中添加组件的方式；

1、配置类=========Spring配置文件

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

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

4、配置文件占位符

1、随机数

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

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

person:
    lastName: zhangsan ${random.uuid}
    age: ${random.int}
    boss: false
    birth: 2018/10/4
    maps: {k1: v1, k2: 12}
    lists:
      -lisi
      -zhaoliu
    dog:
      name: ${person.hello:hello}_dog
      age: 2

5、Profile

1、多Profile文件

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

默认使用application.properties的配置;

2、yml支持多文档块方式

server:
  port: 8090
spring:
  profiles:
    active: dev
---
​
server:
  port: 8003
spring:
  profiles: dev
---
​
server:
  port: 8004
spring:
  profiles: prod
​
---

3、激活指定profile

1、在配置文件中指定Spring.properties.active =dev

2、命令行：

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

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

3、 虚拟机参数：

-Dspring.profile.active=dev

6、配置文件加载位置

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

文件

-file:/config/

-file:/

-classpath:/config/

-classpath:/

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

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

==spring-boot配置文件中server.context-path=/XXXXXXX不起作用：==

==原因是更新后写法变成了`server.servlet.context-path=/XXXXXX，这样写即可==

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

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

java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=C:\Users\80481\Desktop\application.properties

7、外部配置加载顺序

SpringBoot也可以从以下位置加载配置：按照优先级从高到低；高优先级的配置覆盖低优先级的配置，所有配置会形成互补配置

1. 命令行参数

   • 所有的配置都可以在命令行上进行指定；

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

   java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar 
   --server.port=8087 --server.context-path=/abc
   1234

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

   ---

   6.jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件 7.jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件 8.jar包外部的application.properties或application.yml(不带spring.profile)配置文件 9.jar包内部的application.properties或application.yml(不带spring.profile)配置文件

   由jar包外向jar包内进行寻找，优先加载待profile的，再加载不带profile的。1

   ---

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

   所有的配置加载来源；

   参考官方文档

8、自动配置原理

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

配置文件能配置的属性参照

1、自动配置原理

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

2）、@EnableAutoConfiguration作用：

• 利用AutoConfigurationImportSelector给容器中导入了一些组件？

• 可以查看selectImports（）方法的内容；

• List<String> configurations = getCandidateConfigurations(annotationMetadata, ​ attributes);获取候选的配置

  • SpringFactoriesLoader.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.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.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapDataAutoConfiguration,\
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.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.reactor.core.ReactorCoreAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityRequestMatcherProviderAutoConfiguration,\
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.sendgrid.SendGridAutoConfiguration,\
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.client.OAuth2ClientAutoConfiguration,\
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.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.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
​
# Failure analyzers
org.springframework.boot.diagnostics.FailureAnalyzer=\
org.springframework.boot.autoconfigure.diagnostics.analyzer.NoSuchBeanDefinitionFailureAnalyzer,\
org.springframework.boot.autoconfigure.jdbc.DataSourceBeanCreationFailureAnalyzer,\
org.springframework.boot.autoconfigure.jdbc.HikariDriverConfigurationFailureAnalyzer,\
org.springframework.boot.autoconfigure.session.NonUniqueSessionRepositoryFailureAnalyzer
​
# Template availability providers
org.springframework.boot.autoconfigure.template.TemplateAvailabilityProvider=\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerTemplateAvailabilityProvider,\
org.springframework.boot.autoconfigure.mustache.MustacheTemplateAvailabilityProvider,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAvailabilityProvider,\
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafTemplateAvailabilityProvider,\
org.springframework.boot.autoconfigure.web.servlet.JspTemplateAvailabilityProvider

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

3）、每一个自动配置类进行自动配置功能；

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

@Configuration//表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件
@EnableConfigurationProperties(HttpEncodingProperties.class)//启用ConfigurationProperties功能；将配置文件中对应的值和HttpEncidingproperties绑定起来；并把HttpEncodingProperties加入到ioc容器中
​
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)//spring底层@Conditional注解，根据不同的条件，如果满足指定条件，整个配置文件里面的配置就会生效；判断当前应用是否是WEB应用,如果是，当前配置类生效
@ConditionalOnClass(CharacterEncodingFilter.class)//判断当前项目有没有这个类
//CharacterEncodingFilter；springmvc中进行乱码解决的过滤器
@ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true)//判断配置文件中是否存在某个配置spring.http.encoding.enabled;如果不存在，判断也是成立的
//即使我们配置文件中不配置spring.http.encoding.enabled=true,也是默认生效的；
public class HttpEncodingAutoConfiguration {
    
    //他已经和SpringBoot的配置文件映射了
    private final HttpEncodingProperties properties;
    
    //只有一个有参构造器的情况下，参数的值就会从容器中拿
    public HttpEncodingAutoConfiguration(HttpEncodingProperties properties){
        this.properties = properties;
    }
​
    
    @Bean//给容器中添加一个组件，这个组件中的某些值需要从properties中获取
    @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类中封装着；配置文件能配置什么就可以参照某个功能对应的这个属性类

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

精髓

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

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

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

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

xxxxAutoConfigurartion:自动配置类；

给容器中添加组件

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

2、细节

1、@conditional派生注解（spring注解版原生的@conditional作用）

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

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

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

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

============================
CONDITIONS EVALUATION REPORT
============================
​
​
Positive matches:（自动配置类启用的）
-----------------
​
   CodecsAutoConfiguration matched:
      - @ConditionalOnClass found required class 'org.springframework.http.codec.CodecConfigurer'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition)
   CodecsAutoConfiguration.JacksonCodecConfiguration matched:
      - @ConditionalOnClass found required class 'com.fasterxml.jackson.databind.ObjectMapper'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition)
          
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', 'org.aspectj.weaver.AnnotatedElement' (OnClassCondition)
​

三、日志

1、日志框架

小张：开发一个大型系统：

1、System.out.println("");将关键数据打印在控制台：去掉？写在一个文件？

2、框架来记录系统的一些运行时信息；日志框架；zhanglogging.jar;

3、高大上的几个功能？异步模式？自动归档？xxxx?zhanglogging-good.jar?

4、将以前框架卸下来？换上了新的框架，重新修改之前相关的API;zhanglogging-prefect.jar;

5、JDBC---数据库驱动；

写了一个统一的接口层；日志门面（日志的一个抽象层）；logging-abstract.jar;

给项目中导入具体的日志实现就行了；我们之前的日志框架都是实现的抽象层；

市面上的日志框架;

JUL、JCL、Jboss-logging、logback、log4j、log4j2、slf4j....

左面选一个门面（抽象层）、右边来选一个实现；

日志门面：SLF4J;

日志实现：Logback;

SpringBoot:底层框架Spring框架，Spring框架默认是用JCL;

SpringBoot 选用SLF4J和logback；

2、SLF4J使用

1、如何在系统中使用SLF4J

以后开发的时候，日志记录方法的调用，不应该直接调用日志的实现类，而是调用日志抽象层里面的方法；

给系统里面导入slf4j的jar和logback实现的jar

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
​
public class HelloWorld {
  public static void main(String[] args) {
    Logger logger = LoggerFactory.getLogger(HelloWorld.class);
    logger.info("Hello World");
  }
}

图示：

每一个日志的实现框架都有自己的配置文件，使用slf4j以后，配置文件还是做成日志实现框架自己本身的配置文件

2、遗留问题

a(slf4j+logback):Spring(commons-logging)、Hibernate(jboss-logging)、mybatis、xxxx

统一日志记录，即使是别的框架和我们一起统一使用slf4j进行输出？

如何让系统中所有的日志都统一到Slf4j;

==1、将系统中其他日志框架先排除出去；==

==2、用中间包来替换原有的日志框架；==

==3、我们导入slf4其他的实现==

3、SpringBoot日志关系

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

SpringBoot使用它来做日志功能：

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-logging</artifactId>
  <version>2.0.5.RELEASE</version>
  <scope>compile</scope>
</dependency>

SpringBoot底层依赖关系

总结：

1）、SpringBoot底层也是使用slf4j+logback的方式进行日志记录

2）、SpringBoot也把其他的日志都替换了成了slf4j;

3）、中间替换包？

public final class LoggerFactory {
​
    static final String CODES_PREFIX = "http://www.slf4j.org/codes.html";
​
    static final String NO_STATICLOGGERBINDER_URL = CODES_PREFIX + "#StaticLoggerBinder";

4）、如果我们引入其他框架?一定要把这个框架的默认日志依赖移除掉？

Spring框架用的是commons-logging;

SpringBoot能自动适配所有的日志，而且底层使用slf4j+logback的记录方式记录日志，引入其他框架的时候，只需要把这个框架依赖的日志框架排除掉即可；

4、日志使用

1、默认配置

SpringBoot默认帮我们配置好了日志；

@Test
public void contextLoads() {
    //日志记录器
    Logger logger = LoggerFactory.getLogger(getClass());
    //日志的级别
    //由低到高  trace<debug<info<warn<error
    //可以调整输出的日志级别，日志就只会在这个级别及以后的高级别生效
    logger.trace("这是trace日志...");
    logger.debug("这是dubug日志...");
    //SpringBoot默认给我们使用的是info级别的，没有指定级别就用SpringBoot默认规定的级别：root级别
    logger.info("这是info日志。。。");
    logger.warn("这是warn日志。。。");
    logger.error("这是error日志。。。");
​
}

<pattern>%d{yyyy-MM-dd HH:mm:ss} %p%M-> %m%n</pattern>

以上格式说明如下：

%M	输出代码中指定的消息
%p	输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
%r	输出自应用启动到输出该log信息耗费的毫秒数
%c	输出所属的类目，通常就是所在类的全名
%t	输出产生该日志事件的线程名
%n	输出一个回车换行符，Windows平台为“\r\n”，Unix平台为“\n”
%d	输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss,SSS}， 输出类似：2002年10月18日 22：10：28，921
%l	输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java:10)

SpringBoot 修改日志的默认配置

logging.level.org.wl= trace
​
#logging.file=D:springboot.log
#当前磁盘的根路径下创建spring文件夹和里面的log文件夹；使用spring.log作为默认文件
#logging.path=/spring/log
#指定文件中日志的输出格式
logging.pattern.console=

==logback依賴==

<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-core</artifactId>                           <version>1.2.3</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-access</artifactId>
    <version>1.2.3</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>

2、指定配置

给路径下放在每一个日志框架自己的配置文件即可；SpringBoot 就不使用其他默认配置了

LOGGING SYSTEM	CUSTOMIZATION
Logback	logback-spring.xml, logback-spring.groovy, logback.xml, or logback.groovy
Log4j2	log4j2-spring.xml or log4j2.xml

logback.xml:直接就被日志框架识别了；

logback-spring.xml:日志框架就不直接加载日志的配置项，由SpringBoot解析日志配置，可以使用SpringBoot的高级Profile功能

<springProfile name="staging">
    <!-- configuration to be enabled when the "staging" profile is active -->
</springProfile>
可以指定某段配置只在某个环境下生效

否则

no applicable active for [springProfile]

<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    <!--encoder 默认配置为PatternLayoutEncoder-->
    <encoder>
        <springProfile name="dev">
            <pattern>===>>>>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger Line:%-3L - %msg%n</pattern>
            <charset>utf-8</charset>
        </springProfile>
        <springProfile name="!dev">
            <pattern>===>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger Line:%-3L - %msg%n</pattern>
            <charset>utf-8</charset>
        </springProfile>
    </encoder>
    <!--此日志appender是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息-->
    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
        <level>debug</level>
    </filter>
</appender>

5、切换日志框架

可以按照Slf4J日志适配图，进行相关的切换；

slf4+log4的方式

切换成为log4J2

四、Web开发

1、简介

使用SpringBoot;

1)、创建SpringBoot应用，选中我们需要的模块；

2）、SpringBoot已经默认将这些场景配置好了？只需要在配置文件中指定少量配置就可以运行起来；

3）、自己编写业务代码；

自动配置原理？

这个场景SpringBoot帮我们配置好了什么？能不能修改？能修改哪些配置？能不能扩展？xxx

xxxx.AutoConfiguration:帮我们给容器中自动配置组件
xxxx.Properties:配置类来封装配置文件的内容

2、SpringBoot对静态资源的映射规则；

@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
public class ResourceProperties {
//可以设置和静态资源有关的参数，缓存时间等

@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
   if (!this.resourceProperties.isAddMappings()) {
      logger.debug("Default resource handling disabled");
      return;
   }
   Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
   CacheControl cacheControl = this.resourceProperties.getCache()
         .getCachecontrol().toHttpCacheControl();
   if (!registry.hasMappingForPattern("/webjars/**")) {
      customizeResourceHandlerRegistration(registry
            .addResourceHandler("/webjars/**")
            .addResourceLocations("classpath:/META-INF/resources/webjars/")
            .setCachePeriod(getSeconds(cachePeriod))
            .setCacheControl(cacheControl));
   }
   String staticPathPattern = this.mvcProperties.getStaticPathPattern();
   if (!registry.hasMappingForPattern(staticPathPattern)) {
      customizeResourceHandlerRegistration(
            registry.addResourceHandler(staticPathPattern)
                  .addResourceLocations(getResourceLocations(
                        this.resourceProperties.getStaticLocations()))
                  .setCachePeriod(getSeconds(cachePeriod))
                  .setCacheControl(cacheControl));
   }
}
​
private Integer getSeconds(Duration cachePeriod) {
   return (cachePeriod != null) ? (int) cachePeriod.getSeconds() : null;
}

==1）、所有/webjars/**,都去classpath:/META-INF/resources/webjars/找资源；==

webjars:以jar包的方式引入静态资源；

https://www.webjars.org/

localhost:8081/webjars/jquery/3.3.1-1\jquery.js

<!-- 引入jquery-webjars-->在访问的时候只需要写webjars下面的内容即可
<dependency>
    <groupId>org.webjars</groupId>
    <artifactId>jquery</artifactId>
    <version>3.3.1-1</version>
</dependency>

==2 、**"访问当前项目的任何资源，（静态资源的文件夹==）

"classpath:/META-INF/resources/",
"classpath:/resources/",
"classpath:/static/",
"classpath:/public/" 
"/"当前项目的根路径

localhost:8081/abc === 去静态资源文件夹里面找abc

==3) 、迎页：静态资源文件夹下的所有index.html页面；被“/**”映射；==

localhost:8080/找index页面

//配置欢迎页映射
@Bean
public WelcomePageHandlerMapping welcomePageHandlerMapping(
      ApplicationContext applicationContext) {
   return new WelcomePageHandlerMapping(
         new TemplateAvailabilityProviders(applicationContext),
         applicationContext, getWelcomePage(),
         this.mvcProperties.getStaticPathPattern());
}

==4）、所有的**/favicon.ico都是在静态资源文件下找==

//配置我们喜欢的图标
@Configuration
   @ConditionalOnProperty(value = "spring.mvc.favicon.enabled", matchIfMissing = true)
   public static class FaviconConfiguration implements ResourceLoaderAware {
​
      private final ResourceProperties resourceProperties;
​
      private ResourceLoader resourceLoader;
​
      public FaviconConfiguration(ResourceProperties resourceProperties) {
         this.resourceProperties = resourceProperties;
      }
​
      @Override
      public void setResourceLoader(ResourceLoader resourceLoader) {
         this.resourceLoader = resourceLoader;
      }
​
      @Bean
      public SimpleUrlHandlerMapping faviconHandlerMapping() {
         SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping();
         mapping.setOrder(Ordered.HIGHEST_PRECEDENCE + 1);
//所有 **/favicon.ico          mapping.setUrlMap(Collections.singletonMap("**/favicon.ico",
               faviconRequestHandler()));
         return mapping;
      }
​
      @Bean
      public ResourceHttpRequestHandler faviconRequestHandler() {
         ResourceHttpRequestHandler requestHandler = new ResourceHttpRequestHandler();
         requestHandler.setLocations(resolveFaviconLocations());
         return requestHandler;
      }
​
      private List<Resource> resolveFaviconLocations() {
         String[] staticLocations = getResourceLocations(
               this.resourceProperties.getStaticLocations());
         List<Resource> locations = new ArrayList<>(staticLocations.length + 1);
         Arrays.stream(staticLocations).map(this.resourceLoader::getResource)
               .forEach(locations::add);
         locations.add(new ClassPathResource("/"));
         return Collections.unmodifiableList(locations);
      }
​
   }
​
}

3、模板引擎

JSP、Velocity、Freemarker、Thymeleaf;

SpringBoot推荐的Thymeleaf;

语法更简单、功能更强大；

1、引入thymeleaf;

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

2、Thymeleaf使用&语法

private static final Charset DEFAULT_ENCODING = StandardCharsets.UTF_8;
​
public static final String DEFAULT_PREFIX = "classpath:/templates/";
​
public static final String DEFAULT_SUFFIX = ".html";
//只要我么把HTML页面放在classpath:/templates/,thymeleaf就能自动渲染；

使用：

1、导入thymeleaf的名称空间

<html lang="en" xmlns:th="http://www.thymeleaf.org">

2、使用thymeleaf的语法

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>成功</title>
</head>
<body>
    <h1>成功</h1>
    <!--th:text将div里面的文本内容设置为-->
    <div th:text="${hello}">这是显示欢迎信息</div>
</body>
</html>

3、语法规则

1）、th:text；改变当前元素里面的文本内容；

th:任意html属性；来替换原生属性的值

2）、表达式?

Simple expressions:(表达式语法)
    Variable Expressions: ${...}获取变量的值OGNL;
        1)、获取对象的属性、调用方法；
        2）、使用内置的基本对象；
        #ctx : the context object.
        #vars: the context variables.
        #locale : the context locale.
        #request : (only in Web Contexts) the HttpServletRequest object.
        #response : (only in Web Contexts) the HttpServletResponse object.
        #session : (only in Web Contexts) the HttpSession object.
        #servletContext : (only in Web Contexts) the ServletContext object.
        3）、内置的一些工具对象
#execInfo : information about the template being processed.
#messages : methods for obtaining externalized messages inside variables expressions, in the same way as they
would be obtained using #{…} syntax.
#uris : methods for escaping parts of URLs/URIs
Page 20 of 106
#conversions : methods for executing the configured conversion service (if any).
#dates : methods for java.util.Date objects: formatting, component extraction, etc.
#calendars : analogous to #dates , but for java.util.Calendar objects.
#numbers : methods for formatting numeric objects.
#strings : methods for String objects: contains, startsWith, prepending/appending, etc.
#objects : methods for objects in general.
#bools : methods for boolean evaluation.
#arrays : methods for arrays.
#lists : methods for lists.
#sets : methods for sets.
#maps : methods for maps.
#aggregates : methods for creating aggregates on arrays or collections.
#ids : methods for dealing with id attributes that might be repeated (for example, as a result of an iteration).
    
    Selection Variable Expressions: *{...}选择表达式；和${}在功能上是一样；
    补充；配合 th:object="${session.user}"
    <div th:object="${session.user}">
        <p>Name: <span th:text="*{firstName}">Sebastian</span>.</p>
        <p>Surname: <span th:text="*{lastName}">Pepper</span>.</p>
        <p>Nationality: <span th:text="*{nationality}">Saturn</span>.</p>

    </div>
    Message Expressions: #{...}获取国际化功能的
    
    Link URL Expressions: @{...}定义URL
    @{/order/process(execId=${execId},execType='FAST')}
    
    Fragment Expressions: ~{...}片段引用的表达式
    <div th:insert="~{commons :: main}">...</div>
    
Literals（字面量）
    Text literals: 'one text' , 'Another one!' ,…
    Number literals: 0 , 34 , 3.0 , 12.3 ,…
    Boolean literals: true , false
    Null literal: null
    Literal tokens: one , sometext , main ,…
Text operations:（文本操作）
    String concatenation: +
    Literal substitutions: |The name is ${name}|
    Arithmetic operations:（数学运算）
    Binary operators: + , - , * , / , %
    Minus sign (unary operator): -
Boolean operations:（布尔运算）
    Binary operators: and , or
    Boolean negation (unary operator): ! , not
Comparisons and equality:（比较运算）
    Comparators: > , < , >= , <= ( gt , lt , ge , le )
    Equality operators: == , != ( eq , ne )
Conditional operators:（条件运算）（三元符运算）
    If-then: (if) ? (then)
    If-then-else: (if) ? (then) : (else)
    Default: (value) ?: (defaultvalue)
Special tokens:
    Page 17 of 106
    No-Operation: _

4、SpringMVC自动配置

https://docs.spring.io/spring-boot/docs/2.0.5.RELEASE/reference/htmlsingle/#boot-features-developing-web-applications

1、 Spring MVC Auto-configuration

SpringBoot自动配置好了SpringMVC

以下是SpringBoot对SpringMVC的默认：

• Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans.

  • 自动配置了ViewResolver(视图解析器：根据我们方法的返回值得到视图对象（view）,视图对象决定如何渲染（转发？重定向？）)

  • ContentNegotiatingViewResolver组合了所有视图解析器的；

  • ==如何定制：我们可以自己给容器中添加一个视图解析器；自动的将其组合进来；==

• Support for serving static resources, including support for WebJars (covered later in this document)).静态资源文件夹路径webjars

• Static index.html support.静态首页访问

• Custom Favicon support (covered later in this document).

• 自动注册了 of Converter, GenericConverter, and Formatter beans.

  • Converter：转换器；public String hello(User user);类型转换使用Converter

  • Formatter:格式化器；2018.10.7====date

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnProperty(prefix = "spring.mvc", name = "locale")
    public LocaleResolver localeResolver() {
       if (this.mvcProperties
             .getLocaleResolver() == WebMvcProperties.LocaleResolver.FIXED) {
          return new FixedLocaleResolver(this.mvcProperties.getLocale());
       }
       AcceptHeaderLocaleResolver localeResolver = new AcceptHeaderLocaleResolver();
       localeResolver.setDefaultLocale(this.mvcProperties.getLocale());
       return localeResolver;
    }

  ==自己添加的格式化转化器，我们只需要放在容器中即可==

• Support for HttpMessageConverters (covered later in this document).

  • HttpMessageConverters：SpringMVC用来转换Http请求和响应的；user---json;

  • HttpMessageConverters是从容器中确定；获取所有的`HttpMessageConverters;

    ==自己给容器中添加HttpMessageConverter，只需要将自己的组件注册容器中（@Bean,@Component）==

• Automatic registration of MessageCodesResolver (covered later in this document).

  定义错误代码生成规则

• Automatic use of a ConfigurableWebBindingInitializer bean (covered later in this document).

  ==我们可以配置一个ConfigurableWebBindingInitializer来替换默认的(添加到容器中)；==

  初始化WebDataBinder;
  请求数据==== JavaBean

==org.springframework.boot.autoconfigure.web:web的所有自动场景==

If you want to keep Spring Boot MVC features and you want to add additional MVC configuration(interceptors, formatters, view controllers, and other features), you can add your own @Configuration class of type WebMvcConfigurer but without @EnableWebMvc. If you wish to provide custom instances of RequestMappingHandlerMapping, RequestMappingHandlerAdapter, or ExceptionHandlerExceptionResolver, you can declare a WebMvcRegistrationsAdapter instance to provide such components.

If you want to take complete control of Spring MVC, you can add your own @Configurationannotated with @EnableWebMvc.

2、扩展SpringMVC

<mvc:view-controller path="/hello" view-name="success"/>
<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/hello"/>
        <bean></bean>
    </mvc:interceptor>
</mvc:interceptors>

==编写一个配置类（@Configuration）,是WebMvcConfiguerAdapter类型；不能标注@EnableWebMvc==

==WebMvcConfigurerAdapter过期，使用新的WebMvcConfigurationSupport==

既保留了所有的自动配置，也能用我们的扩展配置；

//使用WebMvcConfigurationSupport可以扩展SpringMVC的功能
@Configuration
public class MyMvcConfig extends WebMvcConfigurationSupport {
​
    protected void addViewControllers(ViewControllerRegistry registry) {
        //浏览器发送/wl请求来到success
        registry.addViewController("/wl").setViewName("success");
​
    }
​
}

原理：

1）、WebMvcAutoConfiguration是SpringMVC自动配置类

2）、在做其他自动配置时会导入；@import(EnableWebMvcConfiguration.class)

@Configuration
public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration {
​
​
//从容器中获取所有的WebMvcConfiguration 
@Autowired(required = false)
    public void setConfigurers(List<WebMvcConfigurer> configurers) {
        if (!CollectionUtils.isEmpty(configurers)) {
            this.configurers.addWebMvcConfigurers(configurers);
        }//一个参考实现；将所有的WebMvcConfigurer相关配置都一起调用
    }

3)、容器中所有的WebMvcConfiguration 都会一起起作用

4）、我们的配置类也会被调用；

效果：SpringMvc 的自动配置和我们的扩展配置都会起作用；

3 、全面接管SpringMVC

springBoot对springmvc的自动配置不需要了，所有都是我们自己配；所有的SpringMvc的自动配置都失效；我们需要在配置类中添加@EnableWebMvc即可

5、如何修改SpringBoot的默认配置

模式：

1）、SpringBoot再自动配置很多组件的时候，先看容器 中有没有用户自己配置的（@Bean、@Component）如果有就用用户配置的，如果没有，才自动配置；如果有些组件可以有多个（ViewResolver）将用户配置的和他自己默认的组合起来；

2）、在SpringBoot中会有非常多的xxxConfigurer帮助我们进行扩展配置；