解决Spring/SpringBoot @RequestParam注解无法读取application/json格式数据问题_Java

emmmm…最近在做项目的途中，有遇到一个方法需要接收的参数只有一个或者较少的时候就懒得写实体类去接收，使用spring框架都知道，接收单个参数就使用@requestparam注解就好了，但是前端对应的content-type是需要改成application/x-www-form-urlencoded，所以在接口文档上面特地标记了。

但是…不知道前端是格式改了但是参数还是用的json格式没有改成键值对的方式传递还是什么原因，就一直说参数传不过来，叫我改回json格式的。。

我也实在是懒，另外一个也觉得没必要，就一两个参数就新建一个实体，太浪费，但是这个问题让我觉得不灵活蛮久了，也一直没找到办法，所以借这个机会，打开了我的开发神器，www.baidu.com…输入我的问题，找了好久也没找到有解决的方案，然后就想着看下spring内部是怎么处理的吧，就稍微跟了下源码，下面就说下我解决的方案。

一、requestmappinghandleradapter

requestmappinghandleradapter实现了handleradapter接口，顾名思义，表示handler的adapter，这里的handler指的是spring处理具体请求的某个controller的方法，也就是说handleradapter指的是将当前请求适配到某个handler的处理器。

requestmappinghandleradapter是handleradapter的一个具体实现，主要用于将某个请求适配给@requestmapping类型的handler处理，这里面就包含着请求数据和响应数据的处理。

		// 这里可以获取到处理程序方法参数解析器的一个列表
        list<handlermethodargumentresolver> argumentresolvers =
                requestmappinghandleradapter.getargumentresolvers()

如果是想处理响应参数的话就使用

        //这里可以获取到处理程序方法返回值的处理器
        list<handlermethodreturnvaluehandler> originalhandlers = 
                 requestmappinghandleradapter.getreturnvaluehandlers();

能获取到这个列表了，那需要加入我们自己定义的处理器应该不太麻烦了吧？（这里不讲返回数据的自定义策略处理，网上也有其他文章，如果需要可以找下）

二、handlermethodargumentresolver

策略接口解决方法参数代入参数值在给定请求的上下文（翻译的源码注释）

简单的理解为：它负责处理你handler方法里的所有入参：包括自动封装、自动赋值、校验等等。

那么这个时候我已经知道了第一步获取到的那个列表中存放的类型是什么了，简而言之，我们只需要实现这个策略类，编写我们自己的算法或逻辑就行了

这个接口里面有两个方法需要实现：

第一个方法的作用：是否与给定方法的参数是由该解析器的支持。（如果返回true，那么就使用该类进行参数转换，如果返回false，那么继续找下一个策略类）

第二个方法的作用：解决方法参数成从给定请求的自变量值。由webdatabinderfactory提供了一个方法来创建一个webdatabinder所需数据绑定和类型转换目的时实例。（简单来讲，就是转换参数值的，返回的就是解析的参数值）

三、requestparammethodargumentresolver

这个类就是用来处理controller的方法上有加@requestparam注解的具体处理器。

首先会调用这个方法来确定是否使用这个处理器解析参数，那么我们也看到了，如果参数有requestparam注解，那么则会使用该类进行处理，那么我们能不能效仿呢？

四、myhandlermethodargumentresolver

这个没啥好说，就自己定义的参数解析器。

直接上代码吧

/**
 * @belongsproject: 
 * @belongspackage: 
 * @author: hef
 * @createtime: 2020-06-20 18:49
 * @description: 描述
 */
public class myhandlermethodargumentresolver implements handlermethodargumentresolver {


    /**
     * 这个是处理@requestparam注解的原本策略类
     */
    private requestparammethodargumentresolver requestparammethodargumentresolver;

    /**
     * 全参构造
     */
    public myhandlermethodargumentresolver(requestparammethodargumentresolver requestparammethodargumentresolver) {
        this.requestparammethodargumentresolver = requestparammethodargumentresolver;
    }

    /**
     * 当参数前有@requestparam注解时，会使用此 解析器
     * <p>
     * 注:此方法的返回值将决定:是否使用此解析器解析该参数
     */
    @override
    public boolean supportsparameter(methodparameter methodparameter) {
    	//很明显,就是判断是否有这个注解
        return methodparameter.hasparameterannotation(requestparam.class);
    }


