Springboot学习笔记（1）

m0_46128962

已于 2024-09-24 20:34:38 修改

阅读量1.6k

点赞数 2

于 2020-10-26 16:39:07 首次发布

本文链接：https://blog.csdn.net/m0_46128962/article/details/109174205

版权

Spring Boot简介：
SpringBoot能简化Spring应用开发，约定大于配置，仅仅run就能创建一个独立的，产品级别的应用，解决了J2EE笨重的开发，繁多的配置，低下的开发效率，复杂的部署流程，第三方技术集成难度大的问题。

优点：

快速创建独立运行的Spring项目以及与主流框架集成。
使用嵌入式的Servlet容器，应用无需打包成WAR包。
starters自动依赖于版本控制。
大量的自动配置简化开发，也可以修改默认值
无需配置XML，无代码生成，开箱即用。
准生产环境运行时的应用监控
与云计算的天然集成。

微服务一个应用应该是一组小型服务，可以通过HTTP的方式互通

一.创建一个HelloWorld程序

1.创建Maven项目
2.引入Starters
3.创建主程序
4.启动运行

在Springboot的Controller中一个controller中只能写一个@Responsebody，要不然就不写，否则会只有一个生效。

1.maven插件用法
将项目打包成一个可执行的JAR包

在这里插入图片描述
打包后可以在Target中找到Jar包然后拿出来转到目录Cmd使用java -jar springboot…使用tab键补全执行启动项目，同样可以在浏览器中访问，因为里面自带了Tomcat环境。（使用dir命令查看当前文件下所有文件）

Springboot为什么创建了能直接启动？
依赖：1.在pom.xml中找到父项目(parent)点进去发现还有父项目再查看父项目发现了几乎所有场景的各种jar包版本的依赖
相当于Springboot的版本仲裁中心。

2.导入的依赖

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

Springboot将所有功能的场景抽取出来，做成一个个的启动器（starters），只需在项目里面引入启动器，相关的场景都会导入进来，要用什么功能就导入什么场景的启动器。

3.主程序类：
@SpringBootApplication: Spring Boot应用标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot 就应该运行这个类的main方法来启动SpringBoot应用

@SpringBootApplication—>@SpringBootConfiguration—>@Configuration—>@Component

@SpringBootConﬁguration：Spring Boot的配置类；
标注在某个类上，表示这是一个Spring Boot的配置类；

@Conﬁguration:配置类上来标注这个注解；
配置类 ----- 配置文件；配置类也是容器中的一个组件；@Component
@EnableAutoConﬁguration：开启自动配置功能；
以前我们需要配置的东西，Spring Boot帮我们自动配置；@EnableAutoConﬁguration告诉SpringBoot开启自动配置功能；这样自动配置才能生效；
@AutoConfigurationPackage自动配置包
—>

@Import(AutoConﬁgurationPackages.Registrar.class)：
Spring的底层注解@Import，给容器中导入一个组件；导入的组件由 AutoConﬁgurationPackages.Registrar.class；
将主配置类（@SpringBootApplication标注的类）的所在包（在本人例子中为com.nyb.springboot04web）及下面所有子包里面的所有组件扫描到Spring容器；
@Import({AutoConfigurationImportSelector.class})
给容器中导入组件
AutoConfigurationImportSelector决定导入哪些组件的选择器，将所有需要导入的组件以全类名的方式返回，这些组件就会被添加到容器中；会给容器中导入非常多的自动配置类（可以debug查看），就是给容器中导入这个场景需要的所有组件，并配置好这些组件。
在这里插入图片描述
有了自动配置类就，省去了我们手动编写配置注入功能组件工作的麻烦
从下面加载自动配置类
SpringFactoriesLoader.loadFactoryNames(EnableAutoConﬁguration.class ,classLoader)；

Spring Boot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConﬁguration指定的值，将这些值作为自动配置类导入到容器中，自动配置类就生效，帮我们进行自动配置工作；以前我们需要自己配置的东西，自动配置类都帮我们；
J2EE的整体整合解决方案和自动配置都在spring-boot-autoconﬁgure-1.5.9.RELEASE.jar；

个人认为springboot加载meta-Inf下的factories中的自动配置类到容器中原理还是加载了下载类的配置，也就是说springboot已经将我们需要的组件的各项参数配置好了。

4.使用spring initializer快速创建项目，
直接创建项目，之后可以通过Maven中的刷新按钮将没导入的包导入进来
在编写controller的时候 @Responsebody将这个类所有返回方法的返回数据直接写给浏览器，（如果是对象转为Json数据）

默认生成的Spring Boot项目的特点：
主程序已经生成好了，我们只需要我们自己的逻辑
resources文件夹中目录结构
、 static：保存所有的静态资源； js css images；
、 templates：保存所有的模板页面；（Spring Boot默认jar包使用嵌入式的Tomcat，默认不支持JSP页面）；可以使用模板引擎（freemarker、thymeleaf）；
、 application.properties：Spring Boot应用的配置文件；可以修改一些默认设置；

二.Spring Boot配置文件

1.配置文件
SpringBoot使用一个全局的配置文件，配置文件名是固定的； •application.properties
•application.yml
配置文件的作用：修改Spring Boot的默认配置

2.YAML
1）、特点

标记语言：
以前的配置文件；大多都使用的是 xxxx.xml文件；
YAML：以数据为中心，比json、xml等更适合做配置文件；
YAML：配置例子

server:
  port: 8081

xml:
<server> <port>8081</port> </server>
xml的大量数据都浪费在了标签上，体现出yaml以数据为中心。

2）、yaml语法
k:(空格)v 表示一对键值对（空格必须有）；冒号后必须有空格
以空格的缩进来控制层级关系；只要是左对齐的一列数据，都是同一个层级的

server:
  port: 8081
  path: /hello

属性和值也是大小写敏感

3.值的写法
1）、字面量：普通的值（数字，字符串，布尔

k: v：字面直接来写；
字符串默认不用加上单引号或者双引号；
" "：双引号；不会转义字符串里面的特殊字符；特殊字符会作为本身想表示的意思
name: “zhangsan \n lisi”：输出；zhangsan 换行 lisi

’ '：单引号；会转义特殊字符，特殊字符终只是一个普通的字符串数据
name: ‘zhangsan \n lisi’：输出；zhangsan \n lisi
2）、对象、Map（属性和值）（键值对）：

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

friends: 
  lastName: zhangsan          
  age: 20

行内写法：

friends: {lastName: zhangsan,age: 18}

3）、数组（List、Set）
用-值表示数组中的一个元素

pets:  
  ‐ cat  
  ‐ dog  
  ‐ pig

行内写法

pets: [cat,dog,pig]

4.配置文件值注入
配置文件

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 = "department")
public class Department {

想要在写Yaml等的配置文件时有提示要导入依赖包

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

注意：
解决导入配置文件但是不生效的问题—>用Ctrl+f5刷新项目即可

1）、properties配置文件在idea中默认utf-8可能会乱码（因为我们在文件中默认是utf-8编码，而运行的时候自动会转换成ascii码）所以我们要在编译前进行转换
在这里插入图片描述
2）、@Value获取值和@ConﬁgurationProperties获取值比较

在这里插入图片描述
配置文件是properties还是yaml他们都能获取到值

如果说，我们只是在某个业务逻辑中需要获取一下配置文件中的某项值，使用@Value；如果说，我们专门编写了一个javaBean来和配置文件进行映射，我们就直接使用@ConﬁgurationProperties；

3）、还可以对配置文件注入值进行数据校验
在这里插入图片描述

4）、@PropertySource&@ImportResource&@Bean

@PropertySource
因为@ConfigurationProperties默认从全局配置文件（application.properties/application.yaml）中获取值，所以
@PropertySource：加载指定的配置文件；把一些与Spring Boot无关的配置配置在指定的配置文件例如：person.properties
在这里插入图片描述
@ImportResource：导入Spring的配置文件，让配置文件里面的内容生效；
spring boot里面没有spring配置文件，我们自己编写的配置文件也不能被自动识别，想让spring的配置文件生效，加载进ioc容器，就用
@ImportResource 标注在一个配置类上


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

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

}

但是我们一般不编写Spring的配置文件
在这里插入图片描述
太麻烦了，Spring Boot推荐使用全注解的方式给容器中添加组件：

配置类@Conﬁguration------>Spring配置文件
使用@Bean给容器中添加组件

