1.创建第一个项目：

1.引入依赖：

<!--    所有springboot项目都必须继承自 spring-boot-starter-parent ,如果报	-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.5</version>
    </parent>

这里可能会报错：解决Maven ‘parent.relativePath‘ of POM_BingTaiLi的博客-CSDN博客

2. 导入场景

场景启动器

    <dependencies>
<!--        web开发的场景启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

3. 主程序

@SpringBootApplication //这是一个SpringBoot应用
public class MainApplication {

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

4. 业务

@RestController//将返回内容写入返回体中
public class HelloController {

    @GetMapping("/hello")
    public String hello(){

        return "Hello,Spring Boot 3!";
    }

}

5. 测试

默认启动访问： localhost:8080/hello

6. 打包

<!--    SpringBoot应用打包插件-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

mvn clean package把项目打成可执行的jar包
java -jar demo.jar启动项目

在该路径下输入cmd，然后运行jar包（命令:jva -jar demo.jar,注意这里必须要字面-jar，因为运行的是jar包）
但是能够成功运行要求系统java的环境变量配置的jdk17以上。

3、应用分析

思考：
1、为什么导入starter-web所有相关依赖都导入进来？

开发什么场景，导入什么场景启动器。

<dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
 <!--● 官方提供的场景：命名为：spring-boot-starter-*
		● 第三方提供场景：命名为：*-spring-boot-starter
		ctrl+鼠标右键即可在IDEA查看相关场景所依赖的jar包和场景-->

maven依赖传递原则。A-B-C： A就拥有B和C
导入场景启动器。场景启动器自动把这个场景的所有核心依赖全部导入进来

2、为什么版本号都不用写？

每个boot项目都有一个父项目spring-boot-starter-parent（它也是一个场景）
parent的父项目是spring-boot-dependencies（其中的标签中把所有常见的jar的依赖版本都声明好了。）
父项目 版本仲裁中心，把所有常见的jar的依赖版本都声明好了。
比如：mysql-connector-j

3、自定义版本号

利用maven的就近原则
- 直接在当前项目properties标签中声明父项目用的版本属性的key
- 直接在导入依赖的时候声明版本

4、第三方的jar包

boot父项目没有管理的需要自行声明好

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.16</version>
</dependency>

2. 自动配置机制

1. 初步理解

自动配置的 Tomcat、SpringMVC 等
- 导入场景，容器中就会自动配置好这个场景的核心组件。
- 以前：DispatcherServlet、ViewResolver、CharacterEncodingFilter…
- 现在：自动配置好的这些组件
- 验证：容器中有了什么组件，就具有什么功能

public static void main(String[] args) {

    //java10： 局部变量类型的自动推断（可以不用声明变量的类型，直接根据右边的表达式推断）
    var ioc = SpringApplication.run(MainApplication.class, args);

    //1、获取容器中所有组件的名字
    String[] names = ioc.getBeanDefinitionNames();
    //2、挨个遍历：
    // dispatcherServlet、beanNameViewResolver、characterEncodingFilter、multipartResolver
    // SpringBoot把以前配置的核心组件现在都给我们自动配置好了。
    for (String name : names) {
        System.out.println(name);
    }

}

默认的包扫描规则
- @SpringBootApplication 标注的类就是主程序类
- SpringBoot只会扫描主程序所在的包及其下面的子包，自动的component-scan功能
- 自定义扫描路径
  - @SpringBootApplication(scanBasePackages = “com.atguigu”)//scanBasePackages指定扫描的位置
  - @ComponentScan(“com.atguigu”) 直接指定扫描的路径
配置默认值
- 配置文件的所有配置项是和某个类的对象值进行一一绑定的。
- 绑定了配置文件中每一项值的类： 属性类。
- 比如：
  - ServerProperties绑定了所有Tomcat服务器有关的配置
  - MultipartProperties绑定了所有文件上传相关的配置
  - …参照官方文档：或者参照绑定的 属性类。
按需加载自动配置
- 导入场景spring-boot-starter-web
- 场景启动器除了会导入相关功能依赖(ctrl+鼠标右击可以查看导入的依赖），还导入一个spring-boot-starter(每个场景ctrl点进去的配置文件都有一个的spring-boot-starter），是所有starter的starter，这个starter基础核心starter
- spring-boot-starter导入了一个包 spring-boot-autoconfigure。包里面都是各种场景的AutoConfiguration自动配置类
- 虽然全场景的自动配置都在 spring-boot-autoconfigure这个包，但是不是全都开启的。
  - 导入哪个场景就开启哪个自动配置

总结：导入场景启动器、触发 spring-boot-autoconfigure这个包的自动配置生效、容器中就会具有相关场景的功能

1. 常用注解

SpringBoot摒弃XML配置方式，改为全注解驱动

1. 组件注册

@Configuration、@SpringBootConfiguration
@Bean、@Scope
@Controller、 @Service、@Repository、@Component
@Import
@ComponentScan
步骤：
1、@Configuration 编写一个配置类
2、在配置类中，自定义方法给容器中注册组件。配合@Bean
3、或使用@Import 导入第三方的组件

2. 条件注解

如果注解指定的条件成立，则触发指定行为
@ConditionalOnXxx
@ConditionalOnClass：如果类路径中存在这个类，则触发指定行为
@ConditionalOnMissingClass：如果类路径中不存在这个类，则触发指定行为
@ConditionalOnBean：如果容器中存在这个Bean（组件），则触发指定行为
@ConditionalOnMissingBean：如果容器中不存在这个Bean（组件），则触发指定行为
场景：

如果存在FastsqlException这个类，给容器中放一个Cat组件，名cat01，
否则，就给容器中放一个Dog组件，名dog01
如果系统中有dog01这个组件，就给容器中放一个 User组件，名zhangsan
否则，就放一个User，名叫lisi

@ConditionalOnBean（value=组件类型，name=组件名字）：判断容器中是否有这个类型的组件，并且名字是指定的值

@ConditionalOnRepositoryType (org.springframework.boot.autoconfigure.data)
@ConditionalOnDefaultWebSecurity (org.springframework.boot.autoconfigure.security)
@ConditionalOnSingleCandidate (org.springframework.boot.autoconfigure.condition)
@ConditionalOnWebApplication (org.springframework.boot.autoconfigure.condition)
@ConditionalOnWarDeployment (org.springframework.boot.autoconfigure.condition)
@ConditionalOnJndi (org.springframework.boot.autoconfigure.condition)
@ConditionalOnResource (org.springframework.boot.autoconfigure.condition)
@ConditionalOnExpression (org.springframework.boot.autoconfigure.condition)
@ConditionalOnClass (org.springframework.boot.autoconfigure.condition)
@ConditionalOnEnabledResourceChain (org.springframework.boot.autoconfigure.web)
@ConditionalOnMissingClass(org.springframework.boot.autoconfigure.condition)
@ConditionalOnNotWebApplication (org.springframework.boot.autoconfigure.condition)
@ConditionalOnProperty (org.springframework.boot.autoconfigure.condition)
@ConditionalOnCloudPlatform (org.springframework.boot.autoconfigure.condition)
@ConditionalOnBean (org.springframework.boot.autoconfigure.condition)
@ConditionalOnMissingBean (org.springframework.boot.autoconfigure.condition)
@ConditionalOnMissingFilterBean (org.springframework.boot.autoconfigure.web.servlet)
@Profile (org.springframework.context.annotation)
@ConditionalOnInitializedRestarter (org.springframework.boot.devtools.restart)
@ConditionalOnGraphQlSchema (org.springframework.boot.autoconfigure.graphql)
@ConditionalOnJava (org.springframework.boot.autoconfigure.condition)

3. 属性绑定

@ConfigurationProperties：声明组件的属性和配置文件哪些前缀开始项进行绑定
@EnableConfigurationProperties：快速注册注解：

场景：SpringBoot默认只扫描自己主程序所在的包。如果导入第三方包，即使组件上标注了 @Component、@ConfigurationProperties 注解，也没用。因为组件都扫描不进来，此时使用这个注解就可以快速进行属性绑定并把组件注册进容器

将容器中任意组件（Bean）的属性值和配置文件的配置项的值进行绑定

1、给容器中注册组件（@Component、@Bean）
2、使用@ConfigurationProperties 声明组件和配置文件的哪些配置项进行绑定

更多注解参照：Spring注解驱动开发【1-26集】

待复习常用注解（视频1-26集）：

核心容器：

组件注册：

@Congfiguration:

基于xml的注入方式，需要根据标签逐渐赋值注入容器的。
都有注入容器的功能

package com.example.annotationstudy.config;

import org.springframework.core.io.Resource;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.ClassMetadata;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;

import java.io.IOException;
import java.lang.annotation.Annotation;

public class MytypeFilter implements TypeFilter
    {
    @Override
//    MetadataReader读取到当前真正扫描的类，MetadataReaderFactory可以获取其他任何类的信息
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException
    {
//        获取当前正在扫描的类的注解信息
        AnnotationMetadata annotation= metadataReader.getAnnotationMetadata();
        //获取当前真正扫描类的类信息，比如它的类型是什么，实现了什么接口
         ClassMetadata classMetadata = metadataReader.getClassMetadata();
        //获取当前类资源信息(类路径）
       Resource resource =  metadataReader.getResource();
       String className =classMetadata.getClassName();
        System.out.println("--->"+className);
        if(className.contains("er"))
        return  true;
        return false;
    }
    }

package com.example.annotationstudy;

import com.example.annotationstudy.config.test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

//SpringApplication.run(AnnotationStudyApplication.class, args);
public class AnnotationStudyApplication
{

    public static void main(String[] args)
    {
        ApplicationContext applicationContext =  new AnnotationConfigApplicationContext(test.class);
        System.out.println( applicationContext.getBean(Person.class));
        String[] nameType = applicationContext.getBeanNamesForType(Person.class);//查看Person类的Bean数组在容器中的id数组
        for (String string:nameType)
        {
            System.out.println(string);
        }
    }
//    Person{name='1', age=1}
//     person1
@Test
public void  test01()
{
    ApplicationContext applicationContext =  new AnnotationConfigApplicationContext(test.class);
    String[] nameType = applicationContext.getBeanDefinitionNames();//查看Person类的Bean数组在容器中的id数组
    for (String string:nameType)
    {
        System.out.println(string);
    }
}
/*没有加过滤器前的结果：
test//@Configuration注入的组件,@Configuration注解有@Component修饰
bookController//@Controller注入的组件
bookDao//@Repository注入的组件
bookService//@Service注入的组件
person//  @Bean("person")注入的组件
*/
/*加了过滤器:
test
bookDao
bookService
person*/
/*自定义过滤规则的输出结果
--->com.example.annotationstudy.AnnotationStudyApplication
--->com.example.annotationstudy.config.MytypeFilter
--->com.example.annotationstudy.controller.BookController
--->com.example.annotationstudy.dao.BookDao
--->com.example.annotationstudy.Person
--->com.example.annotationstudy.service.bookService
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
        test
bookDao
        person

进程已结束,退出代码0*/


}

package com.example.annotationstudy.config;

import com.example.annotationstudy.Person;
import com.example.annotationstudy.service.bookService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;

//配置类===配置文件
@Configuration//告诉spring这是一个配置类
@ComponentScan(value="com.example.annotationstudy",
        includeFilters = {@ComponentScan.Filter(type = FilterType.CUSTOM,classes = MytypeFilter.class)})
//将Controller注解过滤掉
//类似xml中的包扫描标签<context:component-sacn base-package="">
//@ComponentScan value（数组类型）指定要扫描的包， Filter[] excludeFilters();指定过滤规则；
// Filter[] includeFilters()指定扫描只包含哪些注解
//FilterType.ANNOTATION按照给定的注解加载（type = FilterType.ANNOTATION,classes = Controller.class)排除/只加载Contorller注解
//FilterType.ASSIGNABLE_TYPE按照给定类型加载,type = FilterType.ASSIGNABLE_TYPE,classes = bookService.class排除/只加载bookService类型的bean
//FilterType.REGEX按照正则表达式，
//FilterType.CUSTOM;使用自定义规则；@ComponentScan.Filter(type = FilterType.CUSTOM,classes = MytypeFilter.class)
//MytypeFilter.class返回ture或false决定是否排除/加载类到容器，如果为ture就加载/排除bean到容器内，其中value指定的路径下所有的类
// 都会在MytypeFilter中进行判断，看能否加入到容器中
public class test
{
//    给容器中注册一个bean,类型为方法的返回值的类型，id默认为方法名作为id,其中该注解的vaule值赋值id的优先级高于方法名
    @Bean("person")//也可以这样给bean赋值为person,最后这里注入bean的id是person;类似xml中的bean标签
    public Person person1()
    {
        return new Person("1",1);
    }

}

2. 完整流程

思考：
1、SpringBoot怎么实现导一个starter、写一些简单配置，应用就能跑起来，我们无需关心整合
2、为什么Tomcat的端口号可以配置在application.properties中，并且Tomcat能启动成功？
3、导入场景后哪些自动配置能生效？

自动配置流程细节梳理：
**1、**导入starter-web：导入了web开发场景

1、场景启动器导入了相关场景的所有依赖：starter-json、starter-tomcat、springmvc
2、每个场景启动器都引入了一个spring-boot-starter，核心场景启动器。
3、核心场景启动器引入了spring-boot-autoconfigure包。
4、spring-boot-autoconfigure里面囊括了所有场景的所有配置。
5、只要这个包下的所有类都能生效，那么相当于SpringBoot官方写好的整合功能就生效了。
6、SpringBoot默认却扫描不到 spring-boot-autoconfigure下写好的所有配置类。（这些配置类给我们做了整合操作），默认只扫描主程序所在的包。

2、主程序：@SpringBootApplication

1、@SpringBootApplication由三个注解组成@SpringBootConfiguration、@EnableAutoConfiguratio、@ComponentScan
2、SpringBoot默认只能扫描自己主程序所在的包及其下面的子包，扫描不到 spring-boot-autoconfigure包中官方写好的配置类
3、@EnableAutoConfiguration：SpringBoot 开启自动配置的核心。
- 1. 是由@Import(AutoConfigurationImportSelector.class){，@Import是一个注解，允许您将其他配置类导入到应用程序上下文中}提供功能：批量给容器中导入组件。
- 1. SpringBoot启动会默认加载 142个配置类。
- 1. 这142个配置类来自于spring-boot-autoconfigure下 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件指定的
- 项目启动的时候利用 @Import 批量导入组件机制把 autoconfigure 包下的142 xxxxAutoConfiguration类导入进来（自动配置类）
- 虽然导入了142个自动配置类
4、按需生效：
- 并不是这142个自动配置类都能生效
- 每一个自动配置类，都有条件注解@ConditionalOnxxx，只有条件成立，才能生效

3、xxxxAutoConfiguration自动配置类

1、给容器中使用@Bean 放一堆组件。
2、每个自动配置类都可能有这个注解@EnableConfigurationProperties(ServerProperties.class)，用来把配置文件中配的指定前缀的属性值封装到 xxxProperties属性类中
3、以Tomcat为例：把服务器的所有配置都是以server开头的。配置都封装到了属性类中。
4、给容器中放的所有组件的一些核心参数，都来自于xxxProperties。xxxProperties都是和配置文件绑定。
只需要改配置文件的值，核心组件的底层参数都能修改

**4、**写业务，全程无需关心各种整合（底层这些整合写好了，而且也生效了）

核心流程总结：
1、导入starter，就会导入autoconfigure包。
2、autoconfigure 包里面有一个文件 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports,里面指定的所有启动要加载的自动配置类
3、@EnableAutoConfiguration 会自动的把上面文件里面写的所有自动配置类都导入进来。xxxAutoConfiguration 是有条件注解进行按需加载
4、xxxAutoConfiguration给容器中导入一堆组件，组件都是从 xxxProperties中提取属性值
5、xxxProperties又是和配置文件进行了绑定
**效果：**导入starter、修改配置文件，就能修改底层行为。

2. YAML配置文件

痛点：SpringBoot 集中化管理配置，application.properties
问题：配置多以后难阅读和修改，层级结构辨识度不高

YAML 是 “YAML Ain’t a Markup Language”（YAML 不是一种标记语言）。在开发的这种语言时，YAML 的意思其实是：“Yet Another Markup Language”（是另一种标记语言）。

设计目标，就是方便人类读写
层次分明，更适合做配置文件
使用.yaml或 .yml作为文件后缀

1. 基本语法

大小写敏感
使用缩进表示层级关系，k: v，使用空格分割k,v
缩进时不允许使用Tab键，只允许使用空格。换行
缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
# 表示注释，从这个字符一直到行尾，都会被解析器忽略。

支持的写法：

对象：键值对的集合，如：映射（map）/ 哈希（hash） / 字典（dictionary）
数组：一组按次序排列的值，如：序列（sequence） / 列表（list）
纯量：单个的、不可再分的值，如：字符串、数字、bool、日期

2. 示例

@Component
@ConfigurationProperties(prefix = "person") //和配置文件person前缀的所有配置进行绑定，
//ConfigurationProperties注解可以将配置文件中的属性映射到一个Java Bean中。
@Data //自动生成JavaBean属性的getter/setter
//@NoArgsConstructor //自动生成无参构造器
//@AllArgsConstructor //自动生成全参构造器
public class Person {
    private String name;
    private Integer age;
    private Date birthDay;
    private Boolean like;
    private Child child; //嵌套对象
    private List<Dog> dogs; //数组（里面是对象）
    private Map<String,Cat> cats; //表示Map
}

@Data
public class Dog {
    private String name;
    private Integer age;
}

@Data
public class Child {
    private String name;
    private Integer age;
    private Date birthDay;
    private List<String> text; //数组
}

@Data
public class Cat {
    private String name;
    private Integer age;
}

properties表示法

person.name=张三
person.age=18
person.birthDay=2010/10/12 12:12:12
person.like=true
person.child.name=李四
person.child.age=12
person.child.birthDay=2018/10/12
person.child.text[0]=abc
person.child.text[1]=def
person.dogs[0].name=小黑
person.dogs[0].age=3
person.dogs[1].name=小白
person.dogs[1].age=2
person.cats.c1.name=小蓝
person.cats.c1.age=3
person.cats.c2.name=小灰
person.cats.c2.age=2

yaml表示法：注意数组的写法：text和dogs两种写法，cat是map的写法。

person:
  name: 张三
  age: 18
  birthDay: 2010/10/10 12:12:12
  like: true
  child:
    name: 李四
    age: 20
    birthDay: 2018/10/10
    text: ["abc","def"]
#数组的2中写法，可以是text形式还可以是dogs的形式（每一个元素用一个-表示，下面的age是一个元素里
#面的内容，要同级并没有-表示。
  dogs:
    - name: 小黑
      age: 3
    - name: 小白
      age: 2
  cats:
    c1:
      name: 小蓝
      age: 3
    c2: {name: 小绿,age: 2} #对象也可用{}表示

3. 细节

birthDay 推荐写为 birth-day,@ConfigurationProperties(prefix = “person”) //和配置文件person前缀的所有配置进行绑定，
文本：
- 单引号不会转义【\n 则为普通字符串显示】
- 双引号会转义【\n会显示为换行符】
大文本
- |开头，大文本写在下层，保留文本格式，换行符正确显示
- 开头，大文本写在下层，折叠换行符
多文档合并
- 使用—可以把多个yaml文档合并在一个文档中，每个文档区依然认为内容独立

4. 小技巧：lombok

简化JavaBean 开发。自动生成构造器、getter/setter、自动生成Builder模式等

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <scope>compile</scope>
</dependency>

使用@Data等注解

3. 日志配置

规范：项目开发不要编写System.out.println()，应该用日志记录信息

感兴趣日志框架关系与起源可参考：https://www.bilibili.com/video/BV1gW411W76m 视频 21~27集

1. 简介

Spring使用commons-logging作为内部日志，但底层日志实现是开放的。可对接其他日志框架。
1. spring5及以后 commons-logging被spring直接自己写了。
支持 jul，log4j2,logback。SpringBoot 提供了默认的控制台输出配置，也可以配置输出为文件。
logback是默认使用的。
虽然日志框架很多，但是我们不用担心，使用 SpringBoot 的默认配置就能工作的很好。

SpringBoot怎么把日志默认配置好的
1、每个starter场景，都会导入一个核心场景spring-boot-starter
2、核心场景引入了日志的所用功能spring-boot-starter-logging（eg:spring-boot-starter-web->spring-boot-starter->spring-boot-starter-logging)
3、默认使用了logback + slf4j 组合作为默认底层日志
4、日志是系统一启动就要用，xxxAutoConfiguration是系统启动好了以后放好的组件，后来用的。
5、日志是利用监听器机制配置好的。ApplicationListener。
6、日志所有的配置都可以通过修改配置文件实现。以logging开始的所有配置。

2. 日志格式

1
2

2023-03-31T13:56:17.511+08:00  INFO 4944 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2023-03-31T13:56:17.511+08:00  INFO 4944 --- [           main] o.apache.catalina.core.StandardEngine    : Starting Servlet engine: [Apache Tomcat/10.1.7]

默认输出格式：

时间和日期：毫秒级精度
日志级别：ERROR,WARN,INFO,DEBUG, orTRACE.
进程 ID(可以在终端使用jps列出当前java程序的进程）
—：消息分割符
线程名：使用[]包含
Logger 名：通常是产生日志的类名
消息：日志记录的内容

注意： logback 没有FATAL级别，对应的是ERROR
默认值：参照：spring-boot包additional-spring-configuration-metadata.json文件
默认输出格式值：%clr(%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd’T’HH:mm:ss.SSSXXX}}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(—){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}
可修改为：‘%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread] %logger{15} ===> %msg%n’

3. 记录日志

1
2
3

Logger logger = LoggerFactory.getLogger(getClass());//使用日志工厂生成日志类
 log.info("info 日志..... 参数a:{} b:{}",a,b);
或者使用Lombok的@Slf4j注解,在该类上使用，就可以不用日志工厂生成日志类直接使用log

4. 日志级别

由低到高：ALL,TRACE, DEBUG, INFO, WARN, ERROR,FATAL,OFF；
- 只会打印指定级别及以上级别的日志
- ALL：打印所有日志
- TRACE：追踪框架详细流程日志，一般不使用
- DEBUG：开发调试细节日志
- INFO：关键、感兴趣信息日志
- WARN：警告但不是错误的信息日志，比如：版本过时
- ERROR：业务错误日志，比如出现各种异常
- FATAL：致命错误日志，比如jvm系统崩溃
- OFF：关闭所有日志记录
不指定级别的所有类，都使用root指定的级别作为默认级别
SpringBoot日志默认级别是 INFO

在application.properties/yaml中配置logging.level.=指定日志级别
level可取值范围：TRACE, DEBUG, INFO, WARN, ERROR, FATAL, or OFF，定义在 LogLevel类中
root 的logger-name叫root，可以配置logging.level.root=warn，代表所有未指定日志级别都使用 root 的 warn 级别

5. 日志分组

比较有用的技巧是：
将相关的logger分组在一起，统一配置。SpringBoot 也支持。比如：Tomcat 相关的日志统一设置

logging.group.tomcat=org.apache.catalina,org.apache.coyote,org.apache.tomcat
//这里是将org.apache.catalina,org.apache.coyote,org.apache.tomcat2个包当成一个组为tomcat
logging.level.tomcat=trace
//这里是将tomcat组的日志级别设置为trace级别

SpringBoot 预定义两个组

Name	Loggers
web	org.springframework.core.codec,org.springframework.http,org.springframework.web,org.springframework.boot.actuate.endpoint.web,org.springframework.boot.web.servlet.ServletContextInitializerBeans
sql	org.springframework.jdbc.core,org.hibernate.SQL,org.jooq.tools.LoggerListener

6. 文件输出

