如何在Spring“HandlerMethodArgumentResolver”中多次读取请求正文？

Question

我试图解析requestmapping方法的某些特定参数，从请求体中提取值并验证它们，然后将它们注入特定的带注释的参数中。

@Override
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
                              NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
    // 1, get corresponding input parameter from NativeWebRequest
    // 2, validate
    // 3, type convertion and assemble value to return
    return null;
}

最大的问题是，我发现HttpServletRequest（从NativeWebRequest)读取输入流（某些参数在请求正文中）的次数不能超过一次。那么，如何多次检索InputStream/Reader或请求正文？

Answer 1

您可以添加一个筛选器，截取当前的HttpServletRequest并将其包装在自定义的HttpServletRequestWrapper中。在自定义的HttpServletRequestWrapper中，读取请求正文并缓存它，然后实现GetInputStream和GetReader以读取缓存的值。由于包装请求后，缓存的值始终存在，因此可以多次读取请求正文：

@Component
public class CachingRequestBodyFilter extends GenericFilterBean {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest currentRequest = (HttpServletRequest) servletRequest;
        MultipleReadHttpRequest wrappedRequest = new MultipleReadHttpRequest(currentRequest);
        chain.doFilter(wrappedRequest, servletResponse);
    }
}

在此筛选之后，每个人都将看到wrappedrequest，它具有多次读取的功能：

public class MultipleReadHttpRequest extends HttpServletRequestWrapper {
    private ByteArrayOutputStream cachedContent;

    public MultipleReadHttpRequest(HttpServletRequest request) throws IOException {
        // Read the request body and populate the cachedContent
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        // Create input stream from cachedContent
        // and return it
    }

    @Override
    public BufferedReader getReader() throws IOException {
        // Create a reader from cachedContent
        // and return it
    }
}

对于实现MultipleReadHttpRequest，您可以查看spring framework中的ContentCachingRequestWrapper，它基本上执行相同的操作。

这种做法有其自身的缺点。首先，它有些低效，因为对于每个请求，请求体至少要被读取两次。另一个重要的缺点是，如果请求体包含10 GB值的流，您将读取10 GB数据，甚至更糟的是将其带入内存以便进一步检查。