SpringBoot源码解析-01

SpringBoot3详细版

一：SpringBoot引入：

1.1.什么是Springboot：

SpringBoot 帮我们简单、快速地创建一个独立的、生产级别的 Spring 应用（说明：SpringBoot底层是Spring）

大多数 SpringBoot 应用只需要编写少量配置即可快速整合 Spring 平台以及第三方技术

特性：

• 快速创建独立 Spring 应用

• • SSM：导包、写配置、启动运行

• 直接嵌入Tomcat、Jetty or Undertow（无需部署 war 包）【Servlet容器】

• • linux java tomcat mysql： war 放到 tomcat 的 webapps下
  • jar： java环境； java -jar

• 重点：提供可选的starter，简化应用整合

• • 场景启动器（starter）：web、json、邮件、oss（对象存储）、异步、定时任务、缓存…
  • 导包一堆，控制好版本。
  • 为每一种场景准备了一个依赖； web-starter。mybatis-starter

• **重点：**按需自动配置 Spring 以及 第三方库

• • 如果这些场景我要使用（生效）。这个场景的所有配置都会自动配置好。
  • 约定大于配置：每个场景都有很多默认配置。
  • 自定义：配置文件中修改几项就可以

• 提供生产级特性：如 监控指标、健康检查、外部化配置等

• • 监控指标、健康检查（k8s）、外部化配置

• 无代码生成、无xml

总结：简化开发，简化配置，简化整合，简化部署，简化监控，简化运维。

Spring Initializr 创建向导:

1.2.问题分析 ：

依赖管理机制

1.2.1、为什么导入starter-web所有相关依赖都导入进来？

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

●maven依赖传递原则。A-B-C： A就拥有B和C

●导入 场景启动器。 场景启动器 自动把这个场景的所有核心依赖全部导入进来

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

●每个boot项目都有一个父项目spring-boot-starter-parent

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.5</version>
</parent>

●而该父项目又有一个父项目是spring-boot-dependencies

●父项目版本仲裁中心，把所有常见的jar的依赖版本都声明好了。

●比如：mysql-connector-j

1.2.3：自定义版本号

●利用maven的就近原则

○直接在当前项目properties标签中声明父项目用的版本属性的key

○直接在导入依赖的时候声明版本

1.2.4:第三方的jar包

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

自动配置机制

• 自动配置的 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”)
    • @ComponentScan("com.atguigu") 直接指定扫描的路径

• 配置默认值

• • 配置文件的所有配置项是和某个类的对象值进行一一绑定的。
  • 绑定了配置文件中每一项值的类： 属性类。
  • 比如：
• • • ServerProperties绑定了所有Tomcat服务器有关的配置
    • MultipartProperties绑定了所有文件上传相关的配置
    • …参照官方文档：或者参照 绑定的 属性类。

• 按需加载自动配置

• • 导入场景spring-boot-starter-web
  • 场景启动器除了会导入相关功能依赖，导入一个spring-boot-starter，是所有starter的starter，基础核心starter
  • spring-boot-starter导入了一个包 spring-boot-autoconfigure。包里面都是各种场景的AutoConfiguration自动配置类
  • 虽然全场景的自动配置都在 spring-boot-autoconfigure这个包，但是不是全都开启的。
• • • 导入哪个场景就开启哪个自动配置

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

1.3.完整流程

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)提供功能：批量给容器中导入组件。
  • 2. SpringBoot启动会默认加载 142个配置类。
  • 3. 这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、**写业务，全程无需关心各种整合（底层这些整合写好了，而且也生效了）

简要总结一下，每个starter都会导入一个boot-starter，这个starter会把许多默认配置类用import导入，具体导入那些由具体的一个文件决定，但是每一个配置类都有条件，比如我们最开始导入的是web的starter，那么web相关的配置类比如Tomcat就会生效。并且这些配置类比如tomcat配置类还有@EnableConfigurationProperties(ServerProperties.class)注解与yml等文件绑定，并且会最终封装到属性类中。

核心流程总结：

1、导入starter，就会导入autoconfigure包。

2、autoconfigure 包里面 有一个文件 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports,里面指定的所有启动要加载的自动配置类，但是springboot默认扫描不到这些。

3、@EnableAutoConfiguration 会自动的把上面文件里面写的所有自动配置类都导入进来。xxxAutoConfiguration 是有条件注解进行按需加载

4、xxxAutoConfiguration给容器中导入一堆组件，组件都是从 xxxProperties中提取属性值

