封面画师：T5-茨舞（微博）     封面ID：104944884

参考视频：黑马程序员Spring视频教程，全面深度讲解spring5底层原理

源码仓库：mofan212/advanced-spring (github.com)

20. RequestMappingHandlerMapping 与 RequestMappingHandlerAdapter

20.1 DispatcherServlet 的初始化

选择支持内嵌 Tomcat 服务器的 Spring 容器作为 ApplicationContext 的实现：

1234public static void main(String[] args) {
    AnnotationConfigServletWebServerApplicationContext context =
        new AnnotationConfigServletWebServerApplicationContext(WebConfig.class);
}

WebConfig 作为配置类，向 Spring 容器中添加内嵌 Web 容器工厂、DispatcherServlet 和 DispatcherServlet 注册对象。

12345678910111213141516171819202122232425262728293031/**
 * @author mofan
 * @date 2023/1/22 22:38
 */
@Configuration
@ComponentScan
public class WebConfig {
    /**
     * 内嵌 Web 容器工厂
     */
    @Bean
    public TomcatServletWebServerFactory tomcatServletWebServerFactory() {
        return new TomcatServletWebServerFactory();
    }

    /**
     * 创建 DispatcherServlet
     */
    @Bean
    public DispatcherServlet dispatcherServlet() {
        return new DispatcherServlet();
    }

    /**
     * 注册 DispatcherServlet，Spring MVC 的入口
     */
    @Bean
    public DispatcherServletRegistrationBean dispatcherServletRegistrationBean(DispatcherServlet dispatcherServlet) {
        return new DispatcherServletRegistrationBean(dispatcherServlet, "/");
    }
}

运行 main() 方法，控制台打印出：

Tomcat initialized with port(s): 8080 (http)
Root WebApplicationContext: initialization completed in 2132 ms

Tomcat 容器初始化成功，Spring 容器初始化成功，但 DispatcherServlet 还未被初始化。

当 Tomcat 服务器 首次 使用到 DispatcherServlet 时，才会由 Tomcat 服务器初始化 DispatcherServlet。

清空控制台信息，使用浏览器访问 localhost:8080，控制台打印出：

信息: Initializing Spring DispatcherServlet 'dispatcherServlet'
[INFO ] Initializing Servlet 'dispatcherServlet' 
[TRACE] No MultipartResolver 'multipartResolver' declared 
[TRACE] No LocaleResolver 'localeResolver': using default [AcceptHeaderLocaleResolver] 
[TRACE] No ThemeResolver 'themeResolver': using default [FixedThemeResolver] 
[TRACE] No HandlerMappings declared for servlet 'dispatcherServlet': using default strategies from DispatcherServlet.properties 
[TRACE] No HandlerAdapters declared for servlet 'dispatcherServlet': using default strategies from DispatcherServlet.properties 
[TRACE] No HandlerExceptionResolvers declared in servlet 'dispatcherServlet': using default strategies from DispatcherServlet.properties 
[TRACE] No RequestToViewNameTranslator 'viewNameTranslator': using default [DefaultRequestToViewNameTranslator] 
[TRACE] No ViewResolvers declared for servlet 'dispatcherServlet': using default strategies from DispatcherServlet.properties 
[TRACE] No FlashMapManager 'flashMapManager': using default [SessionFlashMapManager] 
[INFO] Completed initialization in 482 ms 

完成 DispatcherServlet 的初始化。

使用 DEBUG 查看 DispatcherServlet 的初始化时机

断点 DispatcherServlet 的 onRefresh() 方法中 this.initStrategies(context); 的所在行：

123protected void onRefresh(ApplicationContext context) {
    this.initStrategies(context);
}

以 DEBUG 方式重启程序，此时程序尚未执行到断点处。

再次在浏览器中访问 localhost:8080，程序执行到断点处。

查看调用栈可知，是从 GenericServlet 的 init() 方法执行到 onRefresh() 方法的：

1234public void init(ServletConfig config) throws ServletException {
    this.config = config;
    this.init();
}

因此 DispatcherServlet 的初始化流程走的是 Servlet 的初始化流程。

使 DispatcherServlet 在 Tomcat 服务器启动时被初始化

修改添加到 Spring 容器的 DispatcherServlet 注册 Bean：

123456@Bean
public DispatcherServletRegistrationBean dispatcherServletRegistrationBean(DispatcherServlet dispatcherServlet) {
    DispatcherServletRegistrationBean registrationBean = new DispatcherServletRegistrationBean(dispatcherServlet, "/");
    registrationBean.setLoadOnStartup(1);
    return registrationBean;
}

设置其 loadOnStartup 为一个正数。

当存在多个 DispatcherServlet 需要被注册时，设置的 loadOnStartup 越大，优先级越小，初始化顺序越靠后。

再次重启程序，根据控制台输出的内容可知，不仅完成 Tomcat 和 Spring 容器的初始化，DispatcherServlet 也初始化成功。

抽取配置信息到配置文件中

使用 @PropertySource 注解设置配置类需要读取的配置文件，以便后续读取配置文件中的内容。

要读取配置文件中的内容，可以使用 @Value 注解，但该注解一次仅仅能够读取一个值，现实是往往需要从配置文件中读取多个值。

可以使用 @EnableConfigurationProperties 注解完成配置文件信息与对象的绑定，后续使用时作为 @Bean 注解标记的方法的参数直接在方法中使用即可：

123server.port=9090

spring.mvc.servlet.load-on-startup=1

1234567891011121314151617181920212223242526272829303132@Configuration
@ComponentScan
@PropertySource("classpath:application.properties")
@EnableConfigurationProperties({WebMvcProperties.class, ServerProperties.class})
public class WebConfig {
    /**
     * 内嵌 Web 容器工厂
     */
    @Bean
    public TomcatServletWebServerFactory tomcatServletWebServerFactory(ServerProperties serverProperties) {
        return new TomcatServletWebServerFactory(serverProperties.getPort());
    }

    /**
     * 创建 DispatcherServlet
     */
    @Bean
    public DispatcherServlet dispatcherServlet() {
        return new DispatcherServlet();
    }

    /**
     * 注册 DispatcherServlet，Spring MVC 的入口
     */
    @Bean
    public DispatcherServletRegistrationBean dispatcherServletRegistrationBean(DispatcherServlet dispatcherServlet,
                                                                               WebMvcProperties webMvcProperties) {
        DispatcherServletRegistrationBean registrationBean = new DispatcherServletRegistrationBean(dispatcherServlet, "/");
        registrationBean.setLoadOnStartup(webMvcProperties.getServlet().getLoadOnStartup());
        return registrationBean;
    }
}

再次重启程序，根据控制台输出的内容可知，Tomcat 此时监听的端口是 9090，DispatcherServlet 也在 Tomcat 启动时被初始化。

DispatcherServlet 初始化时执行的操作

回到 DispatcherServlet 的 onRefresh() 方法，它又调用了 initStrategies() 方法：

1234567891011protected void initStrategies(ApplicationContext context) {
    this.initMultipartResolver(context);
    this.initLocaleResolver(context);
    this.initThemeResolver(context);
    this.initHandlerMappings(context);
    this.initHandlerAdapters(context);
    this.initHandlerExceptionResolvers(context);
    this.initRequestToViewNameTranslator(context);
    this.initViewResolvers(context);
    this.initFlashMapManager(context);
}

在这个方法中初始化了一系列组件，见名识意即可，重点介绍：

• initHandlerMappings()：初始化处理器映射器
• initHandlerAdapters()：初始化处理器适配器
• initHandlerExceptionResolvers()：初始化异常处理器

在所有的初始化方法中都有一个相似的逻辑，首先使用一个布尔值判断是否检测 所有 目标组件。

Spring 支持父子容器嵌套，如果判断的布尔值为 true，那么 Spring 不仅会在当前容器中获取目标组件，还会在其所有父级容器中寻找。

以 initHandlerMappings() 为例：

1234567891011121314151617private void initHandlerMappings(ApplicationContext context) {
    this.handlerMappings = null;
    if (this.detectAllHandlerMappings) { // 是否需要检测所有处理器映射器
        // --snip--
    } else {
        // 无需检测所有处理器映射器时，获取当前容器中的处理器映射器
        // --snip--
    }

    if (this.handlerMappings == null) {
        // 当前容器中没有处理器映射器时，设置默认的处理器映射器
        this.handlerMappings = this.getDefaultStrategies(context, HandlerMapping.class);
        // --snip--
    }

    // --snip--
}

20.2 RequestMappingHandlerMapping

HandlerMapping，即处理器映射器，用于建立请求路径与控制器方法的映射关系。

RequestMappingHandlerMapping 是 HandlerMapping 的一种实现，根据类名可知，它是通过 @RequestMapping 注解来实现路径映射。

当 Spring 容器中没有 HandlerMapping 的实现时，尽管 DispatcherServlet 在初始化时会添加一些默认的实现，但这些实现不会交由 Spring 管理，而是作为 DispatcherServlet 的成员变量。

在配置类中将 RequestMappingHandlerMapping 添加到 Spring 容器：

1234@Bean
public RequestMappingHandlerMapping requestMappingHandlerMapping() {
    return new RequestMappingHandlerMapping();
}

定义一个控制器类：

123456789101112131415161718192021222324252627@Slf4j
@Controller
public class Controller1 {
    @GetMapping("/test1")
    public ModelAndView test1() throws Exception {
        log.debug("test1()");
        return null;
    }

