HandlerMethodArgumentResolver(三)：基于消息转换器的参数处理器【享学Spring MVC】

每篇一句

一个事实是：对于大多数技术，了解只需要一天，简单搞起来只需要一周。入门可能只需要一个月

前言

通过 的介绍，相信你对handlermethodargumentresolver了解已经很深刻了。但是你或许和我一样还有一种感觉，似乎还缺点什么：
我们使用非常频繁的@requestbody是怎么封装请求体的呢？？？这块使用非常广泛的地方却还木有讲解到，因为它的处理方式和前面的不太一样，因此单摘出来到本文进行详细描述。

第四类：基于contenttype消息转换器类型

利用httpmessageconverter将输入流转换成对应的参数

这类参数解析器的基类是abstractmessageconvertermethodargumentresolver：

// @since 3.1
public abstract class abstractmessageconvertermethodargumentresolver implements handlermethodargumentresolver {

    // 默认支持的方法（没有deleted方法）
    // httpmethod为null 或者方法不属于这集中 或者没有contendtype且没有body 那就返回null
    // 也就是说如果是deleted请求，即使body里有值也是返回null的。（因为它不是supported_methods ）
    private static final set<httpmethod> supported_methods = enumset.of(httpmethod.post, httpmethod.put, httpmethod.patch);
    private static final object no_value = new object();

    protected final list<httpmessageconverter<?>> messageconverters;
    protected final list<mediatype> allsupportedmediatypes;
    // 和requestbodyadvice和responsebodyadvice有关的
    private final requestresponsebodyadvicechain advice;

    // 构造函数里指定httpmessageconverter
    // 此一个参数的构造函数木人调用
    public abstractmessageconvertermethodargumentresolver(list<httpmessageconverter<?>> converters) {
        this(converters, null);
    }

    // @since 4.2
    public abstractmessageconvertermethodargumentresolver(list<httpmessageconverter<?>> converters, @nullable list<object> requestresponsebodyadvice) {
        assert.notempty(converters, "'messageconverters' must not be empty");
        this.messageconverters = converters;
        // 它会把所有的消息转换器里支持的mediatype都全部拿出来汇聚起来~
        this.allsupportedmediatypes = getallsupportedmediatypes(converters);
        this.advice = new requestresponsebodyadvicechain(requestresponsebodyadvice);
    }

    // 提供一个defualt方法访问
    requestresponsebodyadvicechain getadvice() {
        return this.advice;
    }

    // 子类requestresponsebodymethodprocessor有复写此方法
    @nullable
    protected <t> object readwithmessageconverters(nativewebrequest webrequest, methodparameter parameter, type paramtype) throws ioexception, httpmediatypenotsupportedexception, httpmessagenotreadableexception {

        httpinputmessage inputmessage = createinputmessage(webrequest);
        return readwithmessageconverters(inputmessage, parameter, paramtype);
    }
    ...
}

说明：此抽象类并没有实现resolveargument()这个接口方法，而只是提供了一些protected方法，作为工具方法给子类调用，比如最为重要的这个方法：readwithmessageconverters()就是利用消息转换器解析httpinputmessage的核心。

关于此抽象类的描述，可以看 这里，httpmessageconverter匹配规则

它的继承树如下：

requestpartmethodargumentresolver

它用于解析参数被@requestpart修饰，或者参数类型是multipartfile | servlet 3.0提供的javax.servlet.http.part类型（并且没有被@requestparam修饰），数据通过 httpservletrequest获取

当属性被标注为@requestpart的话，那就会经过httpmessageconverter结合content-type来解析，这个效果特别像@requestbody的处理方式~

// @since 3.1
@target(elementtype.parameter)
@retention(retentionpolicy.runtime)
@documented
public @interface requestpart {
    @aliasfor("name")
    string value() default "";
    @aliasfor("value")
    string name() default "";
    boolean required() default true;
}

// @since 3.1
public class requestpartmethodargumentresolver extends abstractmessageconvertermethodargumentresolver {

    // 标注了@requestpart注解的
    // 没有标注@requestpart并且也没有标注@requestparam，但是是multipart类型的也会处理
    @override
    public boolean supportsparameter(methodparameter parameter) {
        if (parameter.hasparameterannotation(requestpart.class)) {
            return true;
        } else {
            if (parameter.hasparameterannotation(requestparam.class)) {
                return false;
            }
            return multipartresolutiondelegate.ismultipartargument(parameter.nestedifoptional());
        }
    }