5、xxxProperties又是和配置文件进行了绑定

**效果：**导入starter、修改配置文件，就能修改底层行为

举例：

整合redis：

• 选场景：spring-boot-starter-data-redis

• • 场景AutoConfiguration 就是这个场景的自动配置类

• 写配置：

• • 分析到这个场景的自动配置类开启了哪些属性绑定关系
  • @EnableConfigurationProperties(RedisProperties.class)
  • 修改redis相关的配置

• 分析组件：

• • 分析到 RedisAutoConfiguration 给容器中放了 StringRedisTemplate
  • 给业务代码中自动装配 StringRedisTemplate

• 定制化

• • 修改配置文件
  • 自定义组件，自己给容器中放一个 StringRedisTemplate

1.4.常用注解

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

1.4.1. 组件注册

@Configuration、@SpringBootConfiguration

@Bean、@Scope

@Controller、 @Service、@Repository、@Component

@Import

@ComponentScan

步骤：

1、@Configuration 编写一个配置类

2、在配置类中，自定义方法给容器中注册组件。配合@Bean

3、或使用@Import 导入第三方的组件

1.4.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)

1.4.3. 属性绑定

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

@EnableConfigurationProperties：快速注册注解：

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

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

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

（1）：@ConfigurationProperties

例如，我现在有一个pig类，我们在properties文件中为它的属性赋值：

那么我们就可以在pig类上面写：

@ConfigurationProperties(prefix="pig")

即自动匹配properties文件中pig前缀的配置。并且装载到类中。

当然我们也可以写在配置类中的Bean上面。

（2）：@EnableConfigurationProperties：

第一种方法需要将Pig类用Bean方法加入IOc容器，但是我们可以用第二种方法，一步到位：

@Configuration
@EnableConfigurationProperties(Pig.class)
public class Myconfig {

}

@ConfigurationProperties(prefix = "pig")
public class Pig {
    int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Pig{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", number=" + number +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    String name;

    int number;
}

这个一般用于导入第三方包。

1.5.yaml：

使用.yaml或 .yml作为文件后缀：

基本语法

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

支持的写法：

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

@Component
@ConfigurationProperties(prefix = "person") //和配置文件person前缀的所有配置进行绑定
@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表示法

person:
  name: 张三
  age: 18
  birthDay: 2010/10/10 12:12:12
  like: true
  child:
    name: 李四
    age: 20
    birthDay: 2018/10/10
    text: ["abc","def"]
  dogs:
    - name: 小黑
      age: 3
    - name: 小白
      age: 2
  cats:
    c1:
      name: 小蓝
      age: 3
    c2: {name: 小绿,age: 2} #对象也可用{}表示

细节

• birthDay 推荐写为 birth-day

• 文本：

• • 单引号不会转义【\n 则为普通字符串显示】
  • 双引号会转义【\n会显示为换行符】

• 大文本

• • |开头，大文本写在下层，保留文本格式，换行符正确显示
  • >开头，大文本写在下层，折叠换行符

• 多文档合并

• • 使用---可以把多个yaml文档合并在一个文档中，每个文档区依然认为内容独立

1.6.日志：

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

1.6.1. 简介

1. Spring使用commons-logging作为内部日志，但底层日志实现是开放的。可对接其他日志框架。

2. 1. spring5及以后 commons-logging被spring直接自己写了。

3. 支持 jul，log4j2,logback。SpringBoot 提供了默认的控制台输出配置，也可以配置输出为文件。

4. logback是默认使用的。

5. 虽然日志框架很多，但是我们不用担心，使用 SpringBoot 的默认配置就能工作的很好。

SpringBoot怎么把日志默认配置好的

1、每个starter场景，都会导入一个核心场景spring-boot-starter

2、核心场景引入了日志的所用功能spring-boot-starter-logging

3、默认使用了logback + slf4j 组合作为默认底层日志

4、日志是系统一启动就要用，xxxAutoConfiguration是系统启动好了以后放好的组件，后来用的。

5、日志是利用监听器机制配置好的。ApplicationListener。

6、日志所有的配置都可以通过修改配置文件实现。以logging开始的所有

1.6.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, or TRACE.
• 进程 ID
• —： 消息分割符
• 线程名： 使用[]包含
• 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'

我们可以在配置文件中修改日志配置，比如logging.pattern.console就是修改控制台日志格式，logging.pattern.file就是日志存储的格式。logging.pattern.dataformat就是修改默认配置，只用在后面写上你要修改的那一段。

1.6.3. 记录日志

Logger logger = LoggerFactory.getLogger(getClass());

//或者使用Lombok的@Slf4j注解
//log.info("");

1.6.4. 日志级别

• 由低到高：ALL,TRACE, DEBUG, INFO, WARN, ERROR,FATAL,OFF；

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

• 不指定级别的所有类，都使用root指定的级别作为默认级别

• SpringBoot日志默认级别是 INFO

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

可以修改局部的类。

我们可以通过日志来查看某些变量在过程中的值：

log.info("info 日志..... a:{} b:{}",a,b);

1.6.5. 日志分组

比较有用的技巧是：

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

logging.group.tomcat=org.apache.catalina,org.apache.coyote,org.apache.tomcat
logging.level.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

1.6.6. 文件输出

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

1.6.7. 文件归档与滚动切:

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

1每天的日志应该独立分割出来存档。如果使用logback（SpringBoot 默认整合），可以通过application.properties/yaml文件指定日志滚动规则。

2如果是其他日志系统，需要自行配置（添加log4j2.xml或log4j2-spring.xml）

3支持的滚动规则设置如下

配置项	描述
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).

