SpringBoot的学习第二篇

{timeline}
{timeline-item color="#19be6b"}
2022-05-08 01:12:11 星期日 ::(呵呵)
{collapse}
{collapse-item label="

SpringBoot-自动配置特性" open}

自动配好Tomcat

引入Tomcat依赖。

配置Tomcat

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

自动配好SpringMVC

引入SpringMVC全套组件
自动配好SpringMVC常用组件（功能）

自动配好Web常见功能，如：字符编码问题

SpringBoot帮我们配置好了所有web开发的常见场景

public static void main(String[] args) {
  //1、返回我们IOC容器
  ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

  //2、查看容器里面的组件
  String[] names = run.getBeanDefinitionNames();
  for (String name : names) {
      System.out.println(name);
  }
}

默认的包结构

主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来
无需以前的包扫描配置
想要改变扫描路径
- @SpringBootApplication(scanBasePackages=“com.lun”)
- @ComponentScan 指定扫描路径
```
@SpringBootApplication
等同于
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.lun")
```
  各种配置拥有默认值
默认配置最终都是映射到某个类上，如：MultipartProperties
配置文件的值最终会绑定每个类上，这个类会在容器中创建对象
按需加载所有自动配置项
非常多的starter
引入了哪些场景这个场景的自动配置才会开启
SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面

{/collapse-item}
{collapse-item label="

底层注解"}

@Configuration详解

基本使用

Full模式与Lite模式
示例

/**
 * 1、配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
 * 2、配置类本身也是组件
 * 3、proxyBeanMethods：代理bean的方法
 *      Full(proxyBeanMethods = true)（保证每个@Bean方法被调用多少次返回的组件都是单实例的）（默认）
 *      Lite(proxyBeanMethods = false)（每个@Bean方法被调用多少次返回的组件都是新创建的）
 */
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {
    /**
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
     * @return
     */
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user01(){
        User zhangsan = new User("zhangsan", 18);
        //user组件依赖了Pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }
    @Bean("tom")
    public Pet tomcatPet(){
        return new Pet("tomcat");
    }
}

@Configuration测试代码如下:

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.atguigu.boot")
public class MainApplication {

    public static void main(String[] args) {
    //1、返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

    //2、查看容器里面的组件
        String[] names = run.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }

    //3、从容器中获取组件
        Pet tom01 = run.getBean("tom", Pet.class);
        Pet tom02 = run.getBean("tom", Pet.class);
        System.out.println("组件："+(tom01 == tom02));

    //4、com.atguigu.boot.config.MyConfig$$EnhancerBySpringCGLIB$$51f1e1ca@1654a892
        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println(bean);

    //如果@Configuration(proxyBeanMethods = true)代理对象调用方法。SpringBoot总会检查这个组件是否在容器中有。
        //保持组件单实例
        User user = bean.user01();
        User user1 = bean.user01();
        System.out.println(user == user1);

        User user01 = run.getBean("user01", User.class);
        Pet tom = run.getBean("tom", Pet.class);

        System.out.println("用户的宠物："+(user01.getPet() == tom));
    }
}

最佳实战

配置类组件之间无依赖关系用Lite模式加速容器启动过程，减少判断
配置类组件之间有依赖关系，方法会被调用得到之前单实例组件，用Full模式（默认）

{message type="info" content="lite 英 [laɪt] 美 [laɪt]
adj. 低热量的，清淡的(light的一种拼写方法);类似…的劣质品"/}

{message type="warning" content=" IDEA快捷键：
Alt + Ins:生成getter，setter、构造器等代码。
Ctrl + Alt + B:查看类的具体实现代码。"/}

{mtitle title=" 2022-05-08 13:54:17 星期日 "/}

Import导入组件

{card-list}
{card-list-item}
@Bean、@Component、@Controller、@Service、@Repository，它们是Spring的基本标签，在Spring Boot中并未改变它们原来的功能。
{/card-list-item}
{card-list-item}
@ComponentScan 在07、基础入门-SpringBoot-自动配置特性有用例。
{/card-list-item}
{card-list-item}
@Import({User.class, DBHelper.class})给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名
{/card-list-item}
{/card-list}

@Import({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {
}

测试类

//1、返回我们IOC容器
ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

//...

//5、获取组件
String[] beanNamesForType = run.getBeanNamesForType(User.class);

for (String s : beanNamesForType) {
    System.out.println(s);
}

DBHelper bean1 = run.getBean(DBHelper.class);
System.out.println(bean1);

@Conditional条件装配

条件装配：满足Conditional指定的条件，则进行组件注入

用@ConditionalOnMissingBean举例说明

@Configuration(proxyBeanMethods = false)
@ConditionalOnMissingBean(name = "tom")//没有tom名字的Bean时，MyConfig类的Bean才能生效。
public class MyConfig {

    @Bean
    public User user01(){
        User zhangsan = new User("zhangsan", 18);
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }

    @Bean("tom22")
    public Pet tomcatPet(){
        return new Pet("tomcat");
    }
}

public static void main(String[] args) {
    //1、返回我们IOC容器
    ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

    //2、查看容器里面的组件
    String[] names = run.getBeanDefinitionNames();
    for (String name : names) {
        System.out.println(name);
    }

    boolean tom = run.containsBean("tom");
    System.out.println("容器中Tom组件："+tom);//false

    boolean user01 = run.containsBean("user01");
    System.out.println("容器中user01组件："+user01);//true

    boolean tom22 = run.containsBean("tom22");
    System.out.println("容器中tom22组件："+tom22);//true

}

@ImportResource导入Spring配置文件

比如，公司使用bean.xml文件生成配置bean，然而你为了省事，想继续复用bean.xml，
@ImportResource粉墨登场。
bean.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans ...">

    <bean id="haha" class="com.lun.boot.bean.User">
        <property name="name" value="zhangsan"></property>
        <property name="age" value="18"></property>
    </bean>

    <bean id="hehe" class="com.lun.boot.bean.Pet">
        <property name="name" value="tomcat"></property>
    </bean>
</beans>

使用方法：

@ImportResource("classpath:beans.xml")
public class MyConfig {
...
}

测试类：

public static void main(String[] args) {
    //1、返回我们IOC容器
    ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

    boolean haha = run.containsBean("haha");
    boolean hehe = run.containsBean("hehe");
    System.out.println("haha："+haha);//true
    System.out.println("hehe："+hehe);//true
}

@ConfigurationProperties配置绑定

如何使用Java读取到properties文件中的内容，并且把它封装到JavaBean中，以供随时使用

传统方法：

public class getProperties {
     public static void main(String[] args) throws FileNotFoundException, IOException {
         Properties pps = new Properties();
         pps.load(new FileInputStream("a.properties"));
         Enumeration enum1 = pps.propertyNames();//得到配置文件的名字
         while(enum1.hasMoreElements()) {
             String strKey = (String) enum1.nextElement();
             String strValue = pps.getProperty(strKey);
             System.out.println(strKey + "=" + strValue);
             //封装到JavaBean。
         }
     }
 }

{tabs}
{tabs-pane label=" Spring Boot一种配置配置绑定 "}
@ConfigurationProperties + @Component
假设有配置文件application.properties

mycar.brand=BYD
mycar.price=100000

只有在容器中的组件，才会拥有SpringBoot提供的强大功能

@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {
...
}

{/tabs-pane}
{tabs-pane label=" Spring Boot另一种配置配置绑定： "}
@EnableConfigurationProperties + @ConfigurationProperties

开启Car配置绑定功能
把这个Car这个组件自动注册到容器中

@EnableConfigurationProperties(Car.class)
public class MyConfig {
...
}

@ConfigurationProperties(prefix = "mycar")
public class Car {
...
}

{/tabs-pane}
{/tabs}

{/collapse-item}

{collapse-item label="

自动配置【源码分析】-自动包规则原理"}

Spring Boot应用的启动类：

@SpringBootApplication
public class MainApplication {

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

分析下@SpringBootApplication

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

{message type="warning" content="重点分析@SpringBootConfiguration，@EnableAutoConfiguration，@ComponentScan。"/}

@SpringBootConfiguration

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

@Configuration 代表当前是一个配置类。

{card-default label="@ ComponentScan " width=""}
指定扫描哪些Spring注解。

@ComponentScan 在07、基础入门-SpringBoot-自动配置特性有用例。
{/card-default}

@EnableAutoConfiguration

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

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

    String[] excludeName() default {};
}

{message type="warning" content="重点分析@AutoConfigurationPackage，@Import(AutoConfigurationImportSelector.class)。"/}

@AutoConfigurationPackage

标签名直译为：自动配置包，指定了默认的包规则。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)//给容器中导入一个组件
public @interface AutoConfigurationPackage {
    String[] basePackages() default {};

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

利用Registrar给容器中导入一系列组件
将指定的一个包下的所有组件导入进MainApplication所在包下。

{/collapse-item}

{collapse-item label="

自动配置【源码分析】-初始加载自动配置类"}

@Import(AutoConfigurationImportSelector.class)

利用 getAutoConfigurationEntry(annotationMetadata) ;给容器中批量导入一些组件
调用 List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes) 获取到所有需要导入到容器中的配置类
利用工厂加载 Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader); 得到所有的组件
从 META-INF/spring.factories 位置来加载一个文件。
1. 默认扫描我们当前系统里面所有 META-INF/spring.factories 位置的文件
2. spring-boot-autoconfigure-2.3.4.RELEASE.jar 包里面也有 META-INF/spring.factories

# 文件里面写死了spring-boot一启动就要给容器中加载的所有配置类
# spring-boot-autoconfigure-2.3.4.RELEASE.jar/META-INF/spring.factories
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
...

{message type="info" content="虽然我们127个场景的所有自动配置启动的时候默认全部加载，但是 xxxxAutoConfiguration 按照条件装配规则（ @Conditional ），最终会按需配置。"/}
如 AopAutoConfiguration 类：

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnProperty(
    prefix = "spring.aop",
    name = "auto",
    havingValue = "true",
    matchIfMissing = true
)
public class AopAutoConfiguration {
    public AopAutoConfiguration() {
    }
    ...
}

{/collapse-item}
{collapse-item label="

自动配置【源码分析】-自动配置流程"}

以 DispatcherServletAutoConfiguration 的内部类 DispatcherServletConfiguration 为例子:

@Bean
@ConditionalOnBean(MultipartResolver.class)  //容器中有这个类型组件
@ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME) //容器中没有这个名字 multipartResolver 的组件
public MultipartResolver multipartResolver(MultipartResolver resolver) {
    //给@Bean标注的方法传入了对象参数，这个参数的值就会从容器中找。
    //SpringMVC multipartResolver。防止有些用户配置的文件上传解析器不符合规范
    // Detect if the user has created a MultipartResolver but named it incorrectly
    return resolver;//给容器中加入了文件上传解析器；
}

SpringBoot默认会在底层配好所有的组件，但是 如果用户自己配置了以用户的优先。

{card-default label=" 总结： " width=""}

SpringBoot先加载所有的自动配置类 xxxxxAutoConfiguration
每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值。（xxxxProperties里面读取，xxxProperties和配置文件进行了绑定）
生效的配置类就会给容器中装配很多组件
只要容器中有这些组件，相当于这些功能就有了
定制化配置
- 用户直接自己@Bean替换底层的组件
- 用户去看这个组件是获取的配置文件什么值就去修改。

{message type="info" content="xxxxxAutoConfiguration —> 组件 —> xxxxProperties里面拿值 ----> application.properties"/}

{/card-default}

{/collapse-item}

{/collapse}
{/timeline-item}

{timeline-item color="#ed4014"}

2022-05-10 21:00:00 星期二

{collapse}
{collapse-item label="

最佳实践"}

SpringBoot应用如何编写

引入场景依赖
- 官方文档
查看自动配置了哪些（选做）
- 自己分析，引入场景对应的自动配置一般都生效了
- 配置文件中debug=true开启自动配置报告。
  - Negative（不生效）
  - Positive（生效）
是否需要修改
- 参照文档修改配置项
  - 官方文档
  - 自己分析。xxxxProperties绑定了配置文件的哪些。
自定义加入或者替换组件
- @Bean、@Component…
自定义器 XXXXXCustomizer；
…

Lombok简化开发

Lombok用标签方式代替构造器、getter/setter、toString()等鸡肋代码。
spring boot已经管理Lombok。引入依赖：

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

IDEA中File->Settings->Plugins，搜索安装Lombok插件。

@NoArgsConstructor
//@AllArgsConstructor
@Data
@ToString
@EqualsAndHashCode
public class User {

    private String name;
    private Integer age;

    private Pet pet;

    public User(String name,Integer age){
        this.name = name;
        this.age = age;
    }
}

{card-default label=" 简化日志开发 " width=""}

@Slf4j
@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String handle01(@RequestParam("name") String name){
        log.info("请求进来了....");
        return "Hello, Spring Boot 2!"+"你好："+name;
    }
}

dev-tools

{callout color="#f0ad4e"}
Spring Boot includes an additional set of tools that can make the application development experience a little more pleasant. The spring-boot-devtools module can be included in any project to provide additional development-time features.—— link

Applications that use spring-boot-devtools automatically restart whenever files on the classpath change. This can be a useful feature when working in an IDE, as it gives a very fast feedback loop for code changes. By default, any entry on the classpath that points to a directory is monitored for changes. Note that certain resources, such as static assets and view templates, do not need to restart the application .—— link
Triggering a restart
As DevTools monitors classpath resources, the only way to trigger a restart is to update the classpath. The way in which you cause the classpath to be updated depends on the IDE that you are using:

In Eclipse, saving a modified file causes the classpath to be updated and triggers a restart.
In IntelliJ IDEA, building the project ( Build -> Build Project )(shortcut: Ctrl+F9) has the same effect.

{/card-default}

{/callout}
添加依赖：

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

在IDEA中，项目或者页面修改以后：Ctrl+F9。

Spring Initailizr

Spring Initailizr是创建Spring Boot工程向导。
在IDEA中，菜单栏New -> Project -> Spring Initailizr。

{/collapse-item}
{/collapse}

{collapse}
{collapse-item label="

配置文件"}

配置文件-yaml的用法

同以前的properties用法

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

非常适合用来做以数据为中心的配置文件。

基本语法:
key: value；kv之间有空格

大小写敏感
使用缩进表示层级关系
缩进不允许使用tab，只允许空格
缩进的空格数不重要，只要相同层级的元素左对齐即可
'#'表示注释
字符串无需加引号，如果要加，单引号’’、双引号""表示字符串内容会被转义、不转义
数据类型
字面量：单个的、不可再分的值。date、boolean、string、number、null
```
k: v
```
- 对象：键值对的集合。map、hash、set、object
```
#行内写法：  

k: {k1:v1,k2:v2,k3:v3}

#或

k: 
k1: v1
k2: v2
k3: v3
```
- 数组：一组按次序排列的值。array、list、queue

#行内写法：  

k: [v1,v2,v3]

#或者

k:
 - v1
 - v2
 - v3

实例

@Data
public class Person {
    private String userName;
    private Boolean boss;
    private Date birth;
    private Integer age;
    private Pet pet;
    private String[] interests;
    private List<String> animal;
    private Map<String, Object> score;
    private Set<Double> salarys;
    private Map<String, List<Pet>> allPets;
}

@Data
public class Pet {
    private String name;
    private Double weight;
}

用yaml表示以上对象

person:
  userName: zhangsan
  boss: false
  birth: 2019/12/12 20:12:33
  age: 18
  pet: 
    name: tomcat
    weight: 23.4
  interests: [篮球,游泳]
  animal: 
    - jerry
    - mario
  score:
    english: 
      first: 30
      second: 40
      third: 50
    math: [131,140,148]
    chinese: {first: 128,second: 136}
  salarys: [3999,4999.98,5999.99]
  allPets:
    sick:
      - {name: tom}
      - {name: jerry,weight: 47}
    health: [{name: mario,weight: 47}]

配置文件-自定义类绑定的配置提示

{callout color="#f0ad4e"}
You can easily generate your own configuration metadata file from items annotated with @ConfigurationProperties by using the spring-boot-configuration-processor jar. The jar includes a Java annotation processor which is invoked as your project is compiled.—— link
{/callout}

自定义的类和配置文件绑定一般没有提示。若要提示，添加如下依赖：

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

<!-- 下面插件作用是工程打包时，不将spring-boot-configuration-processor打进包内，让其只在编码的时候有用 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <excludes>
                    <exclude>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-configuration-processor</artifactId>
                    </exclude>
                </excludes>
            </configuration>
        </plugin>
    </plugins>
</build>

{/collapse-item}
{collapse-item label="

web场景"}

web开发简介

Spring Boot provides auto-configuration for Spring MVC that works well with most applications.(大多场景我们都无需自定义配置)

The auto-configuration adds the following features on top of Spring’s defaults:

Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans.
- 内容协商视图解析器和BeanName视图解析器
Support for serving static resources, including support for WebJars (covered later in this document )).
- 静态资源（包括webjars）
Automatic registration of Converter , GenericConverter , and Formatter beans.
- 自动注册 Converter，GenericConverter，Formatter
Support for HttpMessageConverters (covered later in this document ).
- 支持 HttpMessageConverters （后来我们配合内容协商理解原理）
Automatic registration of MessageCodesResolver (covered later in this document ).
- 自动注册 MessageCodesResolver （国际化用）
Static index.html support.
- 静态index.html 页支持
Custom Favicon support (covered later in this document ).
- 自定义 Favicon
Automatic use of a ConfigurableWebBindingInitializer bean (covered later in this document ).
- 自动使用 ConfigurableWebBindingInitializer ，（DataBinder负责将请求数据绑定到JavaBean上）

{callout color="#f0ad4e"}
If you want to keep those Spring Boot MVC customizations and make more MVC customizations (interceptors, formatters, view controllers, and other features), you can add your own @Configuration class of type WebMvcConfigurer but without @EnableWebMvc .

不用@EnableWebMvc注解。使用 @Configuration + WebMvcConfigurer 自定义规则
{/callout}

{callout color="#f0ad4e"}
If you want to provide custom instances of RequestMappingHandlerMapping , RequestMappingHandlerAdapter , or ExceptionHandlerExceptionResolver , and still keep the Spring Boot MVC customizations, you can declare a bean of type WebMvcRegistrations and use it to provide custom instances of those components.

声明 WebMvcRegistrations 改变默认底层组件

{/callout}

{callout color="#f0ad4e"}
If you want to take complete control of Spring MVC, you can add your own @Configuration annotated with @EnableWebMvc , or alternatively add your own @Configuration-annotated DelegatingWebMvcConfiguration as described in the Javadoc of @EnableWebMvc.

使用 @EnableWebMvc+@Configuration+DelegatingWebMvcConfiguration 全面接管SpringMVC

{/callout}

静态资源规则与定制化

静态资源目录
只要静态资源放在类路径下： called / static (or / public or / resources or / META-INF/resources

访问：当前项目根路径/ + 静态资源名

原理：静态映射/**。

请求进来，先去找Controller看能不能处理。不能处理的所有请求又都交给静态资源处理器。静态资源也找不到则响应404页面。

也可以改变默认的静态资源路径， /static ， /public , /resources , /META-INF/resources 失效

resources:
  static-locations: [classpath:/haha/]

{mtitle title="
2022-05-29 15:04:22 星期日更新!!!"/}
静态资源访问前缀

spring:
  mvc:
    static-path-pattern: /res/**

当前项目 + static-path-pattern + 静态资源名 = 静态资源文件夹下找

webjar

可用jar方式添加css，js等资源文件，

https://www.webjars.org/

例如，添加jquery

<dependency>
    <groupId>org.webjars</groupId>
    <artifactId>jquery</artifactId>
    <version>3.5.1</version>
</dependency>

访问地址：http://localhost:8080/webjars/jquery/3.5.1/jquery.js 后面地址要按照依赖里面的包路径。

welcome与favicon功能

官方文档
欢迎页支持

静态资源路径下 index.html。
- 可以配置静态资源路径
- 但是不可以配置静态资源的访问前缀。否则导致 index.html不能被默认访问

spring:
#  mvc:
#    static-path-pattern: /res/**   这个会导致welcome page功能失效
  resources:
    static-locations: [classpath:/haha/]

controller能处理/index。
自定义Favicon
指网页标签上的小图标。

favicon.ico 放在静态资源目录下即可。

spring:
#  mvc:
#    static-path-pattern: /res/**   这个会导致 Favicon 功能失效

【源码分析】-静态资源原理

SpringBoot启动默认加载 xxxAutoConfiguration 类（自动配置类）

SpringMVC功能的自动配置类 WebMvcAutoConfiguration ，生效

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

给容器中配置的内容：

配置文件的相关属性的绑定：WebMvcProperties==spring.mvc、ResourceProperties==spring.resources

@Configuration(proxyBeanMethods = false)
@Import(EnableWebMvcConfiguration.class)
@EnableConfigurationProperties({ WebMvcProperties.class, ResourceProperties.class })
@Order(0)
public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer {
  ...
}

配置类只有一个有参构造器

有参构造器所有参数的值都会从容器中确定
public WebMvcAutoConfigurationAdapter(WebProperties webProperties, WebMvcProperties mvcProperties,
      ListableBeanFactory beanFactory, ObjectProvider<HttpMessageConverters> messageConvertersProvider,
      ObjectProvider<ResourceHandlerRegistrationCustomizer> resourceHandlerRegistrationCustomizerProvider,
      ObjectProvider<DispatcherServletPath> dispatcherServletPath,
      ObjectProvider<ServletRegistrationBean<?>> servletRegistrations) {
  this.mvcProperties = mvcProperties;
  this.beanFactory = beanFactory;
  this.messageConvertersProvider = messageConvertersProvider;
  this.resourceHandlerRegistrationCustomizer = resourceHandlerRegistrationCustomizerProvider.getIfAvailable();
  this.dispatcherServletPath = dispatcherServletPath;
  this.servletRegistrations = servletRegistrations;
  this.mvcProperties.checkConfiguration();
}

ResourceProperties resourceProperties；获取和spring.resources绑定的所有的值的对象
WebMvcProperties mvcProperties 获取和spring.mvc绑定的所有的值的对象
ListableBeanFactory beanFactory Spring的beanFactory
HttpMessageConverters 找到所有的HttpMessageConverters
ResourceHandlerRegistrationCustomizer 找到资源处理器的自定义器。
DispatcherServletPath

ServletRegistrationBean 给应用注册Servlet、Filter…
资源处理的默认规则

...
public class WebMvcAutoConfiguration {
  ...
  public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration implements ResourceLoaderAware {
      ...
      @Override
      protected void addResourceHandlers(ResourceHandlerRegistry registry) {
          super.addResourceHandlers(registry);
          if (!this.resourceProperties.isAddMappings()) {
              logger.debug("Default resource handling disabled");
              return;
          }
          ServletContext servletContext = getServletContext();
          addResourceHandler(registry, "/webjars/**", "classpath:/META-INF/resources/webjars/");
          addResourceHandler(registry, this.mvcProperties.getStaticPathPattern(), (registration) -> {
              registration.addResourceLocations(this.resourceProperties.getStaticLocations());
              if (servletContext != null) {
                  registration.addResourceLocations(new ServletContextResource(servletContext, SERVLET_LOCATION));
              }
          });
      }
      ...
      
  }
  ...
}

根据上述代码，我们可以同过配置禁止所有静态资源规则。

spring:
resources:
  add-mappings: false   #禁用所有静态资源规则

静态资源规则：

@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
public class ResourceProperties {

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

  /**
   * Locations of static resources. Defaults to classpath:[/META-INF/resources/,
   * /resources/, /static/, /public/].
   */
  private String[] staticLocations = CLASSPATH_RESOURCE_LOCATIONS;
  ...
}

欢迎页的处理规则

...
public class WebMvcAutoConfiguration {
    ...
    public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration implements ResourceLoaderAware {
        ...
        @Bean
        public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext,
                FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
            WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(
                    new TemplateAvailabilityProviders(applicationContext), applicationContext, getWelcomePage(),
                    this.mvcProperties.getStaticPathPattern());
            welcomePageHandlerMapping.setInterceptors(getInterceptors(mvcConversionService, mvcResourceUrlProvider));
            welcomePageHandlerMapping.setCorsConfigurations(getCorsConfigurations());
            return welcomePageHandlerMapping;
        }

WelcomePageHandlerMapping 的构造方法如下：

WelcomePageHandlerMapping(TemplateAvailabilityProviders templateAvailabilityProviders,
                          ApplicationContext applicationContext, Resource welcomePage, String staticPathPattern) {
    if (welcomePage != null && "/**".equals(staticPathPattern)) {
        //要用欢迎页功能，必须是/**
        logger.info("Adding welcome page: " + welcomePage);
        setRootViewName("forward:index.html");
    }
    else if (welcomeTemplateExists(templateAvailabilityProviders, applicationContext)) {
        //调用Controller /index
        logger.info("Adding welcome page template: index");
        setRootViewName("index");
    }
}

这构造方法内的代码也解释了web场景-welcome与favicon功能中配置 static-path-pattern 了，welcome页面和小图标失效的问题。

{/collapse-item}
{/collapse}

{/timeline-item}

{timeline-item color="#19be6b"}
2022-05-29 15:19:05 星期日

{collapse}
{collapse-item label="

请求处理" }

【源码分析】-Rest映射及源码解析

请求映射

@xxxMapping;
- @GetMapping
- @PostMapping
- @PutMapping
- @DeleteMapping
- Rest风格支持（使用 HTTP 请求方式动词来表示对资源的操作）
以前：
- /getUser 获取用户
- /deleteUser 删除用户
- /editUser 修改用户
- /saveUser保存用户
现在： /user
- GET-获取用户
- DELETE-删除用户
- PUT-修改用户
- POST-保存用户
- 核心Filter；HiddenHttpMethodFilter
用法
- 开启页面表单的Rest功能
- 页面 form的属性method=post，隐藏域 _method=put、delete等（如果直接get或post，无需隐藏域）
- 编写请求映射

spring:
  mvc:
    hiddenmethod:
      filter:
        enabled: true   #开启页面表单的Rest功能

<form action="/user" method="get">
    <input value="REST-GET提交" type="submit" />
</form>

<form action="/user" method="post">
    <input value="REST-POST提交" type="submit" />
</form>

<form action="/user" method="post">
    <input name="_method" type="hidden" value="DELETE"/>
    <input value="REST-DELETE 提交" type="submit"/>
</form>

<form action="/user" method="post">
    <input name="_method" type="hidden" value="PUT" />
    <input value="REST-PUT提交"type="submit" />
<form>

@GetMapping("/user")
//@RequestMapping(value = "/user",method = RequestMethod.GET)
public String getUser(){
    return "GET-张三";
}

@PostMapping("/user")
//@RequestMapping(value = "/user",method = RequestMethod.POST)
public String saveUser(){
    return "POST-张三";
}

@PutMapping("/user")
//@RequestMapping(value = "/user",method = RequestMethod.PUT)
public String putUser(){
    return "PUT-张三";
}

@DeleteMapping("/user")
//@RequestMapping(value = "/user",method = RequestMethod.DELETE)
public String deleteUser(){
    return "DELETE-张三";
}

Rest原理（表单提交要使用REST的时候）
- 表单提交会带上 \_method=PUT
- 请求过来被 HiddenHttpMethodFilter 拦截
- 请求是否正常，并且是POST
  - 获取到 \_method 的值。
  - 兼容以下请求； PUT.DELETE.PATCH
  - 原生request（post），包装模式requesWrapper重写了getMethod方法，返回的是传入的值。
  - 过滤器链放行的时候用wrapper。以后的方法调用getMethod是调用requesWrapper的。

public class HiddenHttpMethodFilter extends OncePerRequestFilter {

    private static final List<String> ALLOWED_METHODS =
            Collections.unmodifiableList(Arrays.asList(HttpMethod.PUT.name(),
                    HttpMethod.DELETE.name(), HttpMethod.PATCH.name()));

    /** Default method parameter: {@code _method}. */
    public static final String DEFAULT_METHOD_PARAM = "_method";

    private String methodParam = DEFAULT_METHOD_PARAM;


    /**
     * Set the parameter name to look for HTTP methods.
     * @see #DEFAULT_METHOD_PARAM
     */
    public void setMethodParam(String methodParam) {
        Assert.hasText(methodParam, "'methodParam' must not be empty");
        this.methodParam = methodParam;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {

        HttpServletRequest requestToUse = request;

        if ("POST".equals(request.getMethod()) && request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE) == null) {
            String paramValue = request.getParameter(this.methodParam);
            if (StringUtils.hasLength(paramValue)) {
                String method = paramValue.toUpperCase(Locale.ENGLISH);
                if (ALLOWED_METHODS.contains(method)) {
                    requestToUse = new HttpMethodRequestWrapper(request, method);
                }
            }
        }

        filterChain.doFilter(requestToUse, response);
    }


    /**
     * Simple {@link HttpServletRequest} wrapper that returns the supplied method for
     * {@link HttpServletRequest#getMethod()}.
     */
    private static class HttpMethodRequestWrapper extends HttpServletRequestWrapper {

        private final String method;

        public HttpMethodRequestWrapper(HttpServletRequest request, String method) {
            super(request);
            this.method = method;
        }

        @Override
        public String getMethod() {
            return this.method;
        }
    }

}

Rest使用客户端工具。
- 如PostMan可直接发送put、delete等方式请求。

【源码分析】-怎么改变默认的_method

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

    ...
    
    @Bean
    @ConditionalOnMissingBean(HiddenHttpMethodFilter.class)
    @ConditionalOnProperty(prefix = "spring.mvc.hiddenmethod.filter", name = "enabled", matchIfMissing = false)
    public OrderedHiddenHttpMethodFilter hiddenHttpMethodFilter() {
        return new OrderedHiddenHttpMethodFilter();
    }
    
    ...
}

@ConditionalOnMissingBean(HiddenHttpMethodFilter.class) 意味着在没有 HiddenHttpMethodFilter 时，才执行 hiddenHttpMethodFilter() 。因此，我们可以自定义filter，改变默认的 \_method 。例如：

@Configuration(proxyBeanMethods = false)
public class WebConfig{
    //自定义filter
    @Bean
    public HiddenHttpMethodFilter hiddenHttpMethodFilter(){
        HiddenHttpMethodFilter methodFilter = new HiddenHttpMethodFilter();
        methodFilter.setMethodParam("_m");
        return methodFilter;
    }    
}

将\_method改成_m。

<form action="/user" method="post">
    <input name="_m" type="hidden" value="DELETE"/>
    <input value="REST-DELETE 提交" type="submit"/>
</form>

【源码分析】-请求映射原理

SpringMVC功能分析都从 org.springframework.web.servlet.DispatcherServlet -> doDispatch()

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    boolean multipartRequestParsed = false;

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

    try {
        ModelAndView mv = null;
        Exception dispatchException = null;

        try {
            processedRequest = checkMultipart(request);
            multipartRequestParsed = (processedRequest != request);

            // 找到当前请求使用哪个Handler（Controller的方法）处理
            mappedHandler = getHandler(processedRequest);

            //HandlerMapping：处理器映射。/xxx->>xxxx
    ...
}

getHandler() 方法如下：

@Nullable
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    if (this.handlerMappings != null) {
        for (HandlerMapping mapping : this.handlerMappings) {
            HandlerExecutionChain handler = mapping.getHandler(request);
            if (handler != null) {
                return handler;
            }
        }
    }
    return null;
}

this.handlerMappings 在Debug模式下展现的内容：

其中，保存了所有@RequestMapping 和handler的映射规则。

所有的请求映射都在HandlerMapping中：
- SpringBoot自动配置欢迎页的 WelcomePageHandlerMapping 。访问 /能访问到index.html；
- SpringBoot自动配置了默认的 RequestMappingHandlerMapping
请求进来，挨个尝试所有的HandlerMapping看是否有请求信息。
- 如果有就找到这个请求对应的handler
- 如果没有就是下一个 HandlerMapping
我们需要一些自定义的映射处理，我们也可以自己给容器中放HandlerMapping。自定义 HandlerMapping
{message type="info" content="IDEA快捷键：

Ctrl + Alt + U : 以UML的类图展现类有哪些继承类，派生类以及实现哪些接口。
Crtl + Alt + Shift + U : 同上，区别在于上条快捷键结果在新页展现，而本条快捷键结果在弹窗展现。
Ctrl + H : 以树形方式展现类层次结构图。"/}

常用参数注解使用

注解：

@PathVariable 路径变量
@RequestHeader 获取请求头
@RequestParam 获取请求参数（指问号后的参数，url?a=1&b=2）
@CookieValue 获取Cookie值
@RequestAttribute 获取request域属性
@RequestBody 获取请求体[POST]

@MatrixVariable 矩阵变量
@ModelAttribute使用用例：

@RestController
public class ParameterTestController {


 //  car/2/owner/zhangsan
 @GetMapping("/car/{id}/owner/{username}")
 public Map<String,Object> getCar(@PathVariable("id") Integer id,
                                  @PathVariable("username") String name,
                                  @PathVariable Map<String,String> pv,
                                  @RequestHeader("User-Agent") String userAgent,
                                  @RequestHeader Map<String,String> header,
                                  @RequestParam("age") Integer age,
                                  @RequestParam("inters") List<String> inters,
                                  @RequestParam Map<String,String> params,
                                  @CookieValue("_ga") String _ga,
                                  @CookieValue("_ga") Cookie cookie){

     Map<String,Object> map = new HashMap<>();

//        map.put("id",id);
//        map.put("name",name);
//        map.put("pv",pv);
//        map.put("userAgent",userAgent);
//        map.put("headers",header);
     map.put("age",age);
     map.put("inters",inters);
     map.put("params",params);
     map.put("_ga",_ga);
     System.out.println(cookie.getName()+"===>"+cookie.getValue());
     return map;
 }


 @PostMapping("/save")
 public Map postMethod(@RequestBody String content){
     Map<String,Object> map = new HashMap<>();
     map.put("content",content);
     return map;
 }
}

@RequestAttribute使用用例：

@Controller
public class RequestController {

 @GetMapping("/goto")
 public String goToPage(HttpServletRequest request){

     request.setAttribute("msg","成功了...");
     request.setAttribute("code",200);
     return "forward:/success";  //转发到  /success请求
 }

 @GetMapping("/params")
 public String testParam(Map<String,Object> map,
                         Model model,
                         HttpServletRequest request,
                         HttpServletResponse response){
     map.put("hello","world666");
     model.addAttribute("world","hello666");
     request.setAttribute("message","HelloWorld");

     Cookie cookie = new Cookie("c1","v1");
     response.addCookie(cookie);
     return "forward:/success";
 }

 ///<-----------------主角@RequestAttribute在这个方法
 @ResponseBody
 @GetMapping("/success")
 public Map success(@RequestAttribute(value = "msg",required = false) String msg,
                    @RequestAttribute(value = "code",required = false)Integer code,
                    HttpServletRequest request){
     Object msg1 = request.getAttribute("msg");

     Map<String,Object> map = new HashMap<>();
     Object hello = request.getAttribute("hello");
     Object world = request.getAttribute("world");
     Object message = request.getAttribute("message");

     map.put("reqMethod_msg",msg1);
     map.put("annotation_msg",msg);
     map.put("hello",hello);
     map.put("world",world);
     map.put("message",message);

     return map;
 }
}

@MatrixVariable 与 UrlPathHelper

语法：请求路径：/cars/sell;low=34;brand=byd,audi,yd
SpringBoot默认是禁用了矩阵变量的功能
1. 手动开启：原理。对于路径的处理。UrlPathHelper的removeSemicolonContent设置为false，让其支持矩阵变量的。
矩阵变量必须有url路径变量才能被解析
手动开启矩阵变量：

实现WebMvcConfigurer接口：

@Configuration(proxyBeanMethods = false)
public class WebConfig implements WebMvcConfigurer {
 @Override
 public void configurePathMatch(PathMatchConfigurer configurer) {

     UrlPathHelper urlPathHelper = new UrlPathHelper();
     // 不移除；后面的内容。矩阵变量功能就可以生效
     urlPathHelper.setRemoveSemicolonContent(false);
     configurer.setUrlPathHelper(urlPathHelper);
 }
}

创建返回 WebMvcConfigurerBean ：

@Configuration(proxyBeanMethods = false)
public class WebConfig{
 @Bean
 public WebMvcConfigurer webMvcConfigurer(){
     return new WebMvcConfigurer() {
                     @Override
         public void configurePathMatch(PathMatchConfigurer configurer) {
             UrlPathHelper urlPathHelper = new UrlPathHelper();
             // 不移除；后面的内容。矩阵变量功能就可以生效
             urlPathHelper.setRemoveSemicolonContent(false);
             configurer.setUrlPathHelper(urlPathHelper);
         }
     }
 }
}

@MatrixVariable 的用例

@RestController
public class ParameterTestController {

 ///cars/sell;low=34;brand=byd,audi,yd
 @GetMapping("/cars/{path}")
 public Map carsSell(@MatrixVariable("low") Integer low,
                     @MatrixVariable("brand") List<String> brand,
                     @PathVariable("path") String path){
     Map<String,Object> map = new HashMap<>();

     map.put("low",low);
     map.put("brand",brand);
     map.put("path",path);
     return map;
 }

 // /boss/1;age=20/2;age=10

 @GetMapping("/boss/{bossId}/{empId}")
 public Map boss(@MatrixVariable(value = "age",pathVar = "bossId") Integer bossAge,
                 @MatrixVariable(value = "age",pathVar = "empId") Integer empAge){
     Map<String,Object> map = new HashMap<>();

     map.put("bossAge",bossAge);
     map.put("empAge",empAge);
     return map;

 }

}

【源码分析】-各种类型参数解析原理

这要从 DispatcherServlet 开始说起：

public class DispatcherServlet extends FrameworkServlet {
 
 protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
     HttpServletRequest processedRequest = request;
     HandlerExecutionChain mappedHandler = null;
     boolean multipartRequestParsed = false;

     WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

     try {
         ModelAndView mv = null;
         Exception dispatchException = null;

         try {
             processedRequest = checkMultipart(request);
             multipartRequestParsed = (processedRequest != request);

             // Determine handler for the current request.
             mappedHandler = getHandler(processedRequest);
             if (mappedHandler == null) {
                 noHandlerFound(processedRequest, response);
                 return;
             }

             // Determine handler adapter for the current request.
             HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
             ...

HandlerMapping中找到能处理请求的Handler（Controller.method()）。
为当前Handler 找一个适配器 HandlerAdapter，用的最多的是RequestMappingHandlerAdapter。
适配器执行目标方法并确定方法参数的每一个值。
HandlerAdapter
默认会加载所有 HandlerAdapter

public class DispatcherServlet extends FrameworkServlet {

    /** Detect all HandlerAdapters or just expect "handlerAdapter" bean?. */
    private boolean detectAllHandlerAdapters = true;

    ...
    
    private void initHandlerAdapters(ApplicationContext context) {
        this.handlerAdapters = null;

        if (this.detectAllHandlerAdapters) {
            // Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
            Map<String, HandlerAdapter> matchingBeans =
                BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
            if (!matchingBeans.isEmpty()) {
                this.handlerAdapters = new ArrayList<>(matchingBeans.values());
                // We keep HandlerAdapters in sorted order.
                AnnotationAwareOrderComparator.sort(this.handlerAdapters);
            }
        }
     ...

有这些 HandlerAdapter ：

支持方法上标注@RequestMapping
支持函数式编程的
…

…
执行目标方法

public class DispatcherServlet extends FrameworkServlet {
 
 protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
     ModelAndView mv = null;
     
     ...

     // Determine handler for the current request.
     mappedHandler = getHandler(processedRequest);
     if (mappedHandler == null) {
         noHandlerFound(processedRequest, response);
         return;
     }

     // Determine handler adapter for the current request.
     HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

     ...
     //本节重点
     // Actually invoke the handler.
     mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

HandlerAdapter 接口实现类 RequestMappingHandlerAdapter （主要用来处理 @RequestMapping ）

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
     implements BeanFactoryAware, InitializingBean {

 ...
 
 //AbstractHandlerMethodAdapter类的方法，RequestMappingHandlerAdapter继承AbstractHandlerMethodAdapter
 public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
     throws Exception {

     return handleInternal(request, response, (HandlerMethod) handler);
 }

 @Override
 protected ModelAndView handleInternal(HttpServletRequest request,
         HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
     ModelAndView mav;
     //handleInternal的核心
     mav = invokeHandlerMethod(request, response, handlerMethod);//解释看下节
     //...
     return mav;
 }
}

参数解析器
确定将要执行的目标方法的每一个参数的值是什么;
SpringMVC目标方法能写多少种参数类型。取决于参数解析器argumentResolvers。

@Nullable
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
                                        HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

 ServletWebRequest webRequest = new ServletWebRequest(request, response);
 try {
     WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
     ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);

     ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
     if (this.argumentResolvers != null) {//<-----关注点
         invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
     }
     
     ...

this.argumentResolvers 在 afterPropertiesSet() 方法内初始化

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
     implements BeanFactoryAware, InitializingBean {
 
 @Nullable
 private HandlerMethodArgumentResolverComposite argumentResolvers;
 
 @Override
 public void afterPropertiesSet() {
     ...
     if (this.argumentResolvers == null) {//初始化argumentResolvers
         List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
         this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
     }
     ...
 }

 //初始化了一堆的实现HandlerMethodArgumentResolver接口的
 private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
     List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>(30);

     // Annotation-based argument resolution
     resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
     resolvers.add(new RequestParamMapMethodArgumentResolver());
     resolvers.add(new PathVariableMethodArgumentResolver());
     resolvers.add(new PathVariableMapMethodArgumentResolver());
     resolvers.add(new MatrixVariableMethodArgumentResolver());
     resolvers.add(new MatrixVariableMapMethodArgumentResolver());
     resolvers.add(new ServletModelAttributeMethodProcessor(false));
     resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
     resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters(), this.requestResponseBodyAdvice));
     resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));
     resolvers.add(new RequestHeaderMapMethodArgumentResolver());
     resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));
     resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));
     resolvers.add(new SessionAttributeMethodArgumentResolver());
     resolvers.add(new RequestAttributeMethodArgumentResolver());

     // Type-based argument resolution
     resolvers.add(new ServletRequestMethodArgumentResolver());
     resolvers.add(new ServletResponseMethodArgumentResolver());
     resolvers.add(new HttpEntityMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
     resolvers.add(new RedirectAttributesMethodArgumentResolver());
     resolvers.add(new ModelMethodProcessor());
     resolvers.add(new MapMethodProcessor());
     resolvers.add(new ErrorsMethodArgumentResolver());
     resolvers.add(new SessionStatusMethodArgumentResolver());
     resolvers.add(new UriComponentsBuilderMethodArgumentResolver());
     if (KotlinDetector.isKotlinPresent()) {
         resolvers.add(new ContinuationHandlerMethodArgumentResolver());
     }

     // Custom arguments
     if (getCustomArgumentResolvers() != null) {
         resolvers.addAll(getCustomArgumentResolvers());
     }

     // Catch-all
     resolvers.add(new PrincipalMethodArgumentResolver());
     resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
     resolvers.add(new ServletModelAttributeMethodProcessor(true));

     return resolvers;
 }
 
}

HandlerMethodArgumentResolverComposite 类如下：（众多参数解析器 argumentResolvers 的包装类）。

public class HandlerMethodArgumentResolverComposite implements HandlerMethodArgumentResolver {

    private final List<HandlerMethodArgumentResolver> argumentResolvers = new ArrayList<>();
    
    ...
    
    public HandlerMethodArgumentResolverComposite addResolvers(
            @Nullable HandlerMethodArgumentResolver... resolvers) {

        if (resolvers != null) {
            Collections.addAll(this.argumentResolvers, resolvers);
        }
        return this;
    }
    
    ...
}

我们看看 HandlerMethodArgumentResolver 的源码：

public interface HandlerMethodArgumentResolver {

    //当前解析器是否支持解析这种参数
    boolean supportsParameter(MethodParameter parameter);

    @Nullable//如果支持，就调用 resolveArgument
    Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
            NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception;

}

返回值处理器
ValueHandler

@Nullable
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
                                           HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

    ServletWebRequest webRequest = new ServletWebRequest(request, response);
    try {
        WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
        ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);

        ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
        if (this.argumentResolvers != null) {
            invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
        }
        if (this.returnValueHandlers != null) {//<---关注点
            invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
        }
     ...

this.returnValueHandlers 在 afterPropertiesSet() 方法内初始化

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
        implements BeanFactoryAware, InitializingBean {
    
    @Nullable
    private HandlerMethodReturnValueHandlerComposite returnValueHandlers;
    
    @Override
    public void afterPropertiesSet() {

        ...
        
        if (this.returnValueHandlers == null) {
            List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
            this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
        }
    }
    
    //初始化了一堆的实现HandlerMethodReturnValueHandler接口的
    private List<HandlerMethodReturnValueHandler> getDefaultReturnValueHandlers() {
        List<HandlerMethodReturnValueHandler> handlers = new ArrayList<>(20);

        // Single-purpose return value types
        handlers.add(new ModelAndViewMethodReturnValueHandler());
        handlers.add(new ModelMethodProcessor());
        handlers.add(new ViewMethodReturnValueHandler());
        handlers.add(new ResponseBodyEmitterReturnValueHandler(getMessageConverters(),
                this.reactiveAdapterRegistry, this.taskExecutor, this.contentNegotiationManager));
        handlers.add(new StreamingResponseBodyReturnValueHandler());
        handlers.add(new HttpEntityMethodProcessor(getMessageConverters(),
                this.contentNegotiationManager, this.requestResponseBodyAdvice));
        handlers.add(new HttpHeadersReturnValueHandler());
        handlers.add(new CallableMethodReturnValueHandler());
        handlers.add(new DeferredResultMethodReturnValueHandler());
        handlers.add(new AsyncTaskMethodReturnValueHandler(this.beanFactory));

        // Annotation-based return value types
        handlers.add(new ServletModelAttributeMethodProcessor(false));
        handlers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(),
                this.contentNegotiationManager, this.requestResponseBodyAdvice));

        // Multi-purpose return value types
        handlers.add(new ViewNameMethodReturnValueHandler());
        handlers.add(new MapMethodProcessor());

        // Custom return value types
        if (getCustomReturnValueHandlers() != null) {
            handlers.addAll(getCustomReturnValueHandlers());
        }

        // Catch-all
        if (!CollectionUtils.isEmpty(getModelAndViewResolvers())) {
            handlers.add(new ModelAndViewResolverMethodReturnValueHandler(getModelAndViewResolvers()));
        }
        else {
            handlers.add(new ServletModelAttributeMethodProcessor(true));
        }

        return handlers;
    }
}

HandlerMethodReturnValueHandlerComposite 类如下：

public class HandlerMethodReturnValueHandlerComposite implements HandlerMethodReturnValueHandler {

    private final List<HandlerMethodReturnValueHandler> returnValueHandlers = new ArrayList<>();

    ...
    
    public HandlerMethodReturnValueHandlerComposite addHandlers(
            @Nullable List<? extends HandlerMethodReturnValueHandler> handlers) {

        if (handlers != null) {
            this.returnValueHandlers.addAll(handlers);
        }
        return this;
    }

}

HandlerMethodReturnValueHandler 接口：

public interface HandlerMethodReturnValueHandler {

    boolean supportsReturnType(MethodParameter returnType);

    void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
            ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception;

}

回顾执行目标方法

public class DispatcherServlet extends FrameworkServlet {
    ...
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView mv = null;
        ...
        mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

RequestMappingHandlerAdapter 的 handle() 方法：

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
        implements BeanFactoryAware, InitializingBean {

    ...
    
    //AbstractHandlerMethodAdapter类的方法，RequestMappingHandlerAdapter继承AbstractHandlerMethodAdapter
    public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
        throws Exception {

        return handleInternal(request, response, (HandlerMethod) handler);
    }

    @Override
    protected ModelAndView handleInternal(HttpServletRequest request,
            HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
        ModelAndView mav;
        //handleInternal的核心
        mav = invokeHandlerMethod(request, response, handlerMethod);//解释看下节
        //...
        return mav;
    }
}

RequestMappingHandlerAdapter 的 invokeHandlerMethod() 方法：

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
        implements BeanFactoryAware, InitializingBean {
    
    protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
            HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

        ServletWebRequest webRequest = new ServletWebRequest(request, response);
        try {
            ...
            
            ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
            if (this.argumentResolvers != null) {
                invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
            }
            if (this.returnValueHandlers != null) {
                invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
            }
            ...

            //关注点：执行目标方法
            invocableMethod.invokeAndHandle(webRequest, mavContainer);
            if (asyncManager.isConcurrentHandlingStarted()) {
                return null;
            }

            return getModelAndView(mavContainer, modelFactory, webRequest);
        }
        finally {
            webRequest.requestCompleted();
        }
    }

invokeAndHandle() 方法如下：

public class ServletInvocableHandlerMethod extends InvocableHandlerMethod {

    public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
            Object... providedArgs) throws Exception {

        Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);

        ...
        
        try {
            //returnValue存储起来
            this.returnValueHandlers.handleReturnValue(
                    returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
        }
        catch (Exception ex) {
            ...
        }
    }
    
    @Nullable//InvocableHandlerMethod类的，ServletInvocableHandlerMethod类继承InvocableHandlerMethod类
    public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
            Object... providedArgs) throws Exception {

        获取方法的参数值
        Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);

        ...
       
        return doInvoke(args);
    }

    @Nullable
    protected Object doInvoke(Object... args) throws Exception {
        Method method = getBridgedMethod();//@RequestMapping的方法
        ReflectionUtils.makeAccessible(method);
        try {
            if (KotlinDetector.isSuspendingFunction(method)) {
                return CoroutinesUtils.invokeSuspendingFunction(method, getBean(), args);
            }
            //通过反射调用
            return method.invoke(getBean(), args);//getBean()指@RequestMapping的方法所在类的对象。
        }
        catch (IllegalArgumentException ex) {
            ...
        }
        catch (InvocationTargetException ex) {
            ...
        }
    }
    
}

如何确定目标方法每一个参数的值
重点分析 ServletInvocableHandlerMethod 的 getMethodArgumentValues 方法

public class ServletInvocableHandlerMethod extends InvocableHandlerMethod {
    ...

    @Nullable//InvocableHandlerMethod类的，ServletInvocableHandlerMethod类继承InvocableHandlerMethod类
    public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
            Object... providedArgs) throws Exception {

        获取方法的参数值
        Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);

        ...
       
        return doInvoke(args);
    }
 
    //本节重点，获取方法的参数值
    protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
            Object... providedArgs) throws Exception {

        MethodParameter[] parameters = getMethodParameters();
        if (ObjectUtils.isEmpty(parameters)) {
            return EMPTY_ARGS;
        }

        Object[] args = new Object[parameters.length];
        for (int i = 0; i < parameters.length; i++) {
            MethodParameter parameter = parameters[i];
            parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
            args[i] = findProvidedArgument(parameter, providedArgs);
            if (args[i] != null) {
                continue;
            }
            //查看resolvers是否有支持
            if (!this.resolvers.supportsParameter(parameter)) {
                throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
            }
            try {
                //支持的话就开始解析吧
                args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
            }
            catch (Exception ex) {
                ....
            }
        }
        return args;
    }
    
}