@Configuration
//@Configuration指明当前类是一个配置类，就是来替代之前的Spring配置文件
//在配置文件中使用<bean></bean>来添加组件
public class MyMvcController implements WebMvcConfigurer {
    @Bean
    //@Bean的作用是将方法的返回值添加到容器中，容器中这个组件的默认id就是方法名
    public WebMvcConfigurationSupport webMvcConfigurationSupport(){
        WebMvcConfigurationSupport webMvcConfigurationSupport=new WebMvcConfigurationSupport(){

这个类相当于给容器中添加了一个WebMvcConfigurationSupport组件。

5.配置占位符
1）、可以用来取随机数

${radom.value},$ {radom.int}, ${radom.long},$ {radom.int[10]}等

2）、可以用来获取之前配置的值，没有则取冒号之后的值

例如：person.dog.name=${person.name:hello}_dog//意思是获取person的值再加上dog，如果之前没有person的值则为hello。

6.profile

1）、多profile

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

spring.profiles.active=cn//改变配置文件位置

2）、yaml支持多文档块的方式

server:
  port: 8080
spring:
  profiles:
    active: dev
---
server:
  port: 8081
spring:
  profiles: dev
---
server:
  port: 8082
spring:
  profiles: prod

3）、激活指定的profile

在配置文件中指定要激活的配置文件spring.profiles.active=profile
命令行激活
（1）可以在项目配置中

（2）可以打包成jar包之后在命令行执行
java -jar spring-boot-04-web-restfulcrud-0.0.1-SNAPSHOT.jar --spring.profiles.active=prod

（3）虚拟机参数
-D是固定写法

7.配置文件加载位置
spring boot启动会扫描一下位置的application.properties或者yml文件座位spring boot的默认配置文件
–ﬁle:./conﬁg/ （根路径下）
–ﬁle:./
–classpath:/conﬁg/ （类路径下）
–classpath:/
优先级从高到低，高优先级的会覆盖低优先级的配置
spring boot会从这四个位置全部加载主配置文件，互补配置

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

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

java -jar spring-boot-04-web-restfulcrud-0.0.1-SNAPSHOT.jar --spring.config.location=D:/application.properties

8.外部加载配置顺序
SpringBoot也可以从以下位置加载配置；优先级从高到低；高优先级的配置覆盖低优先级的配置，所有的配置会形成互补配置
1）、命令行参数
所有的配置都可以在命令行上进行指定
java -jar spring-boot-02-conﬁg-02-0.0.1-SNAPSHOT.jar --server.port=8087 --server.context-path=/abc 多个配置用空格分开； --配置项=值
2）、来自java:comp/env的JNDI属性
3）、Java系统属性（System.getProperties()）
4）、操作系统环境变量
5）、RandomValuePropertySource配置的random.*属性值
由jar包外向jar包内进行寻找；优先加载带proﬁle
6）、jar包外部的application-{proﬁle}.properties或application.yml(带spring.proﬁle)配置文件
7）、jar包内部的application-{proﬁle}.properties或application.yml(带spring.proﬁle)配置文件
再来加载不带proﬁle
8）、jar包外部的application.properties或application.yml(不带spring.proﬁle)配置文件
9）、jar包内部的application.properties或application.yml(不带spring.proﬁle)配置文件
10）、@Conﬁguration注解类上的@PropertySource
11）、通过SpringApplication.setDefaultProperties指定的默认属性

9.自动配置原理
自动配置原理：
1）、SpringBoot启动的时候加载主配置类，开启了自动配置功能 @EnableAutoConﬁguration
2）、@EnableAutoConﬁguration 作用：

利用EnableAutoConﬁgurationImportSelector给容器中导入一些组件？
可以查看getCandidateConfigurations方法的内容；

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
        return configurations;
    }

再点进SpringFactoriesLoader查看

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            try {
                Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                LinkedMultiValueMap result = new LinkedMultiValueMap();

                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();

                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryTypeName = ((String)entry.getKey()).trim();
                        String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        int var10 = var9.length;

                        for(int var11 = 0; var11 < var10; ++var11) {
                            String factoryImplementationName = var9[var11];
                            result.add(factoryTypeName, factoryImplementationName.trim());
                        }
                    }
                }

                cache.put(classLoader, result);
                return result;

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

public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}//这个类与properties中的enableautoconfiguration类是对应的

然后把他们添加在容器中

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

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.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration,\
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.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRestClientAutoConfiguration,\
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.r2dbc.R2dbcDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.r2dbc.R2dbcRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.r2dbc.R2dbcTransactionManagerAutoConfiguration,\
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.ElasticsearchRestClientAutoConfiguration,\
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
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.jersey.JerseyAutoConfiguration,\
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration,\
org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
org.springframework.boot.autoconfigure.availability.ApplicationAvailabilityAutoConfiguration,\
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.r2dbc.R2dbcAutoConfiguration,\
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

每一个这样的 xxxAutoConﬁguration类都是容器中的一个组件，都加入到容器中；用他们来做自动配置；
3）、每一个自动配置类进行自动配置功能；
4）、以HttpEncodingAutoConﬁguration（Http编码自动配置）为例解释自动配置原理；

@Configuration(
    proxyBeanMethods = false
)//表示这是一个配置类，以前编写的配置文件一样，可以向容器中添加组件
@EnableConfigurationProperties({ServerProperties.class})//表示启动指定类的configurationProperties功能，将配置文件中对应的值和serverproperties绑定起来;并把ServerProperties加入到IOC容器中
@ConditionalOnWebApplication(
    type = Type.SERVLET
)//spring底层@condition注解，根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效；   判断当前应用是不是web应用，如果是当前配置类生效
@ConditionalOnClass({CharacterEncodingFilter.class})//判断当前项目有没有这个类characterencodingfilter；springMVC中解决乱码的过滤器
@ConditionalOnProperty(
    prefix = "server.servlet.encoding",
    value = {"enabled"},
    matchIfMissing = true
)//判断配置文件中是否存在某个配置server.servlet.encoding，如果不存在判断也是成立的
public class HttpEncodingAutoConfiguration {
    private final Encoding properties;//他已经和SpringBoot的配置文件映射了 
    //只有一个有参构造器的情况下，参数的值就会从容器中拿
    public HttpEncodingAutoConfiguration(ServerProperties properties) {
        this.properties = properties.getServlet().getEncoding();
    }
    @Bean//给容器中添加一个组件，这个组件的某些值需要从properties中获取 
    @ConditionalOnMissingBean//判断容器没有这个组件
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
        filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.web.servlet.server.Encoding.Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.web.servlet.server.Encoding.Type.RESPONSE));
        return filter;
    }

上面第二行的类点进去发现：
说明所有在配置文件中能配置的属性都是在xxxxProperties类中封装着；配置文件能配置什么就可以参照某个功能对应的这个属性类


@ConfigurationProperties(
    prefix = "server",
    ignoreUnknownFields = true
)//从配置文件中获取指定的值和bean的属性进行绑定
public class ServerProperties {

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

精髓：

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

xxxxAutoConﬁgurartion：自动配置类；
给容器中添加组件

细节：conditional
@Conditional派生注解（Spring注解版原生的@Conditional作用）
作用：必须是@Conditional指定的条件成立，才给容器中添加组件，配置配里面的所有内容才生效；

自动配置类必须在一定的条件下才能生效；
我们怎么知道哪些自动配置类生效；
我们可以通过启用 debug=true属性；来让控制台打印自动配置报告，这样我们就可以很方便的知道哪些自动配置类生效；


Negative matches://没有启动的，没有匹配成功的自动配置类
-----------------

   ActiveMQAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'javax.jms.ConnectionFactory' (OnClassCondition)

Positive matches://自动匹配类启用成功的
-----------------

   AopAutoConfiguration matched:
      - @ConditionalOnProperty (spring.aop.auto=true) matched (OnPropertyCondition)

三、日志

1.日志框架

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

1）、System.out.println(“”)；将关键数据打印在控制台；去掉？写在一个文件？
2）、框架来记录系统的一些运行时信息；日志框架； zhanglogging.jar；
3）、高大上的几个功能？异步模式？自动归档？xxxx？ zhanglogging-good.jar？

4）、将以前框架卸下来？换上新的框架，重新修改之前相关的API；zhanglogging-prefect.jar；
5）、JDBC—数据库驱动；

写了一个统一的接口层；日志门面（日志的一个抽象层）；logging-abstract.jar；
给项目中导入具体的日志实现就行了；我们之前的日志框架都是实现的抽象层；
***市面上的日志框架
在这里插入图片描述
左边选一个门面（抽象层）、右边来选一个实现；
日志门面： SLF4J；日志实现：Logback；
SpringBoot：底层是Spring框架，Spring框架默认是用JCL；‘
SpringBoot选用 SLF4j和logback；

2.SLF4j使用
1）、如何在SpringBoot中使用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以后，配置文件还是做成日志实现框架自己本身的配置文件； 也就是说加入实现框架是log4j就要用log4j的配置文件

2）、遗留问题
a（slf4j+logback）: Spring（commons-logging）、Hibernate（jboss-logging）、MyBatis、xxxx
统一日志记录，即使是别的框架如何和我一起统一使用slf4j进行输出？
在这里插入图片描述

如何让系统中所有的日志都统一到slf4j；
1、将系统中其他日志框架先排除出去；（先删除掉原本的日志框架）
2、用中间包来替换原有的日志框架； （中间包已经包含了原本的框架，并且还加入了适配slf4j的jar包起到一个适配层的作用）
3、我们导入slf4j其他的实现

3、SpringBoot日志关系
点进pom中右键Diagrams展示jar包依赖关系

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

依赖

<dependency>//springBoot 使用它来做日志功能
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-logging</artifactId>
      <version>2.3.3.RELEASE</version>
      <scope>compile</scope>
    </dependency>

底层依赖关系：
在这里插入图片描述

总结：

1）、SpringBoot底层也是使用slf4j+logback的方式进行日志记录
2）、SpringBoot也把其他的日志都替换成了slf4j；
3）、中间替换包的作用？
在这里插入图片描述
也就是说在中间替换包中，虽然门面上是log4j但是在实际的jar包中的实现细节其实早就换成了slf4j

4）、如果我们要引入其他框架？一定要把这个框架的默认日志依赖移除掉？
比如Spring框架用的是commons-logging；在spring Boot的spring-boot-starter-logging中就把commons-logging排除掉了

<dependency>          
    <groupId>org.springframework</groupId>  
                <artifactId>spring‐core</artifactId>   
                           <exclusions>            
                             <exclusion>   
                                  <groupId>commons‐logging</groupId>                
                                                  <artifactId>commons‐logging</artifactId>               
                             </exclusion>                  
                            </exclusions>         
</dependency>

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

4.日志使用
1）、默认配置
springBoot默认帮我们配置好了日志。