 #指定文件路径路径，日志文件默认叫spring.log
#logging.file.path=D:\\
#指定日志文件的名，只写名字就在当前项目的同位置生成相对应的日志文件。
#也可以写名字+路径，就会在指定的路径下生成相应的日志文件然后把日志写进去
logging.file.name 
#file.name和file.path同时存在,只有file.name生效

SpringBoot 默认只把日志写在控制台，如果想额外记录到文件，可以在application.properties中添加logging.file.name or logging.file.path配置项。

logging.file.name	logging.file.path	示例	效果
未指定	未指定		仅控制台输出
指定	未指定	my.log	写入指定文件。可以加路径
未指定	指定	/var/log	写入指定目录，文件名为spring.log
指定	指定		以logging.file.name为准

7. 文件归档与滚动切割

归档：每天的日志单独存到一个文档中。
切割：每个文件10MB，超过大小切割成另外一个文件。

每天的日志应该独立分割出来存档。如果使用logback（SpringBoot 默认整合），可以通过application.properties/yaml文件指定日志滚动规则。
如果是其他日志系统，需要自行配置（添加log4j2.xml或log4j2-spring.xml）
不用特意配置日志，会使用默认的日志
支持的滚动规则设置如下
| 配置项 | 描述 |
| — | — |
| logging.logback.rollingpolicy.file-name-pattern | 日志存档的文件名（类似每天产生的日志单独生成在一个文件中）格式（默认值：${LOG_FILE}.%d{yyyy-MM-dd}.%i.gz） |
| logging.logback.rollingpolicy.clean-history-on-start | 应用启动时是否清除以前存档（默认值：false） |
| logging.logback.rollingpolicy.max-file-size | 存档前，每个日志文件的最大大小（默认值：10MB） |
| logging.logback.rollingpolicy.total-size-cap | 日志文件被删除之前，可以容纳的最大大小（默认值：0B）。设置1GB则磁盘存储超过 1GB 日志后就会删除旧日志文件 |
| logging.logback.rollingpolicy.max-history | 日志文件保存的最大天数(默认值：7). |

8. 自定义配置

通常我们配置 application.properties 就够了。当然也可以自定义。比如：

日志系统	自定义
Logback	logback-spring.xml,logback-spring.groovy,
logback.xml, or logback.groovy
Log4j2	log4j2-spring.xmlorlog4j2.xml
JDK (Java Util Logging)	logging.properties

如果可能，我们建议您在日志配置中使用-spring 变量（例如，logback-spring.xml 而不是 logback.xml）。如果您使用标准配置文件，spring 无法完全控制日志初始化。
最佳实战：自己要写配置，配置文件名加上 xx-spring.xml

9. 切换日志组合

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

log4j2支持yaml和json格式的配置文件

格式	依赖	文件名
YAML	com.fasterxml.jackson.core:jackson-databind+com.fasterxml.jackson.dataformat:jackson-dataformat-yaml	log4j2.yaml+log4j2.yml
JSON	com.fasterxml.jackson.core:jackson-databind	log4j2.json+log4j2.jsn

10. 最佳实战

导入任何第三方框架，先排除它的日志包，因为Boot底层控制好了日志
修改 application.properties 配置文件，就可以调整日志的所有行为。如果不够，可以编写日志框架自己的配置文件放在类路径下就行，比如logback-spring.xml，log4j2-spring.xml
如需对接专业日志系统，也只需要把 logback 记录的日志灌倒** kafka**之类的中间件，这和SpringBoot没关系，都是日志框架自己的配置，修改配置文件即可
业务中使用slf4j-api记录日志。不要再 sout 了

2、SpringBoot3-Web开发

SpringBoot的Web开发能力，由SpringMVC提供。

1. Web场景

1、整合web场景

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

2、引入了 autoconfigure功能（是spring-boot-starter-web下的spring-boot-starter里面的一个依赖）
3、springboot起点的时候会加载一个@EnableAutoConfiguration注解（@SpringBootApplication注解里被@EnableAutoConfiguration注解修饰）。@EnableAutoConfiguration注解使用@Import(AutoConfigurationImportSelector.class)批量导入组件，加载 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件中配置的所有组件
5、所有自动配置类如下

org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration
org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration
====以下是响应式web场景和现在的没关系======
org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.ReactiveMultipartAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration
org.springframework.boot.autoconfigure.web.reactive.WebSessionIdResolverAutoConfiguration
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

6、绑定了配置文件的一堆配置项

1、SpringMVC的所有配置 spring.mvc
2、Web场景通用配置 spring.web
3、文件上传配置 spring.servlet.multipart
4、服务器的配置 server: 比如：编码方式

2. 默认效果

默认配置：

包含了 ContentNegotiatingViewResolver 和 BeanNameViewResolver 组件，方便视图解析
默认的静态资源处理机制：静态资源放在 static 文件夹下即可直接访问
自动注册了 Converter,GenericConverter,Formatter组件，适配常见数据类型转换和格式化需求
支持 HttpMessageConverters，可以方便返回json等数据类型（比如：@RestController 注解会自动将处理方法的返回值序列化为 JSON式的响应体，并将其发送给客户端。）
注册 MessageCodesResolver，方便国际化及错误消息处理
支持静态index.html
自动使用ConfigurableWebBindingInitializer，实现消息处理、数据绑定（比如将前段传递过来的参数和某些bean绑定)、类型转化、数据校验等功能