this.resolvers 的类型为 HandlerMethodArgumentResolverComposite （在参数解析器章节提及）

public class HandlerMethodArgumentResolverComposite implements HandlerMethodArgumentResolver {
    
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return getArgumentResolver(parameter) != null;
    }

    @Override
    @Nullable
    public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
            NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

        HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
        if (resolver == null) {
            throw new IllegalArgumentException("Unsupported parameter type [" +
                    parameter.getParameterType().getName() + "]. supportsParameter should be called first.");
        }
        return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
    }
    
    
    @Nullable
    private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
        HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
        if (result == null) {
            //挨个判断所有参数解析器那个支持解析这个参数
            for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
                if (resolver.supportsParameter(parameter)) {
                    result = resolver;
                    this.argumentResolverCache.put(parameter, result);//找到了，resolver就缓存起来，方便稍后resolveArgument()方法使用
                    break;
                }
            }
        }
        return result;
    }
}

{alert type="success"}
小结
本节描述，一个请求发送到DispatcherServlet后的具体处理流程，也就是SpringMVC的主要原理。
本节内容较多且硬核，对日后编程很有帮助，需耐心对待。
可以运行一个示例，打断点，在Debug模式下，查看程序流程。
{/alert}

【源码分析】-Servlet API参数解析原理