    Logger logger = LoggerFactory.getLogger(getClass());
    @Test
    void contextLoads() {


      //日志级别由低到高，可以调整日志的级别，日志只会在更高级别后生效
       logger.trace("这是跟踪信息");
       logger.debug("这是debug日志");
       //sprig Boot 默认给我们使用的日志输出级别是info,自己没有指定就用spring默认规定的级别：root
       logger.info("这是info信息");
       logger.warn("这是warn信息");
       logger.error("这是错误信息");

在application.properties中可对日志进行配置

logging.level.root=info   
#这是整个springboot 项目的日志配置，一般是info级别，过低则会导致各种错误（trace和debug）
logging.level.com.nyb.springboot04web=trace
#这是指定某个文件的日志级别，让该文件下的日志输出设置为某级别

配置输出日志文件

#在当前项目新建一个spring.log文件夹并在该文件夹下生成spring.log日志文件
logging.file.path=spring.log
#在当期项目下生成一个spring.log日志文件
logging.file.name=spring.log

logging.file.path=D:/spring.log  //也可以指定在电脑文件夹下生成日志文件

还可以用
logging.pattern.console=配置控制台的日志输出格式
logging.pattern.file=配置文件中日志的输出格式

springboot的日志配置都可以在下列文件中查看
在这里插入图片描述
2）、指定配置
给类路径下放上每个日志框架自己的配置文件（可从上图中的logback中找到再修改）即可；SpringBoot就不使用他默认配置的了

logback.xml：直接就被日志框架识别了；
logback-spring.xml：日志框架就不直接加载日志的配置项，由SpringBoot解析日志配置，可以使用SpringBoot 的高级Proﬁle功能，比直接用logback的功能更强。

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

可以在多个springProfile中写不同的name，然后在配置文件中指定要生效的name即可。

5.切换日志框架
可以按照slf4j的日志适配图，进行相关的切换；
slf4j+log4j的方式；
先将logback和log4j-to-slf4j排除掉

<exclusions> </exclusions>

再导入slf4j-log4j12.jar进行适配，这个自动会导入剩下的log4j包，还可能需要配置相应的XML文件使其正常运行。

切换日志框架的时候我们只要按照官方图谱来做就行。

四.web开发

1.简介

使用springboot：
1）、创建SpringBoot应用，选中我们需要的模块；
2）、SpringBoot已经默认将这些场景配置好了，只需要在配置文件中指定少量配置就可以运行起来
3）、自己编写业务代码；

自动配置原理：
这个场景SpringBoot帮我们配置了什么？能不能修改？能修改哪些配置？能不能扩展？xxx

xxxxAutoConfiguration：这些类帮我们给容器中自动配置组件；用注解@EnableAutoConfiguration
xxxxProperties:这些配置类来封装配置文件的内容；用注解@ConfigurationProperties

在web开发中@Responsebody能让return返回的字符串或者对象直接以json形式返回到网页

2.springboot对静态资源的映射规则

1）、所有 /webjars/** ，都去 classpath:/META-INF/resources/webjars/ 找资源；（表示webmvc将在classpath:/META-INF/resources/webjars/目录下找所有 /webjars/** 映射的资源）

public void addResourceHandlers(ResourceHandlerRegistry registry) {
            if (!this.resourceProperties.isAddMappings()) {
                logger.debug("Default resource handling disabled");
            } else {
                Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
                CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
                if (!registry.hasMappingForPattern("/webjars/**")) {
                    this.customizeResourceHandlerRegistration(registry.addResourceHandler(new String[]{"/webjars/**"}).addResourceLocations(new String[]{"classpath:/META-INF/resources/webjars/"}).setCachePeriod(this.getSeconds(cachePeriod)).setCacheControl(cacheControl));
                }

                String staticPathPattern = this.mvcProperties.getStaticPathPattern();
                if (!registry.hasMappingForPattern(staticPathPattern)) {
                    this.customizeResourceHandlerRegistration(registry.addResourceHandler(new String[]{staticPathPattern}).addResourceLocations(WebMvcAutoConfiguration.getResourceLocations(this.resourceProperties.getStaticLocations())).setCachePeriod(this.getSeconds(cachePeriod)).setCacheControl(cacheControl));
                }

            }
        }

此方法需要去webjars官网中导入相应的jar包依赖
2）、"/**"访问当前项目任何资源（可以从下面代码中看到添加了一个路径staticPathPattern，而这个路劲又是通过this.mvcProperties.getStaticPathPattern() 获取的，我们查看getStaticPathPattern就可以查看到这个路径 "/ ** "）。

String staticPathPattern = this.mvcProperties.getStaticPathPattern();
                if (!registry.hasMappingForPattern(staticPathPattern)) {
                    this.customizeResourceHandlerRegistration(registry.addResourceHandler(new String[]{staticPathPattern}).addResourceLocations(WebMvcAutoConfiguration.getResourceLocations(this.resourceProperties.getStaticLocations())).setCachePeriod(this.getSeconds(cachePeriod)).setCacheControl(cacheControl));
                }

然后我们又可以看到在这之后又addResourceLocations，里面的参数的方法getStaticLocations()最终得到的是一个：

private static final String[] CLASSPATH_RESOURCE_LOCATIONS = new String[]{
"classpath:/META-INF/resources/", 
"classpath:/resources/", 
"classpath:/static/", 
"classpath:/public/"};

综上：也就是说访问路径的时候，只要没人处理，都会在上面那些静态资源文件夹下找
比如访问localhost:8080/abc === 没人处理就要去静态资源文件夹里面找abc

3）、欢迎页

@Bean
        public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext, FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
            WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(new TemplateAvailabilityProviders(applicationContext), applicationContext, this.getWelcomePage(), this.mvcProperties.getStaticPathPattern());
            welcomePageHandlerMapping.setInterceptors(this.getInterceptors(mvcConversionService, mvcResourceUrlProvider));
            welcomePageHandlerMapping.setCorsConfigurations(this.getCorsConfigurations());
            return welcomePageHandlerMapping;
        }
        private Optional<Resource> getWelcomePage() {
            String[] locations = WebMvcAutoConfiguration.getResourceLocations(this.resourceProperties.getStaticLocations());
            return Arrays.stream(locations).map(this::getIndexHtml).filter(this::isReadable).findFirst();
        }

可以看到这个函数传入三个参数进行递归查找，而传入的最后一个参数是上面介绍的那些静态文件夹路径。
就是说静态资源文件夹下的所有index.html页面；被"/** "映射；
比如localhost:8080/就会到所有的静态资源文件夹下找index页面(可加可不加.html),而当它在静态资源文件夹下的asserts文件下时，则要通过localhost:8080/asserts/index.html才能访问(必须加.html),这个跟welcomepage的源码有关。

4）、所有的/ **/favicon.ico 都是在静态资源文件下找；(因为springboot设置了格式为favicon.ico格式的文件为图标文件，并且在静态资源文件夹下扫描这类文件。)
这里默认的只能放在静态资源文件夹下，不能放在静态资源文件下更深的文件夹下（暂时还不知道为什么。。。）。

3.模板引擎
为什么要用模板引擎？。。。。因为springboot自带的Tomcat不支持jsp功能，而静态页面又太鸡肋。
JSP、Velocity、Freemarker、Thymeleaf都是模板引擎
模板引擎的思想：
在这里插入图片描述
springboot推荐thymeleaf，功能强大语法简单。
1）、引入Thymeleaf。

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

2）、thymeleaf使用

@ConfigurationProperties(
    prefix = "spring.thymeleaf"
)
public class ThymeleafProperties {
    private static final Charset DEFAULT_ENCODING;
    public static final String DEFAULT_PREFIX = "classpath:/templates/";
    public static final String DEFAULT_SUFFIX = ".html";
    private boolean checkTemplate = true;
    private boolean checkTemplateLocation = true;
    private String prefix = "classpath:/templates/";
    private String 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</title>
</head>
<body>
<div th:text="${hello}"></div>
</body>
</html>

public class HelloController {
    @RequestMapping("/hello")
    public String hello(Map<String,Object> map){
        map.put("hello","你好");
        return "hello";
    }

**注意：在controller中不能加@ResponseBody，否则会返回json字符串（return中的字符）
3、语法规则
th:text；改变当前元素里面的文本内容；
th：任意html属性；来替换原生属性的值（<div th:text=“${hello}”></div>会覆盖掉<div id=“hello”>hello</div>）

在这里插入图片描述
遍历数组元素：

<body>
<h2> thymeleaf</h2>
<div th:text="${user}"></div>
<h4 th:text="${use}" th:each="use:${user}"></h4>
<h4>
    <span th:each="use:${user}">[[${use}]]</span>
</h4>
</body>

其他thymeleaf语法在这里不过多阐述。

4.SpringMvc自动配置

1）、Spring Boot 自动配置好了SpringMvc
以下是SpringBoot对SpringMvc的默认配置

Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans.
- 自动配置了ViewResolver（视图解析器：根据方法的返回值得到视图对象（View），视图对象决定如何渲染（转发？重定向？））
- ContentNegotiatingViewResolver：可以找到它里面有下列方法组合所有的视图解析器让其解析视图；
- 如何定制：我们可以自己给容器中添加一个视图解析器；自动的将其组合进来

public void setViewResolvers(List<ViewResolver> viewResolvers) {
        this.viewResolvers = viewResolvers;
    }

支持 serving static resources, including support for WebJars (covered later in this document)).静态资源文件夹路径和webjars下的路径访问
自动注册了 Converter, GenericConverter, and Formatter beans.
- Converter：转换器； public String hello(User user)：类型转换使用Converter （比如页面提交文本18将它转换为Integer对象）
- Formatter 格式化器； 2017.12.17等转换为Date类型；
  可以在下面发现format是得到配置中的getFormat方法，然后再找下去可以发现下面的代码，应该是配置了就用配置了的，没配就用默认的。

@Bean
        public FormattingConversionService mvcConversionService() {
            Format format = this.mvcProperties.getFormat();
            WebConversionService conversionService = new WebConversionService((new DateTimeFormatters()).dateFormat(format.getDate()).timeFormat(format.getTime()).dateTimeFormat(format.getDateTime()));
            this.addFormatters(conversionService);
            return conversionService;
        }

 @Deprecated
    @DeprecatedConfigurationProperty(
        replacement = "spring.mvc.format.date"
    )
    public String getDateFormat() {
        return this.format.getDate();
    }

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

Support for HttpMessageConverters (covered later in this document).
- HttpMessageConverter：转换器：SpringMVC用来转换Http请求和响应的；User—Json
- 当类只有一个有参构造器的情况下，参数的值要从容器中拿，所以查看源代码可以发现HttpMessageConverter是从容器中拿的：从容器中获取所有的HttpMessageConverter。所有我们自己给容器中添加HttpMessageConverter，只需要将自己的组件注册容器中（@Bean,@Component）
Automatic registration of MessageCodesResolver (covered later in this document).（定义错误代码生成规则）
Static index.html support.静态首页访问
Custom Favicon support (covered later in this document).设置在静态资源文件夹下寻找favicon.ico文件作为图标。
Automatic use of a ConfigurableWebBindingInitializer bean (covered later in this document).我们也可以配置一个ConﬁgurableWebBindingInitializer来替换默认的；（添加到容器）它的作用：初始化WebDataBinder；webDateBinder的作用是将页面数据与我们的javaBean绑定

org.springframework.boot.autoconﬁgure.web包下的…AutoConfiguration：配置了web的所有自动配置场景；

2）、扩展SpringMvc功能
编写一个配置类（@Conﬁguration），是WebMvcConﬁgurer类型（实现这个接口）；不能标注@EnableWebMvc;
既保留了所有的自动配置，也能用我们扩展的配置；

//使用WebMvcConfigurerAdapter可以来扩展SpringMVC的功能 
@Configuration
public class MyMvcConfig implements WebMvcConfigurer {
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/success").setViewName("hello");//浏览器发送/success请求来到hello页面
    }

原理：
1、WebMvcAutoConﬁguration是SpringMVC的自动配置类
2、在这个自动配置类中有个WebMvcAutoConfigurationAdapter实现了WebMvcConfigurer接口，它做其他自动配置时会导入@Import(EnableWebMvcConﬁguration.class)，点进去会发现它继承下面的类DelegatingWebMvcConfiguration

@Configuration(
        proxyBeanMethods = false
    )
    public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration implements ResourceLoaderAware {

而从DelegatingWebMvcConfiguration中又会发现它将容器中所有的WebMvcConfigurer取出来给这个类的configurers，

@Configuration(
    proxyBeanMethods = false
)
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
    private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();

    public DelegatingWebMvcConfiguration() {
    }

    @Autowired(
        required = false
    )//@Autowired放在方法前方法的参数会从容器中获取
    public void setConfigurers(List<WebMvcConfigurer> configurers) {
        if (!CollectionUtils.isEmpty(configurers)) {
            this.configurers.addWebMvcConfigurers(configurers);
        }

    }

而我们从这个类又会发现很多实现方法，比如下面的

protected void addViewControllers(ViewControllerRegistry registry) {
        this.configurers.addViewControllers(registry);
    }

它就是用的这个类中的configurers，configurers实现方法addViewControllers（），再看下面的函数可以看出递归将所有WebMvcConfigurers 的configurer调用addViewControllers（）加入ViewControllers。

 public void addViewControllers(ViewControllerRegistry registry) {
        Iterator var2 = this.delegates.iterator();

        while(var2.hasNext()) {
            WebMvcConfigurer delegate = (WebMvcConfigurer)var2.next();
            delegate.addViewControllers(registry);
        }

这样可以实现我们的配置和容器中自带的配置一起生效。
3）、全面接管SpringMvc
SpringBoot对SpringMVC的自动配置不需要了，所有都是我们自己配置；所有的SpringMVC的自动配置都失效了
我们只需要在配置类中添加@EnableWebMvc即可；

@EnableWebMvc
@Configuration
public class MyMvcConfig implements WebMvcConfigurer {

原理：
为什么加了这个注解之后自动配置就失效了
1、@EnableWebMvc的核心：导入一个DelegatingWebMvcConfiguration

@Import({DelegatingWebMvcConfiguration.class})
public @interface EnableWebMvc {
}

点进去发现下列代码，是不是发现与我们之前SpringMvc的扩展很像，再看它的父类也没发现任何问题，

public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
    private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();

    public DelegatingWebMvcConfiguration() {
    }

    @Autowired(
        required = false
    )
    public void setConfigurers(List<WebMvcConfigurer> configurers) {
        if (!CollectionUtils.isEmpty(configurers)) {
            this.configurers.addWebMvcConfigurers(configurers);
        }

但是！！！当我们回过头去看WebMvcAutoConfiguration时就能找出原因

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
@ConditionalOnClass({Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class})
@ConditionalOnMissingBean({WebMvcConfigurationSupport.class})
@AutoConfigureOrder(-2147483638)
@AutoConfigureAfter({DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class, ValidationAutoConfiguration.class})
public class WebMvcAutoConfiguration {

我们可以看到@ConditionalOnMissingBean({WebMvcConfigurationSupport.class})这一行表示容器中没有这个组件的时候，这个自动配置类才生效，而@EnableWebMvc将WebMvcConﬁgurationSupport组件导入进来了，导入的WebMvcConﬁgurationSupport只是SpringMVC基本的功能，其他的功能如视图解析器等都需要我们自己去配置

5.如何修改SpringBoot的默认配置
模式：
1）、SpringBoot在自动配置很多组件的时候，先看容器中有没有用户自己配置的（@Bean、@Component）如果有就用用户配置的，如果没有，才自动配置；如果有些组件可以有多个（比如ViewResolver）将用户配置的和自己默认的组合起来
2）、在SpringBoot中会有非常多的xxxConﬁgurer帮助我们进行扩展配置
3）、在springboot中会有很多的xxxCustomizer帮助我们进行定制配置（见7、8节）

6.RestfulCRUD实验
1）、默认访问首页

//@EnableWebMvc不要全面接管WebMvc
@Configuration
public class MyMvcConfig implements WebMvcConfigurer {
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/success").setViewName("hello");
    }
    //除此之外还可以用下面的实现抽象类的抽象方法返回一个对象；
    //所有的WebMvcConfigurer组件都会一起起作用
    @Bean//将组件注册在容器中
    public WebMvcConfigurer webMvcConfigurer(){
        WebMvcConfigurer webMvcConfigurer=new WebMvcConfigurer() {
            @Override
            public void addViewControllers(ViewControllerRegistry registry) {
                registry.addViewController("/").setViewName("login");
                registry.addViewController("/index.html").setViewName("login");
            }
        };
        return webMvcConfigurer;
    }
}

后面的那个方法一定要加@Bean否则不会注册组件,这种用抽象方法构造个人非常喜欢。
2）、国际化（国际化的自动配置应该可以在MessageSourceAutoConfiguration类中找到）
以前我们在SpringMvc中要做以下步骤，而现在我们在SpringBoot中都默认配置好了所以只需要做第一步：
1、编写国际化配置
2、使用ResourceBundleMessageSource管理国际化资源文件
3、在页面使用fmt:message取出国际化内容
步骤：
1、在静态资源文件夹下New一个i18n包再new一个login.properties，再new一个login_zh_CN.properties文件，idea就能识别到你要做国际化内容，然后你只需要new其他的国际语言文件就可以了。点进properties里面就会发现下面有一个Resource Bundle，点击就能更方便的编写一一对应的配置
在这里插入图片描述
2、SpringBoot自动配置好了管理国际化资源文件的组件；

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnMissingBean(
    name = {"messageSource"},
    search = SearchStrategy.CURRENT
)
@AutoConfigureOrder(-2147483648)
@Conditional({MessageSourceAutoConfiguration.ResourceBundleCondition.class})
@EnableConfigurationProperties
public class MessageSourceAutoConfiguration {
    private static final Resource[] NO_RESOURCES = new Resource[0];

    public MessageSourceAutoConfiguration() {
    }

    @Bean
    @ConfigurationProperties(
        prefix = "spring.messages"
    )
    public MessageSourceProperties messageSourceProperties() {
        return new MessageSourceProperties();
    }

    @Bean
    public MessageSource messageSource(MessageSourceProperties properties) {
        ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
        if (StringUtils.hasText(properties.getBasename())) {
//这个设置国际化资源文件的基础名（去掉语言国家代码的）
            messageSource.setBasenames(StringUtils.commaDelimitedListToStringArray(StringUtils.trimAllWhitespace(properties.getBasename())));
        }

        if (properties.getEncoding() != null) {
            messageSource.setDefaultEncoding(properties.getEncoding().name());
        }

        messageSource.setFallbackToSystemLocale(properties.isFallbackToSystemLocale());
        Duration cacheDuration = properties.getCacheDuration();
        if (cacheDuration != null) {
            messageSource.setCacheMillis(cacheDuration.toMillis());
        }

        messageSource.setAlwaysUseMessageFormat(properties.isAlwaysUseMessageFormat());
        messageSource.setUseCodeAsDefaultMessage(properties.isUseCodeAsDefaultMessage());
        return messageSource;
    }

点进上面设置基础名的getBasename()方法可以在这个类中发现：

public String getBasename() {
        return this.basename;
    }

    public void setBasename(String basename) {
        this.basename = basename;
    }

public class MessageSourceProperties {
    private String basename = "messages";

所以我们的配置文件可以直接放在类路径下叫messages.properties，这是默认配置，而我们可以修改配置，在application.properties中配置

spring.messages.basename=i18n.login

3、去页面获取国际化的值；
先修改乱码问题，file->otherSetting->Settingfornewprojects->file encoding
在这里插入图片描述

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
		<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
		<meta name="description" content="">
		<meta name="author" content="">
		<title>Signin Template for Bootstrap</title>
		<!-- Bootstrap core CSS -->
		<link href="asserts/css/bootstrap.min.css" th:href="@{/webjars/bootstrap/4.5.0/css/bootstrap.css}" rel="stylesheet">
		<!-- Custom styles for this template -->
		<link href="asserts/css/signin.css" th:href="@{/asserts/css/signin.css}" rel="stylesheet">
	</head>

	<body class="text-center">
		<form class="form-signin" action="dashboard.html" th:action="@{/user/login}" method="post">
			<img class="mb-4" src="asserts/img/bootstrap-solid.svg" th:src="@{/asserts/img/bootstrap-solid.svg}" alt="" width="72" height="72">
			<h1 class="h3 mb-3 font-weight-normal" th:text="#{login.tip}">Please sign in</h1>
			<p style="color: red" th:text="${message}" th:if="${not #strings.isEmpty(message)}"></p>
			<label class="sr-only"  th:text="#{login.username}">Username</label>
			<input type="text" class="form-control" name="username" placeholder="Username" th:placeholder="#{login.username}" required="" autofocus="">
			<label class="sr-only"  th:text="#{login.password}">Password</label>
			<input type="password" class="form-control" name="password" placeholder="Password" th:placeholder="#{login.password}" required="">
			<div class="checkbox mb-3">
				<label>
				<input type="checkbox" value="remember-me"/> [[#{login.remember}]]<!--	没有标签体，所以我们用行内表达式-->
				</label>
			</div>
			<button class="btn btn-lg btn-primary btn-block" type="submit" th:text="#{login.btn}">Sign in</button>
			<p class="mt-5 mb-3 text-muted">© 2017-2018</p>
			<a class="btn btn-sm" >中文</a>
			<a class="btn btn-sm" >English</a>
		</form>

	</body>

</html>

效果：根据浏览器语言设置的信息切换了国际化；
原理：

国际化Locale（区域信息对象）；LocaleResolver（获取区域信息对象）；

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

默认的就是根据请求头带来的区域信息获取Locale进行国际化
4）、点击链接切换国际化
1、先实现LocalResolver

// 可以在连接上携带区域信息
public class MyLocalResolver implements LocaleResolver {
    @Override
    public Locale resolveLocale(HttpServletRequest httpServletRequest) {
       String l= httpServletRequest.getParameter("l");
       Locale locale=Locale.getDefault();
       if(!StringUtils.isEmpty(l)){
           String[] split=l.split("_");
           locale=new Locale(split[0],split[1]);
       }
       return locale;
    }

    @Override
    public void setLocale(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Locale locale) {

    }

2、再将自己实现的LocalResolver注入到容器中
注意：要在WebMvcConfigure中实现区域化信息的方法才能注入到容器让自动配置用我们写的解析器（因为我们之前说过要扩展SpringMvc功能
编写的配置类（@Conﬁguration），要是WebMvcConﬁgurer类型（实现这个接口））

 @Bean
    public LocaleResolver localeResolver(){
        return new MyLocalResolver();
    }

3）、登陆
开发期间模板引擎页面修改以后，要实时生效
1、禁用模板引擎的缓存

spring.thymeleaf.cache=false

2、页面修改完成以后ctrl+f9：重新编译；（只用于页面修改，项目刷新用ctrl+f5）

登陆错误消息的表达式

<p style="color: red" th:text="${message}" th:if="${not #strings.isEmpty(message)}"></p>拦截器进行登陆检查

4）、拦截器进行登陆检查
（因为我们在登陆成功过后刷新页面会有表单重新提交提示，我们不让他重新提交，而刷新页面是又发了一个User/login请求，为了防止表单重复提交我们要让他重定向到这个页面）
重定向：

return "redirect:/main.html";//"/"号表示重定向到根目录下，一定要加

在WebMvcConfigure中

registry.addViewController("main.html").setViewName("dashboard");

但是我们这样做会导致一个问题：用户直接发/main.htm请求会直接到后台页面，这个时候我们就需要做一个拦截器机制进行登录检查。
1、拦截器

public class LoginHandlerInterceptor implements HandlerInterceptor {
    /*登陆检查*/

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Object user=request.getSession().getAttribute("loginUser");//从前面处理登陆请求的session中获取用户名的值并判断是否为空
        if(user==null){
            request.setAttribute("message","没有权限，请先登陆！");
            request.getRequestDispatcher("/").forward(request,response);//转发到主页面
            return false;
        }else{
            return true;
        }

    }

2、将拦截器加入容器中

@Configuration
public class MyMvcConfig implements WebMvcConfigurer {
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/success").setViewName("hello");
    }
     //注册拦截器 
     //静态资源；  *.css , *.js ,**/webjars/**等,SpringBoot已经做好了静态资源映射 
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginHandlerInterceptor()).addPathPatterns("/**").excludePathPatterns("/","/index.html","/user/login","/asserts/**","/webjars/**");
    }

5）、CRUD-员工列表
实验要求：
1、RestfulCRUD：CRUD满足Rest风格
URI： /资源名称/资源标识 HTTP请求方式区分对资源CRUD操作

	普通CRUD（uri来区分操作）	RestfulCRUD
查询	getEmp	emp—GET
添加	addEmp?xxx	emp—POST
修改	updateEmp?id=xxx&xxx=xx	emp/{id}—PUT
删除	deleteEmp?id=1	emp/{id}—DELETE
2、实验的请求架构;
实验功能	请求URI	请求方式
----	----	-----
查询所有员工	emps	GET
查询某个员工（来到修改页面）	emp/{id}	GET
来到添加页面	emp	GET
添加员工	emp	POST
来到修改页面（查出员工进行信息回显）	emp{id}	GET
修改员工	emp	PUT
删除员工	emp/{id}	DELETE
3、员工列表
thymeleaf公共页面元素抽取

抽取公共片段

<div th:fragment="copy"> 
&copy; 2011 The Good Thymes Virtual Grocery 
</div>

引入公共片段
注意：模板名会使用thymeleaf的配置前后缀规则进行解析

<div th:insert="~{footer :: copy}"></div> 
~{templatename::selector}：模板名::选择器   //<div th:replace="~{dashboard::#sidebar}"></div>
~{templatename::fragmentname}:模板名::片段名 //我们用的是这种<div th:replace="dashboard::topbar"></div>

默认效果：

insert的公共片段在div标签中 
如果使用th:insert等属性进行引入，可以不用写~{}： 
行内写法可以加上：[[~{}]];[(~{})]；

三种引入公共片段的th属性：
th:insert：将公共片段整个插入到声明引入的元素中
th:replace：将声明引入的元素替换为公共片段
th:include：将被引入的片段的内容包含进这个标签中

<footer th:fragment="copy"> 
&copy; 2011 The Good Thymes Virtual Grocery 
</footer>   
引入方式 
<div th:insert="footer :: copy"></div>
<div th:replace="footer :: copy"></div> 
<div th:include="footer :: copy"></div> 
效果
<div>     
    <footer>     
    &copy; 2011 The Good Thymes Virtual Grocery     
    </footer> 
</div> 

<footer> 
     &copy; 2011 The Good Thymes Virtual Grocery 
</footer> 

<div> 
     &copy; 2011 The Good Thymes Virtual Grocery 
</div>

引入片段的时候传入参数（获取对应侧边栏的高亮样式横幅）
（在dashboard.html中引入侧边栏的时候就要传入参数main.html）

<body>
   <div th:replace="commons/bar::topbar"></div>

		<div class="container-fluid">
			<div class="row">
<!--                引入sidebar-->
				<div th:replace="~{commons/bar::#sidebar(activeUri='main.html')}"></div>

（在list.html中引入片段的时候就要传入参数emps）

<div class="container-fluid">
			<div class="row">
				<div th:replace="~{commons/bar::#sidebar(activeUri='emps')}"></div>

				<main role="main" class="col-md-9 ml-sm-auto col-lg-10 pt-3 px-4">
					<h2><a class="btn btn-sm btn-success" th:href="@{/emp}">员工添加</a></h2>

6）、CRUD-员工添加和员工修改二合一
页面

<div th:replace="commons/bar::topbar"></div>

		<div class="container-fluid">
			<div class="row">
				<!--引入侧边栏-->
				<div th:replace="commons/bar::#sidebar(activeUri='emps')"></div>

				<main role="main" class="col-md-9 ml-sm-auto col-lg-10 pt-3 px-4">
					<!--需要区分是员工修改还是添加；-->
					<form th:action="@{/emp}" method="post">
						<!--发送put请求修改员工数据-->
						<!--
						1、SpringMVC中配置HiddenHttpMethodFilter;（SpringBoot自动配置好的）
						2、页面创建一个post表单
						3、创建一个input项，name="_method";值就是我们指定的请求方式
						-->
						<input type="hidden" name="_method" value="put" th:if="${emp!=null}"/>
						<input type="hidden" name="id" th:if="${emp!=null}" th:value="${emp.id}">
						<div class="form-group">
							<label>LastName</label>
							<input name="lastName" type="text" class="form-control" placeholder="zhangsan" th:value="${emp!=null}?${emp.lastName}">
						</div>
						<div class="form-group">
							<label>Email</label>
							<input name="email" type="email" class="form-control" placeholder="zhangsan@atguigu.com" th:value="${emp!=null}?${emp.email}">
						</div>
						<div class="form-group">
							<label>Gender</label><br/>
							<div class="form-check form-check-inline">
								<input class="form-check-input" type="radio" name="gender" value="1" th:checked="${emp!=null}?${emp.gender==1}">
								<label class="form-check-label">男</label>
							</div>
							<div class="form-check form-check-inline">
								<input class="form-check-input" type="radio" name="gender" value="0" th:checked="${emp!=null}?${emp.gender==0}">
								<label class="form-check-label">女</label>
							</div>
						</div>
						<div class="form-group">
							<label>department</label>
							<!--提交的是部门的id-->
							<select class="form-control" name="department.id">
								<option th:selected="${emp!=null}?${dept.id == emp.department.id}" th:value="${dept.id}" th:each="dept:${depts}" th:text="${dept.departmentName}">1</option>
							</select>
						</div>
						<div class="form-group">
							<label>Birth</label>
							<input name="birth" type="text" class="form-control" placeholder="zhangsan" th:value="${emp!=null}?${#dates.format(emp.birth, 'yyyy-MM-dd')}">
						</div>
						<button type="submit" class="btn btn-primary" th:text="${emp!=null}?'修改':'添加'"></button>
					</form>
				</main>
			</div>
		</div>

注意：当前面两个隐藏的input不起作用时要在配置文件中加上

spring.mvc.format.date=yyyy-MM-dd//日期格式化
spring.mvc.hiddenmethod.filter.enabled=true

还有在表单中的隐藏input框就是为了将post请求转换为put请求和携带数据

提交的数据格式不对：生日：日期；
2017-12-12；2017/12/12；2017.12.12；
日期的格式化；SpringMVC将页面提交的值需要转换为指定的类型;
2017-12-12—Date；类型转换，格式化;
默认日期是按照/的方式；

在controller中

 //来到员工添加页面
    @GetMapping("/emp")
    public String toAddPage(Model model){
        Collection<Department> departments  = departmentDao.getDepartments();
        model.addAttribute("depts",departments);
        return "emp/add";
    }
    //添加员工
    //SpringMvc自动将请求参数和入参对象的属性进行一一绑定，要求了请求参数的名字和javaBean入参的对象属性名是一样的。
    @PostMapping("/emp")
    public String addEmployee(Employee employee){
        //来到员工列表页面
        //redirect:表示重定向到一个地址,/代表当前项目下的路径
        //forward:表示转发到一个地址
        employeeDao.save(employee);
        return "redirect:/emps";
    }
    //来到员工修改页面，先要查出员工信息，在页面回显
    @GetMapping("/emp/{id}")
    public String toEditPage(@PathVariable("id") Integer id, Model model){
        Employee employee = employeeDao.get(id);
        model.addAttribute("emp",employee);
        Collection<Department> departments  = departmentDao.getDepartments();
        model.addAttribute("depts",departments);
        //回到修改页面（add是一个修改添加二合一的页面）
        return "emp/add";
    }
    //员工修改,需要提交员工id
    @PutMapping("/emp")
    public String updateEmployee(Employee employee){
        System.out.println("你好"+employee);
        employeeDao.save(employee);
        return "redirect:/emps";
    }

7）、员工删除

                                   <td>
                                        <a class=" btn btn-sm btn-primary" th:href="@{/emp/}+${emp.id}">编辑</a>
                                        <button type="submit" th:attr="del_uri=@{/emp/}+${emp.id}" class=" btn btn-sm btn-danger deleteBtn">删除</button>
                                    </td>
              <form id="deleteEmpForm" method="post">
                <input type="hidden" name="_method" value="delete"/>
            </form>
 <script>
    $(".deleteBtn").click(function(){
        //删除当前员工的
        $("#deleteEmpForm").attr("action",$(this).attr("del_uri")).submit();
        return false;
    });
</script>

7.错误处理机制
1）、SpringBoot默认的错误处理机制
默认效果：

1、浏览器，返回一个默认的错误页面
在这里插入图片描述
浏览器发送请求的请求头：

2、如果是其他客户端，默认响应一个json数据
在这里插入图片描述

{
    "timestamp": "2020-10-25T12:14:15.138+00:00",
    "status": 404,
    "error": "Not Found",
    "message": "",
    "path": "/aaa"
}

原理：

可以参照ErrorMvcAutoConﬁguration；错误处理的自动配置；

给容器中添加了以下组件

（1）、 DefaultErrorAttributes：帮我们在页面共享信息

public Map<String, Object> getErrorAttributes(WebRequest webRequest, boolean includeStackTrace) {
        Map<String, Object> errorAttributes = new LinkedHashMap();
        errorAttributes.put("timestamp", new Date());
        this.addStatus(errorAttributes, webRequest);
        this.addErrorDetails(errorAttributes, webRequest, includeStackTrace);
        this.addPath(errorAttributes, webRequest);
        return errorAttributes;
    }

（2）、BasicErrorController：处理默认/error请求

@Controller
@RequestMapping({"${server.error.path:${error.path:/error}}"})//如果没配error.path就用/error
public class BasicErrorController extends AbstractErrorController {
 @RequestMapping(
        produces = {"text/html"}
    )//产生html数据,浏览器发送的请求来到这个方法处理
    public ModelAndView errorHtml(HttpServletRequest request, HttpServletResponse response) {
        HttpStatus status = this.getStatus(request);
        Map<String, Object> model = Collections.unmodifiableMap(this.getErrorAttributes(request, this.getErrorAttributeOptions(request, MediaType.TEXT_HTML)));
        response.setStatus(status.value());

          //去哪个页面作为错误页面；包含页面地址和页面内容 
        ModelAndView modelAndView = this.resolveErrorView(request, response, status, model);
        return modelAndView != null ? modelAndView : new ModelAndView("error", model);
    }

    @RequestMapping//产生json数据，其他客户端来到这个方法处理
    public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
        HttpStatus status = this.getStatus(request);
        if (status == HttpStatus.NO_CONTENT) {
            return new ResponseEntity(status);
        } else {
            Map<String, Object> body = this.getErrorAttributes(request, this.getErrorAttributeOptions(request, MediaType.ALL));
            return new ResponseEntity(body, status);
        }

（3）、ErrorPageCustomizer：

    @Value("${error.path:/error}")
    private String path = "/error";//系统出现请求后给/error处理（类似以前web.xml注册的错误页 面规则）

（4）、DefaultErrorViewResolver：

public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status, Map<String, Object> model) {
        ModelAndView modelAndView = this.resolve(String.valueOf(status.value()), model);
        if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
            modelAndView = this.resolve((String)SERIES_VIEWS.get(status.series()), model);
        }

        return modelAndView;
    }

    private ModelAndView resolve(String viewName, Map<String, Object> model) {
    //默认SpringBoot可以去找到一个页面？  error/404 
        String errorViewName = "error/" + viewName;
        
 //模板引擎可以解析这个页面地址就用模板引擎解析 
        TemplateAvailabilityProvider provider = this.templateAvailabilityProviders.getProvider(errorViewName, this.applicationContext);
        return provider != null ? new ModelAndView(errorViewName, model) : this.resolveResource(errorViewName, model);
        //模板引擎可用的情况下返回到errorViewName指定的视图地址 ,模板引擎不可用，就在静态资源文件夹下找errorViewName对应的页面   error/404.html 
    }




resolveResource(errorViewName, model);中点进去


private ModelAndView resolveResource(String viewName, Map<String, Object> model) {
        String[] var3 = this.resourceProperties.getStaticLocations();
        int var4 = var3.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            String location = var3[var5];

            try {
                Resource resource = this.applicationContext.getResource(location);
                resource = resource.createRelative(viewName + ".html");
                if (resource.exists()) {
                    return new ModelAndView(new DefaultErrorViewResolver.HtmlResourceView(resource), model);
                }
            } catch (Exception var8) {
            }
        }

        return null;
    }

步骤：
一但系统出现4xx或者5xx之类的错误；ErrorPageCustomizer就会生效（定制错误的响应规则）；就会来到/error 请求；就会被BasicErrorController处理；

1、响应页面；去哪个页面是由DefaultErrorViewResolver解析得到的；

protected ModelAndView resolveErrorView(HttpServletRequest request, HttpServletResponse response, HttpStatus status, Map<String, Object> model) {
        Iterator var5 = this.errorViewResolvers.iterator();//所有的errorViewResolvers得到modelAndView

        ModelAndView modelAndView;
        do {
            if (!var5.hasNext()) {
                return null;
            }

            ErrorViewResolver resolver = (ErrorViewResolver)var5.next();
            modelAndView = resolver.resolveErrorView(request, status, model);
        } while(modelAndView == null);

        return modelAndView;
    }

2）、如果定制错误响应
1、如何定制错误的页面；

（1）、有模板引擎的情况下；error/状态码; 【将错误页面命名为错误状态码.html 放在模板引擎文件夹里面的 error文件夹下】，发生此状态码的错误就会来到对应的页面；

我们可以使用4xx和5xx作为错误页面的文件名来匹配这种类型的所有错误，精确优先（优先寻找精确的状态码.html）；

页面能获取的信息：
（从Map<String, Object> model = Collections.unmodifiableMap(this.getErrorAttributes(request, this.getErrorAttributeOptions(request, MediaType.TEXT_HTML)));中点进getErrorAttributes）再点this.errorAttributes，再点ErrorAttributes再找他的实现类就能发现前面（1）中那个类的作用
timestamp：时间戳
status：状态码
error：错误提示
exception：异常对象
message：异常消息
errors：JSR303数据校验的错误都在这里

（2）、没有模板引擎（模板引擎找不到这个错误页面），可以将错误页面放在静态资源文件夹下找
（3）、以上都没有错误页面，就是默认来到SpringBoot默认的错误提示页面；
2、如何定制错误的json数据

（1）、自定义异常处理&返回定制json数据；

@ControllerAdvice
public class MyExceptionHandler {
    @ResponseBody
    @ExceptionHandler(UserNotExistException.class)
    public Map<String,Object> handlerException(Exception e, HttpServletRequest request){
        Map<String,Object> map=new HashMap<>();
        map.put("message","用户出错啦");
        map.put("code","user not exist");
        return map;
    }
    //没有自适应效果，两种返回的都是我们定制的json数据

（ 2）、转发到/error进行自适应响应效果处理（转发到error请求basicErrorController就会进行自适应处理），但是没有用我们的map数据，都是默认的

@ControllerAdvice
public class MyExceptionHandler {
    @ExceptionHandler(UserNotExistException.class)
    public String handlerException(Exception e, HttpServletRequest request){
        Map<String,Object> map=new HashMap<>();
        request.setAttribute("javax.servlet.error.status_code",500);
        //传入我们自己的错误状态码  4xx 5xx，否则就不会进入定制错误页面的解析流程
        //Integer statusCode = (Integer)request.getAttribute("javax.servlet.error.status_code");(从BasicErrorController中获取ModelAndView errorHtml方法中的getStatus（）方法)
        map.put("message",e.getMessage());
        map.put("code","user not exist");
        //转发到/error进行处理
        return "forward:/error";
    }
}

(3）、将我们的定制数据携带出去;
出现错误以后，会来到/error请求，会被BasicErrorController处理，而我们在ErrorMvcAutoConfiguration又发现在容器中添加BasicErrorController的时候有一个判断

@ConditionalOnMissingBean(
        value = {ErrorController.class},
        search = SearchStrategy.CURRENT
    )
    public BasicErrorController basicErrorController(ErrorAttributes errorAttributes, ObjectProvider<ErrorViewResolver> errorViewResolvers) {

1、所以我们可以完全来编写一个ErrorController（这种办法太麻烦了）的实现类【或者是编写AbstractErrorController的子类】，放在容器中；
2、不管是客户端的json字符串还是我们的页面响应出去可以获取我们自己的数据都是由BasicErrorController中的getErrorAttributes（）得到的，点进去又可以发现是由它的父类AbstractErrorController中的this.errorAttributes得到的，errorAttributes又是ErrorAttributes接口创建的，而DefaultErrorAttributes又实现了这个接口，但是在ErrorMvcAutoConfigurationz中添加DefaultErrorAttributes这个组件的时候也有个判断

@ConditionalOnMissingBean(
        value = {ErrorAttributes.class},
        search = SearchStrategy.CURRENT
    )
    public DefaultErrorAttributes errorAttributes() {
        return new DefaultErrorAttributes();
    }

DefaultErrorAttributes加入了各种错误数据（message，status等）默认进行数据处理的；
所以我们可以自定义ErrorAttributes（直接继承DefaultErrorAttributes）

//给容器中加入我们自己定义的ErrorAttributes
@Component
public class MyErrorAttributes extends DefaultErrorAttributes {
    //返回的map就是页面和json能获取的所有字段
    @Override
    public Map<String, Object> getErrorAttributes(WebRequest webRequest, ErrorAttributeOptions options) {
        Map<String,Object>  map=super.getErrorAttributes(webRequest, options);
        map.put("company","nyb");
        //我们的异常处理器携带的数据
        Map<String,Object> myMessage = (Map<String, Object>) webRequest.getAttribute("myMessage", 0);
        /*int SCOPE_REQUEST = 0;从webRequest.getAttribute发现0为从request中取，1为从session中取
        int SCOPE_SESSION = 1;
        String REFERENCE_REQUEST = "request";
        String REFERENCE_SESSION = "session";*/
        map.put("myMessage",myMessage);
        return map;
    }

终的效果：响应是自适应的，可以通过定制ErrorAttributes改变需要返回的内容，
在这里插入图片描述
1、springboot默认的规则
2、我们通过定制ErrorAttributes添加的字段
3、我们的异常处理器给我们额外带的两个字段
8.配置嵌入式Servlet容器
SpringBoot默认使用Tomcat作为嵌入式（内置）的Servlet容器；（Tomcat是servlet容器的一种）
在这里插入图片描述
问题？
1）、如何定制和修改Servlet容器的相关配置；

1、修改和server有关的配置（ServerProperties【也是EmbeddedServletContainerCustomizer】）

server.port=8080
server.servlet.context-path=/crud

server.tomcat.uri-encoding=utf-8
#通用的Servlet容器设置
server.xxx
#tomcat的设置
server.tomcat.xxx

2、编写一个WebServerFactoryCustomizer：嵌入式的Servlet容器的定制器；来修改Servlet容器的配置

@Configuration
    public class MyMvcConfig implements WebMvcConfigurer {
        @Bean
        public WebServerFactoryCustomizer<ConfigurableWebServerFactory> customizerBean(){

            return new WebServerFactoryCustomizer<ConfigurableWebServerFactory>() {
                //定制嵌入式的Servlet容器相关的规则
                @Override
                public void customize(ConfigurableWebServerFactory factory) {
                    factory.setPort(8083);
                }
            };

2）、注册Servlet三大组件【Servlet、Filter、Listener】三大组件介绍：https://www.cnblogs.com/PoetryAndYou/p/11622184.html
由于SpringBoot默认是以jar包的方式启动嵌入式的Servlet容器来启动SpringBoot的web应用，没有web.xml文件。
注册三大组件用以下方式

ServletRegistrationBean

//注册三大组件
    @Bean
    public ServletRegistrationBean servletRegistrationBean(){
        ServletRegistrationBean registrationBean = new ServletRegistrationBean(new MyServlet(), "/myServlet");
        return registrationBean;
    }

FilterRegistrationBean

    //注册过滤器
    @Bean
    public FilterRegistrationBean filterRegistrationBean(){
        FilterRegistrationBean filterRegistrationBean=new FilterRegistrationBean();
        filterRegistrationBean.setFilter(new MyFilter());
        filterRegistrationBean.setUrlPatterns(Arrays.asList("/hello","/myServlet"));
        return filterRegistrationBean;
    }

ServletListenerRegistrationBean

 //注册监听器
    @Bean
    public ServletListenerRegistrationBean listenerRegistrationBean(){
        ServletListenerRegistrationBean<MyListener> myListenerServletListenerRegistrationBean = new ServletListenerRegistrationBean<>(new MyListener());
        return myListenerServletListenerRegistrationBean;
    }

SpringBoot帮我们自动SpringMVC的时候，自动的注册SpringMVC的前端控制器；DIspatcherServlet；

        @Bean(
            name = {"dispatcherServletRegistration"}
        )
        @ConditionalOnBean(
            value = {DispatcherServlet.class},
            name = {"dispatcherServlet"}
        )
        public DispatcherServletRegistrationBean dispatcherServletRegistration(DispatcherServlet dispatcherServlet, WebMvcProperties webMvcProperties, ObjectProvider<MultipartConfigElement> multipartConfig) {
            DispatcherServletRegistrationBean registration = new DispatcherServletRegistrationBean(dispatcherServlet, webMvcProperties.getServlet().getPath());
            //点进去可以发现默认拦截所有"/"下请求，包括静态资源，但是不拦截jsp请求；"/*"会拦截jsp
            //由这个getPath()进去可以发现可以通过spring.mvc.servlet.path来修改springMvc前端控制器默认拦截的请求路径

            registration.setName("dispatcherServlet");
            registration.setLoadOnStartup(webMvcProperties.getServlet().getLoadOnStartup());
            multipartConfig.ifAvailable(registration::setMultipartConfig);
            return registration;
        }

2）、SpringBoot能不能支持其他的Servlet容器；

3）、替换为其他嵌入式Servlet容器
ctrl+h打开继承树
在这里插入图片描述
默认支持：
Tomcat（默认使用）

<!--        引入web模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
<!--        引入web模块默认使用的就是嵌入式的Tomcat作为servlet容器，所以这里不用加依赖，在里面有配置-->

jetty

<!--        引入web模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                    <groupId>org.springframework.boot</groupId>
                </exclusion>
            </exclusions>

        </dependency>
<!--引入其他的servlet容器-->
        <dependency>
            <artifactId>spring-boot-starter-jetty</artifactId>
            <groupId>org.springframework.boot</groupId>
        </dependency>

undertow

<!--        引入web模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                    <groupId>org.springframework.boot</groupId>
                </exclusion>
            </exclusions>

        </dependency>
<!--引入其他的servlet容器-->
        <dependency>
            <artifactId>spring-boot-starter-undertow</artifactId>
            <groupId>org.springframework.boot</groupId>
        </dependency>

4）、嵌入式Servlet容器自动配置原理；

Embedded包下的ServletContainerAutoConﬁguration：嵌入式的Servlet容器自动配置？
下面有四种容器：

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnWebApplication
@EnableConfigurationProperties({ServerProperties.class})
public class EmbeddedWebServerFactoryCustomizerAutoConfiguration {
    public EmbeddedWebServerFactoryCustomizerAutoConfiguration() {
    }
        @Configuration(
        proxyBeanMethods = false
    )
    @ConditionalOnClass({HttpServer.class})
    public static class NettyWebServerFactoryCustomizerConfiguration {
        public NettyWebServerFactoryCustomizerConfiguration() {
        }

        @Bean
        public NettyWebServerFactoryCustomizer nettyWebServerFactoryCustomizer(Environment environment, ServerProperties serverProperties) {
            return new NettyWebServerFactoryCustomizer(environment, serverProperties);
        }
    }

    @Configuration(
        proxyBeanMethods = false
    )
    @ConditionalOnClass({Undertow.class, SslClientAuthMode.class})
    public static class UndertowWebServerFactoryCustomizerConfiguration {
        public UndertowWebServerFactoryCustomizerConfiguration() {
        }

        @Bean
        public UndertowWebServerFactoryCustomizer undertowWebServerFactoryCustomizer(Environment environment, ServerProperties serverProperties) {
            return new UndertowWebServerFactoryCustomizer(environment, serverProperties);
        }
    }

    @Configuration(
        proxyBeanMethods = false
    )
    @ConditionalOnClass({Server.class, Loader.class, WebAppContext.class})
    public static class JettyWebServerFactoryCustomizerConfiguration {
        public JettyWebServerFactoryCustomizerConfiguration() {
        }

        @Bean
        public JettyWebServerFactoryCustomizer jettyWebServerFactoryCustomizer(Environment environment, ServerProperties serverProperties) {
            return new JettyWebServerFactoryCustomizer(environment, serverProperties);
        }
    }

    @Configuration(
        proxyBeanMethods = false
    )
    @ConditionalOnClass({Tomcat.class, UpgradeProtocol.class})
    public static class TomcatWebServerFactoryCustomizerConfiguration {
        public TomcatWebServerFactoryCustomizerConfiguration() {
        }

        @Bean
        public TomcatWebServerFactoryCustomizer tomcatWebServerFactoryCustomizer(Environment environment, ServerProperties serverProperties) {
            return new TomcatWebServerFactoryCustomizer(environment, serverProperties);
        }

//在ServletWebServerFactoryConfiguration这个类中


    @Configuration(
        proxyBeanMethods = false
    )
    @ConditionalOnClass({Servlet.class, Tomcat.class, UpgradeProtocol.class})//判断当前是否引入了tomcat依赖
    @ConditionalOnMissingBean(
        value = {ServletWebServerFactory.class},
        search = SearchStrategy.CURRENT
    )//判断当前项目下有没有用户自己定义的ServletWebServerFactory：嵌入式的servlet容器工厂；作用：创建嵌入式的servlet容器
    static class EmbeddedTomcat {
        EmbeddedTomcat() {
        }

        @Bean
        TomcatServletWebServerFactory tomcatServletWebServerFactory(ObjectProvider<TomcatConnectorCustomizer> connectorCustomizers, ObjectProvider<TomcatContextCustomizer> contextCustomizers, ObjectProvider<TomcatProtocolHandlerCustomizer<?>> protocolHandlerCustomizers) {
            TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
            factory.getTomcatConnectorCustomizers().addAll((Collection)connectorCustomizers.orderedStream().collect(Collectors.toList()));
            factory.getTomcatContextCustomizers().addAll((Collection)contextCustomizers.orderedStream().collect(Collectors.toList()));
            factory.getTomcatProtocolHandlerCustomizers().addAll((Collection)protocolHandlerCustomizers.orderedStream().collect(Collectors.toList()));
            return factory;
        }

1、servlet容器工厂ServletWebServerFactory

@FunctionalInterface
public interface ServletWebServerFactory {
//获取嵌入式的servlet容器
    WebServer getWebServer(ServletContextInitializer... initializers);
}

查看ServletWebServerFactory的继承者可以看到接口ConfigurableServletWebServerFactory，查看它（可配置的Servlet容器工厂）的继承树
ctrl+h
在这里插入图片描述
而我们再查看WebServer的实现树
2、web服务器（四种）

3、以嵌入式的tomcat容器工厂为例（TomcatServletWebServerFactory）

    public WebServer getWebServer(ServletContextInitializer... initializers) {
        if (this.disableMBeanRegistry) {
            Registry.disableRegistry();
        }
       //创建一个tomcat
        Tomcat tomcat = new Tomcat();

//配置Tomcat的基本环节
        File baseDir = this.baseDirectory != null ? this.baseDirectory : this.createTempDir("tomcat");
        tomcat.setBaseDir(baseDir.getAbsolutePath());
        Connector connector = new Connector(this.protocol);
        connector.setThrowOnFailure(true);
        tomcat.getService().addConnector(connector);
        this.customizeConnector(connector);
        tomcat.setConnector(connector);
        tomcat.getHost().setAutoDeploy(false);
        this.configureEngine(tomcat.getEngine());
        Iterator var5 = this.additionalTomcatConnectors.iterator();

        while(var5.hasNext()) {
            Connector additionalConnector = (Connector)var5.next();
            tomcat.getService().addConnector(additionalConnector);
        }

        this.prepareContext(tomcat.getHost(), initializers);
        //将配置好的tomcat传入进去，返回一个嵌入式的web服务器
        return this.getTomcatWebServer(tomcat);
    }

点进getTomcatWebServer(tomcat);

    protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) {
        return new TomcatWebServer(tomcat, this.getPort() >= 0, this.getShutdown());
    }

可以看到它传入三个参数，再点进这个函数

    public TomcatWebServer(Tomcat tomcat, boolean autoStart, Shutdown shutdown) {
        this.monitor = new Object();
        this.serviceConnectors = new HashMap();
        Assert.notNull(tomcat, "Tomcat Server must not be null");
        this.tomcat = tomcat;
        this.autoStart = autoStart;
        this.gracefulShutdown = shutdown == Shutdown.GRACEFUL ? new GracefulShutdown(tomcat) : null;
        this.initialize();
    }

可以看到它最后初始化了并且启动了
初始化中还有一段代码，与我们控制台的内容相符

        logger.info("Tomcat initialized with port(s): " + this.getPortsDescription(false));

                this.tomcat.start();

4、我们对嵌入式容器的配置修改是怎么生效？

ServerProperties
WebServerFactoryCustomizer
WebServerFactoryCustomizer定制器帮我们修改了Servlet容器的配置
怎么修改的原理？
这里与老师讲的不同（个人分析看法）
（1）、在EmbeddedWebServerFactoryCustomizerAutoConfiguration中有很多配置导入servlet容器定制器的配置类：我们举一个例子Tomcat

    @Configuration(
        proxyBeanMethods = false
    )
    @ConditionalOnClass({Tomcat.class, UpgradeProtocol.class})
    public static class TomcatWebServerFactoryCustomizerConfiguration {
        public TomcatWebServerFactoryCustomizerConfiguration() {
        }

        @Bean
        public TomcatWebServerFactoryCustomizer tomcatWebServerFactoryCustomizer(Environment environment, ServerProperties serverProperties) {
            return new TomcatWebServerFactoryCustomizer(environment, serverProperties);
        }

上面代码表示当我们在容器中导入了Tomcat时这个类就会生效，它就会将一个TomcatWebServerFactoryCustomizer ：Tomcat容器工厂的定制器加入到容器中（注意，它在放入容器中的这个方法中还传入了serverProperties参数，这也是我们为什么可以通过application.properties来修改servlet容器的配置比如port等）所以我觉得他就是根据你导入哪个包，然后抽象的WebServerFactoryCustomizer 就会定制具体的TomcatWebServerFactoryCustomizer，然后就用里面的定制方法定制servlet容器
解释不下去了。。。老师的笔记如下
1）、SpringBoot根据导入的依赖情况，给容器中添加相应的 EmbeddedServletContainerFactory【TomcatEmbeddedServletContainerFactory】
2）、容器中某个组件要创建对象就会惊动后置处理器； EmbeddedServletContainerCustomizerBeanPostProcessor；只要是嵌入式的Servlet容器工厂，后置处理器就工作；
3）、后置处理器，从容器中获取所有的EmbeddedServletContainerCustomizer，调用定制器的定制方法

9.使用外置的Servlet容器
嵌入式Servlet容器：应用打成可执行的jar
优点：简单、便携；

缺点：默认不支持JSP、优化定制比较复杂（使用定制器【ServerProperties、自定义 EmbeddedServletContainerCustomizer】，自己编写嵌入式Servlet容器的创建工厂【EmbeddedServletContainerFactory】）；
外置的Servlet容器：外面安装Tomcat—应用war包的方式打包；
1）、必须创建一个War项目（还要在项目结构中配置tomcat,先要在项目结构中的Modules中配置web目录和xml文件，然后Edit Configurations加入本地的Tomcat，）
2）、将嵌入式的tomcat制定为provided

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

3）、必须编写一个SpringBootServletInitializer的子类（在SpringBoot目录下），并调用conﬁgure方法

package com.atguigu.springboot;
	@Override
	protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
		return application.sources(SpringBoot04WebJspApplication.class);
	}

4）、启动服务器即可

原理
jar包：执行SpringBoot主类的main方法，启动ioc容器，创建嵌入式的Servlet容器；
war包：启动服务器，服务器启动SpringBoot应用【SpringBootServletInitializer】，启动ioc容器；
在servlet3.0文档中有（Spring注解版）：
8.2.4 Shared libraries / runtimes pluggability：
规则：

1）、服务器启动（web应用启动）会创建当前web应用里面每一个jar包里面ServletContainerInitializer实例：
2）、ServletContainerInitializer的实现放在jar包的META-INF/services文件夹下，有一个名为 javax.servlet.ServletContainerInitializer的文件，内容就是ServletContainerInitializer的实现类的全类名
3）、还可以使用@HandlesTypes，在应用启动的时候加载我们感兴趣的类；
流程：
1）、启动Tomcat
2）、Spring的web模块里面有这个文件：org\springframework\spring-web\4.3.14.RELEASE\spring-web-4.3.14.RELEASE.jar!\METAINF\services\javax.servlet.ServletContainerInitializer：这个文件里面写的是： org.springframework.web.SpringServletContainerInitializer表示在同包下的org目录下有这个类说明应用启动的时候要创建这个实例对象
3）、SpringServletContainerInitializer将@HandlesTypes(WebApplicationInitializer.class)标注的所有这个类型的类都传入到onStartup方法的Set<Class<?>>集合中；为这些WebApplicationInitializer类型的类创建实例；
4）、每一个WebApplicationInitializer都调用自己的onStartup；
在这里插入图片描述
5）、相当于我们的SpringBootServletInitializer的类会被创建对象，并执行onStartup方法
6）、SpringBootServletInitializer实例执行onStartup的时候会createRootApplicationContext；创建容器

   protected WebApplicationContext createRootApplicationContext(ServletContext servletContext) {
        SpringApplicationBuilder builder = this.createSpringApplicationBuilder();
        builder.main(this.getClass());
        ApplicationContext parent = this.getExistingRootWebApplicationContext(servletContext);
        if (parent != null) {
            this.logger.info("Root context already created (using as parent).");
            servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, (Object)null);
            builder.initializers(new ApplicationContextInitializer[]{new ParentContextApplicationContextInitializer(parent)});
        }

        builder.initializers(new ApplicationContextInitializer[]{new ServletContextApplicationContextInitializer(servletContext)});
        builder.contextClass(AnnotationConfigServletWebServerApplicationContext.class);

//调用configure方法，子类重写了这个方法，将SpringBoot的主程序类传入了进来 
        builder = this.configure(builder);
        builder.listeners(new ApplicationListener[]{new SpringBootServletInitializer.WebEnvironmentPropertySourceInitializer(servletContext)});

  //使用builder创建一个Spring应用 
        SpringApplication application = builder.build();
        if (application.getAllSources().isEmpty() && MergedAnnotations.from(this.getClass(), SearchStrategy.TYPE_HIERARCHY).isPresent(Configuration.class)) {
            application.addPrimarySources(Collections.singleton(this.getClass()));
        }

        Assert.state(!application.getAllSources().isEmpty(), "No SpringApplication sources have been defined. Either override the configure method or add an @Configuration annotation");
        if (this.registerErrorPageFilter) {
            application.addPrimarySources(Collections.singleton(ErrorPageFilterConfiguration.class));
        }

        application.setRegisterShutdownHook(false);

   //启动Spring应用
        return this.run(application);
    }

7）、Spring的应用就启动并且创建IOC容器

    public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
        this.configureHeadlessProperty();
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        listeners.starting();

        Collection exceptionReporters;
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
            this.configureIgnoreBeanInfo(environment);
            Banner printedBanner = this.printBanner(environment);
            context = this.createApplicationContext();
            exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
            this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);

//刷新IOC容器
            this.refreshContext(context);
            this.afterRefresh(context, applicationArguments);
            stopWatch.stop();
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
            }

            listeners.started(context);
            this.callRunners(context, applicationArguments);
        } catch (Throwable var10) {
            this.handleRunFailure(context, var10, exceptionReporters, listeners);
            throw new IllegalStateException(var10);
        }

        try {
            listeners.running(context);
            return context;
        } catch (Throwable var9) {
            this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
            throw new IllegalStateException(var9);
        }
    }