重要：

如果想保持 boot mvc 的默认配置，并且自定义更多的 mvc 配置，如：interceptors, formatters, view controllers 等。可以使用@Configuration注解添加一个 WebMvcConfigurer 类型的配置类，并不要标注 @EnableWebMvc
如果想保持 boot mvc 的默认配置，但要自定义核心组件实例，比如：RequestMappingHandlerMapping, RequestMappingHandlerAdapter, 或ExceptionHandlerExceptionResolver，给容器中放一个 WebMvcRegistrations 组件即可
如果想全面接管 Spring MVC，@Configuration 标注一个配置类，并加上 @EnableWebMvc注解，
实现 WebMvcConfigurer 接口

WebMvcAutoConfiguration原理

WebMvcAutoConfiguration 是 Spring Boot 中的一个自动配置类，它负责自动配置 Spring MVC（Model-View-Controller）的相关功能。
在 Spring Boot 应用程序中，当您引入了 spring-boot-starter-web 依赖时，WebMvcAutoConfiguration 将自动生效。它会根据应用程序的类路径和配置属性来自动配置 Spring MVC。它是@EnableAutoConfiguration注解使用@Import(AutoConfigurationImportSelector.class)批量导入组件中的一个组件。

1. 生效条件

@AutoConfiguration(after = { DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
		ValidationAutoConfiguration.class }) //在这些自动配置之后,
@ConditionalOnWebApplication(type = Type.SERVLET) //如果是web应用就生效，类型是SERVLETweb，其他还有、REACTIVE 响应式web
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class) //容器中没有这个Bean，才生效。默认就是没有
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)//优先级
@ImportRuntimeHints(WebResourcesRuntimeHints.class)
public class WebMvcAutoConfiguration { 
}

2. WebMvcAutoConfiguration产生的效果

放了两个Filter：
1. HiddenHttpMethodFilter；页面表单提交Rest请求（GET、POST、PUT、DELETE）Spring MVC过滤器-HiddenHttpMethodFilter_Korbin Luo的博客-CSDN博客

某些场景下，例如 HTML 表单只支持 GET 和 POST 方法，无法直接发送 PUT 或 DELETE 请求。
为了解决这个问题，Spring Framework 提供了 HiddenHttpMethodFilter 过滤器。
HiddenHttpMethodFilter 允许您在 HTML 表单中使用一个隐藏字段（通常命名为 "_method"）
来指定要使用的 HTTP 方法，例如 PUT 或 DELETE。当表单提交时，过滤器会检查隐藏字段的值，并将请求方法转换为相应的 HTTP 方法。
<form action="/example" method="post">
    <input type="hidden" name="_method" value="put">
    <!-- 其他表单字段 -->
    <button type="submit">提交</button>
</form>
在上面的示例中，隐藏字段 _method 的值被设置为 "put"，表示要使用 PUT 方法进行请求。
在您的控制器方法中，使用 @RequestMapping 注解或其他合适的注解来处理相应的请求方法。
@RequestMapping(value = "/example", method = RequestMethod.PUT)
public ResponseEntity<String> updateExample() {
    // 处理 PUT 请求
}