WebRequest
ServletRequest
MultipartRequest
HttpSession
javax.servlet.http.PushBuilder
Principal
InputStream
Reader
HttpMethod
Locale
TimeZone

ZoneId

ServletRequestMethodArgumentResolver 用来处理以上的参数

public class ServletRequestMethodArgumentResolver implements HandlerMethodArgumentResolver {

  @Nullable
  private static Class<?> pushBuilder;

  static {
      try {
          pushBuilder = ClassUtils.forName("javax.servlet.http.PushBuilder",
                  ServletRequestMethodArgumentResolver.class.getClassLoader());
      }
      catch (ClassNotFoundException ex) {
          // Servlet 4.0 PushBuilder not found - not supported for injection
          pushBuilder = null;
      }
  }


  @Override
  public boolean supportsParameter(MethodParameter parameter) {
      Class<?> paramType = parameter.getParameterType();
      return (WebRequest.class.isAssignableFrom(paramType) ||
              ServletRequest.class.isAssignableFrom(paramType) ||
              MultipartRequest.class.isAssignableFrom(paramType) ||
              HttpSession.class.isAssignableFrom(paramType) ||
              (pushBuilder != null && pushBuilder.isAssignableFrom(paramType)) ||
              (Principal.class.isAssignableFrom(paramType) && !parameter.hasParameterAnnotations()) ||
              InputStream.class.isAssignableFrom(paramType) ||
              Reader.class.isAssignableFrom(paramType) ||
              HttpMethod.class == paramType ||
              Locale.class == paramType ||
              TimeZone.class == paramType ||
              ZoneId.class == paramType);
  }