    /**
     * 解析参数
     */
    @override
    public object resolveargument(methodparameter methodparameter, modelandviewcontainer modelandviewcontainer,
                                  nativewebrequest nativewebrequest, webdatabinderfactory webdatabinderfactory)
            throws exception {
        final string applicationjson = "application/json";
        httpservletrequest request = nativewebrequest.getnativerequest(httpservletrequest.class);
        if (request == null) {
            throw new runtimeexception(" request must not be null!");
        }
        //获取到内容类型
        string contenttype = request.getcontenttype();
        //如果类型是属于json 那么则跑自己解析的方法
        if (null != contenttype && contenttype.contains(applicationjson )) {
        	//获取参数名称
            string parametername = methodparameter.getparametername();
            //获取参数类型
            class<?> parametertype = methodparameter.getparametertype();
			//因为json数据是放在流里面,所以要去读取流,
			//但是servletrequest的getreader()和getinputstream()两个方法只能被调用一次，而且不能两个都调用。
			//所以这里是需要写个自定义的httpservletrequestwrapper,主要功能就是需要重复读取流数据
            string read = getread(request.getreader());
            //转换json
            jsonobject jsonobject = json.parseobject(read);
            object o1;
            if (jsonobject == null) {
            	//这里有一个可能性就是比如get请求,参数是拼接在url后面,但是如果我们还是去读流里面的数据就会读取不到
                map<string, string[]> parametermap = request.getparametermap();
                o1 = parametermap.get(parametername);
            }else {
                o1 = jsonobject.get(parametername);
            }
            object arg = null;
            //如果已经获取到了值的话那么再做类型转换
            if (o1 != null) {
                webdatabinder binder = webdatabinderfactory.createbinder(nativewebrequest, null, parametername);
                arg = binder.convertifnecessary(o1, parametertype, methodparameter);
            }
            return arg;
        }
		//否则跑原本的策略类.
        object o = requestparammethodargumentresolver.resolveargument(methodparameter,
                modelandviewcontainer, nativewebrequest, webdatabinderfactory);
        return o;
    }

    /**
     * 流转字符串
     *
     * @param bf
     * @return
     */
    private static string getread(bufferedreader bf) {
        stringbuilder sb = new stringbuilder();
        try {
            char[] buff = new char[1024];
            int len;
            while ((len = bf.read(buff)) != -1) {
                sb.append(buff, 0, len);
            }
        } catch (ioexception e) {
            e.printstacktrace();
        }
        return sb.tostring();
    }
}

四、configargumentresolvers

自己的策略类已经写好了，那么怎么加入到配置中去呢？

/**
 * @belongsproject: 
 * @belongspackage: 
 * @author: hef
 * @createtime: 2020-06-20 18:49
 * @description: 描述
 */
@configuration
public class configargumentresolvers {
    private final requestmappinghandleradapter requestmappinghandleradapter;

    public configargumentresolvers(requestmappinghandleradapter requestmappinghandleradapter) {
        this.requestmappinghandleradapter = requestmappinghandleradapter;
    }

	//springboot启动的时候执行
    @postconstruct
    private void addargumentresolvers() {
        // 获取到框架定义好的参数解析集合
        list<handlermethodargumentresolver> argumentresolvers =
                requestmappinghandleradapter.getargumentresolvers();
        myhandlermethodargumentresolver myhandlermethodargumentresolver = getmyhandlermethodargumentresolver(argumentresolvers);
        // ha.getargumentresolvers()获取到的是不可变的集合,所以我们需要新建一个集合来放置参数解析器
        list<handlermethodargumentresolver> myargumentresolvers =
                new arraylist<>(argumentresolvers.size() + 1);
        //这里有一个注意点就是自定义的处理器需要放在requestparammethodargumentresolver前面
        //为什么呢?因为如果放在它后面的话,那么它已经处理掉了,就到不了我们自己定义的策略里面去了
        //所以直接把自定义的策略放在第一个,稳妥!
        // 将自定义的解析器，放置在第一个； 并保留原来的解析器
        myargumentresolvers.add(myhandlermethodargumentresolver);
        myargumentresolvers.addall(argumentresolvers);
        //再把新的集合设置进去
        requestmappinghandleradapter.setargumentresolvers(myargumentresolvers);
    }

    /**
     * 获取myhandlermethodargumentresolver实例
     */
    private myhandlermethodargumentresolver getmyhandlermethodargumentresolver(
            list<handlermethodargumentresolver> argumentresolverslist) {
        // 原本处理requestparam的类
        requestparammethodargumentresolver requestparammethodargumentresolver = null;

        if (argumentresolverslist == null) {
            throw new runtimeexception("argumentresolverlist must not be null!");
        }
        for (handlermethodargumentresolver argumentresolver : argumentresolverslist) {
            if (requestparammethodargumentresolver != null) {
                break;
            }
            if (argumentresolver instanceof requestparammethodargumentresolver) {
            // 因为在我们自己策略里面是还需要用到这个原本的类的,所以需要得到这个对象实例
                requestparammethodargumentresolver = (requestparammethodargumentresolver) argumentresolver;
            }
        }
        if (requestparammethodargumentresolver == null) {
            throw new runtimeexception("requestparammethodargumentresolver not be null!");
        }
        //实例化自定义参数解析器
        return new myhandlermethodargumentresolver(requestparammethodargumentresolver);
    }
}

