如何实现多次读取request里面的参数值

首先需要明确如下几个概念：

1：web开发的时候，过滤器属于java原生组件，而拦截器属于spring框架的组件，从它们的参数就可以看出来，过滤器参数为ServletRequest, 而拦截器为HttpServeletRequest，因为spring本来就是web开发针对的就是http协议，而java则是针对所有网络通信不单单是http协议。

2：需要了解一下ServletRequest  HttpServletRequest 之间的联系和区别

3：tomcat处理http请求的。Tomcat将请求转换成了RequestFacade传给过滤器，而RequestFacade实现了HttpServlestRequest接口。至于如何转换可以看（http://blog.csdn.net/aesop_wubo/article/details/7630440）

4：大部分IO输入流是无法重复读取的，只能读取一次。再读取时，会抛出IO异常。无论是get请求还是post请求，在后端读取一次之后，便无法再次读取为了解决这个问题，我们需要包装HttpServletRequest对象，缓存body里面的数据，再次读取的时候从缓存里面读取。

5: 我们可以定义自己的HttpServletRequest实现类来达到缓存的目的。

public class MAPIHttpServletRequestWrapper extends HttpServletRequestWrapper {
    private static final Logger logger = LoggerFactory.getLogger(MAPIHttpServletRequestWrapper.class);

    private Map<String, String[]> parameterMap; // get方法 
    private byte[] requestBody = null;          // post 方法body数据

    public MAPIHttpServletRequestWrapper(HttpServletRequest request) {
        super(request);
        //缓存请求body
        try {
            parameterMap = request.getParameterMap();
            requestBody = StreamUtils.copyToByteArray(request.getInputStream());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取所有参数名, get相关方法重写
     *
     * @return 返回所有参数名
     */
    @Override
    public Enumeration<String> getParameterNames() {
        Vector<String> vector = new Vector<>(parameterMap.keySet());
        return vector.elements();
    }

    /**
     * 获取指定参数名的值，如果有重复的参数名，则返回第一个的值 接收一般变量 ，如text类型
     *
     * @param name
     *            指定参数名
     * @return 指定参数名的值
     */
    @Override
    public String getParameter(String name) {
        String[] results = parameterMap.get(name);
        if (results == null || results.length <= 0)
            return null;
        else {
            System.out.println("modify before：" + results[0]);
            return modify(results[0]);
        }
    }

    /**
     * 获取指定参数名的所有值的数组，如：checkbox的所有数据
     * 接收数组变量 ，如checkobx类型
     */
    @Override
    public String[] getParameterValues(String name) {
        String[] results = parameterMap.get(name);
        if (results == null || results.length <= 0)
            return null;
        else {
            int length = results.length;
            for (int i = 0; i < length; i++) {
                results[i] = modify(results[i]);
                logger.info("modify before,{}:{}",name, results[i]);
            }
            return results;
        }
    }

    /**
     * 自定义的一个简单修改原参数的方法，即：给原来的参数值前面添加了一个修改标志的字符串
     *
     * @param string
     *            原参数值
     * @return 修改之后的值 ,这里并不进行改变
     */
    private String modify(String string) {
        return string;
    }


    /**
     * 重写 getReader()
     */
    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

    /**
     * 重写 getInputStream()
     */
    @Override
    public ServletInputStream getInputStream() throws IOException {
        logger.info("modify before post");
        if(requestBody == null){
            requestBody= new byte[0];
        }
        final ByteArrayInputStream bais = new ByteArrayInputStream(requestBody);
        MyServletInputStream myServletInputStream = new MyServletInputStream(bais);
        return myServletInputStream;
    }

    // 定义自己的ServletInputStream
    class MyServletInputStream extends ServletInputStream{
        private InputStream inputStream;

        public MyServletInputStream(InputStream inputStream){
            super();
            this.inputStream = inputStream;
        }

        @Override
        public boolean isFinished() {
            return false;
        }

        @Override
        public boolean isReady() {
            return false;
        }

        @Override
        public void setReadListener(ReadListener readListener) {
            return;
        }

        @Override
        public int read() throws IOException {
            return inputStream.read();
        }
    }
}

6：修改过滤器 dofilter方法

		if(request instanceof  HttpServletRequest && response instanceof HttpServletResponse){
			request = new MAPIHttpServletRequestWrapper((HttpServletRequest) request);
			response = new MAPIHttpServletResponseWrapper((HttpServletResponse)response);
		}

将tomcat传过来的httprequest实现类RequestFacade转换成我们自己写的类即可，这样就可以实现多次读取request里面的参数值。

总结：其实除了自己可以实现之外也可以使用spring官方提供的组件ContentCachingRequestWrapper，其原理和上面讲的是一样的，只是具体实现细节上有少许不同。

参考资料：

http://tomcat.apache.org/tomcat-7.0-doc/servletapi/javax/servlet/http/HttpServletRequestWrapper.html

http://mabusyao.iteye.com/blog/1048087

https://www.zhihu.com/question/39872707

https://www.jianshu.com/p/dee45d97a4fa

https://www.cnblogs.com/hun2014/articles/3850085.html

https://www.cnblogs.com/wihainan/p/6439892.html