    @PostMapping("/test2")
    public ModelAndView test2(@RequestParam("name") String name) {
        log.debug("test2({})", name);
        return null;
    }

    @PutMapping("/test3")
    public ModelAndView test3(String token) {
        log.debug("test3({})", token);
        return null;
    }

    @RequestMapping("/test4")
    public User test4() {
        log.debug("test4");
        return new User("张三", 18);
    }
}

编写 main() 方法，从 Spring 容器中获取 RequestMappingHandlerMapping，再获取请求路径与映射器方法的映射关系，并根据给定请求获取控制器方法：

123456789101112public static void main(String[] args) throws Exception {
    AnnotationConfigServletWebServerApplicationContext context =
            new AnnotationConfigServletWebServerApplicationContext(WebConfig.class);
    // 解析 @RequestMapping 以及派生注解，在初始化时生成路径与控制器方法的映射关系
    RequestMappingHandlerMapping handlerMapping = context.getBean(RequestMappingHandlerMapping.class);
    // 获取映射结果
    Map<RequestMappingInfo, HandlerMethod> handlerMethods = handlerMapping.getHandlerMethods();
    handlerMethods.forEach((k, v) -> System.out.println(k + " = " + v));
    // 根据给定请求获取控制器方法，返回处理器执行链
    HandlerExecutionChain chain = handlerMapping.getHandler(new MockHttpServletRequest("GET", "/test1"));
    System.out.println(chain);
}

{GET [/test1]} = indi.mofan.a20.Controller1#test1()
{POST [/test2]} = indi.mofan.a20.Controller1#test2(String)
{PUT [/test3]} = indi.mofan.a20.Controller1#test3(String)
{ [/test4]} = indi.mofan.a20.Controller1#test4()
HandlerExecutionChain with [indi.mofan.a20.Controller1#test1()] and 0 interceptors

getHandler() 方法返回的对象时处理器执行链，不仅包含映射器方法，还包含需要执行的拦截器信息。

MockHttpServletRequest 的使用

需要导入以下依赖：

1234<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
</dependency>

20.3 RequestMappingHandlerAdapter

RequestMappingHandlerAdapter 实现了 HandlerAdapter 接口，HandlerAdapter 用于执行控制器方法，而 RequestMapping 表明 RequestMappingHandlerAdapter 用于执行被 @RequestMapping 注解标记的控制器方法。

同样需要在配置类中将 RequestMappingHandlerAdapter 添加到 Spring 容器，但该类中需要测试的方法被 protected 修饰，无法直接使用，因此创建一个子类，将子类添加到 Spring 容器中：

123456public class MyRequestMappingHandlerAdapter extends RequestMappingHandlerAdapter {
    @Override
    public ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
        return super.invokeHandlerMethod(request, response, handlerMethod);
    }
}

1234@Bean
public MyRequestMappingHandlerAdapter myRequestMappingHandlerAdapter() {
    return new MyRequestMappingHandlerAdapter();
}

在 main() 方法中测试 RequestMappingHandlerAdapter 的 invokeHandlerMethod() 方法：

123456789public static void main(String[] args) throws Exception {
    // --snip--

    MockHttpServletRequest request = new MockHttpServletRequest("POST", "/test2");
    request.setParameter("name", "mofan");
    MockHttpServletResponse response = new MockHttpServletResponse();
    MyRequestMappingHandlerAdapter handlerAdapter = context.getBean(MyRequestMappingHandlerAdapter.class);
    handlerAdapter.invokeHandlerMethod(request, response, ((HandlerMethod) handlerMapping.getHandler(request).getHandler()));
}

[DEBUG] indi.mofan.a20.Controller1          - test2(mofan) 

实现控制器方法的调用很简单，但如何将请求参数与方法参数相绑定的呢？

显然是需要解析 @RequestParam 注解。

Spring 支持许多种类的控制器方法参数，不同种类的参数使用不同的解析器，使用 MyRequestMappingHandlerAdapter 的 getArgumentResolvers() 方法获取所有参数解析器。

Spring 也支持许多种类的控制器方法返回值类型，使用 MyRequestMappingHandlerAdapter 的 getReturnValueHandlers() 方法获取所有返回值处理器。

自定义参数解析器

假如经常需要使用到请求头中的 Token 信息，自定义 @Token 注解，使用该注解标记控制器方法的哪个参数来获取 Token 信息：

1234@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface Token {
}

使 test3() 控制器方法参数被 @Token 标记：

12345@PutMapping("/test3")
public ModelAndView test3(@Token String token) {
    log.debug("test3({})", token);
    return null;
}

自定义参数解析器：

1234567891011121314public class TokenArgumentResolver implements HandlerMethodArgumentResolver {
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.getParameterAnnotation(Token.class) != null;
    }

    @Override
    public Object resolveArgument(MethodParameter parameter,
                                  ModelAndViewContainer mavContainer,
                                  NativeWebRequest webRequest,
                                  WebDataBinderFactory binderFactory) throws Exception {
        return webRequest.getHeader("token");
    }
}

将参数解析器添加到 HandlerAdapter 中：

1234567@Bean
public MyRequestMappingHandlerAdapter myRequestMappingHandlerAdapter() {
    TokenArgumentResolver tokenArgumentResolver = new TokenArgumentResolver();
    MyRequestMappingHandlerAdapter adapter = new MyRequestMappingHandlerAdapter();
    adapter.setCustomArgumentResolvers(Collections.singletonList(tokenArgumentResolver));
    return adapter;
}

测试执行 test3() 控制器方法：

1234567public static void main(String[] args) throws Exception {
    // --snip--

    MockHttpServletRequest tokenRequest = new MockHttpServletRequest("PUT", "/test3");
    tokenRequest.addHeader("token", "token info");
    handlerAdapter.invokeHandlerMethod(tokenRequest, response, ((HandlerMethod) handlerMapping.getHandler(tokenRequest).getHandler()));
}

[DEBUG] indi.mofan.a20.Controller1          - test3(token info) 

自定义返回值处理器

当 @ResponseBody 标记了控制器方法时，方法的返回值会转换成 JSON 写入响应体中。

自定义 @Yml 注解，被 @Yml 注解标记的控制器方法的返回值会转换成 YAML 写入响应体中。

1234@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Yml {
}

使 test4() 控制器方法被 @Yml 注解标记：

123456@RequestMapping("/test4")
@Yml
public User test4() {
    log.debug("test4");
    return new User("张三", 18);
}

自定义返回值处理器将返回值转换成 YAML：

123456789101112131415161718192021public class YmlReturnValueHandler implements HandlerMethodReturnValueHandler {
    @Override
    public boolean supportsReturnType(MethodParameter returnType) {
        return returnType.getMethodAnnotation(Yml.class) != null;
    }

    @Override
    public void handleReturnValue(Object returnValue,
                                  MethodParameter returnType,
                                  ModelAndViewContainer mavContainer,
                                  NativeWebRequest webRequest) throws Exception {
        // 转换返回结果为 YAML
        String str = new Yaml().dump(returnValue);
        // 将 YAML 字符串写入响应体
        HttpServletResponse response = webRequest.getNativeResponse(HttpServletResponse.class);
        response.setContentType("text/plain;charset=utf-8");
        response.getWriter().print(str);
        // 设置请求已经处理完毕
        mavContainer.setRequestHandled(true);
    }
}

将返回值处理器添加到 HandlerAdapter 中：

1234567@Bean
public MyRequestMappingHandlerAdapter myRequestMappingHandlerAdapter() {
    MyRequestMappingHandlerAdapter adapter = new MyRequestMappingHandlerAdapter();
    YmlReturnValueHandler ymlReturnValueHandler = new YmlReturnValueHandler();
    adapter.setCustomReturnValueHandlers(Collections.singletonList(ymlReturnValueHandler));
    return adapter;
}

测试执行 test4() 控制器方法：

12345678public static void main(String[] args) throws Exception {
    // --snip--

    MockHttpServletRequest test4Req = new MockHttpServletRequest("GET", "/test4");
    handlerAdapter.invokeHandlerMethod(test4Req, response, ((HandlerMethod) handlerMapping.getHandler(test4Req).getHandler()));
    byte[] content = response.getContentAsByteArray();
    System.out.println(new String(content, StandardCharsets.UTF_8));
}

[DEBUG] indi.mofan.a20.Controller1          - test4 
!!indi.mofan.a20.Controller1$User {age: 18, name: 张三}

21. 参数解析器

Spring 提供了许多种类的控制器方法参数解析器，定义一个包含多个不同种类参数的控制器方法：

1234567891011121314151617181920212223242526static class Controller {
    public void test(
            @RequestParam("name1") String name1, // name1=张三
            String name2, // name2=李四
            @RequestParam("age") int age, // age=18
            @RequestParam(name = "home", defaultValue = "${JAVA_HOME}") String home1, // spring 获取数据
            @RequestParam("file") MultipartFile file, // 上传文件
            @PathVariable("id") int id, //  /test/124   /test/{id}
            @RequestHeader("Content-Type") String header,
            @CookieValue("token") String token,
            @Value("${JAVA_HOME}") String home2, // spring 获取数据  ${} #{}
            HttpServletRequest request, // request, response, session ...
            @ModelAttribute("abc") User user1, // name=zhang&age=18
            User user2, // name=zhang&age=18
            @RequestBody User user3 // json
    ) {
    }
}

@Getter
@Setter
@ToString
static class User {
    private String name;
    private int age;
}

将控制器方法封装成 HandlerMethod 并打印方法中每个参数的信息：