FormContentFilter：表单内容Filter，GET（数据放URL后面）、POST（数据放请求体）请求可以携带数据，PUT、DELETE 的请求体数据会被忽略.为了让put和delete的请求体内容不会被忽略，可以加一个FormContentFilter。
给容器中放了WebMvcConfigurer组件（WebMvcAutoConfigurationAdapter）；给SpringMVC添加各种定制功能

	@Configuration(proxyBeanMethods = false)
	@Import(EnableWebMvcConfiguration.class) //额外导入了其他配置
	@EnableConfigurationProperties({ WebMvcProperties.class, WebProperties.class })
	@Order(0)
	public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer, 
ServletContextAware{
        
    }

所有的功能最终会和配置文件进行绑定
WebMvcProperties： spring.mvc配置文件
WebProperties： spring.web配置文件

@ConfigurationProperties(
prefix = "spring.mvc"
)//@ConfigurationProperties 注解的 prefix 属性被设置为 "spring.mvc"，表示要绑定以
"spring.mvc" 开头的配置属性。
使用 @ConfigurationProperties 注解可以将配置文件中的属性值与 Java 类中的字段或方法关联起来，
从而方便地获取、设置和管理配置属性。

WebMvcConfigurer接口

WebMvcAutoConfiguration中的WebMvcAutoConfigurationAdapter属性实现了该接口。
提供了配置SpringMVC底层的所有组件入口

2. 静态资源

1. 默认规则

@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
    if (!this.resourceProperties.isAddMappings()) {
        logger.debug("Default resource handling disabled");
        return;
    }
    //1、
    addResourceHandler(registry, this.mvcProperties.getWebjarsPathPattern(),
            "classpath:/META-INF/resources/webjars/");
    addResourceHandler(registry, this.mvcProperties.getStaticPathPattern(), (registration) -> {
        registration.addResourceLocations(this.resourceProperties.getStaticLocations());
        if (this.servletContext != null) {
            ServletContextResource resource = new ServletContextResource(this.servletContext, SERVLET_LOCATION);
            registration.addResourceLocations(resource);
        }
    });
}
//

规则一：访问： /webjars/**路径就去 classpath:/META-INF/resources/webjars/下找资源.

/webjars/ 是一个特定的路径前缀，用于在Web应用程序中访问 WebJars 资源。

WebJars 是一种将前端库以 JAR 文件的形式打包并发布到 Maven 仓库的方式。它们允许您通过 Maven 
或 Gradle 等构建工具来管理和引入前端库，就像管理其他 Java 依赖项一样。

当您在 Maven 项目中引入 WebJars 依赖时，它们将被下载并存储在您的项目的 Maven 依赖目录中。
为了在 Web 应用程序中有效地访问这些资源，Spring Boot 提供了一个特殊的处理器来映射 /webjars/
路径。

maven 导入依赖
规则二：访问： /**路径就去静态资源默认的四个位置找资源
1. classpath:/META-INF/resources/
2. classpath:/resources/
3. classpath:/static/
4. classpath:/public/
规则三：静态资源默认都有缓存规则的设置
1. 所有缓存的设置，直接通过配置文件： spring.web
2. cachePeriod：缓存周期；多久不用找服务器要新的。默认没有，以s为单位
3. cacheControl： HTTP缓存控制；https://develop er.mozilla.org/zh-CN/docs/Web/HTTP/Caching
4. useLastModified：是否使用最后一次修改。配合HTTP Cache规则

如果浏览器访问了一个静态资源 index.js，如果服务这个资源没有发生变化，下次访问的时候就可以直接让浏览器用自己缓存中的东西，而不用给服务器发请求

1
2
3

registration.setCachePeriod(getSeconds(this.resourceProperties.getCache().getPeriod()));
registration.setCacheControl(this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl());
registration.setUseLastModified(this.resourceProperties.getCache().isUseLastModified());

1. 静态资源映射

静态资源映射规则在WebMvcAutoConfiguration中进行了定义：

/webjars/**的所有路径资源都在classpath:/META-INF/resources/webjars/
/**的所有路径资源都在classpath:/META-INF/resources/、classpath:/resources/、classpath:/static/、classpath:/public/
所有静态资源都定义了缓存规则。【浏览器访问过一次，就会缓存一段时间】，但此功能参数无默认值
1. period：缓存间隔。默认 0S；
2. cacheControl：缓存控制。默认无；
3. useLastModified：是否使用lastModified头。默认 false；

2. 静态资源缓存

如前面所述

所有静态资源都定义了缓存规则。【浏览器访问过一次，就会缓存一段时间】，但此功能参数无默认值
1. period：缓存间隔。默认 0S；
2. cacheControl：缓存控制。默认无；
3. useLastModified：是否使用lastModified头。默认 false；

3. 欢迎页

欢迎页规则在WebMvcAutoConfiguration中进行了定义：

在静态资源目录下找 index.html
没有就在 templates下找index模板页

4. Favicon

在静态资源目录下找 favicon.ico

5. 缓存实验

server.port=9000

#1、spring.web：
# 1.配置国际化的区域信息
# 2.静态资源策略(开启、处理链、缓存)

#开启静态资源映射规则
spring.web.resources.add-mappings=true

#设置缓存
#spring.web.resources.cache.period=3600
##缓存详细合并项控制，覆盖period配置：
## 浏览器第一次请求服务器，服务器告诉浏览器此资源缓存7200秒，7200秒以内的所有此资源访问
#不用发给服务器请求，7200秒以后发请求给服务器
spring.web.resources.cache.cachecontrol.max-age=7200
#使用资源 last-modified 时间，来对比服务器和浏览器的资源是否相同没有变化。相同返回 304,默认开启
spring.web.resources.cache.use-last-modified=true

2. 自定义静态资源规则

自定义静态资源路径、自定义缓存规则

1. 配置方式

spring.mvc：静态资源访问前缀路径
spring.web：

静态资源目录
静态资源缓存策略

2. 代码方式

容器中只要有一个 WebMvcConfigurer 组件。配置的底层行为都会生效
@EnableWebMvc //禁用boot的默认配置

5. EnableWebMvcConfiguration 源码

也是WebMvcAutoConfiguration的内部类

//SpringBoot 给容器中放 WebMvcConfigurationSupport 组件。
//我们如果自己放了 WebMvcConfigurationSupport 组件，Boot的WebMvcAutoConfiguration都会失效。
@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(WebProperties.class)
public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration implements ResourceLoaderAware 
{

    
}

HandlerMapping：根据请求路径找那个handler能处理请求

SpringMVC工作原理之处理映射[HandlerMapping]
SpringMVC 内部是根据 HandlerMapping 将 Request 和 Controller 里面的方法对应起来的

WelcomePageHandlerMapping(webmvcAutoConfiguration里面注入所依赖的bean)：
1. 访问 /**路径下的所有请求，都在以前四个静态资源路径下找，欢迎页也一样
2. 找index.html：只要静态资源的位置有一个 index.html页面，项目启动默认访问（意思是如果静态资源里面有index.html，那么项目启动也就是根路径默认跳转到index.html）

Favicon ：网站图标

在静态资源目录下找 favicon.ico

理解：springboot启动成功后会在静态资源文件中寻找favicon.ico文件，如果存在这个文件就把网站的图标设置为这个，当然这里的favicon.ico文件名要正确。如果删除了favicon.ico文件，但是浏览器的图标仍然存在，那是因为浏览器的缓存机制缓存了该图标。

5. 缓存实验

1.跟缓存有关的配置是spring.web前缀的配置属性。
2.

@ConfigurationProperties 是一个 Spring Boot 注解，用于将配置属性绑定到 Java 类的字段上。

在 Spring Boot 应用程序中，配置属性通常存储在配置文件（如 application.properties 
或 application.yml）中。@ConfigurationProperties 注解可以使用在一个类上，用于将配置文件中的
属性值绑定到该类的字段上，实现属性的自动注入。
@ConfigurationProperties("spring.web")是将以 "spring.web" 为前缀的配置属性绑定到 Java 类
的字段上。
使用 @ConfigurationProperties 需要进行以下步骤：
创建一个普通的 Java 类，该类的字段将用于存储配置属性的值。
在该类上添加 @ConfigurationProperties 注解，并指定要绑定的配置属性的前缀。
@Configuration
@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {
    private String name;
    private String version;
    // 其他属性及对应的 getter 和 setter 方法
}
在上述示例中，MyAppProperties 类使用 @ConfigurationProperties 注解，并指定了 prefix 属性为
"myapp"。这意味着该类的字段将与以 "myapp" 为前缀的配置属性进行绑定。

假设在配置文件中有以下属性：
myapp.name=My App
myapp.version=1.0.0
通过使用 @ConfigurationProperties 注解，可以将 "My App" 绑定到 name 字段上，
将 "1.0.0" 绑定到 version 字段上。

3.spring.web可以配置国际化的区域信息，配置静态资源策略（开启，处理链，缓存），

server.port=9000

#1、spring.web：
# 1.配置国际化的区域信息
# 2.静态资源策略(开启、处理链、缓存)

#开启静态资源映射规则，默认结果为true,spring.web.resources.add-mappings和Resources类
#的addMappings属性对应。
spring.web.resources.add-mappings=true

#设置缓存,设置了缓存时间为3600s
#spring.web.resources.cache.period=3600
##缓存详细合并项控制，覆盖period配置：
## 浏览器第一次请求服务器，服务器告诉浏览器此资源缓存7200秒，7200秒以内的所有此资源访问不用发给服务器请求，7200秒以后发请求给服务器
spring.web.resources.cache.cachecontrol.max-age=7200
#使用资源 last-modified 时间，来对比服务器和浏览器的资源是否相同没有变化。相同返回 304
spring.web.resources.cache.use-last-modified=true

2. 自定义静态资源规则

自定义静态资源路径、自定义缓存规则

1. 配置方式

spring.mvc：静态资源访问前缀路径
spring.web：

静态资源目录
静态资源缓存策略

#1、spring.web：
# 1.配置国际化的区域信息
# 2.静态资源策略(开启、处理链、缓存)

#开启静态资源映射规则
spring.web.resources.add-mappings=true

#设置缓存
spring.web.resources.cache.period=3600
##缓存详细合并项控制，覆盖period配置：
## 浏览器第一次请求服务器，服务器告诉浏览器此资源缓存7200秒，7200秒以内的所有此资源访问不用发给服务器请求，7200秒以后发请求给服务器
spring.web.resources.cache.cachecontrol.max-age=7200
## 共享缓存，只要是这个客户端其他用户都可以使用这个缓存
spring.web.resources.cache.cachecontrol.cache-public=true
#使用资源 last-modified 时间，来对比服务器和浏览器的资源是否相同没有变化。相同返回 304
spring.web.resources.cache.use-last-modified=true

#自定义静态资源文件夹位置
spring.web.resources.static-locations=classpath:/a/,classpath:/b/,classpath:/static/

#2、 spring.mvc
## 2.1. 自定义webjars路径前缀,以后访问/wj/**路径的时候会在/wedjars/**路径下寻找 
spring.mvc.webjars-path-pattern=/wj/**
## 2.2. 静态资源访问路径前缀常和spring.web.resources.static-locations联合使用
spring.mvc.static-path-pattern=/static/**

2. 代码方式

容器中只要有一个 WebMvcConfigurer 组件。配置的底层行为都会生效
@EnableWebMvc //禁用boot的默认配置

//@EnableWebMvc //禁用boot的默认配置，添加了就会禁用boot的默认配置的规则。
//，没有添加就会保留以前的规则和自己新写的规则
@Configuration //这是一个配置类
public class MyConfig implements WebMvcConfigurer {


    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        //保留以前规则
        //自己写新的规则。
        registry.addResourceHandler("/static/**")
                .addResourceLocations("classpath:/a/","classpath:/b/")
                .setCacheControl(CacheControl.maxAge(1180, TimeUnit.SECONDS));
    }
}

@Configuration //这是一个配置类,给容器中放一个 WebMvcConfigurer 组件，就能自定义底层
public class MyConfig  /*implements WebMvcConfigurer*/ {