  @Override
  public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
          NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

      Class<?> paramType = parameter.getParameterType();

      // WebRequest / NativeWebRequest / ServletWebRequest
      if (WebRequest.class.isAssignableFrom(paramType)) {
          if (!paramType.isInstance(webRequest)) {
              throw new IllegalStateException(
                      "Current request is not of type [" + paramType.getName() + "]: " + webRequest);
          }
          return webRequest;
      }

      // ServletRequest / HttpServletRequest / MultipartRequest / MultipartHttpServletRequest
      if (ServletRequest.class.isAssignableFrom(paramType) || MultipartRequest.class.isAssignableFrom(paramType)) {
          return resolveNativeRequest(webRequest, paramType);
      }

      // HttpServletRequest required for all further argument types
      return resolveArgument(paramType, resolveNativeRequest(webRequest, HttpServletRequest.class));
  }

  private <T> T resolveNativeRequest(NativeWebRequest webRequest, Class<T> requiredType) {
      T nativeRequest = webRequest.getNativeRequest(requiredType);
      if (nativeRequest == null) {
          throw new IllegalStateException(
                  "Current request is not of type [" + requiredType.getName() + "]: " + webRequest);
      }
      return nativeRequest;
  }

  @Nullable
  private Object resolveArgument(Class<?> paramType, HttpServletRequest request) throws IOException {
      if (HttpSession.class.isAssignableFrom(paramType)) {
          HttpSession session = request.getSession();
          if (session != null && !paramType.isInstance(session)) {
              throw new IllegalStateException(
                      "Current session is not of type [" + paramType.getName() + "]: " + session);
          }
          return session;
      }
      else if (pushBuilder != null && pushBuilder.isAssignableFrom(paramType)) {
          return PushBuilderDelegate.resolvePushBuilder(request, paramType);
      }
      else if (InputStream.class.isAssignableFrom(paramType)) {
          InputStream inputStream = request.getInputStream();
          if (inputStream != null && !paramType.isInstance(inputStream)) {
              throw new IllegalStateException(
                      "Request input stream is not of type [" + paramType.getName() + "]: " + inputStream);
          }
          return inputStream;
      }
      else if (Reader.class.isAssignableFrom(paramType)) {
          Reader reader = request.getReader();
          if (reader != null && !paramType.isInstance(reader)) {
              throw new IllegalStateException(
                      "Request body reader is not of type [" + paramType.getName() + "]: " + reader);
          }
          return reader;
      }
      else if (Principal.class.isAssignableFrom(paramType)) {
          Principal userPrincipal = request.getUserPrincipal();
          if (userPrincipal != null && !paramType.isInstance(userPrincipal)) {
              throw new IllegalStateException(
                      "Current user principal is not of type [" + paramType.getName() + "]: " + userPrincipal);
          }
          return userPrincipal;
      }
      else if (HttpMethod.class == paramType) {
          return HttpMethod.resolve(request.getMethod());
      }
      else if (Locale.class == paramType) {
          return RequestContextUtils.getLocale(request);
      }
      else if (TimeZone.class == paramType) {
          TimeZone timeZone = RequestContextUtils.getTimeZone(request);
          return (timeZone != null ? timeZone : TimeZone.getDefault());
      }
      else if (ZoneId.class == paramType) {
          TimeZone timeZone = RequestContextUtils.getTimeZone(request);
          return (timeZone != null ? timeZone.toZoneId() : ZoneId.systemDefault());
      }

      // Should never happen...
      throw new UnsupportedOperationException("Unknown parameter type: " + paramType.getName());
  }


  /**
   * Inner class to avoid a hard dependency on Servlet API 4.0 at runtime.
   */
  private static class PushBuilderDelegate {

      @Nullable
      public static Object resolvePushBuilder(HttpServletRequest request, Class<?> paramType) {
          PushBuilder pushBuilder = request.newPushBuilder();
          if (pushBuilder != null && !paramType.isInstance(pushBuilder)) {
              throw new IllegalStateException(
                      "Current push builder is not of type [" + paramType.getName() + "]: " + pushBuilder);
          }
          return pushBuilder;

      }
  }
}

