之前项目开发用到了数据权限-列权限《列权限》，之后开发的过程中，需要对隐藏的字段进行值清空的同时，还需要把该值对应的属性给干掉，总结起来就是序列化时需要根据用户配置，动态的控制哪些字段参与序列化，即张三本次请求返回姓名、性别、年龄，下次请求可能只返回年龄这个字段，我把这个称为动态序列化

动态序列化

  本节不是重点，简要提下相关的过程。序列化工具我们采用spring mvc自带的jackson来进行的，如果要控制某个字段是否参与序列化，一是可以使用jdk自带的transient来修饰，二是可以使用jackson自带的注解@JsonIgnore或者基于代码方式来进行配置；但此类方式太局限，需要在编码时就要确定好，而不是运行时再确认，故不适用于动态序列化。
  最终我们是采用com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider# addFilter(String id, SimpleBeanPropertyFilter filter)、自定义注解 和 com.fasterxml.jackson.databind.ObjectMapper#addMixIn()来实现。

springMVC链路分析

开始之前先抛几个问题？

• 我们想在springMVC读取前端传参之前，我们再加点东西在参数里面，比如在已有参数中额外追加一个ip：123的参数如何玩？
• 我猜测你上面个问题的答案是用拦截器或者过滤器，那我在问一个：上面说的是springMVC读取前端传参之前，如果是读取之后呢，又再加或者减去一个参数，又该怎么玩
• 如果我想写一个类似@ReponseBody或者@RequestBody的注解，实现把前端提交的User参数封装到对应Ctrl方法中，怎么玩
• 如果我想在所有的方法返回之前都加一个code码，怎么做
  本篇文章从源码层面讲下目前springMVC是怎么做的

之前在列权限里面分析了我们钩子函数是作用于org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor & writeWithMessageConverters(@Nullable T value, MethodParameter returnType, ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage)方法
然后我们就顺着这个方法的前因后果走一遍，我也会介绍下我看源码和跟踪源码的思路和方法，即怎么在源码包里面找到我想看的那部分，怎么跟踪调用链路走

那我们就先拿AbstractMessageConverterMethodProcessor 这个方法开刀；

AbstractMessageConverterMethodProcessor类截图.png

  又到学习英语的时间了，AbstractMessageConverterMethodProcessor 顾名思义：Abstract[ˈæbstrækt , æbˈstrækt]（抽象）Message [ˈmesɪdʒ]（消息）Converter[kənˈvɜːtə(r)]转换 Method Processor[ˈprəʊsesə(r)]（处理器）,结合这个名字和里面大部分的方法可以猜测到应该是返回结果和响应头做处理的一个类。

然后这个时候一般都会很懵逼，此类又没有注释，这下知道注释的重要性了吧，我总结了下主要是不知道这个类在全局中哪个位置起作用，起什么作用，看不到全局，只能看到这个点，这个时候我的建议就是看看这个类的继承体系和接口体系，看看能不能搞点有用的信息

• 那我们先看看此类实现的接口HandlerMethodReturnValueHandler

//好家伙，又没注释，这提交代码扫描的时候能扫描过么，还好只是接口定义，简单明了，从这点也能看出抽象接口多重要，不要一上来就开撸，写一大堆的实现内容
//这个接口名一看就能知道是对方法返回值处理，这意味着我们如果在ctrl层有这种需求就可以实现这个接口来玩
public interface HandlerMethodReturnValueHandler {
    //是否是支持的返回类型，用作逻辑判断，比如返回的类型是某种对象，才会处理，比如：方法上@responseBody注解才进入逻辑处理
    boolean supportsReturnType(MethodParameter var1);
    //具体处理实现，注意看参数，有当前返回对象，有modelView，还有方法参数
    void handleReturnValue(@Nullable Object var1, MethodParameter var2, ModelAndViewContainer var3, NativeWebRequest var4) throws Exception;
}

• 然后我们继续看看这个AbstractMessageConverterMethodProcessor 类的父类，如图

  
  
  AbstractMessageConverterMethodArgumentResolver.png
  
  

  可以看到该父类实现了HandlerMethodArgumentResolver接口

//Resolver [rɪˈzɒlvə]解析器，很明显对请求参数进行解析的，比如说@requestBody注解修饰的参数
public interface HandlerMethodArgumentResolver {
    boolean supportsParameter(MethodParameter var1);
    @Nullable
    Object resolveArgument(MethodParameter var1, @Nullable ModelAndViewContainer var2, NativeWebRequest var3, @Nullable WebDataBinderFactory var4) throws Exception;
}

至此，我们看到了两个重要的接口HandlerMethodArgumentResolver 和HandlerMethodReturnValueHandler ；一个是对返回方法做处理，一个是对入参做处理；我们常见的在在ctrl方法里面会写(HttpServletRequest request, HttpServletResponse response)，就是通过这个来做的，看这个接口的实现有哪些，例如：PathVariableMethodArgumentResolver、RequestHeaderMethodArgumentResolver、RequestParamMethodArgumentResolver

