Spring高级（三）—— SpringMVC

但盼风雨来能留你在此

已于 2022-09-27 10:45:05 修改

阅读量906

点赞数

分类专栏：技术原理文章标签： spring java 后端

于 2022-06-13 16:31:25 首次发布

本文链接：https://blog.csdn.net/weixin_56697114/article/details/125068900

版权

技术原理专栏收录该内容

5 篇文章 1 订阅

订阅专栏

1、RequestMappingHandlerMapping 与 RequestMappingHandlerAdapter

1、DispatcherServlet 初始化

2、参数解析器

3、参数名解析

4、对象绑定与类型转换

1、底层第一套转换接口与实现 (Spring)

5、@ControllerAdvice 之 @InitBinder

6、控制器方法执行流程（@ModelAttribute）

7、返回值处理器

8、MessageConverter

9、@ControllerAdvice 之 ResponseBodyAdvice

10、异常解析器

1、ExceptionHandlerExceptionResolver

2、@ExceptionHandler

11、Tomcat 异常处理

12、BeanNameUrlHandlerMapping 与 SimpleControllerHandlerAdapter

RouterFunctionMapping 与 HandlerFunctionAdapter

13、SimpleUrlHandlerMapping 与 HttpRequestHandlerAdapter

14、mvc 处理流程

1、RequestMappingHandlerMapping 与 RequestMappingHandlerAdapter

RequestMappingHandlerMapping 与 RequestMappingHandlerAdapter 俩是一对，分别用来

处理 @RequestMapping 映射
调用控制器方法、并处理方法参数与方法返回值

1、DispatcherServlet 初始化

自定义注解：

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

// 例如经常需要用到请求头中的 token 信息, 用下面注解来标注由哪个参数来获取它
// token=令牌
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface Token {
}

自定义参数与返回值处理器：

public class MyArgumentResolver implements HandlerMethodArgumentResolver {

    // 是否支持某个参数
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        Token token = parameter.getParameterAnnotation(Token.class);
        return token != null;
    }

    // 解析参数
    @Override
    public Object resolveArgument(MethodParameter methodParameter,
                                  ModelAndViewContainer modelAndViewContainer, NativeWebRequest nativeWebRequest,
                                  WebDataBinderFactory webDataBinderFactory) throws Exception {

        return nativeWebRequest.getHeader("token");
    }
}

public class MyReturn implements HandlerMethodReturnValueHandler {

    @Override
    public boolean supportsReturnType(MethodParameter parameter) {
        Yml yml = parameter.getMethodAnnotation(Yml.class);
        return yml != null;
    }

    @Override
    public void handleReturnValue(Object returnValue, MethodParameter methodParameter, ModelAndViewContainer modelAndViewContainer,
                                  NativeWebRequest nativeWebRequest) throws Exception {

        // 1. 转换返回结果为指定yaml 字符串
        String str = new Yaml().dump(returnValue);

        // 2. 将 yaml 字符串写入响应
        HttpServletResponse response = nativeWebRequest.getNativeResponse(HttpServletResponse.class);
        response.setContentType("text/plain;charset=utf-8");
        response.getWriter().print(str);

        // 3. 设置请求已经处理完毕
        modelAndViewContainer.setRequestHandled(true);

    }
}

@Controller
public class Controller1 {

    private static final Logger log = LoggerFactory.getLogger(Controller1.class);

    @GetMapping("/test1")
    public ModelAndView test1() throws Exception {
        System.err.println("test1");
        return null;
    }

    @PostMapping("/test2")
    public ModelAndView test2(@RequestParam("name") String name) {
        System.err.println("test2："+name);
        return null;
    }

    @PutMapping("/test3")
    public ModelAndView test3(@Token String token) {
        System.err.println("test3："+token);
        return null;
    }

    @RequestMapping("/test4")
//    @ResponseBody
    @Yml
    public User test4() {
        System.err.println("test4");
        return new User("张三", 18);
    }

    public static class User {
        private String name;
        private int age;

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

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }

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

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

    public static void main(String[] args) {
        String str = new Yaml().dump(new User("张三", 18));
        System.out.println(str);
    }
}

配置类：