用例：

@Controller
public class RequestController {

  @GetMapping("/goto")
  public String goToPage(HttpServletRequest request){

      request.setAttribute("msg","成功了...");
      request.setAttribute("code",200);
      return "forward:/success";  //转发到  /success请求
  }
}

【源码分析】-Model、Map原理

复杂参数：

Map
Model（map、model里面的数据会被放在request的请求域 request.setAttribute）
Errors/BindingResult
RedirectAttributes（重定向携带数据）
ServletResponse（response）
SessionStatus
UriComponentsBuilder

ServletUriComponentsBuilder
用例：

@GetMapping("/params")
public String testParam(Map<String,Object> map,
                      Model model,
                      HttpServletRequest request,
                      HttpServletResponse response){
  //下面三位都是可以给request域中放数据
  map.put("hello","world666");
  model.addAttribute("world","hello666");
  request.setAttribute("message","HelloWorld");

  Cookie cookie = new Cookie("c1","v1");
  response.addCookie(cookie);
  return "forward:/success";
}

@ResponseBody
@GetMapping("/success")
public Map success(@RequestAttribute(value = "msg",required = false) String msg,
                 @RequestAttribute(value = "code",required = false)Integer code,
                 HttpServletRequest request){
  Object msg1 = request.getAttribute("msg");

  Map<String,Object> map = new HashMap<>();
  Object hello = request.getAttribute("hello");//得出testParam方法赋予的值 world666
  Object world = request.getAttribute("world");//得出testParam方法赋予的值 hello666
  Object message = request.getAttribute("message");//得出testParam方法赋予的值 HelloWorld

  map.put("reqMethod_msg",msg1);
  map.put("annotation_msg",msg);
  map.put("hello",hello);
  map.put("world",world);
  map.put("message",message);

  return map;
}