    @Bean
    public WebMvcConfigurer webMvcConfigurer(){
        return new WebMvcConfigurer() {
            @Override
            public void addResourceHandlers(ResourceHandlerRegistry registry) {
                registry.addResourceHandler("/static/**")
                        .addResourceLocations("classpath:/a/", "classpath:/b/")
                        .setCacheControl(CacheControl.maxAge(1180, TimeUnit.SECONDS));
            }
        };
    }

}

6. 为什么容器中放一个WebMvcConfigurer就能配置底层行为

WebMvcAutoConfiguration 是一个自动配置类，它里面有一个 EnableWebMvcConfiguration
EnableWebMvcConfiguration继承与 DelegatingWebMvcConfiguration，这两个都生效
DelegatingWebMvcConfiguration利用 ID 把容器中所有 WebMvcConfigurer 注入进来
别人调用 DelegatingWebMvcConfiguration 的方法配置底层规则，而它调用所有 WebMvcConfigurer的配置底层方法。

3. 路径匹配

Spring5.3 之后加入了更多的请求路径匹配的实现策略；
以前只支持 AntPathMatcher 策略, 现在提供了 PathPatternParser策略。并且可以让我们指定到底使用那种策略。

1. Ant风格路径用法

Ant 风格的路径模式语法具有以下规则：

*：表示任意数量的字符。
?：表示任意一个字符。
：表示任意数量的目录**。
{}：表示一个命名的模式占位符。
[]：表示字符集合，例如[a-z]表示小写字母。

例如：

*.html匹配任意名称，扩展名为.html的文件。
/folder1//.java匹配在folder1目录下的任意两级目录下的.java文件。
/folder2/**/*.jsp匹配在folder2目录下任意目录深度的.jsp文件。
/{type}/{id}.html匹配任意文件名为{id}.html，在任意命名的{type}目录下的文件。

注意：Ant 风格的路径模式语法中的特殊字符需要转义，如：

要匹配文件路径中的星号，则需要转义为\*。
要匹配文件路径中的问号，则需要转义为\?。

2. 模式切换

AntPathMatcher 与 PathPatternParser

PathPatternParser在 jmh 基准测试下，有 6~8 倍吞吐量提升，降低 30%~40%空间分配率
PathPatternParser 兼容 AntPathMatcher语法，并支持更多类型的路径模式
PathPatternParser "**" 多段匹配的支持仅允许在模式末尾使用

@GetMapping("/a*/b?/{p1:[a-f]+}")
public String hello(HttpServletRequest request, 
                    @PathVariable("p1") String path) {

    log.info("路径变量p1： {}", path);
    //获取请求路径
    String uri = request.getRequestURI();
    return uri;
}

总结：

使用默认的路径匹配规则，是由 PathPatternParser 提供的
如果路径中间需要有 **，替换成ant风格路径

# 改变路径匹配策略：
# ant_path_matcher 老版策略；
# path_pattern_parser 新版策略；
spring.mvc.pathmatch.matching-strategy=ant_path_matcher

4. 内容协商

一套系统适配多端数据返回

1. 多端内容适配

1. 默认规则

SpringBoot 多端内容适配。
1. 基于请求头内容协商：（默认开启）
  1. 客户端向服务端发送请求，携带HTTP标准的Accept请求头。
    1. Accept: application/json、text/xml、text/yaml
    2. 服务端根据客户端请求头期望的数据类型进行动态返回
    3. **1、默认支持把对象写为json。因为默认web场景导入了jackson处理json的包;jackson-core

2、jackson也支持把数据写为xml。导入xml相关依赖**
2. 基于请求参数内容协商：（需要开启）下面的?format就是要返回数据的格式。
1. 发送请求 GET /projects/spring-boot?format=json
2. 匹配到 @GetMapping(“/projects/spring-boot”)
3. 根据参数协商，优先返回 json 类型数据【需要开启参数匹配设置】
4. 发送请求 GET /projects/spring-boot?format=xml,优先返回 xml 类型数据

2. 效果演示

请求同一个接口，可以返回json和xml不同格式数据,、默认支持把对象写为json。因为默认web场景导入了jackson处理json的包;jackson-core,jackson也支持把数据写为xml。导入xml相关依赖

引入支持写出xml内容依赖

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
</dependency>

标注注解

@JacksonXmlRootElement  // 可以写出为xml文档
@Data
public class Person {
    private Long id;
    private String userName;
    private String email;
    private Integer age;
}

开启基于请求参数的内容协商

# 开启基于请求参数的内容协商功能。 默认参数名：format。 默认此功能不开启
spring.mvc.contentnegotiation.favor-parameter=true
# 指定内容协商时使用的参数名。默认是 format
spring.mvc.contentnegotiation.parameter-name=type

效果

3. 配置协商规则与支持类型

修改内容协商方式

#使用参数进行内容协商
spring.mvc.contentnegotiation.favor-parameter=true  
#自定义参数名，默认为format
spring.mvc.contentnegotiation.parameter-name=myparam

大多数 MediaType 都是开箱即用的。也可以自定义内容类型，如：

1	spring.mvc.contentnegotiation.media-types.yaml=text/yaml

2. 自定义内容返回

1. 增加yaml返回支持

导入依赖

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-yaml</artifactId>
</dependency>

把对象写出成YAML

    public static void main(String[] args) throws JsonProcessingException {
        Person person = new Person();
        person.setId(1L);
        person.setUserName("张三");
        person.setEmail("aaa@qq.com");
        person.setAge(18);
//禁用文档的开始标记
        YAMLFactory factory = new YAMLFactory().disable(YAMLGenerator.Feature.WRITE_DOC_START_MARKER);
        ObjectMapper mapper = new ObjectMapper(factory);

        String s = mapper.writeValueAsString(person);
        System.out.println(s);
    }

编写配置

1 2	#新增一种媒体类型， spring.mvc.contentnegotiation.media-types.yaml=text/yaml

增加HttpMessageConverter组件，专门负责把对象写出为yaml格式

@Bean
public WebMvcConfigurer webMvcConfigurer(){
    return new WebMvcConfigurer() {
        @Override //配置一个能把对象转为yaml的messageConverter
        public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
            converters.add(new MyYamlHttpMessageConverter());//将新增的配置格式和配置类关联起来
        }
    };
}

3. HttpMessageConverter的示例写法

public class MyYamlHttpMessageConverter extends AbstractHttpMessageConverter<Object> {
//或者是实现 HttpMessageConverter
    private ObjectMapper objectMapper = null; //把对象转成yaml

    public MyYamlHttpMessageConverter(){
        //告诉SpringBoot这个MessageConverter支持哪种媒体类型  //媒体类型
        super(new MediaType("text", "yaml", Charset.forName("UTF-8")));
        YAMLFactory factory = new YAMLFactory()
                .disable(YAMLGenerator.Feature.WRITE_DOC_START_MARKER);
        this.objectMapper = new ObjectMapper(factory);
    }

    @Override
    protected boolean supports(Class<?> clazz) {
        //只要是对象类型，不是基本类型
        return true;
    }

    @Override  //@RequestBody,读取请求对象 
    protected Object readInternal(Class<?> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
        return null;
    }