1234567891011121314151617181920public static void main(String[] args) throws Exception {
    // 控制器方法封装成 HandlerMethod
    Method method = Controller.class.getMethod("test", String.class, String.class,
            int.class, String.class, MultipartFile.class,
            int.class, String.class, String.class,
            String.class, HttpServletRequest.class, User.class,
            User.class, User.class);
    HandlerMethod handlerMethod = new HandlerMethod(new Controller(), method);

    // 解析每个参数值
    for (MethodParameter parameter : handlerMethod.getMethodParameters()) {
        String annotations = Arrays.stream(parameter.getParameterAnnotations())
                .map(i -> i.annotationType().getSimpleName()).collect(Collectors.joining());
        String appendAt = annotations.length() > 0 ? "@" + annotations + " " : "";
        // 设置参数名解析器
        parameter.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
        System.out.println("[" + parameter.getParameterIndex() + "] " + appendAt +
                parameter.getParameterType().getSimpleName() + " " + parameter.getParameterName());
    }
}

[0] @RequestParam String name1
[1] String name2
[2] @RequestParam int age
[3] @RequestParam String home1
[4] @RequestParam MultipartFile file
[5] @PathVariable int id
[6] @RequestHeader String header
[7] @CookieValue String token
[8] @Value String home2
[9] HttpServletRequest request
[10] @ModelAttribute User user1
[11] User user2
[12] @RequestBody User user3

21.2 @RequestParam

@RequestParam 注解的解析需要使用到 RequestParamMethodArgumentResolver 参数解析器。构造时需要两个参数：

• beanFactory：Bean 工厂对象。需要解析 ${} 时，就需要指定 Bean 工厂对象
• useDefaultResolution：布尔类型参数。为 false 表示只解析添加了 @RequestParam 注解的参数，为 true 针对未添加 @RequestParam 注解的参数也使用该参数解析器进行解析

RequestParamMethodArgumentResolver 利用 resolveArgument() 方法完成参数的解析，该方法需要传递四个参数：

• parameter：参数对象
• mavContainer：ModelAndView 容器，用来存储中间的 Model 结果
• webRequest：由 ServletWebRequest 封装后的请求对象
• binderFactory：数据绑定工厂，用于完成对象绑定和类型转换，比如将字符串类型的 18 转换成整型

1234567891011121314151617181920212223242526272829303132333435363738394041public static void main(String[] args) throws Exception {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    HttpServletRequest request = mockRequest();

    // 控制器方法封装成 HandlerMethod
    Method method = Controller.class.getMethod("test", String.class, String.class,
            int.class, String.class, MultipartFile.class,
            int.class, String.class, String.class,
            String.class, HttpServletRequest.class, User.class,
            User.class, User.class);
    HandlerMethod handlerMethod = new HandlerMethod(new Controller(), method);

    // 准备对象绑定与类型转换
    ServletRequestDataBinderFactory binderFactory = new ServletRequestDataBinderFactory(null, null);

    // 准备 ModelAndViewContainer 用来存储中间的 Model 结果
    ModelAndViewContainer container = new ModelAndViewContainer();

    // 解析每个参数值
    for (MethodParameter parameter : handlerMethod.getMethodParameters()) {
        // useDefaultResolution 为 false 表示必须添加 @RequestParam 注解
        RequestParamMethodArgumentResolver resolver = new RequestParamMethodArgumentResolver(beanFactory, true);

        String annotations = Arrays.stream(parameter.getParameterAnnotations())
                .map(i -> i.annotationType().getSimpleName()).collect(Collectors.joining());
        String appendAt = annotations.length() > 0 ? "@" + annotations + " " : "";
        // 设置参数名解析器
        parameter.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
        String paramInfo = "[" + parameter.getParameterIndex() + "] " + appendAt +
                parameter.getParameterType().getSimpleName() + " " + parameter.getParameterName();

        if (resolver.supportsParameter(parameter)) {
            Object v = resolver.resolveArgument(parameter, container, new ServletWebRequest(request), binderFactory);
            System.out.println(Objects.requireNonNull(v).getClass());
            System.out.println(paramInfo + " -> " + v);
        } else {
            System.out.println(paramInfo);
        }
    }
}

class java.lang.String
[0] @RequestParam String name1 -> zhangsan
class java.lang.String
[1] String name2 -> lisi
class java.lang.Integer
[2] @RequestParam int age -> 18
class java.lang.String
[3] @RequestParam String home1 -> D:\environment\JDK1.8
class org.springframework.web.multipart.support.StandardMultipartHttpServletRequest$StandardMultipartFile
[4] @RequestParam MultipartFile file -> org.springframework.web.multipart.support.StandardMultipartHttpServletRequest$StandardMultipartFile@f2ff811
Exception in thread "main" java.lang.IllegalStateException: Optional int parameter 'id' is present but cannot be translated into a null value due to being declared as a primitive type. Consider declaring it as object wrapper for the corresponding primitive type.

控制器方法 test() 的前 5 个参数解析成功，但在解析第 6 个参数时产生了异常。

这是因为在构造 RequestParamMethodArgumentResolver 对象时，将 useDefaultResolution 设置为 true，针对未添加 @RequestParam 注解的参数都使用该参数解析器进行解析。第 6 个参数需要的 id 信息使用该解析器解析得到的结果是 null，无法将 null 值赋值给基本类型 int，显然第 6 个及其以后的参数应该使用其他参数解析器进行解析。

多个参数解析器的组合 - 组合模式

不同种类的参数需要不同的参数解析器，当前使用的参数解析器不支持当前参数的解析时，就应该换一个参数解析器进行解析。

可以将所有参数解析器添加到一个集合中，然后遍历这个集合，实现上述需求。

Spring 提供了名为 HandlerMethodArgumentResolverComposite 的类，对上述逻辑进行封装。

12345678910111213141516171819202122public static void main(String[] args) throws Exception {
    // --snip--

    // 解析每个参数值
    for (MethodParameter parameter : handlerMethod.getMethodParameters()) {
        // 多个参数解析器的组合
        HandlerMethodArgumentResolverComposite composite = new HandlerMethodArgumentResolverComposite();
        composite.addResolvers(
                // useDefaultResolution 为 false 表示必须添加 @RequestParam 注解
                new RequestParamMethodArgumentResolver(beanFactory, true)
        );

        // --snip--

        if (composite.supportsParameter(parameter)) {
            Object v = composite.resolveArgument(parameter, container, new ServletWebRequest(request), binderFactory);
            System.out.println(paramInfo + " -> " + v);
        } else {
            System.out.println(paramInfo);
        }
    }
}

21.2 @PathVariable

@PathVariable 注解的解析需要使用到 PathVariableMethodArgumentResolver 参数解析器。构造时无需传入任何参数。

使用该解析器需要一个 Map 集合，该 Map 集合是 @RequestMapping 注解上指定的路径和实际 URL 路径进行匹配后，得到的路径上的参数与实际路径上的值的关系（获取这个 Map 并将其设置给 request 作用域由 HandlerMapping 完成）。

1234567891011121314151617public static void main(String[] args) throws Exception {
    // --snip--

    // 解析每个参数值
    for (MethodParameter parameter : handlerMethod.getMethodParameters()) {
        // 多个参数解析器的组合
        HandlerMethodArgumentResolverComposite composite = new HandlerMethodArgumentResolverComposite();
        composite.addResolvers(
            // useDefaultResolution 为 false 表示必须添加 @RequestParam 注解
            new RequestParamMethodArgumentResolver(beanFactory, false),
            // 解析 @PathVariable
            new PathVariableMethodArgumentResolver()
        );

        // --snip--
    }
}

修改 RequestParamMethodArgumentResolver 参数解析器的构造，将 useDefaultResolution 设置为 false，让程序 暂时 不抛出异常。

[0] @RequestParam String name1 -> zhangsan
[1] String name2
[2] @RequestParam int age -> 18
[3] @RequestParam String home1 -> D:\environment\JDK1.8
[4] @RequestParam MultipartFile file -> org.springframework.web.multipart.support.StandardMultipartHttpServletRequest$StandardMultipartFile@11c9af63
[5] @PathVariable int id -> 123

21.3 @RequestHeader

@RequestHeader 注解的解析需要使用到 RequestHeaderMethodArgumentResolver 参数解析器。构造时需要传入一个 Bean 工厂对象。

12345678910111213141516171819public static void main(String[] args) throws Exception {
    // --snip--

    // 解析每个参数值
    for (MethodParameter parameter : handlerMethod.getMethodParameters()) {
        // 多个参数解析器的组合
        HandlerMethodArgumentResolverComposite composite = new HandlerMethodArgumentResolverComposite();
        composite.addResolvers(
            // useDefaultResolution 为 false 表示必须添加 @RequestParam 注解
            new RequestParamMethodArgumentResolver(beanFactory, false),
            // 解析 @PathVariable
            new PathVariableMethodArgumentResolver(),
            // 解析 @RequestHeader
            new RequestHeaderMethodArgumentResolver(beanFactory)
        );

        // --snip--
    }
}

[0] @RequestParam String name1 -> zhangsan
[1] String name2
[2] @RequestParam int age -> 18
[3] @RequestParam String home1 -> D:\environment\JDK1.8
[4] @RequestParam MultipartFile file -> org.springframework.web.multipart.support.StandardMultipartHttpServletRequest$StandardMultipartFile@3943a2be
[5] @PathVariable int id -> 123
[6] @RequestHeader String header -> application/json