Map<String,Object> map
Model model

HttpServletRequest request
上面三位都是可以给request域中放数据，用request.getAttribute()获取
接下来我们看看，Map<String,Object> map与Model model用什么参数处理器。
Map<String,Object> map 参数用 MapMethodProcessor 处理：

public class MapMethodProcessor implements HandlerMethodArgumentResolver, HandlerMethodReturnValueHandler {

  @Override
  public boolean supportsParameter(MethodParameter parameter) {
      return (Map.class.isAssignableFrom(parameter.getParameterType()) &&
              parameter.getParameterAnnotations().length == 0);
  }

  @Override
  @Nullable
  public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
          NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

      Assert.state(mavContainer != null, "ModelAndViewContainer is required for model exposure");
      return mavContainer.getModel();
  }
  
  ...
  
}

mavContainer.getModel() 如下：

public class ModelAndViewContainer {

  ...

  private final ModelMap defaultModel = new BindingAwareModelMap();

  @Nullable
  private ModelMap redirectModel;

  ...

  public ModelMap getModel() {
      if (useDefaultModel()) {
          return this.defaultModel;
      }
      else {
          if (this.redirectModel == null) {
              this.redirectModel = new ModelMap();
          }
          return this.redirectModel;
      }
  }
  
  private boolean useDefaultModel() {
      return (!this.redirectModelScenario || (this.redirectModel == null && !this.ignoreDefaultModelOnRedirect));
  }
  ...
  
}