@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(1);
        registrationBean.setLoadOnStartup(webMvcProperties.getServlet().getLoadOnStartup());
        return registrationBean;
    }

    // 如果用 DispatcherServlet 初始化时默认添加的组件, 并不会作为 bean, 给测试带来困扰
    // 加入RequestMappingHandlerMapping
    @Bean
    public RequestMappingHandlerMapping requestMappingHandlerMapping(){
        return new RequestMappingHandlerMapping();
    }

    @Bean
    public RequestMappingHandlerAdapter requestMappingHandlerAdapter(){
        RequestMappingHandlerAdapter handlerAdapter = new RequestMappingHandlerAdapter();
        // 自定义参数与返回值处理器
        MyArgumentResolver resolver = new MyArgumentResolver();
        MyReturn myReturn = new MyReturn();

        handlerAdapter.setCustomArgumentResolvers(List.of(resolver));
        handlerAdapter.setCustomReturnValueHandlers(List.of(myReturn));
        return handlerAdapter;
    }

    @Bean("/hello")
    public Controller controller(){
        return (request, response) -> {
            response.getWriter().println("hello world");
            return null;
        };
    }

}

public class Day20Application {
    public 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();
        System.err.println("handlerMethods：");
        handlerMethods.forEach((k, v) -> {
            System.out.println(k+"=="+v);
        });
        System.err.println("------------\n");

        // 请求来了，获取控制器方法  返回处理器执行链对象
        MockHttpServletRequest request = new MockHttpServletRequest("GET", "/test4");
        request.setParameter("name","张三");
        request.addHeader("token","这是个令牌");


        MockHttpServletResponse response = new MockHttpServletResponse();
        HandlerExecutionChain chain = handlerMapping.getHandler(request);
        System.err.println("执行链："+chain);

        System.err.println(">>>>>>>>>>>>");
        // HandlerAdapter 作用: 调用控制器方法
        RequestMappingHandlerAdapter handlerAdapter = context.getBean(RequestMappingHandlerAdapter.class);
        Method method = handlerAdapter.getClass().getDeclaredMethod("invokeHandlerMethod",
                                HttpServletRequest.class, HttpServletResponse.class,HandlerMethod.class);
        method.setAccessible(true);
        method.invoke(handlerAdapter,request,response,(HandlerMethod)chain.getHandler());

        //检测响应
        byte[] content = response.getContentAsByteArray();
        System.err.println(new String(content, StandardCharsets.UTF_8));


//        System.err.println(">>>>>>>>>>>>>>>>>>>>> 所有参数解析器");
//        for (HandlerMethodArgumentResolver resolver : handlerAdapter.getArgumentResolvers()) {
//            System.out.println(resolver);
//        }
//
//        System.err.println(">>>>>>>>>>>>>>>>>>>>> 所有返回值解析器");
//        for (HandlerMethodReturnValueHandler handler : handlerAdapter.getReturnValueHandlers()) {
//            System.out.println(handler);
//        }

    }
}

DispatcherServlet 是在第一次被访问时执行初始化, 也可以通过配置修改为 Tomcat 启动后就初始化
在初始化时会从 Spring 容器中找一些 Web 需要的组件, 如 HandlerMapping、HandlerAdapter 等，并逐一调用它们的初始化
RequestMappingHandlerMapping 初始化时，会收集所有 @RequestMapping 映射信息，封装为 Map，其中
- key 是 RequestMappingInfo 类型，包括请求路径、请求方法等信息
- value 是 HandlerMethod 类型，包括控制器方法对象、控制器对象
- 有了这个 Map，就可以在请求到达时，快速完成映射，找到 HandlerMethod 并与匹配的拦截器一起返回给 DispatcherServlet
RequestMappingHandlerAdapter 初始化时，会准备 HandlerMethod 调用时需要的各个组件，如：
- HandlerMethodArgumentResolver 解析控制器方法参数
- HandlerMethodReturnValueHandler 处理控制器方法返回值

