投稿
  1. 极客之音首页
  2. 其他分类
  3. 微信精选

Request重复读取流

小半 • • 微信精选 • 阅读 339

背景

项目中需要记录用户的请求参数便于后面查找问题，对于这种需求一般可以通过Spring中的拦截器或者是使Servlet中的过滤器来实现。这里我选择使用过滤器来实现，就是添加一个过滤器，然后在过滤器中获取到Request对象，将Reques中的信息记录到日志中。

实现过程

使用过滤器很快我实现了统一记录请求参数的的功能，整个代码实现如下：

@Slf4j
@Component
public class LogFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        Map<String, String[]> parameterMap = request.getParameterMap();
        log.info("请求参数:{}", JSON.toJSONString(parameterMap));
        filterChain.doFilter(request,response);
    }
}

当你以为你已经解决问题的时候往往问题都还没有解决，上面的实现方式对于GET请求没有问题，可以很好的记录前端提交过来的参数。对于POST请求就没那么简单了。根据POST请求中Content-Type类型我们常用的有下面几种：

  • application/x-www-form-urlencoded：这种方式是最常见的方式，浏览器原生的form表单就是这种方式提交。
  • application/json：这种方式也算是一种常见的方式，当我们在提交一个复杂的对象时往往采用这种方式。
  • multipart/form-data：这种方式通常在使用表单上传文件时会用。

上面三种常见的POST方式我实现的过滤器有一种是无法记录到的，当Content-Type为application/json时，通过调用Request对象中getParameter*相关方法是无法获取到请求参数的。

application/json解决方案及问题

想要该形式的请求参数能被打印，我们可以通过读取Request中流的方式来获取请求JSON请求参数，现在修改代码如下：

@Slf4j
@Component
public class LogFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        Map<String, String[]> parameterMap = request.getParameterMap();
        log.info("请求参数:{}",JSON.toJSONString(parameterMap));
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        IOUtils.copy(request.getInputStream(),out);
        log.info("请求体:{}", out.toString(request.getCharacterEncoding()));
        filterChain.doFilter(request,response);
    }
}

上面的代码中我通过获取Request中的流来获取到请求提交到服务器中的JSON数据，最后在日志中能打印出客户端提交过来的JSON数据。但是最后接口的返回并没有成功，而且在Controller中也无法获取到请求参数，最后程序给出的错误提示关键信息为：Required request body is missing

之所以会出现异常是因为Request中的流只能读取一次，我们在过滤器中读取之后如果后面有再次读取流的操作就会导致服务异常，简单的说就是Request中获取的流不支持重复读取。

HttpServletRequestWrapper

通过上面的分析我们知道了问题所在，对于Request中流无法重复读取的问题，我们要想办法让其支持重复读取。难道我们要自己去实现一个Request，且我们的Request中的流还支持重复读取，想想就知道这样做很麻烦了。幸运的是Servlet中提供了一个HttpServletRequestWrapper类，这个类从名字就能看出它是一个Wrapper类，就是我们可以通过它将原先获取流的方法包装一下，让它支持重复读取即可。下面是我自己实现的一个可重复读取流的HttpServletRequestWrapper实现。

public class RepeatReadRequest extends HttpServletRequestWrapper {
    private ByteArrayOutputStream out;
    public RepeatReadRequest(HttpServletRequest request) {
        super(request);
    }
    @Override
    public ServletInputStream getInputStream() throws IOException {
        if (out == null){
            out = new ByteArrayOutputStream();
            IOUtils.copy(super.getInputStream(),out);
        }
        return new CustomerServletInputStream(out.toByteArray());
    }
    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }
    private static class CustomerServletInputStream extends ServletInputStream{
        private final ByteArrayInputStream in;
        public CustomerServletInputStream(byte[] data) {
            this.in = new ByteArrayInputStream(data);
        }
        @Override
        public boolean isFinished() {
            throw new UnsupportedOperationException();
        }
        @Override
        public boolean isReady() {
            throw new UnsupportedOperationException();
        }
        @Override
        public void setReadListener(ReadListener listener) {
            throw new UnsupportedOperationException();
        }
        @Override
        public int read() throws IOException {
            return in.read();
        }
    }
}