Model model 用 ModelMethodProcessor 处理：

public class ModelMethodProcessor implements HandlerMethodArgumentResolver, HandlerMethodReturnValueHandler {

  @Override
  public boolean supportsParameter(MethodParameter parameter) {
      return Model.class.isAssignableFrom(parameter.getParameterType());
  }

  @Override
  @Nullable
  public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
          NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

      Assert.state(mavContainer != null, "ModelAndViewContainer is required for model exposure");
      return mavContainer.getModel();
  }
  ...
}

return mavContainer.getModel() ;这跟 MapMethodProcessor 的一致

Model 也是另一种意义的 Map 。
接下来看看 Map<String,Object> map 与 Model model 值是如何做到用 request.getAttribute() 获取的。
众所周知，所有的数据都放在 ModelAndView 包含要去的页面地址 View ，还包含 Model 数据。
先看ModelAndView接下来是如何处理的？

public class DispatcherServlet extends FrameworkServlet {
    
    ...
    
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ...

        try {
            ModelAndView mv = null;
            
            ...

            // Actually invoke the handler.
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
            
            ...
            
            }
            catch (Exception ex) {
                dispatchException = ex;
            }
            catch (Throwable err) {
                // As of 4.3, we're processing Errors thrown from handler methods as well,
                // making them available for @ExceptionHandler methods and other scenarios.
                dispatchException = new NestedServletException("Handler dispatch failed", err);
            }
            //处理分发结果
            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        }
        ...

    }

    private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
            @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
            @Nullable Exception exception) throws Exception {
        ...

        // Did the handler return a view to render?
        if (mv != null && !mv.wasCleared()) {
            render(mv, request, response);
            ...
        }
        ...
    }

    protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
        ...

        View view;
        String viewName = mv.getViewName();
        if (viewName != null) {
            // We need to resolve the view name.
            view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
            if (view == null) {
                throw new ServletException("Could not resolve view with name '" + mv.getViewName() +
                        "' in servlet with name '" + getServletName() + "'");
            }
        }
        else {
            // No need to lookup: the ModelAndView object contains the actual View object.
            view = mv.getView();
            if (view == null) {
                throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +
                        "View object in servlet with name '" + getServletName() + "'");
            }
        }
        view.render(mv.getModelInternal(), request, response);
        
        ...
    }

}