image.png

image.png

对应的url类关系图如下：

image.png

• 往上面看完了，我们再往下看看，可以看到RequestResponseBodyMethodProcessor是继承于AbstractMessageConverterMethodProcessor，在此类里面实现了resolveArgument和handleReturnValue方法

  
  
  image.png

//看看这个return里面的内容，不用看代码，直接音译方法名：参数是否包含RequestBody.class的注解！这个是不是我们经常用的@RequestBody，是的，就是这个，上面给了这个类的位置，自己找到点进去看看，增加下记忆，看看这些类所在包路径的关系，在哪个jar包下
public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasParameterAnnotation(RequestBody.class);
 }
//和上面一样，判断类上面或者方法上面有没有@ResponseBody注解
public boolean supportsReturnType(MethodParameter returnType) {
        return AnnotatedElementUtils.hasAnnotation(returnType.getContainingClass(), ResponseBody.class) || returnType.hasMethodAnnotation(ResponseBody.class);
}
//resolve[rɪˈzɒlv] (决心;决定) 很明显这个方法是参数解析，意思就是我们提交的前端请求是在这儿提前解析处理的
 public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
        parameter = parameter.nestedIfOptional();
        //这个方法很重要，主要是对入参处理的核心实现，跟进去会到org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor #readWithMessageConverters，紧接着我们会看这个方法
        Object arg = this.readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());
        String name = Conventions.getVariableNameForParameter(parameter);
        if (binderFactory != null) {
            WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name);
            if (arg != null) {
                this.validateIfApplicable(binder, parameter);
                if (binder.getBindingResult().hasErrors() && this.isBindExceptionRequired(binder, parameter)) {
                    throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
                }
            }

            if (mavContainer != null) {
                mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
            }
        }

        return this.adaptArgumentIfNecessary(arg, parameter);
    }

