DispatcherServlet源码及@ResponseBodyAdvice与@RequestBodyAdvice使用

1.@RestControllerAdvice+实现RequestBodyAdvice接口。来对请求头和请求体中进行解密操作

// 这个接口的实现类调用链
//   RequestResponseBodyMethodProcessor.resolveArgument(...)->{
//        Object readWithMessageConverters(...)->{
//            //请求体body不为null,执行
//            HttpInputMessage msgToUse = this.getAdvice().beforeBodyRead(...);
//              body = genericConverter != null ? genericConverter.read(...) : 
//                                                                converter.read();
//              //请求体body为null，执行
//              body = this.getAdvice().afterBodyRead();
//        }
//     }

public interface RequestBodyAdvice {
    //  var1  HandlerMethodParameter对象，为判断方法或参数上是否有某注解
    //  var2  参数类型，即转化器的目标类型
    //  var3  HttpMessageConverter 转化器
    boolean supports(MethodParameter var1, Type var2, Class<? extends                             
            HttpMessageConverter<?>> var3);
    
    // var1 请求头中的header和body，其他上述以介绍
    // 该方法执行时机为 转化器转化body之前 
    HttpInputMessage beforeBodyRead(HttpInputMessage var1, MethodParameter var2, Type var3, 
             Class<? extends HttpMessageConverter<?>> var4) throws IOException;
    
    // var1 转化后的javaType对象
    //该方法执行时机为 转化器转化body之后
    Object afterBodyRead(Object var1, HttpInputMessage var2, MethodParameter var3, Type 
                 var4, Class<? extends HttpMessageConverter<?>> var5);
    // var1为null。一般返回var1。
    // 请求中body为null时调用。
    @Nullable
    Object handleEmptyBody(@Nullable Object var1, HttpInputMessage var2, MethodParameter 
             var3, Type var4, Class<? extends HttpMessageConverter<?>> var5);
}

2.@RestControllerAdvice+实现ResponseBodyAdvice接口。对响应体(返回值)作加密操作

// 这个接口的实现类调用链
//   RequestResponseBodyMethodProcessor.handleReturnValue(...)->{
//        Object this.writeWithMessageConverter(...)->{
//            //body可能为null
//            body = this.getAdvice().beforeBodyWrite(...);
//            //请求体body不为null,则使用转换器将返回值(javaType)转成json后，放入响应体body中
//            genericConverter.write()
//        }
//     } 
public interface ResponseBodyAdvice<T> {
    boolean supports(MethodParameter var1, Class<? extends HttpMessageConverter<?>> var2);
    // var1 方法返回值
    // MethodParameter  var2为ReturnValueMethodParameter类对象
    // var3 为application/json 
    // var4 MappingJackson2HttpMessageConverter.class 
    @Nullable
    T beforeBodyWrite(@Nullable T var1, MethodParameter var2, MediaType var3, Class<? extends HttpMessageConverter<?>> var4, ServerHttpRequest var5, ServerHttpResponse var6);
}

3.一个请求进入DispatcherServlet类的流程

// GenericServlet->HttpServlet->HttpServletBean->
//    FrameworkServlet->DispatcherServlet类

// 在ApplicationFilterChain.internalDoFilter(...)方法执行完过滤器后，执行DispatcherServlet类对象.service(request, response) 方法


//实际执行其父类HttpServlet的方法
DispatcherServlet.service(request, response)->{
    //将请求和响应强转成HttpServlet...请求
    request = (HttpServletRequest)req;
    response = (HttpServletResponse)res;
    
    //实际执行其父类FrameworkServlet的方法
    this.service(request, response)->{
        // 解析httpMethod
        HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());

        // 如果httpMethod！=null 且 解析出的方法不为PATCH，则进入此方法
        // 实际执行其父类HttpServlet的方法
        service(HttpServletRequest req, HttpServletResponse resp)->{
            // 有8中选择 GET,HEAD,POST,PUT,DELETE,OPTIONS,TRACE,其他(resp.sendError(501))
            String method = req.getMethod();
            // 进入POST方法
            // 实际执行其父类FrameworkServlet的方法
            this.doPost(req, resp)->{
                 this.processRequest(request, response)->{
                    // 实际执行DispatcherServlet的方法
                    this.doService(request, response)->{
                        this.doDispatch(request, response)->{
                            // 根据请求从RequestMappingHandlerMapping对象中获取 
                            //     HandlerMethod对象和interceptorList
                            mappedHandler = this.getHandler(processedRequest);
                            // 根据HandlerMethod对象得到RequestMappingHandlerAdapter对象
                            HandlerAdapter ha = 
                                 this.getHandlerAdapter(mappedHandler.getHandler())->{
                            };
                            //执行所有HandlerInterceptor器的PreHandle方法
                            mappedHandler.applyPreHandle(processedRequest, response)
                            //使用ha处理请求
                            mv = ha.handle(processedRequest, response, 
                                 mappedHandler.getHandler())->{
                                invocableMethod.invokeAndHandle(webRequest, mavContainer, 
                                    new Object[0])->{
                                    
                                    //  1和2都为HandlerMethodArgumentResolver接口的实现类
                                    //    该接口方法核心supportsParameter和resolveArgument  
                                    //1.参数中有@RequestBody注解,则
                                    // RequestResponseBodyMethodProcessor.resolveArgument
                                    //       (...)->{
                                    //       
                                    //       //MappingJackson2HttpMessageConverter.read() 
                                    //       //  方法将请求Body中数据转为目标类
                                    //       Object readWithMessageConverters(...)
                                    // }     
                                    //2.参数中有RequestEntity.class,则
                                    // HttpEntityMethodProcessor.resolveArgument(...)->{
                                    //   Object body = readWithMessageConverters(...)
                                    //   //RequestEntity中body，headers，url，method 
                                    //   return RequestEntity;
                                    // }
                                    // 该方法执行完后，返回结果                   
                                    Object returnValue = 
                                    this.invokeForRequest(webRequest, mavContainer, 
                                                   providedArgs);
                                    // 设置响应码
                                    this.setResponseStatus(webRequest);
                                    // 返回结果不为null时，则执行
                                    // 返回值为ModelAndView对象，则
                                    //   ModelAndViewMethodReturnValueHandler处理返回结果
                                    //     作用将ModelAndView对象放到mavContainer
                                    this.returnValueHandlers.handleReturnValue(...)
                                };
                                // 从mavContainer得到ModelAndView对象对象返回
                                var15 = this.getModelAndView(mavContainer, modelFactory, 
                                   webRequest);
                                return var15;
                            };
                            
                            // mav中没有view，则使用请求中默认的view
                            this.applyDefaultViewName(processedRequest, mv);
                            // 执行所有HandlerInterceptor器的postHandle方法
                            mappedHandler.applyPostHandle(processedRequest, response, 
                                    mv);
                            // 将mav对象写入到响应中，执行所有HandlerInterceptor器的 
                            //      afterCompletion方法
                            this.processDispatchResult(...);
                        };
                    };
                 };
            };
        }
     };
}