1.6.8.自定义配置

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

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

如果可能，我们建议您在日志配置中使用-spring 变量（例如，logback-spring.xml 而不是 logback.xml）。如果您使用标准配置文件，spring 无法完全控制日志初始化。

最佳实战：自己要写配置，配置文件名加上 xx-spring.xml

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

1.6.10.最佳实战

1导入任何第三方框架，先排除它的日志包，因为Boot底层控制好了日志

2修改 application.properties 配置文件，就可以调整日志的所有行为。如果不够，可以编写日志框架自己的配置文件放在类路径下就行，比如logback-spring.xml，log4j2-spring.xml

3如需对接专业日志系统，也只需要把 logback 记录的日志灌倒 kafka之类的中间件，这和SpringBoot没关系，都是日志框架自己的配置，修改配置文件即可

4业务中使用slf4j-api记录日志。不要再 sout 了

二：SpringBoot3-Web开发：

1. 自动配置

1.1、整合web场景

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

2、引入了 autoconfigure功能

3、@EnableAutoConfiguration注解使用@Import(AutoConfigurationImportSelector.class)批量导入组件

4、加载 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: 比如：编码方式

1.2. 默认效果

默认配置：

1包含了 ContentNegotiatingViewResolver 和 BeanNameViewResolver 组件，方便视图解析

2默认的静态资源处理机制： 静态资源放在 static 文件夹下即可直接访问

3自动注册了 Converter,GenericConverter,Formatter组件，适配常见数据类型转换和格式化需求

4支持 HttpMessageConverters，可以方便返回json等数据类型

5注册 MessageCodesResolver，方便国际化及错误消息处理

6支持 静态 index.html

7自动使用ConfigurableWebBindingInitializer，实现消息处理、数据绑定、类型转化、数据校验等功能

重要：

●如果想保持 boot mvc 的默认配置，并且自定义更多的 mvc 配置，如：interceptors, formatters, view controllers 等。可以使用@Configuration注解添加一个 WebMvcConfigurer 类型的配置类，并不要标注 @EnableWebMvc

●如果想保持 boot mvc 的默认配置，但要自定义核心组件实例，比如：RequestMappingHandlerMapping, RequestMappingHandlerAdapter, 或ExceptionHandlerExceptionResolver，给容器中放一个 WebMvcRegistrations 组件即可

●如果想全面接管 Spring MVC，@Configuration 标注一个配置类，并加上 @EnableWebMvc注解，实现 WebMvcConfigurer 接口

2. 静态资源

2.1.默认规则

1. 静态资源映射

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