    @override
    @nullable
    public object resolveargument(methodparameter parameter, @nullable modelandviewcontainer mavcontainer,
            nativewebrequest request, @nullable webdatabinderfactory binderfactory) throws exception {

        httpservletrequest servletrequest = request.getnativerequest(httpservletrequest.class);
        assert.state(servletrequest != null, "no httpservletrequest");

        requestpart requestpart = parameter.getparameterannotation(requestpart.class);
        boolean isrequired = ((requestpart == null || requestpart.required()) && !parameter.isoptional());

        // 如果注解没有指定，就取形参名
        string name = getpartname(parameter, requestpart);
        parameter = parameter.nestedifoptional();
        object arg = null;

        // resolvemultipartargument这个方法只处理：
        // multipartfile类型以及对应的数组/集合类型
        // part类型以及对应的数组集合类型
        // 若形参类型不是以上类型，返回unresolvable（空对象）

        // 最终返回standardmultiparthttpservletrequest/request.getparts()[0]等~
        object mparg = multipartresolutiondelegate.resolvemultipartargument(name, parameter, servletrequest);
        if (mparg != multipartresolutiondelegate.unresolvable) {
            arg = mparg; // 是part类型，那就直接赋值吧
        } else { // 其它类型
            ...
        }
        ...
    }
}

此处理器用于解析@requestpart参数类型，它和多部分文件上传有关。关于spring mvc中的文件上传，此处就不便展开了。后面有个专题专门讲解spring mvc中的上传、下载~

---

abstractmessageconvertermethodprocessor（重点）

命名为processor说明它既能处理入参，也能处理返回值，当然本文的关注点是方法入参（和httpmessageconverter相关）。

请求body体一般是一段字符串/字节流，查询参数可以看做url的一部分，这两个是位于请求报文的不同地方。

表单参数可以按照一定格式放在请求体中，也可以放在url上作为查询参数。

响应body体则是response返回的具体内容，对于一个普通的html页面，body里面就是页面的源代码。对于httpmessage响应体里可能就是个json串（但无强制要求）。

响应体一般都会结合content-type一起使用，告诉客户端只有知道这个头了才知道如何渲染。

abstractmessageconvertermethodprocessor源码稍显复杂，它和http协议、内容协商有很大的关联：

// @since 3.1
public abstract class abstractmessageconvertermethodprocessor extends abstractmessageconvertermethodargumentresolver implements handlermethodreturnvaluehandler {

    // 默认情况下：文件们后缀是这些就不弹窗下载
    private static final set<string> whitelisted_extensions = new hashset<>(arrays.aslist("txt", "text", "yml", "properties", "csv",
            "json", "xml", "atom", "rss", "png", "jpe", "jpeg", "jpg", "gif", "wbmp", "bmp"));
    private static final set<string> whitelisted_media_base_types = new hashset<>(arrays.aslist("audio", "image", "video"));
    private static final list<mediatype> all_application_media_types = arrays.aslist(mediatype.all, new mediatype("application"));
    private static final type resource_region_list_type = new parameterizedtypereference<list<resourceregion>>() { }.gettype();
    
    // 用于给url解码 decodingurlpathhelper.decoderequeststring(servletrequest, filename);
    private static final urlpathhelper decodingurlpathhelper = new urlpathhelper();
    // rawurlpathhelper.getoriginatingrequesturi(servletrequest);
    private static final urlpathhelper rawurlpathhelper = new urlpathhelper();
    static {
        rawurlpathhelper.setremovesemicoloncontent(false);
        rawurlpathhelper.seturldecode(false);
    }

    // 内容协商管理器
    private final contentnegotiationmanager contentnegotiationmanager;
    // 扩展名的内容协商策略
    private final pathextensioncontentnegotiationstrategy pathstrategy;
    private final set<string> safeextensions = new hashset<>();