    @Override //@ResponseBody 把对象怎么写出去
    protected void writeInternal(Object methodReturnValue, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {

        //try-with写法，自动关流
        try(OutputStream os = outputMessage.getBody()){
            this.objectMapper.writeValue(os,methodReturnValue);
        }

    }
}

2. 思考：如何增加其他

配置媒体类型支持:
- spring.mvc.contentnegotiation.media-types.yaml=text/yaml
编写对应的HttpMessageConverter，要告诉Boot这个支持的媒体类型
- 按照3的示例
把MessageConverter组件加入到底层
- 容器中放一个WebMvcConfigurer 组件，并配置底层的MessageConverter

3. 内容协商原理-HttpMessageConverter

HttpMessageConverter 怎么工作？合适工作？
定制 HttpMessageConverter 来实现多端内容协商
编写WebMvcConfigurer提供的configureMessageConverters底层，修改底层的MessageConverter

1. @ResponseBody由HttpMessageConverter处理

标注了@ResponseBody的返回值将会由支持它的 HttpMessageConverter写给浏览器

如果controller方法的返回值标注了 @ResponseBody 注解
1. 请求进来先来到DispatcherServlet的doDispatch()进行处理

doDispatch() 是 Spring MVC 中的核心方法之一，用于处理请求的分发和调度。

在 Spring MVC 中，请求的处理流程如下：

1.客户端发送一个 HTTP 请求到服务器。
2.前端控制器（Front Controller）接收到请求，这个控制器通常是 DispatcherServlet，它是 
Spring MVC 的核心组件。
3.DispatcherServlet 根据请求的 URL 找到相应的处理器（Handler）。
4.处理器执行相应的业务逻辑并返回一个 ModelAndView 对象。(其中执行目标方法要准备参数解析器和
返回值解析器）
5.DispatcherServlet 根据 ModelAndView 对象选择合适的视图（View）进行渲染。
最终将渲染结果返回给客户端。（
在这个处理流程中，doDispatch() 方法负责实际执行第 4 步和第 5 步的操作。

具体而言，doDispatch() 方法会执行以下主要任务：

解析请求，包括解析请求的方法、路径、参数等信息。
根据请求的方法和路径，确定匹配的处理器（Handler）。
执行处理器的业务逻辑，处理请求并返回一个 ModelAndView 对象。
根据 ModelAndView 对象中的视图名字，选择合适的视图（View）进行渲染。
渲染视图，生成最终的响应结果。
doDispatch() 方法的具体实现会涉及到请求的映射、处理器适配器、处理器拦截器、参数解析器等等。
该方法是 Spring MVC 框架的核心之一，在请求的处理过程中起到了关键的作用。

需要注意的是，doDispatch() 方法通常由 DispatcherServlet 自动调用，开发者一般不需要直接调用
该方法。开发者主要关注配置合适的请求映射、编写处理器方法以及配置视图解析器等，框架会自动根据
配置和规则来调用 doDispatch() 方法来处理请求。

找到一个 HandlerAdapter 适配器。利用适配器执行目标方法
RequestMappingHandlerAdapter来执行，调用invokeHandlerMethod（）来执行目标方法
目标方法执行之前，准备好两个东西
1. HandlerMethodArgumentResolver：参数解析器，确定目标方法每个参数值
2. HandlerMethodReturnValueHandler：返回值处理器，确定目标方法的返回值改怎么处理
RequestMappingHandlerAdapter 里面的invokeAndHandle()真正执行目标方法
目标方法执行完成，会返回返回值对象
**找到一个合适的返回值处理器 **HandlerMethodReturnValueHandler
最终找到 RequestResponseBodyMethodProcessor能处理标注了 @ResponseBody注解的方法
RequestResponseBodyMethodProcessor 调用writeWithMessageConverters ,利用MessageConverter把返回值写出去

上面解释：@ResponseBody由HttpMessageConverter处理

1
2
3

HttpMessageConverter 是 Spring MVC 中的一个关键接口，用于处理 HTTP 请求和响应消息的转换。
它负责将 Java 对象与 HTTP 请求/响应的内容进行转换，使得应用程序可以方便地处理不同类型的数据格式，
如 JSON、XML、表单数据等。

HttpMessageConverter 会先进行内容协商
1. 遍历所有的MessageConverter看谁支持这种内容类型的数据
2. 默认MessageConverter有以下
4. 最终因为要json所以MappingJackson2HttpMessageConverter支持写出json
5. jackson用ObjectMapper（是一个类）把对象写出去

2. WebMvcAutoConfiguration提供几种默认HttpMessageConverters

EnableWebMvcConfiguration通过 addDefaultHttpMessageConverters添加了默认的MessageConverter；如下：
- ByteArrayHttpMessageConverter：支持字节数据读写
- StringHttpMessageConverter：支持字符串读写
- ResourceHttpMessageConverter：支持资源读写
- ResourceRegionHttpMessageConverter: 支持分区资源写出
- AllEncompassingFormHttpMessageConverter：支持表单xml/json读写
- MappingJackson2HttpMessageConverter：支持请求响应体Json读写

默认8个：

系统提供默认的MessageConverter 功能有限，仅用于json或者普通返回数据。额外增加新的内容协商功能，必须增加新的HttpMessageConverter

5. 模板引擎

由于 SpringBoot 使用了嵌入式 Servlet 容器。所以 JSP 默认是不能使用的。
如果需要服务端页面渲染，优先考虑使用模板引擎。

模板引擎页面默认放在 src/main/resources/templates
SpringBoot 包含以下模板引擎的自动配置

FreeMarker
Groovy
Thymeleaf
Mustache

Thymeleaf官网：https://www.thymeleaf.org/

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
	<title>Good Thymes Virtual Grocery</title>
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
	<link rel="stylesheet" type="text/css" media="all" th:href="@{/css/gtvg.css}" />
</head>
<body>
	<p th:text="#{home.welcome}">Welcome to our grocery store!</p>
</body
</html>

1. Thymeleaf整合（是前后端一体的开发）

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

自动配置原理

开启了org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration自动配置
属性绑定在 ThymeleafProperties类中，对应配置文件 spring.thymeleaf 内容（也就是配置文件中以spring.thymeleaf开头的属性）
所有的模板页面默认在 classpath:/templates文件夹下
默认效果
1. 所有的模板页面在 classpath:/templates/下面找
2. 找后缀名为.html的页面

事例：
1.使用Thymeleaf来处理的项目其controller类用@Controller //适配服务端渲染前后不分离模式开始;而前后端分离的项目用@Resttroller注解
Spring 注解之@RestController与@Controller的区别 - 楼兰胡杨 - 博客园

@RestController无法返回指定页面，而@Controller可以；前者可以直接返回数据，
后者需要@ResponseBody辅助。
如果需要返回JSON，XML或自定义mediaType内容到页面，@RestController自己就可以搞定，
这个注解对于返回数据比较方便，因为它会自动将对象实体转换为JSON格式。而@Controller需要在对应的
方法加上@ResponseBody注解。

2.get请求其参数是写在url中的，而post请求参数是在请求体中的。
3.@GetMapping（）用来修饰处理get请求的方法。
4.//模板的逻辑视图名
//物理视图 = 前缀 + 逻辑视图名 + 后缀
//真实地址 = classpath:/templates/welcome.html其中的前缀和后缀在ThymeleafProperties类中指定了的
5.其Thymeleaf还提供了一些工具类，常用#类名表示，例如：#string。这些工具类可以进行简单的运行操作。
6.如果html中要使用Thymeleaf语法，需要提供其命名空间

2. 基础语法（在html中使用Thymeleaf）

1. 核心用法

导入命名空间：

1
2
3

<html lang="en" xmlns:th="http://www.thymeleaf.org">
xmlns:th属性，该属性是Thymeleaf命名空间（http://www.thymeleaf.org）的声明。
这个命名空间允许您在HTML代码中使用Thymeleaf特定的属性和表达式。

th:xxx：动态渲染指定的 html 标签属性值、或者th指令（遍历、判断等）

th:text：标签体内文本值渲染
- th:utext：不会转义，显示为html原本的样子。也就是文本中的html元素可以被解析
th:属性：标签指定属性渲染
th:attr：标签任意属性渲染
th:if （根据后端逻辑或数据的条件来控制是否在渲染过程中包含或显示某个元素。） th:each…：其他th指令
例如：

<p th:text="${content}">原内容</p>
<a th:href="${url}">登录</a>
<img src="../../images/gtvglogo.png" 
     th:attr="src=@{/images/gtvglogo.png},title=#{logo},alt=#{logo}" />

表达式：用来动态取值

${}：变量取值；使用model共享给页面的值都直接用${}是用下面的方法实现的：

model.addAttribute(“imgUrl”,“/4.jpg”);imgUrl就是共享的值

@{}：url路径；@{}是一个Thymeleaf的URL表达式，它用来在HTML文档中生成一个相对于当前应用上下文的URL路径。当然也可以直接使用{}表示，例如：src="{}"但是其如果在配置文件中配置了server.servlet.context-path=/demo那么要想配置的src路径生效需要在src的路径前添加/demo前缀否则无法访问，如果是使用的是src=的是@{}那么可以不用修改src仍旧可以正常访问。
**@{}路径中的内容会自动添加链接头部和尾部 **
#{}：国际化消息
~{}：片段引用
*{}：变量选择：需要配合th:object绑定对象

系统工具&内置对象：详细文档

param：请求参数对象
session：session对象
application：application对象
#execInfo：模板执行信息
#messages：国际化消息
#uris：uri/url工具
#conversions：类型转换工具
#dates：日期工具，是java.util.Date对象的工具类
#calendars：类似#dates，只不过是java.util.Calendar对象的工具类
#temporals： JDK8+ java.time API 工具类
#numbers：数字操作工具
#strings：字符串操作
#objects：对象操作
#bools：bool操作
#arrays：array工具
#lists：list工具
#sets：set工具
#maps：map工具
#aggregates：集合聚合工具（sum、avg）
#ids：id生成工具

2. 语法示例

表达式：

变量取值：${…}
url 取值：@{…}
国际化消息：#{…}
变量选择：*{…}
片段引用:~{…}

常见：

文本：‘one text’，‘another one!’,…
数字：0,34,3.0,12.3,…
布尔：true、false
null:null
变量名：one,sometext,main…

文本操作：

拼串：+
文本替换：| The name is ${name} |

布尔操作：

二进制运算：and,or
取反：!,not

比较运算：

比较：>，<，<=，>=（gt，lt，ge,le）
等值运算：==,!=（eq，ne）

条件运算：

if-then：(if)?(then)
if-then-else:(if)?(then):(else)
default:(value)?:(defaultValue)

特殊语法：

无操作：_

所有以上都可以嵌套组合

1	'User is of type ' + (${user.isAdmin()} ? 'Administrator' : (${user.type} ?: 'Unknown'))

3. 属性设置

th:href=“@{/product/list}”
th:attr=“class=${active}”
th:attr=“src=@{/images/gtvglogo.png},title=${logo},alt=#{logo}”
th:checked=“${user.active}”

<p th:text="${content}">原内容</p>
<a th:href="${url}">登录</a>
<img src="../../images/gtvglogo.png" 
     th:attr="src=@{/images/gtvglogo.png},title=#{logo},alt=#{logo}" />

4. 遍历

语法： th:each=“元素名,迭代状态 : ${集合}”

<tr th:each="prod : ${prods}">
  <td th:text="${prod.name}">Onions</td>
  <td th:text="${prod.price}">2.41</td>
  <td th:text="${prod.inStock}? #{true} : #{false}">yes</td>
</tr>

<tr th:each="prod,iterStat : ${prods}" th:class="${iterStat.odd}? 'odd'">
  <td th:text="${prod.name}">Onions</td>
  <td th:text="${prod.price}">2.41</td>
  <td th:text="${prod.inStock}? #{true} : #{false}">yes</td>
</tr>

iterStat 有以下属性：

index：当前遍历元素的索引，从0开始
count：当前遍历元素的索引，从1开始
size：需要遍历元素的总数量
current：当前正在遍历的元素对象
even/odd：是否偶数/奇数行
first：是否第一个元素
last：是否最后一个元素

1 2	<th scope="col">#</th>这里的th标签表示是一个表头标签，scope属性指定表头单元格的范围，这里的范围是一个表头占据一个单元格。

5. 判断

th:if

1	<td th:text="\| ${person.age} / ${person.age >= 18?'成年':'未成年' }\|"> </td>

<a
  href="comments.html"
  th:href="@{/product/comments(prodId=${prod.id})}"
  th:if="${not #lists.isEmpty(prod.comments)}"
  >view</a

th:switch

<div th:switch="${user.role}">
  <p th:case="'admin'">User is an administrator</p>//这里的admin的单引号表示其为一个字符串
//，和变量区分

  <p th:case="#{roles.manager}">User is a manager</p>
  <p th:case="*">User is some other thing</p>
</div>

6. 属性优先级

片段
遍历
判断

1
2
3

<ul>
  <li th:each="item : ${items}" th:text="${item.description}">Item description here...</li>
</ul>

Order	Feature	Attributes
1	片段包含	th:insertth:replace
2	遍历	th:each
3	判断	th:ifth:unlessth:switchth:case
4	定义本地变量	th:objectth:with
5	通用方式属性修改	th:attrth:attrprependth:attrappend
6	指定属性修改	th:valueth:hrefth:src…
7	文本值	th:textth:utext
8	片段指定	th:fragment
9	片段移除	th:remove

7. 行内写法

[[…]] or [(…)]

1	<p>Hello, [[${session.user.name}]]!</p>

8. 变量选择

<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>

等同于

<div>
  <p>Name: <span th:text="${session.user.firstName}">Sebastian</span>.</p>
  <p>Surname: <span th:text="${session.user.lastName}">Pepper</span>.</p>
  <p>Nationality: <span th:text="${session.user.nationality}">Saturn</span>.</p>
</div

9. 模板布局

定义模板： th:fragment
引用模板：~{templatename::selector}
插入模板：th:insert、th:replace

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

<body>
  <div th:insert="~{footer :: copy}"></div>
  <div th:replace="~{footer :: copy}"></div>
</body>
<body>
  结果：
  <body>
    <div>
      <footer>&copy; 2011 The Good Thymes Virtual Grocery</footer>
    </div>

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

1
2
3

th:insert和th:replace是Thymeleaf模板引擎中的两个属性，用于在模板中插入或替换其他模板片段。
th:insert属性用于在当前模板中插入另一个模板片段。
th:replace属性用于在当前模板中替换自身的内容为另一个模板片段。

10. devtools

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

修改页面后；ctrl+F9刷新效果（热启动）；前提是配置了devtools。
java代码的修改，如果devtools热启动了，可能会引起一些bug，难以排查
（缓存机制）
spring.thymeleaf.check-template=false检查模板是否存在

6. 国际化

国际化的自动配置参照MessageSourceAutoConfiguration
实现步骤：

Spring Boot 在类路径根下查找messages资源绑定文件（配置。文件名为：messages.properties
多语言可以定义多个消息文件，命名为messages_区域代码.properties。如：
1. messages.properties：默认
2. messages_zh_CN.properties：中文环境
3. messages_en_US.properties：英语环境
在程序中可以自动注入 MessageSource组件，获取国际化的配置项值
在页面中可以使用表达式 #{}获取国际化的配置项值

@Autowired  //国际化取消息用的组件
MessageSource messageSource;
@GetMapping("/haha")
public String haha(HttpServletRequest request){

    Locale locale = request.getLocale();
    //利用代码的方式获取国际化配置文件中指定的配置项的值
    String login = messageSource.getMessage("login", null, locale);
    return login;
}

7. 错误处理

1. 默认机制

错误处理的自动配置都在ErrorMvcAutoConfiguration中，两大核心机制：

1. SpringBoot 会自适应处理错误，响应页面或JSON数据

Spring Boot 会根据请求的类型和接受的媒体类型，自适应地处理错误，返回合适的响应格式。
如果请求是一个浏览器请求，Spring Boot 会返回一个 HTML 错误页面，这个页面也被称为白标错误页面。
如果请求是一个 RESTful 请求，或者接受的媒体类型是 JSON，Spring Boot 会返回一个 JSON 响应，
包含错误的详细信息，HTTP 状态码，和异常消息

2.** SpringMVC的错误处理机制依然保留，MVC处理不了，才会交给boot进行处理**

1.springMvc处理错误：

这里如果发生了错误，会执行@ExceptionHandler修饰的方法，这里是将handleException中的方法的返回值写到返回体中，然后返回该浏览器。
2.

发生错误以后，转发给/error路径，SpringBoot在底层写好一个 BasicErrorController的组件，专门处理这个请求

@RequestMapping(produces = MediaType.TEXT_HTML_VALUE) //返回HTML
public ModelAndView errorHtml(HttpServletRequest request, HttpServletResponse response) {
	HttpStatus status = getStatus(request);
	Map<String, Object> model = Collections
		.unmodifiableMap(getErrorAttributes(request, getErrorAttributeOptions(request, MediaType.TEXT_HTML)));
	response.setStatus(status.value());
	ModelAndView modelAndView = resolveErrorView(request, response, status, model);
	return (modelAndView != null) ? modelAndView : new ModelAndView("error", model);
}

@RequestMapping  //返回 ResponseEntity, JSON
public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
	HttpStatus status = getStatus(request);
	if (status == HttpStatus.NO_CONTENT) {
		return new ResponseEntity<>(status);
	}
	Map<String, Object> body = getErrorAttributes(request, getErrorAttributeOptions(request, MediaType.ALL));
	return new ResponseEntity<>(body, status);
}

错误页面是这么解析到的

//1、解析错误的自定义视图地址	
ModelAndView modelAndView = resolveErrorView(request, response, status, model);
//2、如果解析不到错误页面的地址，默认的错误页就是 error
return (modelAndView != null) ? modelAndView : new ModelAndView("error", model);

容器中专门有一个错误视图解析器

@Bean
@ConditionalOnBean(DispatcherServlet.class)
@ConditionalOnMissingBean(ErrorViewResolver.class)
DefaultErrorViewResolver conventionErrorViewResolver() {
    return new DefaultErrorViewResolver(this.applicationContext, this.resources);
}

SpringBoot解析自定义错误页的默认规则

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

private ModelAndView resolve(String viewName, Map<String, Object> model) {
	String errorViewName = "error/" + viewName;
	TemplateAvailabilityProvider provider = this.templateAvailabilityProviders.getProvider(errorViewName,
			this.applicationContext);
	if (provider != null) {
		return new ModelAndView(errorViewName, model);
	}
	return resolveResource(errorViewName, model);
}

private ModelAndView resolveResource(String viewName, Map<String, Object> model) {
	for (String location : this.resources.getStaticLocations()) {
		try {
			Resource resource = this.applicationContext.getResource(location);
			resource = resource.createRelative(viewName + ".html");
			if (resource.exists()) {
				return new ModelAndView(new HtmlResourceView(resource), model);
			}
		}
		catch (Exception ex) {
		}
	}
	return null;
}

容器中有一个默认的名为 error 的 view；提供了默认白页功能

@Bean(name = "error")
@ConditionalOnMissingBean(name = "error")
public View defaultErrorView() {
    return this.defaultErrorView;
}

封装了JSON格式的错误信息

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

规则：

解析一个错误页
1. 如果发生了500、404、503、403 这些错误
  1. 如果有模板引擎，默认在 classpath:/templates/error/精确码.html
  2. 如果没有模板引擎，在静态资源文件夹下找 精确码.html
2. 如果匹配不到精确码.html这些精确的错误页，就去找5xx.html，4xx.html模糊匹配
  1. 如果有模板引擎，默认在 classpath:/templates/error/5xx.html
  2. 如果没有模板引擎，在静态资源文件夹下找 5xx.html
如果模板引擎路径templates下有 error.html页面，就直接渲染

2. 自定义错误响应

1. 自定义json响应

使用@ControllerAdvice + @ExceptionHandler 进行统一异常处理

2. 自定义页面响应

根据boot的错误页面规则，自定义页面模板

3. 最佳实战

前后分离
- 后台发生的所有错误，@ControllerAdvice + @ExceptionHandler进行统一异常处理。
服务端页面渲染
- 不可预知的一些，HTTP码表示的服务器或客户端错误
  - 给classpath:/templates/error/下面，放常用精确的错误码页面。500.html，404.html
  - 给classpath:/templates/error/下面，放通用模糊匹配的错误码页面。 5xx.html，4xx.html
- 发生业务错误
  - 核心业务，每一种错误，都应该代码控制，跳转到自己定制的错误页。
  - 通用业务，classpath:/templates/error.html页面，显示错误信息（可以通过在错误页面中添加[[${trance}]]来显示错误堆栈信息）。

页面，JSON，可用的Model数据如下

8. 嵌入式容器

Servlet容器：管理、运行Servlet组件（Servlet、Filter、Listener）的环境，一般指服务器

1. 自动配置原理

SpringBoot 默认嵌入Tomcat作为Servlet容器。
自动配置类是ServletWebServerFactoryAutoConfiguration，EmbeddedWebServerFactoryCustomizerAutoConfiguration
自动配置类开始分析功能。xxxxAutoConfiguration

@AutoConfiguration
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@ConditionalOnClass(ServletRequest.class)//@ConditionOn表示满足这些条件才将该类加载到容器中
@ConditionalOnWebApplication(type = Type.SERVLET)
@EnableConfigurationProperties(ServerProperties.class)
@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
		ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
		ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
		ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
public class ServletWebServerFactoryAutoConfiguration {
    
}

@AutoConfiguration：该注解表示这是一个自动配置类，用于自动配置应用程序的某些功能或组件。

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)：该注解指定了自动配置类的优先级，
使用 Ordered.HIGHEST_PRECEDENCE 表示具有最高优先级。优先级较高的自动配置类将在启动过程中优先
加载和应用。