上面的代码很简单，就是在获取流的同时将流里面的内容缓存起来，如果再次获取流时返回一个新创建的流给你。所以在过滤器中我们只要将原始的Request对象包装一下，然后再FilterChain中使用我们包装的Request即可，修改代码如下：

@Slf4j
@Component
public class LogFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        Map<String, String[]> parameterMap = request.getParameterMap();
        log.info("请求参数:{}",JSON.toJSONString(parameterMap));
        //使用包装Request替换原始的Request
        request = new RepeatReadRequest(request);
        //读取流中的内容
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        IOUtils.copy(request.getInputStream(),out);
        log.info("请求体:{}", out.toString(request.getCharacterEncoding()));
        
        filterChain.doFilter(request,response);
    }
}

流读取导致参数解析失败

我在上面的过滤器中先调用了getParameterMap方法获取参数，然后再获取流。这样是没毛病的。但是在我写这个之前遇见一个特别奇怪的问题，就是如果我先getInputStream然后再调用getParameterMap会导致参数解析失败。例如我将过滤器中代码调整顺序为如下：

@Slf4j
@Component
public class LogFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        //使用包装Request替换原始的Request
        request = new RepeatReadRequest(request);
        //读取流中的内容
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        IOUtils.copy(request.getInputStream(),out);
        log.info("请求体:{}", out.toString(request.getCharacterEncoding()));
        Map<String, String[]> parameterMap = request.getParameterMap();
        log.info("请求参数:{}",JSON.toJSONString(parameterMap));
        filterChain.doFilter(request,response);
    }
}

现在发送请求如下：

curl -d 'userName=tom&password=123' -H 'Content-type:application/x-www-form-urlencoded' -X POST http://127.0.0.1:8080/post/form

最后日志打印结果如下：

请求体:userName=tom&password=123

请求参数:{}

而之前的日志的打印结果如下：

请求参数:{“userName”:[“tom”],”password”:[“123”]} 

请求体:

我只是调整了getInputStream和getParameterMap这两个方法的调用时机，最后却会产生两种结果，这让我一度以为这个是个BUG。最后我从源码中知道了为啥会有这种结果，如果我们先调用getInputStream，这将会getParameterMap时不会去解析参数，以下代码是SpringBoot中嵌入的tomcat实现：

org.apache.catalina.connector.Request.class