org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor#readWithMessageConverters
protected <T> Object readWithMessageConverters(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {
        ...//省略无关代码
                if (message.hasBody()) {
                    //在read当前参数前，提供了一个钩子函数处理实现了RequestBodyAdvice接口的beforeBodyRead方法，这意味着:【`我们想在springMVC默认解析器读取当前请求参数之前，想改变请求参数值，就可以实现该接口，这个逻辑和ReponseBodyAdvice是一样的（这个接口我们之前自己实现了对列权限的处理）`】
                    //之前看过其他项目，要统一处理request中的参数都是写一个baseController，然后所有的CTRL都要继承这个base，这种耦合性太强了，万一要继承其他类就凉凉了，而且基于这种方法实现很优雅，后续不用的时候，只需要把这个接口实现干掉即可，下面业务开发的同事也不需要关注这个逻辑，对他们是无感知的，直接使用即可
                    HttpInputMessage msgToUse = this.getAdvice().beforeBodyRead(message, parameter, targetType, converterType);
                    //这个read是一个接口，我们常见的fasejson、jackson、gson等都实现了这个方法的，就是正儿八经的序列化方法，我没有乱说，你自己去看下这个接口的实现就知道
                    body = genericConverter != null ? genericConverter.read(targetType, contextClass, msgToUse) : converter.read(targetClass, msgToUse);
                    //这个就不说了，就是人家序列化封装好后，你还想改东西，就实现这个接口，这个也是本文开始某个提问的答案之一
                    body = this.getAdvice().afterBodyRead(body, msgToUse, parameter, targetType, converterType);
                } else {
                    body = this.getAdvice().handleEmptyBody((Object)null, message, parameter, targetType, converterType);
                }
            }
       ...

看到这儿总结下，避免车速过快晕车：RequestResponseBodyMethodProcessor这个处理器负责对参数解析和返回值处理，具体的逻辑在上面代码里面有分析，那这个处理器是什么时候被注册，什么时候生效呢，接下来要继续发车了

RequestMappingHandlerAdapter实现了InitializingBean接口，所以spring在它初始化阶段自动回调InitializingBean接口的afterPropertiesSet()方法，在这个方法中创建一些默认的参数解析器，其中就包含RequestResponseBodyMethodProcessor，我们主要看该类的afterPropertiesSet（）、getDefaultArgumentResolvers()方法，如图所示：

image.png

public void afterPropertiesSet() {
...
        this.initControllerAdviceCache();
        List handlers;
        if (this.argumentResolvers == null) {
            handlers = this.getDefaultArgumentResolvers();
            this.argumentResolvers = (new HandlerMethodArgumentResolverComposite()).addResolvers(handlers);
        }
...

//这儿注册默认的参数解析器
private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
        List<HandlerMethodArgumentResolver> resolvers = new ArrayList(30);
        resolvers.add(new RequestParamMethodArgumentResolver(this.getBeanFactory(), false));
        resolvers.add(new RequestParamMapMethodArgumentResolver());
        resolvers.add(new PathVariableMethodArgumentResolver());
        resolvers.add(new PathVariableMapMethodArgumentResolver());
        resolvers.add(new MatrixVariableMethodArgumentResolver());
        resolvers.add(new MatrixVariableMapMethodArgumentResolver());
        resolvers.add(new ServletModelAttributeMethodProcessor(false));
        //  这个就是我们分析的类
        resolvers.add(new RequestResponseBodyMethodProcessor(this.getMessageConverters(), this.requestResponseBodyAdvice));
        resolvers.add(new RequestPartMethodArgumentResolver(this.getMessageConverters(), this.requestResponseBodyAdvice));
        resolvers.add(new RequestHeaderMethodArgumentResolver(this.getBeanFactory()));
        resolvers.add(new RequestHeaderMapMethodArgumentResolver());
        resolvers.add(new ServletCookieValueMethodArgumentResolver(this.getBeanFactory()));
        resolvers.add(new ExpressionValueMethodArgumentResolver(this.getBeanFactory()));
        resolvers.add(new SessionAttributeMethodArgumentResolver());
        resolvers.add(new RequestAttributeMethodArgumentResolver());
        resolvers.add(new ServletRequestMethodArgumentResolver());
        resolvers.add(new ServletResponseMethodArgumentResolver());
        resolvers.add(new HttpEntityMethodProcessor(this.getMessageConverters(), this.requestResponseBodyAdvice));
        resolvers.add(new RedirectAttributesMethodArgumentResolver());
        resolvers.add(new ModelMethodProcessor());
        resolvers.add(new MapMethodProcessor());
        resolvers.add(new ErrorsMethodArgumentResolver());
        resolvers.add(new SessionStatusMethodArgumentResolver());
        resolvers.add(new UriComponentsBuilderMethodArgumentResolver());
        if (KotlinDetector.isKotlinPresent()) {
            resolvers.add(new ContinuationHandlerMethodArgumentResolver());
        }

        if (this.getCustomArgumentResolvers() != null) {
            resolvers.addAll(this.getCustomArgumentResolvers());
        }

        resolvers.add(new PrincipalMethodArgumentResolver());
        resolvers.add(new RequestParamMethodArgumentResolver(this.getBeanFactory(), true));
        resolvers.add(new ServletModelAttributeMethodProcessor(true));
        return resolvers;
    }
//注册返回结果的处理器
private List<HandlerMethodReturnValueHandler> getDefaultReturnValueHandlers() {
        List<HandlerMethodReturnValueHandler> handlers = new ArrayList(20);
        handlers.add(new ModelAndViewMethodReturnValueHandler());
        handlers.add(new ModelMethodProcessor());
        handlers.add(new ViewMethodReturnValueHandler());
        handlers.add(new ResponseBodyEmitterReturnValueHandler(this.getMessageConverters(), this.reactiveAdapterRegistry, this.taskExecutor, this.contentNegotiationManager));
        handlers.add(new StreamingResponseBodyReturnValueHandler());
        handlers.add(new HttpEntityMethodProcessor(this.getMessageConverters(), this.contentNegotiationManager, this.requestResponseBodyAdvice));
        handlers.add(new HttpHeadersReturnValueHandler());
        handlers.add(new CallableMethodReturnValueHandler());
        handlers.add(new DeferredResultMethodReturnValueHandler());
        handlers.add(new AsyncTaskMethodReturnValueHandler(this.beanFactory));
        handlers.add(new ServletModelAttributeMethodProcessor(false));
        //又见到了熟悉的身影
        handlers.add(new RequestResponseBodyMethodProcessor(this.getMessageConverters(), this.contentNegotiationManager, this.requestResponseBodyAdvice));
        handlers.add(new ViewNameMethodReturnValueHandler());
        handlers.add(new MapMethodProcessor());
        if (this.getCustomReturnValueHandlers() != null) {
            handlers.addAll(this.getCustomReturnValueHandlers());
        }

        if (!CollectionUtils.isEmpty(this.getModelAndViewResolvers())) {
            handlers.add(new ModelAndViewResolverMethodReturnValueHandler(this.getModelAndViewResolvers()));
        } else {
            handlers.add(new ServletModelAttributeMethodProcessor(true));
        }

        return handlers;
    }

至此，关于参数解析和返回的链路就分析完了，从这些接口和注册，用到了很多抽象类、接口的定义，各种模型设计，也用到了设计模式，我们往往看代码缺乏一个全局的认识，即分为哪些模块，各模块之间是怎么链接的，哪儿是配置、哪儿是初始化，哪儿是运行处理逻辑，主要是缺乏对关键节点的提炼能力