21.4 @CookieValue

@CookieValue 注解的解析需要使用到 ServletCookieValueMethodArgumentResolver 参数解析器。构造时需要传入一个 Bean 工厂对象。

123456789101112131415161718192021public static void main(String[] args) throws Exception {
    // --snip--

    // 解析每个参数值
    for (MethodParameter parameter : handlerMethod.getMethodParameters()) {
        // 多个参数解析器的组合
        HandlerMethodArgumentResolverComposite composite = new HandlerMethodArgumentResolverComposite();
        composite.addResolvers(
            // useDefaultResolution 为 false 表示必须添加 @RequestParam 注解
            new RequestParamMethodArgumentResolver(beanFactory, false),
            // 解析 @PathVariable
            new PathVariableMethodArgumentResolver(),
            // 解析 @RequestHeader
            new RequestHeaderMethodArgumentResolver(beanFactory),
            // 解析 @CookieValue
            new ServletCookieValueMethodArgumentResolver(beanFactory)
        );

        // --snip--
    }
}

[0] @RequestParam String name1 -> zhangsan
[1] String name2
[2] @RequestParam int age -> 18
[3] @RequestParam String home1 -> D:\environment\JDK1.8
[4] @RequestParam MultipartFile file -> org.springframework.web.multipart.support.StandardMultipartHttpServletRequest$StandardMultipartFile@1329eff
[5] @PathVariable int id -> 123
[6] @RequestHeader String header -> application/json
[7] @CookieValue String token -> 123456

21.5 @Value

@Value 注解的解析需要使用到 ExpressionValueMethodArgumentResolver 参数解析器。构造时需要传入一个 Bean 工厂对象。

1234567891011121314151617181920212223public static void main(String[] args) throws Exception {
    // --snip--

    // 解析每个参数值
    for (MethodParameter parameter : handlerMethod.getMethodParameters()) {
        // 多个参数解析器的组合
        HandlerMethodArgumentResolverComposite composite = new HandlerMethodArgumentResolverComposite();
        composite.addResolvers(
            // useDefaultResolution 为 false 表示必须添加 @RequestParam 注解
            new RequestParamMethodArgumentResolver(beanFactory, false),
            // 解析 @PathVariable
            new PathVariableMethodArgumentResolver(),
            // 解析 @RequestHeader
            new RequestHeaderMethodArgumentResolver(beanFactory),
            // 解析 @CookieValue
            new ServletCookieValueMethodArgumentResolver(beanFactory),
            // 解析 @Value
            new ExpressionValueMethodArgumentResolver(beanFactory)
        );

        // --snip--
    }
}

[0] @RequestParam String name1 -> zhangsan
[1] String name2
[2] @RequestParam int age -> 18
[3] @RequestParam String home1 -> D:\environment\JDK1.8
[4] @RequestParam MultipartFile file -> org.springframework.web.multipart.support.StandardMultipartHttpServletRequest$StandardMultipartFile@46fa7c39
[5] @PathVariable int id -> 123
[6] @RequestHeader String header -> application/json
[7] @CookieValue String token -> 123456
[8] @Value String home2 -> D:\environment\JDK1.8

21.6 HttpServletRequest

HttpServletRequest 类型的参数的解析需要使用到 ServletRequestMethodArgumentResolver 参数解析器。构造时无需传入任何参数。

12345678910111213141516171819202122232425public static void main(String[] args) throws Exception {
    // --snip--

    // 解析每个参数值
    for (MethodParameter parameter : handlerMethod.getMethodParameters()) {
        // 多个参数解析器的组合
        HandlerMethodArgumentResolverComposite composite = new HandlerMethodArgumentResolverComposite();
        composite.addResolvers(
            // useDefaultResolution 为 false 表示必须添加 @RequestParam 注解
            new RequestParamMethodArgumentResolver(beanFactory, false),
            // 解析 @PathVariable
            new PathVariableMethodArgumentResolver(),
            // 解析 @RequestHeader
            new RequestHeaderMethodArgumentResolver(beanFactory),
            // 解析 @CookieValue
            new ServletCookieValueMethodArgumentResolver(beanFactory),
            // 解析 @Value
            new ExpressionValueMethodArgumentResolver(beanFactory),
            // 解析 HttpServletRequest
            new ServletRequestMethodArgumentResolver()
        );

        // --snip--
    }
}

[0] @RequestParam String name1 -> zhangsan
[1] String name2
[2] @RequestParam int age -> 18
[3] @RequestParam String home1 -> D:\environment\JDK1.8
[4] @RequestParam MultipartFile file -> org.springframework.web.multipart.support.StandardMultipartHttpServletRequest$StandardMultipartFile@5f683daf
[5] @PathVariable int id -> 123
[6] @RequestHeader String header -> application/json
[7] @CookieValue String token -> 123456
[8] @Value String home2 -> D:\environment\JDK1.8
[9] HttpServletRequest request -> org.springframework.web.multipart.support.StandardMultipartHttpServletRequest@152aa092

ServletRequestMethodArgumentResolver 参数解析器不仅可以解析 HttpServletRequest 类型的参数，还支持许多其他类型的参数，其支持的参数类型可在 supportsParameter() 方法中看到：

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

21.7 @ModelAttribute

@ModelAttribute 注解的解析需要使用到 ServletModelAttributeMethodProcessor 参数解析器。构造时需要传入一个布尔类型的值。为 false 时，表示 @ModelAttribute 不是不必须的，即是必须的。

针对 @ModelAttribute("abc") User user1 和 User user2 两种参数来说，尽管后者没有使用 @ModelAttribute 注解，但它们使用的是同一种解析器。

添加两个 ServletModelAttributeMethodProcessor 参数解析器，先解析带 @ModelAttribute 注解的参数，再解析不带 @ModelAttribute 注解的参数。

通过 ServletModelAttributeMethodProcessor 解析得到的数据还会被存入 ModelAndViewContainer 中。存储的数据结构是一个 Map，其 key 为 @ModelAttribute 注解指定的 value 值，在未显式指定的情况下，默认为对象类型的首字母小写对应的字符串。

123456789static class Controller {
    public void test(
		// 指定 value
        @ModelAttribute("abc") User user1, // name=zhang&age=18
        User user2, // name=zhang&age=18
        @RequestBody User user3 // json
    ) {
    }
}

12345678910111213141516171819202122232425262728293031323334353637383940public static void main(String[] args) throws Exception {
    // --snip--

    // 解析每个参数值
    for (MethodParameter parameter : handlerMethod.getMethodParameters()) {
        // 多个参数解析器的组合
        HandlerMethodArgumentResolverComposite composite = new HandlerMethodArgumentResolverComposite();
        composite.addResolvers(
            // useDefaultResolution 为 false 表示必须添加 @RequestParam 注解
            new RequestParamMethodArgumentResolver(beanFactory, false),
            // 解析 @PathVariable
            new PathVariableMethodArgumentResolver(),
            // 解析 @RequestHeader
            new RequestHeaderMethodArgumentResolver(beanFactory),
            // 解析 @CookieValue
            new ServletCookieValueMethodArgumentResolver(beanFactory),
            // 解析 @Value
            new ExpressionValueMethodArgumentResolver(beanFactory),
            // 解析 HttpServletRequest
            new ServletRequestMethodArgumentResolver(),
            // 解析 @ModelAttribute，且不能省略
            new ServletModelAttributeMethodProcessor(false),
            new ServletModelAttributeMethodProcessor(true)
        );

        // --snip--

        if (composite.supportsParameter(parameter)) {
            Object v = composite.resolveArgument(parameter, container, new ServletWebRequest(request), binderFactory);
            System.out.println(paramInfo + " -> " + v);
            // 打印模型数据
            ModelMap modelMap = container.getModel();
            if (MapUtils.isNotEmpty(modelMap)) {
                System.out.println("模型数据: " + modelMap);
            }
        } else {
            System.out.println(paramInfo);
        }
    }
}

[0] @RequestParam String name1 -> zhangsan
[1] String name2
[2] @RequestParam int age -> 18
[3] @RequestParam String home1 -> D:\environment\JDK1.8
[4] @RequestParam MultipartFile file -> org.springframework.web.multipart.support.StandardMultipartHttpServletRequest$StandardMultipartFile@2beee7ff
[5] @PathVariable int id -> 123
[6] @RequestHeader String header -> application/json
[7] @CookieValue String token -> 123456
[8] @Value String home2 -> D:\environment\JDK1.8
[9] HttpServletRequest request -> org.springframework.web.multipart.support.StandardMultipartHttpServletRequest@5fa07e12
[10] @ModelAttribute User user1 -> A21.User(name=张三, age=18)
模型数据: {abc=A21.User(name=张三, age=18), org.springframework.validation.BindingResult.abc=org.springframework.validation.BeanPropertyBindingResult: 0 errors}
[11] User user2 -> A21.User(name=张三, age=18)
模型数据: {abc=A21.User(name=张三, age=18), org.springframework.validation.BindingResult.abc=org.springframework.validation.BeanPropertyBindingResult: 0 errors, user=A21.User(name=张三, age=18), org.springframework.validation.BindingResult.user=org.springframework.validation.BeanPropertyBindingResult: 0 errors}
[12] @RequestBody User user3 -> A21.User(name=李四, age=20)
模型数据: {abc=A21.User(name=张三, age=18), org.springframework.validation.BindingResult.abc=org.springframework.validation.BeanPropertyBindingResult: 0 errors, user=A21.User(name=张三, age=18), org.springframework.validation.BindingResult.user=org.springframework.validation.BeanPropertyBindingResult: 0 errors}