2、参数解析器

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

        // 准备测试 Request
        HttpServletRequest request = mockRequest();

        // 要点1. 控制器方法被封装为 HandlerMethod
        HandlerMethod handlerMethod = new HandlerMethod(new Controller(), 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));

        // 要点2. 准备对象绑定与类型转换
        ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(null,null);

        // 要点3. 准备 ModelAndViewContainer 用来存储中间 Model 结果
        ModelAndViewContainer container = new ModelAndViewContainer();

        // 要点4. 解析每个参数值
        for (MethodParameter parameter : handlerMethod.getMethodParameters()) {
            //多个解析的组合
            HandlerMethodArgumentResolverComposite composite = new HandlerMethodArgumentResolverComposite();
            composite.addResolvers(

                    new RequestParamMethodArgumentResolver(beanFactory,false),//为 false 则必须有@RequestParam
                    new PathVariableMethodArgumentResolver(),
                    new RequestHeaderMethodArgumentResolver(beanFactory),
                    new ServletCookieValueMethodArgumentResolver(beanFactory),
                    new ExpressionValueMethodArgumentResolver(beanFactory),
                    new ServletRequestMethodArgumentResolver(),

                    new ServletModelAttributeMethodProcessor(false),// 必须有 @ModelAttribute
                    new RequestResponseBodyMethodProcessor(List.of(new MappingJackson2HttpMessageConverter())),//↓↑位置不能对调
                    new ServletModelAttributeMethodProcessor(true),// 省略了 @ModelAttribute

                    new RequestParamMethodArgumentResolver(beanFactory,true)//可省略@RequestParam
            );
            List<String> list = new ArrayList<>();
            //获取参数上的注解
            Arrays.stream(parameter.getParameterAnnotations()).forEach(annotation -> {
                list.add("【@"+annotation.annotationType().getSimpleName()+"】 ");
            });
            //解析参数名
            parameter.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
            if(list.size() == 0){
                list.add("");
            }

            if(composite.supportsParameter(parameter)){
                Object v = composite.resolveArgument(parameter, container, new ServletWebRequest(request), factory);
                System.err.println(v.getClass());
                System.err.println("【"+parameter.getParameterIndex()+"】 "+ list.get(0) +parameter.getParameterType().getSimpleName()
                        +" - "+parameter.getParameterName()+" --> "+v);
                if(container.getModel() != null && container.getModel().size() > 0){
                    System.err.println("模型数据为:："+container.getModel());
                }

            }else{
                System.err.println("【"+parameter.getParameterIndex()+"】 "+ list.get(0) +parameter.getParameterType().getSimpleName()
                        +" - "+parameter.getParameterName());
            }

        }

    }

    private static HttpServletRequest mockRequest() {
        MockHttpServletRequest request = new MockHttpServletRequest();
        request.setParameter("name1", "zhangsan");
        request.setParameter("name2", "lisi");
        request.addPart(new MockPart("file", "abc", "hello".getBytes(StandardCharsets.UTF_8)));
        //建立对应关系，并存储到map当中
        Map<String, String> map = new AntPathMatcher().extractUriTemplateVariables("/test/{id}", "/test/123");
        System.out.println(">>>"+map);
        request.setAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, map);

        request.setContentType("application/json");
        request.setCookies(new Cookie("token", "123456"));
        request.setParameter("name", "张三");
        request.setParameter("age", "18");
        request.setContent(("{\"name\":\"李四\",\"age\":20}").getBytes(StandardCharsets.UTF_8));

        return new StandardServletMultipartResolver().resolveMultipart(request);
    }

    static 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
        ) {
        }
    }

    static class User {
        private String name;
        private int age;

        public String getName() {
            return name;
        }

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

        public int getAge() {
            return age;
        }

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

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

初步了解 RequestMappingHandlerAdapter 的调用过程
1. 控制器方法被封装为 HandlerMethod
2. 准备对象绑定与类型转换
3. 准备 ModelAndViewContainer 用来存储中间 Model 结果
4. 解析每个参数值
解析参数依赖的就是各种参数解析器，它们都有两个重要方法
- supportsParameter 判断是否支持方法参数
- resolveArgument 解析方法参数
常见参数的解析
- @RequestParam
- 省略 @RequestParam
- @RequestParam(defaultValue)
- MultipartFile
- @PathVariable
- @RequestHeader
- @CookieValue
- @Value
- HttpServletRequest 等
- @ModelAttribute
- 省略 @ModelAttribute
- @RequestBody
组合模式在 Spring 中的体现
@RequestParam, @CookieValue 等注解中的参数名、默认值, 都可以写成活的, 即从 ${ } #{ }中获取

3、参数名解析

/*
    目标: 如何获取方法参数名, 注意把 a22 目录添加至模块的类路径
        1. a22 不在 src 是避免 idea 自动编译它下面的类
        2. spring boot 在编译时会加 -parameters
        3. 大部分 IDE 编译时都会加 -g
 */
public class A22 {

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

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

    }

}

如果编译时添加了 -parameters 可以生成参数表, 反射时就可以拿到参数名
如果编译时添加了 -g 可以生成调试信息, 但分为两种情况
- 普通类, 会包含局部变量表, 用 asm 可以拿到参数名
- 接口, 不会包含局部变量表, 无法获得参数名

这也是 MyBatis 在实现 Mapper 接口时为何要提供 @Param 注解来辅助获得参数名