    protected abstractmessageconvertermethodprocessor(list<httpmessageconverter<?>> converters) {
        this(converters, null, null);
    }
    // 可以指定内容协商管理器contentnegotiationmanager 
    protected abstractmessageconvertermethodprocessor(list<httpmessageconverter<?>> converters, @nullable contentnegotiationmanager contentnegotiationmanager) {
        this(converters, contentnegotiationmanager, null);
    }
    // 这个构造器才是重点
    protected abstractmessageconvertermethodprocessor(list<httpmessageconverter<?>> converters, @nullable contentnegotiationmanager manager, @nullable list<object> requestresponsebodyadvice) {
        super(converters, requestresponsebodyadvice);

        // 可以看到：默认情况下会直接new一个
        this.contentnegotiationmanager = (manager != null ? manager : new contentnegotiationmanager());
        // 若管理器里有就用管理器里的，否则new pathextensioncontentnegotiationstrategy()
        this.pathstrategy = initpathstrategy(this.contentnegotiationmanager);

        // 用safeextensions装上内容协商所支持的所有后缀
        // 并且把后缀白名单也加上去（表示是默认支持的后缀）
        this.safeextensions.addall(this.contentnegotiationmanager.getallfileextensions());
        this.safeextensions.addall(whitelisted_extensions);
    }

    // servletserverhttpresponse是对httpservletresponse的包装，主要是对响应头进行处理
    // 主要是处理：setcontenttype、setcharacterencoding等等
    // 所以子类若要写数据，就调用此方法来向输出流里写吧~~~
    protected servletserverhttpresponse createoutputmessage(nativewebrequest webrequest) {
        httpservletresponse response = webrequest.getnativeresponse(httpservletresponse.class);
        assert.state(response != null, "no httpservletresponse");
        return new servletserverhttpresponse(response);
    }

    // 注意：createinputmessage()方法是父类提供的，对httpservletrequest的包装
    // 主要处理了：geturi()、getheaders()等方法
    // getheaders()方法主要是处理了：getcontenttype()...


    protected <t> void writewithmessageconverters(t value, methodparameter returntype, nativewebrequest webrequest) throws ioexception, httpmediatypenotacceptableexception, httpmessagenotwritableexception {
        servletserverhttprequest inputmessage = createinputmessage(webrequest);
        servletserverhttpresponse outputmessage = createoutputmessage(webrequest);
        writewithmessageconverters(value, returntype, inputmessage, outputmessage);
    }

    // 这个方法省略
    // 这个方法是消息处理的核心之核心：处理了contenttype、消息转换、内容协商、下载等等
    // 注意：此处并且还会执行requestresponsebodyadvicechain，进行前后拦截
    protected <t> void writewithmessageconverters(@nullable t value, methodparameter returntype,
            servletserverhttprequest inputmessage, servletserverhttpresponse outputmessage)
            throws ioexception, httpmediatypenotacceptableexception, httpmessagenotwritableexception { ... }
}

本类的核心是各式各样的httpmessageconverter消息转换器，因为最终的write都是交给它们去完成。
此抽象类里，它完成了内容协商~

关于内容协商的详解，强烈建议你点击 。另外 也深入的分析了abstractmessageconvertermethodprocessor这个类，可以作为参考。

既然父类都已经完成了这么多事，那么子类自然就非常的简单的。看看它的两个具体实现子类：

requestresponsebodymethodprocessor

顾名思义，它负责处理@requestbody这个注解的参数

public class requestresponsebodymethodprocessor extends abstractmessageconvertermethodprocessor {
    @override
    public boolean supportsparameter(methodparameter parameter) {
        return parameter.hasparameterannotation(requestbody.class);
    }

    @override
    public object resolveargument(methodparameter parameter, @nullable modelandviewcontainer mavcontainer, nativewebrequest webrequest, @nullable webdatabinderfactory binderfactory) throws exception {

        parameter = parameter.nestedifoptional();
        // 所以核心逻辑：读取流、消息换换等都在父类里已经完成。子类直接调用就可以拿到转换后的值arg 
        // arg 一般都是个类对象。比如person实例
        object arg = readwithmessageconverters(webrequest, parameter, parameter.getnestedgenericparametertype());
        // 若是pojo，就是类名首字母小写（并不是形参名）
        string name = conventions.getvariablenameforparameter(parameter);

        // 进行数据校验（之前已经详细分析过，此处一笔带过）
        if (binderfactory != null) {
            webdatabinder binder = binderfactory.createbinder(webrequest, arg, name);
            if (arg != null) {
                validateifapplicable(binder, parameter);
                if (binder.getbindingresult().haserrors() && isbindexceptionrequired(binder, parameter)) {
                    throw new methodargumentnotvalidexception(parameter, binder.getbindingresult());
                }
            }

            // 把校验结果放进model里，方便页面里获取
            if (mavcontainer != null) {
                mavcontainer.addattribute(bindingresult.model_key_prefix + name, binder.getbindingresult());
            }
        }