@RequestBody User user3 参数也被 ServletModelAttributeMethodProcessor 解析了，如果想使其数据通过 JSON 数据转换而来，则需要使用另一个参数解析器。

21.8 @RequestBody

@RequestBody 注解的解析需要使用到 RequestResponseBodyMethodProcessor 参数解析器。构造时需要传入一个消息转换器列表。

1234567891011121314151617181920212223242526272829public static void main(String[] args) throws Exception {
    // --snip--

    // 解析每个参数值
    for (MethodParameter parameter : handlerMethod.getMethodParameters()) {
        // 多个参数解析器的组合
        HandlerMethodArgumentResolverComposite composite = new HandlerMethodArgumentResolverComposite();
        composite.addResolvers(
            // useDefaultResolution 为 false 表示必须添加 @RequestParam 注解
            new RequestParamMethodArgumentResolver(beanFactory, false),
            // 解析 @PathVariable
            new PathVariableMethodArgumentResolver(),
            // 解析 @RequestHeader
            new RequestHeaderMethodArgumentResolver(beanFactory),
            // 解析 @CookieValue
            new ServletCookieValueMethodArgumentResolver(beanFactory),
            // 解析 @Value
            new ExpressionValueMethodArgumentResolver(beanFactory),
            // 解析 HttpServletRequest
            new ServletRequestMethodArgumentResolver(),
            // 解析 @ModelAttribute，且不能省略
            new ServletModelAttributeMethodProcessor(false),
            new RequestResponseBodyMethodProcessor(Collections.singletonList(new MappingJackson2HttpMessageConverter())),
            new ServletModelAttributeMethodProcessor(true)
        );

        // --snip--
    }
}

[0] @RequestParam String name1 -> zhangsan
[1] String name2
[2] @RequestParam int age -> 18
[3] @RequestParam String home1 -> D:\environment\JDK1.8
[4] @RequestParam MultipartFile file -> org.springframework.web.multipart.support.StandardMultipartHttpServletRequest$StandardMultipartFile@5e17553a
[5] @PathVariable int id -> 123
[6] @RequestHeader String header -> application/json
[7] @CookieValue String token -> 123456
[8] @Value String home2 -> D:\environment\JDK1.8
[9] HttpServletRequest request -> org.springframework.web.multipart.support.StandardMultipartHttpServletRequest@13bc8645
[10] @ModelAttribute User user1 -> A21.User(name=张三, age=18)
[11] User user2 -> A21.User(name=张三, age=18)
[12] @RequestBody User user3 -> A21.User(name=李四, age=20)

@RequestBody User user3 参数数据通过 JSON 数据得到，与上一节的解析进行区分。

除此之外，添加的参数解析器顺序也影响着解析结果：

123new ServletModelAttributeMethodProcessor(false),
new RequestResponseBodyMethodProcessor(Collections.singletonList(new MappingJackson2HttpMessageConverter())),
new ServletModelAttributeMethodProcessor(true)

先添加解析 @ModelAttribute 注解的解析器，再添加解析 @RequestBody 注解的解析器，最后添加解析省略了 @ModelAttribute 注解的解析器。如果更换最后两个解析器的顺序，那么 @RequestBody User user3 将会被 ServletModelAttributeMethodProcessor 解析，而不是 RequestResponseBodyMethodProcessor。

因此 String name2 参数也能通过添加同种参数但不同构造参数的解析器进行解析，注意添加的解析器的顺序，先处理对象，再处理单个参数：

123456789101112131415161718192021222324252627282930public static void main(String[] args) throws Exception {
    // --snip--

    // 解析每个参数值
    for (MethodParameter parameter : handlerMethod.getMethodParameters()) {
        // 多个参数解析器的组合
        HandlerMethodArgumentResolverComposite composite = new HandlerMethodArgumentResolverComposite();
        composite.addResolvers(
            // useDefaultResolution 为 false 表示必须添加 @RequestParam 注解
            new RequestParamMethodArgumentResolver(beanFactory, false),
            // 解析 @PathVariable
            new PathVariableMethodArgumentResolver(),
            // 解析 @RequestHeader
            new RequestHeaderMethodArgumentResolver(beanFactory),
            // 解析 @CookieValue
            new ServletCookieValueMethodArgumentResolver(beanFactory),
            // 解析 @Value
            new ExpressionValueMethodArgumentResolver(beanFactory),
            // 解析 HttpServletRequest
            new ServletRequestMethodArgumentResolver(),
            // 解析 @ModelAttribute，且不能省略
            new ServletModelAttributeMethodProcessor(false),
            new RequestResponseBodyMethodProcessor(Collections.singletonList(new MappingJackson2HttpMessageConverter())),
            new ServletModelAttributeMethodProcessor(true),
            new RequestParamMethodArgumentResolver(beanFactory, true)
        );

        // --snip--
    }
}

[0] @RequestParam String name1 -> zhangsan
[1] String name2 -> lisi
[2] @RequestParam int age -> 18
[3] @RequestParam String home1 -> D:\environment\JDK1.8
[4] @RequestParam MultipartFile file -> org.springframework.web.multipart.support.StandardMultipartHttpServletRequest$StandardMultipartFile@5e17553a
[5] @PathVariable int id -> 123
[6] @RequestHeader String header -> application/json
[7] @CookieValue String token -> 123456
[8] @Value String home2 -> D:\environment\JDK1.8
[9] HttpServletRequest request -> org.springframework.web.multipart.support.StandardMultipartHttpServletRequest@13bc8645
[10] @ModelAttribute User user1 -> A21.User(name=张三, age=18)
[11] User user2 -> A21.User(name=张三, age=18)
[12] @RequestBody User user3 -> A21.User(name=李四, age=20)

22. 获取参数名

在项目的 src 目录外创建一个 Bean2.java 文件，使其不会被 IDEA 自动编译：

1234567package indi.mofan.a22;

public class Bean2 {
    public void foo(String name, int age) {

    }
}

将命令行切换到 Bean2.java 文件所在目录的位置，执行 javac .\Bean2.java 命令手动编译 Bean2.java。查看 Bean2.class 文件的内容：

123456789package indi.mofan.a22;

public class Bean2 {
    public Bean2() {
    }

    public void foo(String var1, int var2) {
    }
}

编译生成的 class 文件中的 foo() 方法的参数名称不再是 name 和 age，也就是说直接使用 javac 命令进行编译得到的字节码文件不会保存方法的参数名称。

执行 javac -parameters .\Bean2.java 再次编译 Bean2.java，并查看得到的 Bean2.class 文件内容：

123456789package indi.mofan.a22;

public class Bean2 {
    public Bean2() {
    }

    public void foo(String name, int age) {
    }
}

foo() 方法的参数名称得以保留。

还可以使用 javap -c -v .\Bean2.class 命令反编译 Bean2.class，foo() 方法的反编译结果如下：

123456789101112public void foo(java.lang.String, int);
  descriptor: (Ljava/lang/String;I)V
  flags: ACC_PUBLIC
  Code:
    stack=0, locals=3, args_size=3
       0: return
    LineNumberTable:
      line 6: 0
  MethodParameters:
    Name                           Flags
    name
    age

foo() 方法的参数信息被保存在 MethodParameters 中，可以使用 反射 获取：

1234567public static void main(String[] args) throws Exception {
    // 反射获取参数名
    Method foo = Bean2.class.getMethod("foo", String.class, int.class);
    for (Parameter parameter : foo.getParameters()) {
        System.out.println(parameter.getName());       
    }
}

name
age

使用 javac -g .\Bean2.java 命令进行编译也会保留方法的参数信息。再次使用 javap 反编译 Bean2.class，foo() 方法的反编译结果如下：

12345678910111213public void foo(java.lang.String, int);
  descriptor: (Ljava/lang/String;I)V
  flags: ACC_PUBLIC
  Code:
    stack=0, locals=3, args_size=3
       0: return
    LineNumberTable:
      line 6: 0
    LocalVariableTable:
      Start  Length  Slot  Name   Signature
          0       1     0  this   Lindi/mofan/a22/Bean2;
          0       1     1  name   Ljava/lang/String;
          0       1     2   age   I

foo() 方法的参数信息被保存在 LocalVariableTable 中，不能使用反射获取，但可以使用 ASM 获取，使用 Spring 封装的解析工具：

123456789public static void main(String[] args) throws Exception {
    // 反射获取参数名
    Method foo = Bean2.class.getMethod("foo", String.class, int.class);

    // 基于 LocalVariableTable 本地变量表获取
    LocalVariableTableParameterNameDiscoverer discoverer = new LocalVariableTableParameterNameDiscoverer();
    String[] parameterNames = discoverer.getParameterNames(foo);
    System.out.println(Arrays.toString(parameterNames));
}

[name, age]

在【21. 参数解析器】中并没有使用 LocalVariableTableParameterNameDiscoverer，而是使用的是 DefaultParameterNameDiscoverer。DefaultParameterNameDiscoverer 将两种实现进行了统一：

1234567891011public class DefaultParameterNameDiscoverer extends PrioritizedParameterNameDiscoverer {

   public DefaultParameterNameDiscoverer() {
      if (KotlinDetector.isKotlinReflectPresent() && !NativeDetector.inNativeImage()) {
         addDiscoverer(new KotlinReflectionParameterNameDiscoverer());
      }
      addDiscoverer(new StandardReflectionParameterNameDiscoverer());
      addDiscoverer(new LocalVariableTableParameterNameDiscoverer());
   }

}