4、对象绑定与类型转换

1、底层第一套转换接口与实现 (Spring)

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

2、底层第二套转换接口(jdk)

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

3、高层接口与实现

它们都实现了 TypeConverter 这个高层转换接口，在转换时，会用到 TypeConverter Delegate 委派ConversionService 与 PropertyEditorRegistry 真正执行转换（Facade 门面模式）
- 首先看是否有自定义转换器, @InitBinder 添加的即属于这种 (用了适配器模式把 Formatter 转为需要的 PropertyEditor)
- 再看有没有 ConversionService 转换
- 再利用默认的 PropertyEditor 转换
- 最后有一些特殊处理
SimpleTypeConverter 仅做类型转换
BeanWrapperImpl 为 bean 的属性赋值，当需要时做类型转换，走 Property（get、set）
DirectFieldAccessor 为 bean 的属性赋值，当需要时做类型转换，走 Field（成员变量）
ServletRequestDataBinder 为 bean 的属性执行绑定，当需要时做类型转换，根据 directFieldAccess 选择走 Property （false）还是 Field（true），具备校验与获取校验结果功能

4、类型转换与数据绑定

public class Test1 {
    public static void main(String[] args) {
        // 仅有类型转换的功能
        SimpleTypeConverter converter = new SimpleTypeConverter();
        Integer num = converter.convertIfNecessary("13", int.class);
        Date date = converter.convertIfNecessary("2022/01/01", Date.class);

        System.err.println(num);
        System.err.println(date);

    }
}

public class Test2 {
    public static void main(String[] args) {

        // 利用反射原理, 为 bean 的属性赋值
        MyBean myBean = new MyBean();
        BeanWrapperImpl wrapper = new BeanWrapperImpl(myBean);
        wrapper.setPropertyValue("a","10");
        wrapper.setPropertyValue("b","hello");
        wrapper.setPropertyValue("c","2022/01/01");
        System.err.println(myBean);

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

        public int getA() {
            return a;
        }

        public void setA(int a) {
            this.a = a;
        }

        public String getB() {
            return b;
        }

        public void setB(String b) {
            this.b = b;
        }

        public Date getC() {
            return c;
        }

        public void setC(Date c) {
            this.c = c;
        }

        @Override
        public String toString() {
            return "MyBean{" +
                    "a=" + a +
                    ", b='" + b + '\'' +
                    ", c=" + c +
                    '}';
        }
    }

}

public class Test3 {
    public static void main(String[] args) {

        // 利用反射原理, 为 bean 的属性赋值
        Test2.MyBean myBean = new Test2.MyBean();
        DirectFieldAccessor accessor = new DirectFieldAccessor(myBean);
        accessor.setPropertyValue("a","10");
        accessor.setPropertyValue("b","hello");
        accessor.setPropertyValue("c","2022/01/01");
        System.err.println(myBean);

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

        @Override
        public String toString() {
            return "MyBean{" +
                    "a=" + a +
                    ", b='" + b + '\'' +
                    ", c=" + c +
                    '}';
        }
    }
}

public class Test4 {
    public static void main(String[] args) {
        // 执行数据绑定
        MyBean myBean = new MyBean();
        DataBinder binder = new DataBinder(myBean);
        binder.initDirectFieldAccess();
        MutablePropertyValues pvs = new MutablePropertyValues();
        pvs.add("a","10");
        pvs.add("b","hello");
        pvs.add("c","2022/01/01");

        binder.bind(pvs);
        System.err.println(myBean);
    }

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

        @Override
        public String toString() {
            return "MyBean{" +
                    "a=" + a +
                    ", b='" + b + '\'' +
                    ", c=" + c +
                    '}';
        }
    }
}

web 环境下

public class Test5 {
    public static void main(String[] args) {
        // web 环境下的数据绑定
        MyBean myBean = new MyBean();
        ServletRequestDataBinder binder = new ServletRequestDataBinder(myBean);
        MockHttpServletRequest request = new MockHttpServletRequest();
        request.setParameter("a","10");
        request.setParameter("b","hello");
        request.setParameter("c","2022/01/01");

        binder.bind(new ServletRequestParameterPropertyValues(request));
        System.err.println(myBean);
    }

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

        public int getA() {
            return a;
        }

        public void setA(int a) {
            this.a = a;
        }

        public String getB() {
            return b;
        }

        public void setB(String b) {
            this.b = b;
        }

        public Date getC() {
            return c;
        }