        // 适配：支持到optional类型的参数
        return adaptargumentifnecessary(arg, parameter);
    }
}

httpentitymethodprocessor

用于处理httpentity和requestentity类型的入参的。

public class httpentitymethodprocessor extends abstractmessageconvertermethodprocessor {
    @override
    public boolean supportsparameter(methodparameter parameter) {
        return (httpentity.class == parameter.getparametertype() || requestentity.class == parameter.getparametertype());
    }

    @override
    @nullable
    public object resolveargument(methodparameter parameter, @nullable modelandviewcontainer mavcontainer,
            nativewebrequest webrequest, @nullable webdatabinderfactory binderfactory) throws ioexception, httpmediatypenotsupportedexception {

        servletserverhttprequest inputmessage = createinputmessage(webrequest);
        // 拿到httpentity的泛型类型
        type paramtype = gethttpentitytype(parameter);
        if (paramtype == null) {
            // 注意：这个泛型类型是必须指定的，必须的
            throw new illegalargumentexception("httpentity parameter '" + parameter.getparametername() + "' in method " + parameter.getmethod() + " is not parameterized");
        }

        // 调用父类方法拿到body的值(把泛型类型传进去了，所以返回的是个实例)
        object body = readwithmessageconverters(webrequest, parameter, paramtype);
        // 注意步操作：new了一个requestentity进去，持有实例即可
        if (requestentity.class == parameter.getparametertype()) {
            return new requestentity<>(body, inputmessage.getheaders(), inputmessage.getmethod(), inputmessage.geturi());
        } else { // 用的父类httpentity，那就会丢失掉method等信息（因此建议入参用requestentity类型，更加强大些）
            return new httpentity<>(body, inputmessage.getheaders());
        }
    }
}

注意：这里可没有validate校验了，这也是经常被面试问到的：使用httpentity和@requestbody有什么区别呢？

从代码里可以直观的看到：有了抽象父类后，子类需要做的事情已经很少了，只需要匹配参数类型、做不同的返回而已。
关于它俩的使用案例，此处不用再展示了，因为各位平时工作中都在使用，再熟悉不过了。但针对他俩的使用，我总结出如下几个小细节，供以参考：

1. @requestbody/httpentity它的参数（泛型）类型允许是map
2. 方法上的和类上的@responsebody都可以被继承，但@requestbody不可以

3. @requestbody它自带有bean validation校验能力（当然需要启用），httpentity更加的轻量和方便

   httpentity/requestentity所在包是：org.springframework.http，属于spring-web
   @requestbody位于org.springframework.web.bind.annotation，同样属于spring-web

最后还落了一个errorsmethodargumentresolver，在这里补充一下：

errorsmethodargumentresolver

它用于在方法参数可以写errors类型，来拿到数据校验结果。

public class errorsmethodargumentresolver implements handlermethodargumentresolver {
    @override
    public boolean supportsparameter(methodparameter parameter) {
        class<?> paramtype = parameter.getparametertype();
        return errors.class.isassignablefrom(paramtype);
    }

    @override
    @nullable
    public object resolveargument(methodparameter parameter,
            @nullable modelandviewcontainer mavcontainer, nativewebrequest webrequest,
            @nullable webdatabinderfactory binderfactory) throws exception {

        assert.state(mavcontainer != null,
                "errors/bindingresult argument only supported on regular handler methods");

        modelmap model = mavcontainer.getmodel();
        string lastkey = collectionutils.lastelement(model.keyset());
        
        // 只有@requestbody/@requestpart注解的  这里面才会有值
        if (lastkey != null && lastkey.startswith(bindingresult.model_key_prefix)) {
            return model.get(lastkey);
        }

        // 简单的说：必须有@requestbody/@requestpart这注解标注，errors参数才有意义
        throw new illegalstateexception(
                "an errors/bindingresult argument is expected to be declared immediately after " +
                "the model attribute, the @requestbody or the @requestpart arguments " +
                "to which they apply: " + parameter.getmethod());
    }
}

---

spring mvc参数处理器的注册与顺序

到这里，一个不落的把spring mvc内置提供的参数处理器argumentresolver说了个遍。
前面我有提到过：参数处理对处理器的顺序是敏感的，因此我们需要关注spring mvc最终的执行顺序，这时候我们的聚合容器handlermethodargumentresolvercomposite就出场了：

public class handlermethodargumentresolvercomposite implements handlermethodargumentresolver {