javac -g 的局限性

假设有这样一个接口：

12345package indi.mofan.a22;

public interface Bean1 {
    public void foo(String name, int age);
}

如果使用 javac -g .\Bean1.java 命令进行编译后，再利用 javap 查看 foo() 方法的反编译结果：

123public abstract void foo(java.lang.String, int);
  descriptor: (Ljava/lang/String;I)V
  flags: ACC_PUBLIC, ACC_ABSTRACT

并没有记录抽象方法 foo() 的参数信息。

如果使用 javac -parameters .\Bean1.java 呢？

1234567public abstract void foo(java.lang.String, int);
  descriptor: (Ljava/lang/String;I)V
  flags: ACC_PUBLIC, ACC_ABSTRACT
  MethodParameters:
    Name                           Flags
    name
    age

参数信息得以保留。

23. 对象绑定与类型转换

23.1 三种转换接口

底层第一套转换接口与实现

• Printer 把其它类型转为 String
• Parser 把 String 转为其它类型
• Formatter 综合 Printer 与 Parser 的功能
• Converter 把类型 S 转为类型 T
• Printer、Parser、Converter 经过适配转换成 GenericConverter 放入 Converters 集合
• FormattingConversionService 利用其它接口实现转换

底层第二套转换接口

由 JDK 提供，而不是 Spring。

• PropertyEditor 将 String 与其它类型相互转换
• PropertyEditorRegistry 可以注册多个 PropertyEditor 对象
• 可以通过 FormatterPropertyEditorAdapter 与第一套接口进行适配

高层转换接口与实现

• 它们都实现了 TypeConverter 高层转换接口，在转换时会用到 TypeConverterDelegate 委派 ConversionService 与 PropertyEditorRegistry 真正执行转换（使用 Facade 门面模式）
  • 首先查看是否存在实现了 PropertyEditorRegistry 的自定义转换器，@InitBinder 注解实现的就是自定义转换器（用了适配器模式把 Formatter 转为需要的 PropertyEditor）
  • 再查看是否存在 ConversionService 实现
  • 再利用默认的 PropertyEditor 实现
  • 最后有一些特殊处理
• SimpleTypeConverter 仅做类型转换
• BeanWrapperImpl 利用 Property，即 Getter/Setter，为 Bean 的属性赋值，，必要时进行类型转换
• DirectFieldAccessor 利用 Field，即字段，为 Bean 的字段赋值，必要时进行类型转换
• ServletRequestDataBinder 为 Bean 的属性执行绑定，必要时进行类型转换，根据布尔类型成员变量 directFieldAccess 选择利用 Property 还是 Field，还具备校验与获取校验结果功能

23.2 使用示例

SimpleTypeConverter

1234567public static void main(String[] args) {
    SimpleTypeConverter converter = new SimpleTypeConverter();
    Integer number = converter.convertIfNecessary("13", int.class);
    System.out.println(number);
    Date date = converter.convertIfNecessary("1999/03/04", Date.class);
    System.out.println(date);
}

13
Thu Mar 04 00:00:00 CST 1999

BeanWrapperImpl

123456789101112131415161718public static void main(String[] args) {
    // 利用反射为 bean 的属性赋值
    MyBean bean = new MyBean();
    BeanWrapperImpl wrapper = new BeanWrapperImpl(bean);
    wrapper.setPropertyValue("a", "10");
    wrapper.setPropertyValue("b", "hello");
    wrapper.setPropertyValue("c", "1999/03/04");
    System.out.println(bean);
}

@Getter
@Setter
@ToString
static class MyBean {
    private int a;
    private String b;
    private Date c;
}

TestBeanWrapper.MyBean(a=10, b=hello, c=Thu Mar 04 00:00:00 CST 1999)

DirectFieldAccessor

12345678910111213141516public static void main(String[] args) {
    // 利用反射为 bean 的字段赋值
    MyBean bean = new MyBean();
    DirectFieldAccessor accessor = new DirectFieldAccessor(bean);
    accessor.setPropertyValue("a", "10");
    accessor.setPropertyValue("b", "hello");
    accessor.setPropertyValue("c", "1999/03/04");
    System.out.println(bean);
}

@ToString
static class MyBean {
    private int a;
    private String b;
    private Date c;
}

TestFieldAccessor.MyBean(a=10, b=hello, c=Thu Mar 04 00:00:00 CST 1999)

DataBinder

1234567891011121314151617181920public static void main(String[] args) {
    // 执行数据绑定
    MyBean bean = new MyBean();
    DataBinder binder = new DataBinder(bean);
    MutablePropertyValues pvs = new MutablePropertyValues();
    pvs.add("a", "10");
    pvs.add("b", "hello");
    pvs.add("c", "1999/03/04");
    binder.bind(pvs);
    System.out.println(bean);
}

@Getter
@Setter
@ToString
static class MyBean {
    private int a;
    private String b;
    private Date c;
}

TestDataBinder.MyBean(a=10, b=hello, c=Thu Mar 04 00:00:00 CST 1999)

如果 MyBean 没有提供 Getter/Setter 方法，可以调用 DataBinder 的 initDirectFieldAccess() 方法使数据绑定逻辑走字段赋值，而不是属性赋值：

12345678910111213141516171819public static void main(String[] args) {
    // 执行数据绑定
    MyBean bean = new MyBean();
    DataBinder binder = new DataBinder(bean);
    binder.initDirectFieldAccess();
    MutablePropertyValues pvs = new MutablePropertyValues();
    pvs.add("a", "10");
    pvs.add("b", "hello");
    pvs.add("c", "1999/03/04");
    binder.bind(pvs);
    System.out.println(bean);
}

@ToString
static class MyBean {
    private int a;
    private String b;
    private Date c;
}

TestDataBinder.MyBean(a=10, b=hello, c=Thu Mar 04 00:00:00 CST 1999)

Web 环境下的数据绑定

Web 环境下的数据绑定需要使用 DataBinder 的子类 ServletRequestDataBinder。

12345678910111213141516171819202122public static void main(String[] args) {
    // web 环境下的数据绑定
    MyBean bean = new MyBean();
    DataBinder dataBinder = new ServletRequestDataBinder(bean);
    MockHttpServletRequest request = new MockHttpServletRequest();
    request.setParameter("a", "10");
    request.setParameter("b", "hello");
    request.setParameter("c", "1999/03/04");

    dataBinder.bind(new ServletRequestParameterPropertyValues(request));

    System.out.println(bean);
}

@Getter
@Setter
@ToString
static class MyBean {
    private int a;
    private String b;
    private Date c;
}

TestServletDataBinder.MyBean(a=10, b=hello, c=Thu Mar 04 00:00:00 CST 1999)

23.3 绑定器工厂

现有如下两个类：

1234567891011121314@Getter
@Setter
@ToString
public static class User {
    private Date birthday;
    private Address address;
}

@Getter
@Setter
@ToString
public static class Address {
    private String name;
}

在 Web 环境下进行数据绑定：

1234567891011public static void main(String[] args) {
    MockHttpServletRequest request = new MockHttpServletRequest();
    request.setParameter("birthday", "1999|01|02");
    request.setParameter("address.name", "成都");

    User user = new User();
    ServletRequestDataBinder dataBinder = new ServletRequestDataBinder(user);

    dataBinder.bind(new ServletRequestParameterPropertyValues(request));
    System.out.println(user);
}

birthday 和 address.name 都能绑定成功吗？

TestServletDataBinderFactory.User(birthday=null, address=TestServletDataBinderFactory.Address(name=成都))

birthday 绑定失败，要想使其绑定成功，需要自定义转换器，有两种方式：

• 使用 Spring 提供的 ConversionService
• 使用 JDK 提供的 PropertyEditorRegistry

创建 DataBinder 的职责交由 DataBinderFactory 完成，以便添加各种选项，拓展不同的自定义转换器。

12345678910111213@SneakyThrows
public static void main(String[] args) {
    MockHttpServletRequest request = new MockHttpServletRequest();
    request.setParameter("birthday", "1999|01|02");
    request.setParameter("address.name", "成都");

    User user = new User();
    ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(null, null);
    WebDataBinder dataBinder = factory.createBinder(new ServletWebRequest(request), user, "user");

    dataBinder.bind(new ServletRequestParameterPropertyValues(request));
    System.out.println(user);
}

运行 main() 方法后，控制台输出的结果不变。

利用 @InitBinder 自定义转换器

声明一个 Controller 类，其中包含一个被 @InitBinder 注解标记的方法：

1234567static class MyController {
    @InitBinder
    public void myMethod(WebDataBinder dataBinder) {
        // 拓展 dataBinder 的转换器
        dataBinder.addCustomFormatter(new MyDateFormatter("用 @InitBinder 进行拓展"));
    }
}

以 WebDataBinder 作为方法参数，在方法体类添加自定义转换器 MyDateFormatter：

12345678910111213141516171819202122@Slf4j
public class MyDateFormatter implements Formatter<Date> {
    private final String desc;

    public MyDateFormatter(String desc) {
        // 仅做测试
        this.desc = desc;
    }

    @Override
    public String print(Date date, Locale locale) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy|MM|dd");
        return sdf.format(date);
    }

    @Override
    public Date parse(String text, Locale locale) throws ParseException {
        log.debug(">>>>>> 进入了: {}", desc);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy|MM|dd");
        return sdf.parse(text);
    }
}