        public void setC(Date c) {
            this.c = c;
        }

        @Override
        public String toString() {
            return "MyBean{" +
                    "a=" + a +
                    ", b='" + b + '\'' +
                    ", c=" + c +
                    '}';
        }
    }
}

5、数据绑定工厂

public class Test6 {
    public static void main(String[] args) throws Exception {
        User user = new User();
        MockHttpServletRequest request = new MockHttpServletRequest();

        request.setParameter("birthday","2022|01|01");
        request.setParameter("address.name","北京");
//        ServletRequestDataBinder binder = new ServletRequestDataBinder(user);

        // 1. 用工厂, 无转换功能
//        ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(null,null);

        //2. 用 @InitBinder 转换  使用的是：PropertyEditorRegistry PropertyEditor
//        InvocableHandlerMethod method = new InvocableHandlerMethod(new MyController(), MyController.class.getMethod("test", WebDataBinder.class));
//        ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(List.of(method),null);

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

        //4. 同时加了 @InitBinder（优先） 和 ConversionService

        //5. 使用默认 ConversionService 转换 需要@DateTimeFormat配合使用
//        DefaultFormattingConversionService service = new DefaultFormattingConversionService(); //非spring boot
        ApplicationConversionService service = new ApplicationConversionService();//spring boot 使用
        ConfigurableWebBindingInitializer initializer = new ConfigurableWebBindingInitializer();
        initializer.setConversionService(service);
        ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(null,initializer);

        WebDataBinder binder = factory.createBinder(new ServletWebRequest(request), user, "user");
        binder.bind(new ServletRequestParameterPropertyValues(request));
        System.err.println(user);
    }

    static class MyController{
        @InitBinder
        public void test(WebDataBinder dataBinder){
            // 扩展 dataBinder 的转换器
            dataBinder.addCustomFormatter(new MyDateFormatter("用 @InitBinder 方式扩展的"));
        }
    }

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

        public Address getAddress() {
            return address;
        }

        public void setAddress(Address address) {
            this.address = address;
        }

        public Date getBirthday() {
            return birthday;
        }

        public void setBirthday(Date birthday) {
            this.birthday = birthday;
        }

        @Override
        public String toString() {
            return "User{" +
                    "birthday=" + birthday +
                    ", address=" + address +
                    '}';
        }
    }

    public static class Address {
        private String name;

        public String getName() {
            return name;
        }

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

        @Override
        public String toString() {
            return "Address{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }
}

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 {
        System.err.println(desc);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy|MM|dd");
        return sdf.parse(text);
    }

}

ServletRequestDataBinderFactory 的用法和扩展点

可以解析控制器的 @InitBinder 标注方法作为扩展点，添加自定义转换器
- 控制器私有范围
可以通过 ConfigurableWebBindingInitializer 配置 ConversionService 作为扩展点，添加自定义转换器
- 公共范围
同时加了 @InitBinder 和 ConversionService 的转换优先级
1. 优先采用 @InitBinder 的转换器
2. 其次使用 ConversionService 的转换器
3. 使用默认转换器
4. 特殊处理（例如有参构造）

6、获取泛型参数

public class Test7 {
    public static void main(String[] args) {
        // 1. java api
        Type type = StudentDao.class.getGenericSuperclass();
        System.err.println(type);

        if(type instanceof ParameterizedType){
            ParameterizedType parameterizedType = (ParameterizedType) type;
            System.err.println(">>>"+parameterizedType.getActualTypeArguments()[0]);
        }

        System.err.println("===================");

        // 2. spring api 1
        Class<?> clazz = GenericTypeResolver.resolveTypeArgument(StudentDao.class, BaseDao.class);
        System.err.println(clazz);

        // 3. spring api 2
        Class<?> c = ResolvableType.forClass(StudentDao.class).getSuperType().getGeneric().resolve();
        System.err.println(c);
    }

    static  class StudentDao extends BaseDao<Student> {
    }
}

5、@ControllerAdvice 之 @InitBinder

@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 bar() {

        }
    }

}

public class A24 {

    private static final Logger log = LoggerFactory.getLogger(A24.class);

    public static void main(String[] args) throws Exception {
        /*
            @InitBinder 的来源有两个
            1. @ControllerAdvice 中 @InitBinder 标注的方法，由 RequestMappingHandlerAdapter 在初始化时解析并记录
            2. @Controller 中 @InitBinder 标注的方法，由 RequestMappingHandlerAdapter 会在控制器方法首次执行时解析并记录
         */

        AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(WebConfig.class);

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

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

    }