    private final list<handlermethodargumentresolver> argumentresolvers = new linkedlist<>();
    // 具有缓存
    private final map<methodparameter, handlermethodargumentresolver> argumentresolvercache = new concurrenthashmap<>(256); 
    ...
    // @since 4.3  木有任何地方调用
    public void clear() {
        this.argumentresolvers.clear();
    }

    // getargumentresolver()方法是本文的核心
    @override
    public boolean supportsparameter(methodparameter parameter) {
        return getargumentresolver(parameter) != null;
    }
    @override
    @nullable
    public object resolveargument(methodparameter parameter, @nullable modelandviewcontainer mavcontainer, nativewebrequest webrequest, @nullable webdatabinderfactory binderfactory) throws exception {
        
        // 这里是关键：每个参数最多只会被一个处理器处理
        handlermethodargumentresolver resolver = getargumentresolver(parameter);
        if (resolver == null) {
            throw new illegalargumentexception("unsupported parameter type [" + parameter.getparametertype().getname() + "]." + " supportsparameter should be called first.");
        }
        return resolver.resolveargument(parameter, mavcontainer, webrequest, binderfactory);
    }
    
    ... 

    // 这块逻辑保证了每个parameter参数最多只会被一个处理器处理
    // 这个从缓存的数据结构中也能够看出来的
    @nullable
    private handlermethodargumentresolver getargumentresolver(methodparameter parameter) {
        handlermethodargumentresolver result = this.argumentresolvercache.get(parameter);
        if (result == null) {
            for (handlermethodargumentresolver methodargumentresolver : this.argumentresolvers) {
                if (methodargumentresolver.supportsparameter(parameter)) {
                    result = methodargumentresolver;
                    this.argumentresolvercache.put(parameter, result);
                    break;
                }
            }
        }
        return result;
    }
}

缺省情况spring mvc注册的处理器（顺序）如下：

它初始化处的代码如下：

requestmappinghandleradapter：
    @override
    public void afterpropertiesset() {
        ...
        // 26个，详见方法getdefaultargumentresolvers
        if (this.argumentresolvers == null) {
            list<handlermethodargumentresolver> resolvers = getdefaultargumentresolvers();
            this.argumentresolvers = new handlermethodargumentresolvercomposite().addresolvers(resolvers);
        }
        // 12个  详见方法getdefaultinitbinderargumentresolvers
        if (this.initbinderargumentresolvers == null) {
            list<handlermethodargumentresolver> resolvers = getdefaultinitbinderargumentresolvers();
            this.initbinderargumentresolvers = new handlermethodargumentresolvercomposite().addresolvers(resolvers);
        }
        ...
    }

注意：这里面initbinderargumentresolvers最终只会有12个处理器，因为它的注册方法如下截图（也是这个顺序）：

前面有提到过说标注有@initbinder注解里也可以写很多类型的参数，但因为它只会有12个处理器，所以有些参数它是不能写的（比如@requestbody、errors等等这种都是不能写的），不用一一枚举，做到心中有数就成。

总结

本文介绍的处理内容，其实还是比较重要的，因为它和消息转换器httpmessageconverter有关，毕竟它是我们目前主流的使用方式，希望可以帮助到大家理解。
这里可以提前预告一下：下篇文章将非常重要，因为我将结合实际场景，演示一个我们通过自定义handlermethodargumentresolver实现的特殊场景的解决方案，非常的优雅和值得推广，有兴趣者可持续关注

相关阅读

contentnegotiation内容协商机制(一)---spring mvc内置支持的4种内容协商方式【享学spring mvc】

handlermethodargumentresolver(一)：controller方法入参自动封装器（将参数parameter解析为值）【享学spring mvc】
handlermethodargumentresolver(二)：map参数类型和固定参数类型【享学spring mvc】
handlermethodargumentresolver(三)：基于httpmessageconverter消息转换器的参数处理器【享学spring mvc】

知识交流

==the last：如果觉得本文对你有帮助，不妨点个赞呗。当然分享到你的朋友圈让更多小伙伴看到也是被作者本人许可的~==

若对技术内容感兴趣可以加入wx群交流：java高工、架构师3群。
若群二维码失效，请加wx号：fsx641385712（或者扫描下方wx二维码）。并且备注："java入群" 字样，会手动邀请入群
==若对spring、springboot、mybatis等源码分析感兴趣，可加我wx：fsx641385712，手动邀请你入群一起飞==