五、myhttpservletrequestwrapper

这个就是自定义的httpservletrequest，保证可以重复获取到流数据

/**
 * @belongsproject: 
 * @belongspackage: 
 * @author: hef
 * @createtime: 2020-06-22 16:29
 * @description: 描述
 */
public class myhttpservletrequestwrapper extends httpservletrequestwrapper {
    private final byte[] body;

    public myhttpservletrequestwrapper(httpservletrequest request) throws ioexception {
        super(request);
        //在读取流之前获取一次这个parametermap,否则读取流后无法再解析出数据,
        // 原因是org.apache.catalina.connector.request里面有usinginputstream 和 usingreader两个全局变量记录流是否被读取过
        //org.apache.catalina.connector.request里面的parseparameters方法就是用来解析请求参数(parse request parameters.)
        //在解析参数之前会有一个判断,如果流被读取过 则不再解析请求参数 //
        // if (usinginputstream || usingreader) { 这是源码里面的判断
        //                success = true;
        //                return;
        //            }
        //如果先请求过一次后,那么org.apache.catalina.util.parametermap里面会有一个locked状态,如果读过一次之后 会变成锁定状态 那么后面再读都是读取解析过后的map
        //    /**
        //     * the current lock state of this parameter map.
        //     */
        //    private boolean locked = false;
        request.getparametermap();
        body = readaschars(request).getbytes(charset.forname("utf-8"));
    }

    @override
    public bufferedreader getreader() throws ioexception {
        return new bufferedreader(new inputstreamreader(getinputstream()));
    }

    @override
    public servletinputstream getinputstream() throws ioexception {

        final bytearrayinputstream bais = new bytearrayinputstream(body);

        return new servletinputstream() {

            @override
            public int read() throws ioexception {
                return bais.read();
            }

            @override
            public boolean isfinished() {
                return false;
            }

            @override
            public boolean isready() {
                return false;
            }

            @override
            public void setreadlistener(readlistener readlistener) {

            }
        };
    }

	/**
     * 解析流
     * @param request
     * @return
     */
	public static string readaschars(servletrequest request)
        {
            inputstream is = null;
            stringbuilder sb = new stringbuilder();
            try
            {
                is = request.getinputstream();

                byte[] b = new byte[4096];
                for (int n; (n = is.read(b)) != -1;)
                {
                    sb.append(new string(b, 0, n));
                }
            }
            catch (ioexception e)
            {
                e.printstacktrace();
            }
            finally
            {
                if (null != is)
                {
                    try
                    {
                        is.close();
                    }
                    catch (ioexception e)
                    {
                        e.printstacktrace();
                    }
                }
            }
            return sb.tostring();
        }
}

六、httpservletrequestreplacedfilter

替换掉原本的request对象，使用自定义的

/**
 * @belongsproject: 
 * @belongspackage: 
 * @author: hef
 * @createtime: 2020-06-22 16:47
 * @description: 描述
 */
@component
public class httpservletrequestreplacedfilter implements filter {
    @override
    public void dofilter(servletrequest request, servletresponse response, filterchain chain) throws ioexception, servletexception {
        servletrequest requestwrapper = null;
        if(request instanceof httpservletrequest) {
            requestwrapper = new myhttpservletrequestwrapper((httpservletrequest) request);
        }
        if(null == requestwrapper) {
            chain.dofilter(request, response);
        } else {
            chain.dofilter(requestwrapper, response);
        }
    }
}

七、总结

如果是想@requestbody接收表单形式的参数也可以用此方法，处理起来更简单，只需要实例化自定义处理器的时候传入另外两个个处理器就可以了

    /**
     * 解析content-type为application/json的默认解析器是requestresponsebodymethodprocessor
     */
    private requestresponsebodymethodprocessor requestresponsebodymethodprocessor;

    /**
     * 解析content-type为application/x-www-form-urlencoded的默认解析器是servletmodelattributemethodprocessor
     */
    private servletmodelattributemethodprocessor servletmodelattributemethodprocessor;

到这一步就已经实现了requestparam注解也可以接受json格式数据了，我也没进行更多的测试，具体还会出现什么关联性的问题暂时是没发现。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持代码网。