protected void parseParameters() {
    parametersParsed = true;
    Parameters parameters = coyoteRequest.getParameters();
    boolean success = false;
    try {
        // Set this every time in case limit has been changed via JMX
        parameters.setLimit(getConnector().getMaxParameterCount());
        // getCharacterEncoding() may have been overridden to search for
        // hidden form field containing request encoding
        Charset charset = getCharset();
        boolean useBodyEncodingForURI = connector.getUseBodyEncodingForURI();
        parameters.setCharset(charset);
        if (useBodyEncodingForURI) {
            parameters.setQueryStringCharset(charset);
        }
        // Note: If !useBodyEncodingForURI, the query string encoding is
        //       that set towards the start of CoyoyeAdapter.service()
        parameters.handleQueryParameters();
        if (usingInputStream || usingReader) {
            success = true;
            return;
        }
        String contentType = getContentType();
        if (contentType == null) {
            contentType = "";
        }
        int semicolon = contentType.indexOf(';');
        if (semicolon >= 0) {
            contentType = contentType.substring(0, semicolon).trim();
        } else {
            contentType = contentType.trim();
        }
        if ("multipart/form-data".equals(contentType)) {
            parseParts(false);
            success = true;
            return;
        }
        if( !getConnector().isParseBodyMethod(getMethod()) ) {
            success = true;
            return;
        }
        if (!("application/x-www-form-urlencoded".equals(contentType))) {
            success = true;
            return;
        }
        int len = getContentLength();
        if (len > 0) {
            int maxPostSize = connector.getMaxPostSize();
            if ((maxPostSize >= 0) && (len > maxPostSize)) {
                Context context = getContext();
                if (context != null && context.getLogger().isDebugEnabled()) {
                    context.getLogger().debug(
                            sm.getString("coyoteRequest.postTooLarge"));
                }
                checkSwallowInput();
                parameters.setParseFailedReason(FailReason.POST_TOO_LARGE);
                return;
            }
            byte[] formData = null;
            if (len < CACHED_POST_LEN) {
                if (postData == null) {
                    postData = new byte[CACHED_POST_LEN];
                }
                formData = postData;
            } else {
                formData = new byte[len];
            }
            try {
                if (readPostBody(formData, len) != len) {
                    parameters.setParseFailedReason(FailReason.REQUEST_BODY_INCOMPLETE);
                    return;
                }
            } catch (IOException e) {
                // Client disconnect
                Context context = getContext();
                if (context != null && context.getLogger().isDebugEnabled()) {
                    context.getLogger().debug(
                            sm.getString("coyoteRequest.parseParameters"), e);
                }
                parameters.setParseFailedReason(FailReason.CLIENT_DISCONNECT);
                return;
            }
            parameters.processParameters(formData, 0, len);
        } else if ("chunked".equalsIgnoreCase(
                coyoteRequest.getHeader("transfer-encoding"))) {
            byte[] formData = null;
            try {
                formData = readChunkedPostBody();
            } catch (IllegalStateException ise) {
                // chunkedPostTooLarge error
                parameters.setParseFailedReason(FailReason.POST_TOO_LARGE);
                Context context = getContext();
                if (context != null && context.getLogger().isDebugEnabled()) {
                    context.getLogger().debug(
                            sm.getString("coyoteRequest.parseParameters"),
                            ise);
                }
                return;
            } catch (IOException e) {
                // Client disconnect
                parameters.setParseFailedReason(FailReason.CLIENT_DISCONNECT);
                Context context = getContext();
                if (context != null && context.getLogger().isDebugEnabled()) {
                    context.getLogger().debug(
                            sm.getString("coyoteRequest.parseParameters"), e);
                }
                return;
            }
            if (formData != null) {
                parameters.processParameters(formData, 0, formData.length);
            }
        }
        success = true;
    } finally {
        if (!success) {
            parameters.setParseFailedReason(FailReason.UNKNOWN);
        }
    }
}

上面代码从方法名字可以看出就是用来解析参数的，其中有一处关键的信息如下：

        if (usingInputStream || usingReader) {
            success = true;
            return;
        }

这个判断的意思是如果usingInputStream或者usingReader为true，将导致解析中断直接认为已经解析成功了。这个是两个属性默认都为false，而将它们设置为true的地方只有两处，分别为getInputStream和getReader，源码如下：getInputStream()

public ServletInputStream getInputStream() throws IOException {
    if (usingReader) {
        throw new IllegalStateException(sm.getString("coyoteRequest.getInputStream.ise"));
    }
    //设置usingInputStream 为true
    usingInputStream = true;
    if (inputStream == null) {
        inputStream = new CoyoteInputStream(inputBuffer);
    }
    return inputStream;
}

getReader()

public BufferedReader getReader() throws IOException {
    if (usingInputStream) {
        throw new IllegalStateException(sm.getString("coyoteRequest.getReader.ise"));
    }
    if (coyoteRequest.getCharacterEncoding() == null) {
        // Nothing currently set explicitly.
        // Check the content
        Context context = getContext();
        if (context != null) {
            String enc = context.getRequestCharacterEncoding();
            if (enc != null) {
                // Explicitly set the context default so it is visible to
                // InputBuffer when creating the Reader.
                setCharacterEncoding(enc);
            }
        }
    }
 //设置usingReader为true
    usingReader = true;
    inputBuffer.checkConverter();
    if (reader == null) {
        reader = new CoyoteReader(inputBuffer);
    }
    return reader;
}

为何在tomcat要如此实现呢？tomcat如此实现可能是有它的道理，作为Servlet容器那必须按照Servlet规范来实现，通过查询相关文档还真就找到了Servlet规范中的内容，下面是Servlet3.1规范中关于参数解析的部分内容：

Request重复读取流

总结

为了获取请求中的参数我们要解决的核心问题就是让流可以重复读取即可，同时注意先读取流会导致getParameterMap时参数无法解析这两点关键点即可。

示例代码:https://gitee.com/zengchao_workspace/servelt-log.git


原文始发于微信公众号（一只菜鸟程序员）：Request重复读取流

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/73172.html

赞 (0)
小半的头像小半
0 0

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！