    //（了解）
    @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())
        );
    }
}

RequestMappingHandlerAdapter 初始化时会解析 @ControllerAdvice 中的 @InitBinder 方法
RequestMappingHandlerAdapter 会以类为单位，在该类首次使用时，解析此类的 @InitBinder 方法
以上两种 @InitBinder 的解析结果都会缓存来避免重复解析
控制器方法调用时，会综合利用本类的 @InitBinder 方法和 @ControllerAdvice 中的 @InitBinder 方法创建绑定工厂

6、控制器方法执行流程（@ModelAttribute）

HandlerMethod 需要

bean 即是哪个 Controller
method 即是 Controller 中的哪个方法

ServletInvocableHandlerMethod 需要

WebDataBinderFactory 负责对象绑定、类型转换
ParameterNameDiscoverer 负责参数名解析
HandlerMethodArgumentResolverComposite 负责解析参数
HandlerMethodReturnValueHandlerComposite 负责处理返回值

可拆分成：

@Configuration
public class WebConfig {

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

    @Controller
    static class Controller1 {
        @ModelAttribute("b")
        public String aa() {
            return "bb";
        }

        @ResponseStatus(HttpStatus.OK)
        public ModelAndView foo(@ModelAttribute("u") User user) {
            System.out.println("foo");
            return null;
        }
    }

    static class User {
        private String name;

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

        public String getName() {

            return name;
        }

        @Override
        public String toString() {
            return "User{" +
                   "name='" + name + '\'' +
                   '}';
        }
    }
}

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

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

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

        /*
            现在可以通过 ServletInvocableHandlerMethod 把这些整合在一起, 并完成控制器方法的调用, 如下
         */
        ServletInvocableHandlerMethod handlerMethod = new ServletInvocableHandlerMethod(
                new WebConfig.Controller1(),WebConfig.Controller1.class.getMethod("foo", WebConfig.User.class)
        );

        ServletRequestDataBinderFactory factory = new ServletRequestDataBinderFactory(null,null);

        handlerMethod.setDataBinderFactory(factory);
        handlerMethod.setParameterNameDiscoverer(new DefaultParameterNameDiscoverer());
        handlerMethod.setHandlerMethodArgumentResolvers(getArgumentResolvers(context));

        ModelAndViewContainer container = new ModelAndViewContainer();

        // 获取模型工厂方法
        Method method = RequestMappingHandlerAdapter.class.getDeclaredMethod("getModelFactory",
                                HandlerMethod.class, WebDataBinderFactory.class);
        method.setAccessible(true);
        ModelFactory modelFactory = (ModelFactory) method.invoke(adapter, handlerMethod, factory);
        // 初始化模型数据
        modelFactory.initModel(new ServletWebRequest(request),container,handlerMethod);

        handlerMethod.invokeAndHandle(new ServletWebRequest(request),container);

        System.err.println(container.getModel());

        container.getClass();
    }

    public static HandlerMethodArgumentResolverComposite getArgumentResolvers(AnnotationConfigApplicationContext context) {
        HandlerMethodArgumentResolverComposite composite = new HandlerMethodArgumentResolverComposite();
        composite.addResolvers(
                new RequestParamMethodArgumentResolver(context.getDefaultListableBeanFactory(), false),
                new PathVariableMethodArgumentResolver(),
                new RequestHeaderMethodArgumentResolver(context.getDefaultListableBeanFactory()),
                new ServletCookieValueMethodArgumentResolver(context.getDefaultListableBeanFactory()),
                new ExpressionValueMethodArgumentResolver(context.getDefaultListableBeanFactory()),
                new ServletRequestMethodArgumentResolver(),
                new ServletModelAttributeMethodProcessor(false),
                new RequestResponseBodyMethodProcessor(List.of(new MappingJackson2HttpMessageConverter())),
                new ServletModelAttributeMethodProcessor(true),
                new RequestParamMethodArgumentResolver(context.getDefaultListableBeanFactory(), true)
        );
        return composite;
    }
}

RequestMappingHandlerAdapter 初始化时会解析 @ControllerAdvice 中的 @ModelAttribute 方法
RequestMappingHandlerAdapter 会以类为单位，在该类首次使用时，解析此类的 @ModelAttribute 方法
以上两种 @ModelAttribute 的解析结果都会缓存来避免重复解析
控制器方法调用时，会综合利用本类的 @ModelAttribute 方法和 @ControllerAdvice 中的 @ModelAttribute 方法创建模型工厂