1/webjars/** 的所有路径 资源都在 classpath:/META-INF/resources/webjars/

2/** 的所有路径 资源都在 classpath:/META-INF/resources/、classpath:/resources/、classpath:/static/、classpath:/public/

3所有静态资源都定义了缓存规则。【浏览器访问过一次，就会缓存一段时间】，但此功能参数无默认值

aperiod： 缓存间隔。 默认 0S；

bcacheControl：缓存控制。 默认无；

cuseLastModified：是否使用lastModified头。 默认 false；

WebMvcAutoConfiguration是starter导入的配置类之一，下面来详细讲一讲它的功能：

注：它的源码位于org.springframework.boot.autoconfigure.web.servlet 包下

（1）：生效原理：

@AutoConfiguration(after = { DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
		ValidationAutoConfiguration.class }) //在这些自动配置之后
@ConditionalOnWebApplication(type = Type.SERVLET) //如果是web应用就生效，类型SERVLET、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）：效果：

1. 放了两个Filter：

2. 1. HiddenHttpMethodFilter；页面表单提交Rest请求（GET、POST、PUT、DELETE）
   2. FormContentFilter： 表单内容Filter，GET（数据放URL后面）、POST（数据放请求体）请求可以携带数据，PUT、DELETE 的请求体数据会被忽略，开启让它不忽略。

3. 给容器中放了WebMvcConfigurer组件；给SpringMVC添加各种定制功能

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

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

6. （3）：WebMvcConfigurer接口

7. 提供了配置SpringMVC底层的所有组件入口：

(4) : 静态资源规则源码:

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

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

2. 1. maven 导入依赖

3. 规则二：访问： /**路径就去 静态资源默认的四个位置找资源

4. 1. classpath:/META-INF/resources/
   2. classpath:/resources/
   3. classpath:/static/
   4. classpath:/public/

5. 规则三：静态资源默认都有缓存规则的设置

6. 1. 所有缓存的设置，直接通过配置文件： spring.web
   2. cachePeriod： 缓存周期； 多久不用找服务器要新的。 默认没有，以s为单位
   3. cacheControl： HTTP缓存控制；https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Caching
   4. useLastModified：是否使用最后一次修改。配合HTTP Cache规则

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

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

注意，这里是类路径，也就是resources目录下面。

（5）：EnableWebMvcConfiguration 源码：

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

    
}

和上面呼应，这个类是放在WebMvcAutoConfiguration这个大类那里面，而在大类上面有注解：

@ConditionalOnMissingBean(WebMvcConfigurationSupport.class) //容器中没有这个Bean，才生效。默认就是没有

如果我们手动的配置了自定义WebMvcConfigurationSupport，那么该大类不会生效，而如果我们没有配置，那么大类生效后会配置默认springboot的EnableWebMvcConfiguration。

1. HandlerMapping： 根据请求路径 /a 找那个handler能处理请求

2. 1. WelcomePageHandlerMapping：

3. 1. 1. 访问 /**路径下的所有请求，都在以前四个静态资源路径下找，欢迎页也一样

      2. 找index.html：只要静态资源的位置有一个 index.html页面，项目启动默认访问

2. 静态资源缓存

如前面所述

1所有静态资源都定义了缓存规则。【浏览器访问过一次，就会缓存一段时间】，但此功能参数无默认值

aperiod： 缓存间隔。 默认 0S；

bcacheControl：缓存控制。 默认无；

cuseLastModified：是否使用lastModified头。 默认 false；

3. 欢迎页

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

1在静态资源目录下找 index.html

2没有就在 templates下找index模板页

4. Favicon

1在静态资源目录下找 favicon.ico，注意这个就是app的图标显示。

类似于这只鸟。

这不完全是boot的功能，更像是网页的一种请求。

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.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路径前缀
spring.mvc.webjars-path-pattern=/wj/**
## 2.2. 静态资源访问路径前缀
spring.mvc.static-path-pattern=/static/**

可能会用到重点：

自定义静态资源文件的位置及其前缀修改。

2.代码方式自定义：

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

@Configuration //这是一个配置类
public class MyConfig implements WebMvcConfigurer {


    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        //保留以前规则，事实上不写这句话都可以，因为没有加上@EnableWebMvc，默认就有之前的功能
         WebMvcConfigurer.super.addResourceHandlers(registry);
        //自己写新的规则。
        registry.addResourceHandler("/static/**")
                .addResourceLocations("classpath:/a/","classpath:/b/")
                .setCacheControl(CacheControl.maxAge(1180, TimeUnit.SECONDS));
    }
}

这就是手自一体。注意，不能加上@EnableWebMvc。

这段代码是增加一个资源处理器，而不是覆盖现有的配置。在Spring MVC中，你可以通过addResourceHandler方法添加多个资源处理器来处理不同的URL路径模式，并将它们映射到不同的资源位置。

registry.addResourceHandler("/static/**") 实际上是在告诉Spring MVC：“对于所有以/static/开头的URL，请使用一个资源处理器来处理它们。”

.addResourceLocations("classpath:/a/","classpath:/b/") 接着指定了这些URL应该映射到哪些资源位置。在这个例子中，它映射到了类路径下的/a/和/b/目录。

注意，这个映射只对static有效。

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

具体到WebMvcConfigurer，Spring MVC允许您注册多个实现，每个实现都可以添加或定制不同的方面，如资源处理、拦截器、视图解析器等。当Spring MVC初始化时，它会收集所有WebMvcConfigurer的实现，并调用它们的相应方法来构建最终的配置。这意味着多个WebMvcConfigurer可以添加多个资源处理器，而不是相互覆盖。所以原来的配置还是生效的。

问题：为什么容器中放一个WebMvcConfigurer就能配置底层行为？

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

如图，收集所有的WebMvcConfigurer。

这也解释了为什么上面的重写没有覆盖掉原来的配置。

补充：

在Spring Boot中，当您想要自定义Spring MVC的配置时，可以选择实现WebMvcConfigurer接口或继承WebMvcConfigurationSupport类。这两者都提供了自定义Spring MVC配置的能力，但它们之间有一些重要的区别。

实现WebMvcConfigurer接口

实现WebMvcConfigurer接口是Spring Boot推荐的方式来自定义MVC配置。当您实现这个接口时，您可以覆盖其中的方法来提供自定义配置，比如添加拦截器、配置视图解析器、定义资源处理器等。由于您只是实现了接口的方法，Spring Boot的自动配置仍然会提供默认的配置，除非您明确地覆盖了它们。

这种方式的一个关键优势是，它允许您保留Spring Boot的自动配置特性，同时只覆盖您关心的部分。这意味着您不需要重新实现所有的配置，而只需要提供您自己的定制。

继承WebMvcConfigurationSupport类

继承WebMvcConfigurationSupport类是一种更为直接的方式来完全控制Spring MVC的配置。但是，当您继承这个类时，Spring Boot将不会应用其默认的MVC自动配置。这意味着您需要提供所有的配置，包括那些您可能想要保留的默认配置。

因此，使用WebMvcConfigurationSupport通常意味着您需要编写更多的代码，并且可能会失去Spring Boot提供的便利性。除非您有非常特殊的需求，或者确实需要完全控制MVC的配置，否则通常不推荐使用这种方式。

总结

• WebMvcConfigurer：推荐的方式，允许您覆盖特定的配置方法，同时保留Spring Boot的自动配置。
• WebMvcConfigurationSupport：更为直接的方式，但会禁用Spring Boot的MVC自动配置，需要您提供完整的MVC配置。

在大多数情况下，实现WebMvcConfigurer接口是更好的选择，因为它提供了更大的灵活性和更少的维护负担。只有当您有非常特殊的需求，或者确实需要完全控制MVC的配置时，才应该考虑继承WebMvcConfigurationSupport类。

3.路径匹配：

Spring5.3 之后加入了更多的请求路径匹配的实现策略；

以前只支持 AntPathMatcher 策略, 现在提供了 PathPatternParser 策略。并且可以让我们指定到底使用那种策略。

3.1. Ant风格路径用法

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

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

例如：

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

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

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

3.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.内容协商：

在开发中，不同场景希望我们返回不同的格式。

4.1. 多端内容适配

1. 默认规则

1. SpringBoot 多端内容适配。

2. 1. 基于请求头内容协商：（默认开启）
3. 1. 1. 客户端向服务端发送请求，携带HTTP标准的Accept请求头。
4. 1. 1. 1. Accept: application/json、text/xml、text/yaml
         2. 服务端根据客户端请求头期望的数据类型进行动态返回
5. 1. 基于请求参数内容协商：（需要开启）
6. 1. 1. 发送请求 GET /projects/spring-boot?format=json
      2. 匹配到 @GetMapping(“/projects/spring-boot”)
      3. 根据参数协商，优先返回 json 类型数据【需要开启参数匹配设置】
      4. 发送请求 GET /projects/spring-boot?format=xml,优先返回 xml 类型数据

注意，第二种必须要手动开启。第一种不是一定会成功，因为有的时候accept不是我们想要的。比如优先.html。

2. 效果演示

请求同一个接口，可以返回json和xml不同格式数据

1. 引入支持写出xml内容依赖

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

注意，springboot默认支持json格式，web引入了这个依赖，所以不需要再次引入。

2.标注注解

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

注意，这里是标记在实体类上。

3.开启基于请求参数的内容协商(不然不能正确解析xml)

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

​ 4.效果

4.2. 自定义内容返回(先看4.3)

比如之前的系统的默认中可以解析json，xml，就无需编写HttpMessageConverter，但是没有yaml，所以要编写这个类。

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

这段代码只是将单个Java对象（person）序列化为一个YAML格式的字符串，并打印到控制台。它使用了Jackson库来完成序列化过程，并且通过配置YAMLFactory禁用了YAML文档的起始标记。这并不涉及mvc的配置。

编写配置

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

spring.mvc.contentnegotiation.media-types.yaml=text/yaml是在Spring框架中配置内容协商时新增一种媒体类型的方式。

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

    @Bean
    public WebMvcConfigurer webMvcConfigurer(){
        return new WebMvcConfigurer() {
            @Override //配置一个能把对象转为yaml的messageConverter
            public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
                converters.add(new MyYamlHttpMessageConverter());
            }
        };
    }

1. public void configureMessageConverters(List<HttpMessageConverter<?>> converters) 方法：这是WebMvcConfigurer接口中的一个方法，用于配置消息转换器列表。消息转换器用于在HTTP请求和响应中转换数据格式，例如从JSON转换为Java对象，或从Java对象转换为JSON。

2. converters.add(new MyYamlHttpMessageConverter());：这行代码向converters列表中添加了一个新创建的MyYamlHttpMessageConverter实例。这意味着当Spring MVC需要处理YAML格式的请求或响应时，它将使用这个自定义的转换器。

2. 思考：如何增加其他

• 配置媒体类型支持:

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

• 编写对应的HttpMessageConverter，要告诉Boot这个支持的媒体类型

• • 按照3的示例

• 把MessageConverter组件加入到底层

• • 容器中放一个WebMvcConfigurer 组件，并配置底层的MessageConverter

3. HttpMessageConverter的示例写法

public class MyYamlHttpMessageConverter extends AbstractHttpMessageConverter<Object> {

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

    }
}

下面是对该类中各个部分的详细解释：

1. 类定义和字段

public class MyYamlHttpMessageConverter extends AbstractHttpMessageConverter<Object> {  
    private ObjectMapper objectMapper = null;

这个类继承了AbstractHttpMessageConverter，并指定它可以处理的泛型类型为Object。它还定义了一个ObjectMapper字段，用于将对象转换为YAML格式。

2. 构造函数

public MyYamlHttpMessageConverter(){  
    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);  
}

在构造函数中，它首先调用了父类的构造函数，指定了这个转换器支持的媒体类型为text/yaml，并使用UTF-8字符集。然后，它创建了一个YAMLFactory对象，并禁用了YAML文档的起始标记。最后，它使用这个工厂创建了一个ObjectMapper对象，用于后续的YAML序列化。

3. supports方法

@Override  
protected boolean supports(Class<?> clazz) {  
    return true;  
}

supports方法用于判断这个转换器是否支持将给定的类转换为HTTP消息。在这个例子中，它简单地返回true`，意味着这个转换器支持所有对象类型的转换。在实际应用中，你可能需要更精细地控制哪些类型被支持。

4. readInternal方法

@Override  
protected Object readInternal(Class<?> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {  
    return null;  
}

readInternal方法用于从HTTP输入消息中读取并解析YAML数据。在这个例子中，它简单地返回null`，意味着这个转换器没有实现YAML到Java对象的解析逻辑。在实际应用中，你需要在这里实现YAML的解析逻辑。

5. writeInternal方法

@Override  
protected void writeInternal(Object methodReturnValue, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {  
    try(OutputStream os = outputMessage.getBody()){  
        this.objectMapper.writeValue(os, methodReturnValue);  
    }  
}

writeInternal方法用于将Java对象转换为YAML格式并写入HTTP输出消息。在这个例子中，它使用了ObjectMapper的writeValue`方法将对象转换为YAML，并写入到输出流中。这里使用了try-with-resources语句来自动关闭输出流。

注意，它目前只实现了将Java对象转换为YAML并写入HTTP响应的功能，还没有实现从HTTP请求中读取并解析YAML的功能。

4.3. 内容协商原理-HttpMessageConverter

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

1. @ResponseBody由HttpMessageConverter处理

总结：标注了@ResponseBody的返回值将会由支持它的 HttpMessageConverter写给浏览器，过程如下：

1. 如果controller方法的返回值标注了 @ResponseBody 注解

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

上面解释：@ResponseBody由HttpMessageConverter处理

1. HttpMessageConverter 会先进行内容协商

2. 1. 遍历所有的MessageConverter看谁支持这种内容类型的数据

   2. 默认MessageConverter有以下

   3. 

   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