@ConditionalOnClass(ServletRequest.class)：该注解表示只有当类路径上存在 ServletRequest 类时
，才会加载和应用该自动配置类。也就是说，只有当 Servlet 相关的类存在时，该自动配置类才会生效。

@ConditionalOnWebApplication(type = Type.SERVLET)：该注解表示只有当应用程序类型为 Servlet
Web 应用时，才会加载和应用该自动配置类。这意味着该自动配置类仅适用于基于 Servlet 的 Web 
应用程序，而不适用于其他类型的应用程序。web程序除了servlet外还有其他的，比如：响应式，JSP等。
关于 Servlet 的特点，以下是一些主要的特点：
平台无关性：Servlet 是基于 Java 技术的，可以在任何支持 Java 的平台上运行，无论是 Windows、
Linux 还是其他操作系统。
可移植性：Servlet 可以在不同的 Web 容器中运行，例如 Tomcat、Jetty、WebLogic 等。
这使得开发人员可以在不同的容器中部署和运行 Servlet，而不需要修改代码。

@EnableConfigurationProperties(ServerProperties.class)：用于启用配置属性的绑定并将其注入到
Spring 容器中。
在这种情况下，ServerProperties 类的配置属性将被绑定到该自动配置类中。
其中ServerProperties 类被@ConfigurationProperties(
    prefix = "server",
    ignoreUnknownFields = true
)修饰，@ConfigurationProperties 是一个注解，用于将配置属性绑定到一个类上。在上述代码中，
它被应用在类级别上，表示将配置属性绑定到带有 prefix 前缀的属性上，并且忽略未知的字段。
但是其ServerProperties 类在此时并未注入到容器中。

@Import({ ... })：该注解用于导入其他的配置类或组件。在这个例子中，它导入了与 Servlet Web
服务器工厂相关的配置类，包括 Tomcat、Jetty 和 Undertow 的配置。