在Debug模式下， view 属为 InternalResourceView 类。

public class InternalResourceView extends AbstractUrlBasedView {
    
     @Override//该方法在AbstractView，AbstractUrlBasedView继承了AbstractView
    public void render(@Nullable Map<String, ?> model, HttpServletRequest request,
            HttpServletResponse response) throws Exception {
        
        ...
        
        Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);
        prepareResponse(request, response);
        
        //看下一个方法实现
        renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);
    }
    
    @Override
    protected void renderMergedOutputModel(
            Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {

        // Expose the model object as request attributes.
        // 暴露模型作为请求域属性
        exposeModelAsRequestAttributes(model, request);//<---重点

        // Expose helpers as request attributes, if any.
        exposeHelpers(request);

        // Determine the path for the request dispatcher.
        String dispatcherPath = prepareForRendering(request, response);

        // Obtain a RequestDispatcher for the target resource (typically a JSP).
        RequestDispatcher rd = getRequestDispatcher(request, dispatcherPath);
        
        ...
    }
    
    //该方法在AbstractView，AbstractUrlBasedView继承了AbstractView
    protected void exposeModelAsRequestAttributes(Map<String, Object> model,
            HttpServletRequest request) throws Exception {

        model.forEach((name, value) -> {
            if (value != null) {
                request.setAttribute(name, value);
            }
            else {
                request.removeAttribute(name);
            }
        });
    }
    
}

exposeModelAsRequestAttributes 方法看出， Map<String,Object> map ， Model model 这两种类型数据可以给 request 域中放数据，用 request.getAttribute() 获取。

【源码分析】-自定义参数绑定原理

@RestController
public class ParameterTestController {

    /**
     * 数据绑定：页面提交的请求数据（GET、POST）都可以和对象属性进行绑定
     * @param person
     * @return
     */
    @PostMapping("/saveuser")
    public Person saveuser(Person person){
        return person;
    }
}

/**
 *     姓名： <input name="userName"/> <br/>
 *     年龄： <input name="age"/> <br/>
 *     生日： <input name="birth"/> <br/>
 *     宠物姓名：<input name="pet.name"/><br/>
 *     宠物年龄：<input name="pet.age"/>
 */
@Data
public class Person {
    
    private String userName;
    private Integer age;
    private Date birth;
    private Pet pet;
    
}

@Data
public class Pet {

    private String name;
    private String age;

}

封装过程用到 ServletModelAttributeMethodProcessor

public class ServletModelAttributeMethodProcessor extends ModelAttributeMethodProcessor {
    
    @Override//本方法在ModelAttributeMethodProcessor类，
    public boolean supportsParameter(MethodParameter parameter) {
        return (parameter.hasParameterAnnotation(ModelAttribute.class) ||
                (this.annotationNotRequired && !BeanUtils.isSimpleProperty(parameter.getParameterType())));
    }

    @Override
    @Nullable//本方法在ModelAttributeMethodProcessor类，
    public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
            NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

        ...

        String name = ModelFactory.getNameForParameter(parameter);
        ModelAttribute ann = parameter.getParameterAnnotation(ModelAttribute.class);
        if (ann != null) {
            mavContainer.setBinding(name, ann.binding());
        }

        Object attribute = null;
        BindingResult bindingResult = null;

        if (mavContainer.containsAttribute(name)) {
            attribute = mavContainer.getModel().get(name);
        }
        else {
            // Create attribute instance
            try {
                attribute = createAttribute(name, parameter, binderFactory, webRequest);
            }
            catch (BindException ex) {
                ...
            }
        }

        if (bindingResult == null) {
            // Bean property binding and validation;
            // skipped in case of binding failure on construction.
            WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);
            if (binder.getTarget() != null) {
                if (!mavContainer.isBindingDisabled(name)) {
                    //web数据绑定器，将请求参数的值绑定到指定的JavaBean里面**
                    bindRequestParameters(binder, webRequest);
                }
                validateIfApplicable(binder, parameter);
                if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
                    throw new BindException(binder.getBindingResult());
                }
            }
            // Value type adaptation, also covering java.util.Optional
            if (!parameter.getParameterType().isInstance(attribute)) {
                attribute = binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
            }
            bindingResult = binder.getBindingResult();
        }

        // Add resolved attribute and BindingResult at the end of the model
        Map<String, Object> bindingResultModel = bindingResult.getModel();
        mavContainer.removeAttributes(bindingResultModel);
        mavContainer.addAllAttributes(bindingResultModel);

        return attribute;
    }
}

WebDataBinder 利用它里面的 Converters 将请求数据转成指定的数据类型。再次封装到JavaBean中
在过程当中，用到GenericConversionService：在设置每一个值的时候，找它里面的所有converter那个可以将这个数据类型（request带来参数的字符串）转换到指定的类型

【源码分析】-自定义Converter原理

未来我们可以给 WebDataBinder 里面放自己的 Converter ；

下面演示将字符串“ 啊猫,3 ”转换成 Pet对象 。

//1、WebMvcConfigurer定制化SpringMVC的功能
    @Bean
    public WebMvcConfigurer webMvcConfigurer(){
        return new WebMvcConfigurer() {

            @Override
            public void addFormatters(FormatterRegistry registry) {
                registry.addConverter(new Converter<String, Pet>() {

                    @Override
                    public Pet convert(String source) {
                        // 啊猫,3
                        if(!StringUtils.isEmpty(source)){
                            Pet pet = new Pet();
                            String[] split = source.split(",");
                            pet.setName(split[0]);
                            pet.setAge(Integer.parseInt(split[1]));
                            return pet;
                        }
                        return null;
                    }
                });
            }
        };
    }

{/collapse-item}
{/collapse}
{/timeline-item}
{timeline-item color="#ed4014"}
点击跳转：SpringBoot的学习第三篇
{/timeline-item}
{/timeline}

SpringBoot的学习第二篇

SpringBoot-自动配置特性" open}

底层注解"}

@Configuration详解

Import导入组件

@Conditional条件装配

@ImportResource导入Spring配置文件

@ConfigurationProperties配置绑定

自动配置【源码分析】-自动包规则原理"}

@SpringBootConfiguration

@EnableAutoConfiguration

@AutoConfigurationPackage

自动配置【源码分析】-初始加载自动配置类"}

@Import(AutoConfigurationImportSelector.class)

自动配置【源码分析】-自动配置流程"}

最佳实践"}

SpringBoot应用如何编写

Lombok简化开发

dev-tools

Spring Initailizr

配置文件"}

配置文件-yaml的用法

配置文件-自定义类绑定的配置提示

web场景"}

web开发简介

静态资源规则与定制化

welcome与favicon功能

【源码分析】-静态资源原理

请求处理" }

【源码分析】-Rest映射及源码解析

【源码分析】-怎么改变默认的_method

【源码分析】-请求映射原理

常用参数注解使用

【源码分析】-各种类型参数解析原理

【源码分析】-Servlet API参数解析原理

【源码分析】-Model、Map原理

【源码分析】-自定义参数绑定原理

【源码分析】-自定义Converter原理

{mtitle title="后接SpringBoot的学习第三篇"/}