在构造 DataBinderFactory 时传入 InvocableHandlerMethod 列表，列表中包含根据 Controller 对象、Controller 类中被 @InitBinder 注解标记的方法对象构造的 InvocableHandlerMethod 对象：

1234567891011@SneakyThrows
public static void main(String[] args) {
    // --snip--

    InvocableHandlerMethod handlerMethod =
        new InvocableHandlerMethod(new MyController(), MyController.class.getMethod("myMethod", WebDataBinder.class));

    ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(Collections.singletonList(handlerMethod), null);

	// --snip--
}

再次执行 main()，birthday 被成功绑定：

[DEBUG] indi.mofan.a23.MyDateFormatter      - >>>>>> 进入了: 用 @InitBinder 进行拓展 
TestServletDataBinderFactory.User(birthday=Sat Jan 02 00:00:00 CST 1999, address=TestServletDataBinderFactory.Address(name=成都))

这种方式使用了 JDK 提供的 PropertyEditorRegistry，证据就在 WebDataBinder 的 addCustomFormatter() 方法中：

1234public void addCustomFormatter(Formatter<?> formatter) {
   FormatterPropertyEditorAdapter adapter = new FormatterPropertyEditorAdapter(formatter);
   getPropertyEditorRegistry().registerCustomEditor(adapter.getFieldType(), adapter);
}

ConversionService 拓展

选择 FormattingConversionService 作为 ConversionService 的实现，向其中添加自定义转换器 MyDateFormatter。

构造 DataBinderFactory 时传入 WebBindingInitializer 的实现，因此将 FormattingConversionService 封装成 ConfigurableWebBindingInitializer 传入 DataBinderFactory 的构造方法中：

12345678910111213@SneakyThrows
public static void main(String[] args) {
    // --snip-- 

    // 使用 ConversionService 转换
    FormattingConversionService service = new FormattingConversionService();
    service.addFormatter(new MyDateFormatter("用 ConversionService 方式拓展转换功能"));
    ConfigurableWebBindingInitializer initializer = new ConfigurableWebBindingInitializer();
    initializer.setConversionService(service);
    ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(null, initializer);

    // --snip--
}

[DEBUG] indi.mofan.a23.MyDateFormatter      - >>>>>> 进入了: 用 ConversionService 方式拓展转换功能 
TestServletDataBinderFactory.User(birthday=Sat Jan 02 00:00:00 CST 1999, address=TestServletDataBinderFactory.Address(name=成都))

如果同时存在 @InitBinder 和 ConversionService，将以 @InitBinder 为主，@InitBinder 实现的转换器属于自定义转换器，自定义转换器的优先级更高：

1234567891011121314@SneakyThrows
public static void main(String[] args) {
    // --snip-- 

    FormattingConversionService service = new FormattingConversionService();
    service.addFormatter(new MyDateFormatter("用 ConversionService 方式拓展转换功能"));
    ConfigurableWebBindingInitializer initializer = new ConfigurableWebBindingInitializer();
    initializer.setConversionService(service);
    InvocableHandlerMethod handlerMethod =
        new InvocableHandlerMethod(new MyController(), MyController.class.getMethod("myMethod", WebDataBinder.class));
    ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(Collections.singletonList(handlerMethod), initializer);

    // --snip--
}

[DEBUG] indi.mofan.a23.MyDateFormatter      - >>>>>> 进入了: 用 @InitBinder 进行拓展 
TestServletDataBinderFactory.User(birthday=Sat Jan 02 00:00:00 CST 1999, address=TestServletDataBinderFactory.Address(name=成都))

默认的 ConversionService

ConversionService 有一个默认实现 DefaultFormattingConversionService，它还是 FormattingConversionService 的子类：

1234567891011@SneakyThrows
public static void main(String[] args) {
    // --snip-- 

    DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService();
    ConfigurableWebBindingInitializer initializer = new ConfigurableWebBindingInitializer();
    initializer.setConversionService(conversionService);
    ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(null, initializer);

    // --snip--
}

运行 main() 方法后，控制台打印出：

TestServletDataBinderFactory.User(birthday=null, address=TestServletDataBinderFactory.Address(name=成都))

birthday 绑定失败，默认的 ConversionService 需要搭配注解 @DateTimeFormat 使用。在目标类的字段上使用该注解标记，并指定被转换的日期格式：

12345678@Getter
@Setter
@ToString
public static class User {
    @DateTimeFormat(pattern = "yyyy|MM|dd")
    private Date birthday;
    private Address address;
}

再次运行 main() 方法：

TestServletDataBinderFactory.User(birthday=Sat Jan 02 00:00:00 CST 1999, address=TestServletDataBinderFactory.Address(name=成都))

在 SpringBoot 中还提供了 ApplicationConversionService，它也是 FormattingConversionService 的子类，上述代码将 DefaultFormattingConversionService 换成 ApplicationConversionService 也能达到相同效果。

23.4 Spring 的泛型操作技巧

有一基类 BaseDao，接收一个泛型参数：

12345public class BaseDao<T> {
    T findOne() {
        return null;
    }
}

围绕 BaseDao 有如下五个类：

1234567891011121314public class EmployeeDao extends BaseDao {
}

public class Student {
}

public class StudentDao extends BaseDao<Student> {
}

public class Teacher {
}

public class TeacherDao extends BaseDao<Teacher> {
}

尝试获取 BaseDao 子类泛型参数：

123456789101112131415161718192021222324252627public static void main(String[] args) {
    // 1. java api
    System.out.println(">>>>>>>>>>>>>>>>>>>>>>>");
    // 带有泛型信息的父类信息
    Type teacherDaoType = TeacherDao.class.getGenericSuperclass();
    System.out.println("TeacherDao type: " + teacherDaoType);
    System.out.println("TeacherDao type class: " + teacherDaoType.getClass());

    Type employeeDaoType = EmployeeDao.class.getGenericSuperclass();
    System.out.println("EmployeeDao type: " + employeeDaoType);
    System.out.println("EmployeeDao type class: " + employeeDaoType.getClass());

    // 有泛型参数的 Type 对象才是 ParameterizedType 类型
    if (teacherDaoType instanceof ParameterizedType) {
        ParameterizedType parameterizedType = (ParameterizedType) teacherDaoType;
        System.out.println(parameterizedType.getActualTypeArguments()[0]);
    }

    // 2. spring api 1
    System.out.println(">>>>>>>>>>>>>>>>>>>>>>>");
    Class<?> t = GenericTypeResolver.resolveTypeArgument(TeacherDao.class, BaseDao.class);
    System.out.println(t);

    // 3. spring api 2
    System.out.println(">>>>>>>>>>>>>>>>>>>>>>>");
    System.out.println(ResolvableType.forClass(StudentDao.class).getSuperType().getGeneric().resolve());
}

>>>>>>>>>>>>>>>>>>>>>>>
TeacherDao type: indi.mofan.a23.sub.BaseDao
TeacherDao type class: class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
EmployeeDao type: class indi.mofan.a23.sub.BaseDao
EmployeeDao type class: class java.lang.Class
class indi.mofan.a23.sub.Teacher
>>>>>>>>>>>>>>>>>>>>>>>
class indi.mofan.a23.sub.Teacher
>>>>>>>>>>>>>>>>>>>>>>>
class indi.mofan.a23.sub.Student

24. ControllerAdvice 之 @InitBinder

准备 @InitBinder 在整个 HandlerAdapter 调用过程中所处的位置：

备注：

• RequestMappingHandlerAdapter 在图中缩写为 HandlerAdapter
• HandlerMethodArgumentResolverComposite 在图中缩写为 ArgumentResolvers
• HandlerMethodReturnValueHandlerComposite 在图中缩写为 ReturnValueHandlers

功能与使用

@InitBinder 注解只能作用在方法上，通常搭配 @ControllerAdvice 和 @Controller 以及他们的衍生注解使用。比如：

12345678910111213141516171819202122232425262728293031323334353637@Configuration
public class WebConfig {
    @ControllerAdvice
    static class MyControllerAdvice {
        @InitBinder
        public void binder3(WebDataBinder webDataBinder) {
            webDataBinder.addCustomFormatter(new MyDateFormatter("binder3 转换器"));
        }
    }

    @Controller
    static class Controller1 {
        @InitBinder
        public void binder1(WebDataBinder webDataBinder) {
            webDataBinder.addCustomFormatter(new MyDateFormatter("binder1 转换器"));
        }

        public void foo() {
        }
    }

    @Controller
    static class Controller2 {
        @InitBinder
        public void binder21(WebDataBinder webDataBinder) {
            webDataBinder.addCustomFormatter(new MyDateFormatter("binder21 转换器"));
        }

        @InitBinder
        public void binder22(WebDataBinder webDataBinder) {
            webDataBinder.addCustomFormatter(new MyDateFormatter("binder22 转换器"));
        }

        public void foo() {
        }
    }
}

当 @InitBinder 作用的方法存在于被 @ControllerAdvice 标记的类里面时，是对 所有 控制器都生效的自定义类型转换器。当 @InitBinder 作用的方法存在于被 @Controller 标记的类里面时，是 只对当前 控制器生效的自定义类型转换器。

@InitBinder 的来源有两个：

1. @ControllerAdvice 标记的类中 @InitBinder 标记的方法，由 RequestMappingHandlerAdapter 在初始化时解析并记录
2. @Controller 标记的类中 @InitBinder 标记的方法，由 RequestMappingHandlerAdapter 在控制器方法首次执行时解析并记录