ServletWebServerFactoryAutoConfiguration 自动配置了嵌入式容器场景
绑定了ServerProperties配置类，所有和服务器有关的配置 server（也就是配置文件·中以server开头的配置属性是关于服务器的）
ServletWebServerFactoryAutoConfiguration 导入了嵌入式的三大服务器 Tomcat、Jetty、Undertow

1.servlet不仅支持Tomcat服务器还支持Jetty ，Netty，Undertow服务器
2.

@ConditionalOnClass({Servlet.class, Tomcat.class, UpgradeProtocol.class})
    @ConditionalOnMissingBean(
        value = {ServletWebServerFactory.class},
        search = SearchStrategy.CURRENT
    )
    static class EmbeddedTomcat {
        EmbeddedTomcat() {
        }
@ConditionalOnClass({Servlet.class, Tomcat.class, UpgradeProtocol.class})决定了web程序的服务器
类型，而避免了其他类型的服务器。

导入 Tomcat、Jetty、Undertow 都有条件注解。系统中有这个类才行（也就是导了包）也是这种方式决定了web程序采用的服务器类型。
默认 Tomcat配置生效。给容器中放 TomcatServletWebServerFactory
都给容器中 ServletWebServerFactory放了一个** web服务器工厂（造web服务器的）可以在ServletWebServerFactoryAutoConfiguration类中查看到注入了不同的 ServletWebServerFactory**

1 2	@Bean TomcatServletWebServerFactory tomcatServletWebServerFactory

**web服务器工厂都有一个功能，**getWebServer获取web服务器。其中TomcatServletWebServerFactory 创建了tomcat而其他服务器工厂没有创建。
TomcatServletWebServerFactory 创建了 tomcat。
ServletWebServerFactory 什么时候会创建 webServer出来。
ServletWebServerApplicationContextioc容器，启动的时候会调用创建web服务器
Spring**容器刷新（启动）**的时候，会预留一个时机，刷新子容器。onRefresh()
refresh() 容器刷新十二大步的刷新子容器会调用 onRefresh()；

@Override
protected void onRefresh() {
	super.onRefresh();
	try {
		createWebServer();
	}
	catch (Throwable ex) {
		throw new ApplicationContextException("Unable to start web server", ex);
	}
}

Web场景的Spring容器启动，在onRefresh的时候，会调用创建web服务器的方法。
Web服务器的创建是通过WebServerFactory搞定的。容器中又会根据导了什么包条件注解，启动相关的服务器配置，默认EmbeddedTomcat会给容器中放一个 TomcatServletWebServerFactory，导致项目启动，自动创建出Tomcat。
用法：
1.修改server下的相关配置就可以修改服务器的参数
2.通过给容器中放一个ServletWebServerFactory,来禁用掉springBoot默认配置的服务器工厂，实现自定义的嵌入式服务器。

2. 自定义

<properties>
    <servlet-api.version>3.1.0</servlet-api.version>
</properties>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <!-- Exclude the Tomcat dependency -->
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!-- Use Jetty instead -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

3. 最佳实践

用法：

修改server下的相关配置就可以修改服务器参数
通过给容器中放一个ServletWebServerFactory，来禁用掉SpringBoot默认放的服务器工厂，实现自定义嵌入任意服务器。

9. 全面接管SpringMVC

SpringBoot 默认配置好了 SpringMVC 的所有常用特性。
如果我们需要全面接管SpringMVC的所有配置并禁用默认配置，仅需要编写一个WebMvcConfigurer配置类，并标注 @EnableWebMvc 即可
全手动模式
- @EnableWebMvc : 禁用默认配置，该注解在@Configuration上
- WebMvcConfigurer组件：定义MVC的底层行为

1. WebMvcAutoConfiguration 到底自动配置了哪些规则

SpringMVC自动配置场景给我们配置了如下所有默认行为

WebMvcAutoConfigurationweb场景的自动配置类
1. 支持RESTful的filter：HiddenHttpMethodFilter(HiddenHttpMethodFilter 的作用就是检查通过 POST 请求提交的表单数据中是否包含名为 _method 的隐藏字段，并将其值作为实际的 HTTP 方法进行处理。也就是新增了delete,和patch)
2. 支持非POST请求，请求体携带数据：FormContentFilter(FormContentFilter 的作用是解析请求体中的表单数据，并将其转换为相应的请求参数，以便后续的处理器（Handler）能够方便地获取和使用这些参数。)
3. 导入EnableWebMvcConfiguration：
  1. RequestMappingHandlerAdapter
  2. WelcomePageHandlerMapping： 欢迎页功能支持（模板引擎目录、静态资源目录放index.html），项目访问/ 就默认展示这个页面.
  3. RequestMappingHandlerMapping：找每个请求由谁处理的映射关系
  4. ExceptionHandlerExceptionResolver：默认的异常解析器
  5. LocaleResolver：国际化解析器
  6. ThemeResolver：主题解析器
  7. FlashMapManager：临时数据共享
  8. FormattingConversionService：数据格式化、类型转化
  9. Validator：数据校验JSR303提供的数据校验功能
  10. WebBindingInitializer：请求参数的封装与绑定
  11. ContentNegotiationManager：内容协商管理器
4. WebMvcAutoConfigurationAdapter配置生效，它是一个WebMvcConfigurer，定义mvc底层组件
  1. 定义好 WebMvcConfigurer底层组件默认功能；所有功能详见列表
  2. 视图解析器：InternalResourceViewResolver
  3. 视图解析器：BeanNameViewResolver,**视图名（controller方法的返回值字符串）**就是组件名
  4. 内容协商解析器：ContentNegotiatingViewResolver
  5. 请求上下文过滤器：RequestContextFilter: 任意位置直接获取当前请求
  6. 静态资源链规则
  7. ProblemDetailsExceptionHandler：错误详情
    1. SpringMVC内部场景异常被它捕获：
5. 定义了MVC默认的底层行为: WebMvcConfigurer

2. @EnableWebMvc 禁用默认行为

@EnableWebMvc给容器中导入 DelegatingWebMvcConfiguration组件，

他是 WebMvcConfigurationSupport

WebMvcAutoConfiguration有一个核心的条件注解, @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)，容器中没有WebMvcConfigurationSupport，WebMvcAutoConfiguration才生效.
@EnableWebMvc 导入 WebMvcConfigurationSupport 导致 WebMvcAutoConfiguration 失效。导致禁用了默认行为

@EnableWebMVC 禁用了 Mvc的自动配置
WebMvcConfigurer 定义SpringMVC底层组件的功能类

2. WebMvcConfigurer 功能

定义扩展SpringMVC底层功能

提供方法	核心参数	功能	默认
addFormatters	FormatterRegistry	格式化器：支持属性上@NumberFormat和@DatetimeFormat的数据类型转换	GenericConversionService
getValidator	无	数据校验：校验 Controller 上使用@Valid标注的参数合法性。需要导入starter-validator	无
addInterceptors	InterceptorRegistry	拦截器：拦截收到的所有请求	无
configureContentNegotiation	ContentNegotiationConfigurer	内容协商：支持多种数据格式返回。需要配合支持这种类型的HttpMessageConverter	支持 json
configureMessageConverters	List<HttpMessageConverter<?>>	消息转换器：标注@ResponseBody的返回值会利用MessageConverter直接写出去	8 个，支持byte，string,multipart,resource，json
addViewControllers	ViewControllerRegistry	视图映射：直接将请求路径与物理视图映射。用于无 java 业务逻辑的直接视图页渲染	无
mvc:view-controller
configureViewResolvers	ViewResolverRegistry	视图解析器：逻辑视图转为物理视图	ViewResolverComposite
addResourceHandlers	ResourceHandlerRegistry	静态资源处理：静态资源路径映射、缓存控制	ResourceHandlerRegistry
configureDefaultServletHandling	DefaultServletHandlerConfigurer	默认 Servlet：可以覆盖 Tomcat 的DefaultServlet。让DispatcherServlet拦截/	无
configurePathMatch	PathMatchConfigurer	路径匹配：自定义 URL 路径匹配。可以自动为所有路径加上指定前缀，比如 /api	无
configureAsyncSupport	AsyncSupportConfigurer	异步支持：	TaskExecutionAutoConfiguration
addCorsMappings	CorsRegistry	跨域：	无
addArgumentResolvers	List	参数解析器：	mvc 默认提供
addReturnValueHandlers	List	返回值解析器：	mvc 默认提供
configureHandlerExceptionResolvers	List	异常处理器：	默认 3 个
ExceptionHandlerExceptionResolver
ResponseStatusExceptionResolver
DefaultHandlerExceptionResolver
getMessageCodesResolver	无	消息码解析器：国际化使用	无

10. 最佳实践

SpringBoot 已经默认配置好了Web开发场景常用功能。我们直接使用即可。

三种方式

方式	用法	效果
全自动	直接编写控制器逻辑	全部使用自动配置默认效果
手自一体	@Configuration +
配置WebMvcConfigurer+
配置 WebMvcRegistrations	不要标注
@EnableWebMvc	保留自动配置效果
手动设置部分功能
定义MVC底层组件
全手动	@Configuration +
配置WebMvcConfigurer	标注
@EnableWebMvc	禁用自动配置效果
全手动设置

总结：
给容器中写一个配置类@Configuration实现 WebMvcConfigurer但是不要标注 @EnableWebMvc注解，实现手自一体的效果。

11. Web新特性

1. Problemdetails

RFC 7807: https://www.rfc-editor.org/rfc/rfc7807

1 2	ProblemDetails 是一种在Web API中表示错误和异常信息的规范化格式。它是根据RFC 7807规范定义的，旨在提供一种统一的方式来描述和传递错误信息。

错误信息返回新格式
原理：

@Configuration(proxyBeanMethods = false)
//配置过一个属性 spring.mvc.problemdetails.enabled=true才能让
//ProblemDetailsErrorHandlingConfiguration生效，其中spring.mvc.problemdetails.enabled
//默认是false的，也就是ProbleDetailsErroHandlingConfiguration默认是关闭的
@ConditionalOnProperty(prefix = "spring.mvc.problemdetails", name = "enabled", havingValue = "true")
static class ProblemDetailsErrorHandlingConfiguration {

    @Bean
    @ConditionalOnMissingBean(ResponseEntityExceptionHandler.class)
    ProblemDetailsExceptionHandler problemDetailsExceptionHandler() {
        return new ProblemDetailsExceptionHandler();
    }

}

ProblemDetailsExceptionHandler (被 @ControllerAdvice修饰的类）是一个 @ControllerAdvice集中处理系统异常,

ProblemDetailsExceptionHandler 继承ResponseEntityExceptionHandler ，而ResponseEntityExceptionHandler类有一个@ExceptionHandle注解用于修饰ResponseEntity