123456789101112131415161718192021222324252627282930313233public static void main(String[] args) throws Exception {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);
    RequestMappingHandlerAdapter handlerAdapter = new RequestMappingHandlerAdapter();

    handlerAdapter.setApplicationContext(context);
    handlerAdapter.afterPropertiesSet();

    log.debug("1. 刚开始...");
    showBindMethods(handlerAdapter);

    context.close();
}

@SuppressWarnings("all")
private static void showBindMethods(RequestMappingHandlerAdapter handlerAdapter) throws NoSuchFieldException, IllegalAccessException {
    Field initBinderAdviceCache = RequestMappingHandlerAdapter.class.getDeclaredField("initBinderAdviceCache");
    initBinderAdviceCache.setAccessible(true);
    Map<ControllerAdviceBean, Set<Method>> globalMap = (Map<ControllerAdviceBean, Set<Method>>) initBinderAdviceCache.get(handlerAdapter);
    log.debug("全局的 @InitBinder 方法 {}",
              globalMap.values().stream()
              .flatMap(ms -> ms.stream().map(m -> m.getName()))
              .collect(Collectors.toList())
             );

    Field initBinderCache = RequestMappingHandlerAdapter.class.getDeclaredField("initBinderCache");
    initBinderCache.setAccessible(true);
    Map<Class<?>, Set<Method>> controllerMap = (Map<Class<?>, Set<Method>>) initBinderCache.get(handlerAdapter);
    log.debug("控制器的 @InitBinder 方法 {}",
              controllerMap.entrySet().stream()
              .flatMap(e -> e.getValue().stream().map(v -> e.getKey().getSimpleName() + "." + v.getName()))
              .collect(Collectors.toList())
             );
}

运行 main() 方法后，控制台打印出：

indi.mofan.a24.A24                  - 1. 刚开始... 
indi.mofan.a24.A24                  - 全局的 @InitBinder 方法 [binder3] 
indi.mofan.a24.A24                  - 控制器的 @InitBinder 方法 [] 

全局的 @InitBinder 方法被解析并记录，但控制器中被 @InitBinder 标记的方法并没有被解析记录。

模拟调用控制器方法：

123456789101112131415161718public static void main(String[] args) throws Exception {
    // --snip--
    
    log.debug("1. 刚开始...");
    showBindMethods(handlerAdapter);

    Method getDataBinderFactory = RequestMappingHandlerAdapter.class.getDeclaredMethod("getDataBinderFactory", HandlerMethod.class);
    getDataBinderFactory.setAccessible(true);
    log.debug("2. 模拟调用 Controller1 的 foo 方法...");
    getDataBinderFactory.invoke(handlerAdapter, new HandlerMethod(new WebConfig.Controller1(), WebConfig.Controller1.class.getMethod("foo")));
    showBindMethods(handlerAdapter);

    log.debug("3. 模拟调用 Controller2 的 bar 方法时...");
    getDataBinderFactory.invoke(handlerAdapter, new HandlerMethod(new WebConfig.Controller2(), WebConfig.Controller2.class.getMethod("bar")));
    showBindMethods(handlerAdapter);

    context.close();
}

1. 刚开始... 
全局的 @InitBinder 方法 [binder3] 
控制器的 @InitBinder 方法 [] 
2. 模拟调用 Controller1 的 foo 方法... 
全局的 @InitBinder 方法 [binder3] 
控制器的 @InitBinder 方法 [Controller1.binder1] 
3. 模拟调用 Controller2 的 bar 方法时... 
全局的 @InitBinder 方法 [binder3] 
控制器的 @InitBinder 方法 [Controller1.binder1, Controller2.binder22, Controller2.binder21] 

首次调用控制器中的方法时，控制器中被 @InitBinder 标记方法被解析记录。

25. 控制器方法执行流程

ServletInvocableHandlerMethod 的组成

HandlerMethod 需要：

• bean，即哪个 Controller
• method，即 Controller 中的哪个方法

ServletInvocableHandlerMethod 需要：

• WebDataBinderFactory，用于对象绑定、类型转换
• ParameterNameDiscoverer，用于参数名解析
• HandlerMethodArgumentResolverComposite，用于解析参数
• HandlerMethodReturnValueHandlerComposite，用于处理返回值

控制器方法执行流程

以 RequestMappingHandlerAdapter 为起点，创建 WebDataBinderFactory，添加自定义类型转换器，再创建 ModelFactory，添加 Model 数据：

接下来调用 ServletInvocableHandlerMethod，主要完成三件事：

1. 准备参数
2. 反射调用控制器方法
3. 处理返回值

代码演示

提供配置类 WebConfig，其中包含一个控制器 Controller1：

12345678910111213141516171819@Configuration
public class WebConfig {
    @Controller
    static class Controller1 {
        @ResponseStatus(HttpStatus.OK)
        public ModelAndView foo(User user) {
            // 使用 @ResponseStatus 注解，咋不考虑返回值的处理
            System.out.println("foo");
            return null;
        }
    }

    @Getter
    @Setter
    @ToString
    static class User {
        private String name;
    }
}

创建 Spring 容器，Mock 请求，创建 HandlerMethod 对象指定需要执行的控制器方法，创建 DataBinderFactory 数据绑定工厂。向创建的 HandlerMethod 对象中添加数据绑定工厂、参数名称解析器、参数解析器（暂不考虑返回值的处理），最后创建模型视图容器，调用 HandlerMethod 的 invokeAndHandle 方法执行控制器方法：

1234567891011121314151617181920212223@SneakyThrows
public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);

    MockHttpServletRequest request = new MockHttpServletRequest();
    request.setParameter("name", "mofan");

    ServletInvocableHandlerMethod handlerMethod =
        new ServletInvocableHandlerMethod(new WebConfig.Controller1(), WebConfig.Controller1.class.getMethod("foo", WebConfig.User.class));
    ServletRequestDataBinderFactory binderFactory = new ServletRequestDataBinderFactory(null, null);

    handlerMethod.setDataBinderFactory(binderFactory);
    handlerMethod.setParameterNameDiscoverer(new DefaultParameterNameDiscoverer());
    // getArgumentResolvers() 组装了一系列参数解析器，省略具体实现
    handlerMethod.setHandlerMethodArgumentResolvers(getArgumentResolvers(context));
    // 暂不考虑返回值的处理

    ModelAndViewContainer container = new ModelAndViewContainer();
    handlerMethod.invokeAndHandle(new ServletWebRequest(request), container);
    System.out.println(container.getModel());

    context.close();
}

foo
{user=WebConfig.User(name=mofan), org.springframework.validation.BindingResult.user=org.springframework.validation.BeanPropertyBindingResult: 0 errors}

26. ControllerAdvice 之 @ModelAttribute

准备 @ModelAttribute 在整个 HandlerAdapter 调用过程中所处的位置：

功能与使用

@ModelAttribute 可以作用在参数上和方法上。

当其作用在参数上时，会将请求中的参数信息 按名称 注入到指定对象中，并将这个对象信息自动添加到 ModelMap 中。当未指定 @ModelAttribute 的 value 时，添加到 ModelMap 中的 key 是对象类型首字母小写对应的字符串。此时的 @ModelAttribute 注解由 ServletModelAttributeMethodProcessor 解析。

当其作用在方法上时：

• 如果该方法在被 @Controller 注解标记的类中，会在当前控制器中每个控制器方法执行前执行被 @ModelAttribute 标记的方法，如果该方法有返回值，自动将返回值添加到 ModelMap 中。当未指定 @ModelAttribute 的 value 时，添加到 ModelMap 中的 key 是返回值类型首字母小写对应的字符串
• 如果该方法在被 @ControllerAdvice 注解标记的类中，会在所有控制器方法执行前执行该方法

作用在方法上的 @ModelAttribute 注解由 RequestMappingHandlerAdapter 解析。

1234567891011121314151617@Controller
static class Controller1 {
    @ResponseStatus(HttpStatus.OK)
    public ModelAndView foo(@ModelAttribute("u") User user) {
        // 使用 @ResponseStatus 注解，咋不考虑返回值的处理
        System.out.println("foo");
        return null;
    }
}

@ControllerAdvice
static class MyControllerAdvice {
    @ModelAttribute("a")
    public String aa() {
        return "aa";
    }
}

先不使用 RequestMappingHandlerAdapter 对作用在方法上的 @ModelAttribute 注解进行解析，沿用【25. 控制器方法执行流程】中的 main() 方法：

foo
{u=WebConfig.User(name=mofan), org.springframework.validation.BindingResult.u=org.springframework.validation.BeanPropertyBindingResult: 0 errors}

再解析方法上的 @ModelAttribute 注解：

1234567891011121314151617181920212223@SneakyThrows
public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(WebConfig.class);

    RequestMappingHandlerAdapter adapter = new RequestMappingHandlerAdapter();
    adapter.setApplicationContext(context);
    adapter.afterPropertiesSet();

    MockHttpServletRequest request = new MockHttpServletRequest();
    request.setParameter("name", "mofan");

    // --snip--

    // 获取模型工厂
    Method getModelFactory = RequestMappingHandlerAdapter.class.getDeclaredMethod("getModelFactory", HandlerMethod.class, WebDataBinderFactory.class);
    getModelFactory.setAccessible(true);
    ModelFactory modelFactory = (ModelFactory) getModelFactory.invoke(adapter, handlerMethod, binderFactory);

    // 初始化模型数据
    modelFactory.initModel(new ServletWebRequest(request), container, handlerMethod);

    // --snip--
}