如何优雅记录 HTTP 请求/ 响应数据？

经常会遇到需要处理 http 请求以及响应 body 的场景。 而这里比较大的一个问题是 servlet的 requestBody 或 responseBody 流一旦被读取了就无法二次读取了。 针对这个问题，Spring 本身提供了解决方案，即：

• ContentCachingRequestWrapper
• ContentCachingResponseWrapper。

我们编写一个过滤器: public  abstract  class HttpBodyRecorderFilter extends OncePerRequestFilter {

     private  static  final  int DEFAULT_MAX_PAYLOAD_LENGTH =  1024 *  512;

     private  int maxPayloadLength = DEFAULT_MAX_PAYLOAD_LENGTH;

     @Override

     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {

         boolean isFirstRequest = !isAsyncDispatch(request);

        HttpServletRequest requestToUse = request;

         if (isFirstRequest && !(request  instanceof ContentCachingRequestWrapper)
   && (request.getMethod().equals(HttpMethod.PUT.name())
                        || request.getMethod().equals(HttpMethod.POST.name()))) {
            requestToUse =  new ContentCachingRequestWrapper(request);
        }

        HttpServletResponse responseToUse = response;

         if (!(response  instanceof ContentCachingResponseWrapper) && (request.getMethod().equals(HttpMethod.PUT.name())
                        || request.getMethod().equals(HttpMethod.POST.name()))) {
            responseToUse =  new ContentCachingResponseWrapper(response);
        }

         boolean hasException =  false;

         try {
            filterChain.doFilter(requestToUse, responseToUse);
        }  catch ( final Exception e) {
            hasException =  true;
             throw e;
        }  finally {
             int code = hasException ?  500 : response.getStatus();

             if (!isAsyncStarted(requestToUse) && ( this.codeMatched(code, AdvancedHunterConfigManager.recordCode()))) {
                recordBody(createRequest(requestToUse), createResponse(responseToUse));
            }  else {
                writeResponseBack(responseToUse);
            }

        }

    }

     protected String createRequest(HttpServletRequest request) {
        String payload =  "";

        ContentCachingRequestWrapper wrapper = WebUtils.getNativeRequest(request, ContentCachingRequestWrapper .class);

         if (wrapper !=  null) {
             byte[] buf = wrapper.getContentAsByteArray();
            payload = genPayload(payload, buf, wrapper.getCharacterEncoding());
        }

         return payload;
    }

     protected String createResponse(HttpServletResponse resp) {
        String response =  "";

        ContentCachingResponseWrapper wrapper = WebUtils.getNativeResponse(resp, ContentCachingResponseWrapper .class);

         if (wrapper !=  null) {
             byte[] buf = wrapper.getContentAsByteArray();

             try {
                wrapper.copyBodyToResponse();
            }  catch (IOException e) {
                e.printStackTrace();
            }

            response = genPayload(response, buf, wrapper.getCharacterEncoding());
        }

         return response;

    }

     protected void writeResponseBack(HttpServletResponse resp) {
        ContentCachingResponseWrapper wrapper = WebUtils.getNativeResponse(resp, ContentCachingResponseWrapper .class);

         if (wrapper !=  null) {
             try {
                wrapper.copyBodyToResponse();
            }  catch (IOException e) {
                LOG.error( "Fail to write response body back", e);
            }
        }

    }

     private String genPayload(String payload, byte[] buf, String characterEncoding) {

         if (buf.length >  0 && buf.length < getMaxPayloadLength()) {
             try {
                payload =  new String(buf,  0, buf.length, characterEncoding);
            }  catch (UnsupportedEncodingException ex) {
                payload =  "[unknown]";
            }
        }

         return payload;

    }

     public int getMaxPayloadLength() {
         return maxPayloadLength;
    }

     private boolean codeMatched(int responseStatus, String statusCode) {

         if (statusCode.matches( "^[0-9,]*$")) {
            String[] filteredCode = statusCode.split( ",");
             return Stream.of(filteredCode).map(Integer::parseInt).collect(Collectors.toList()).contains(responseStatus);
        }  else {
             return  false;
        }

    }

     protected abstract void recordBody(String payload, String response);

     protected abstract String recordCode();

}
这样自定义一个filter继承HttpBodyRecorderFilter，重写recordBody方法就能自定义自己的处理逻辑了。 另外，recordCode方法可用于定义在请求响应码为多少的时候才会去记录body，例如可以定义为只有遇到400或500时才记录body，用于错误侦测。 过滤器的匹配规则比较简单，如果想要像springmvc那样进行匹配，我们可以使用：AntPathMatcher。 class PatternMappingFilterProxy implements Filter {

     private  final Filter delegate;

     private  final List pathUrlPatterns =  new ArrayList();

     private PathMatcher pathMatcher;

     public PatternMappingFilterProxy(Filter delegate, String... urlPatterns) {
        Assert.notNull(delegate,  "A delegate Filter is required");
         this.delegate = delegate;
         int length = urlPatterns.length;
        pathMatcher =  new AntPathMatcher();
         for ( int index =  0; index < length; ++index) {
            String urlPattern = urlPatterns[index];
             this.pathUrlPatterns.add(urlPattern);
        }

    }

     @Override

     public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
            throws IOException, ServletException {

        HttpServletRequest httpRequest = (HttpServletRequest) request;

        String path = httpRequest.getRequestURI();

         if ( this.matches(path)) {
             this.delegate.doFilter(request, response, filterChain);
        }  else {
            filterChain.doFilter(request, response);
        }

    }

     private boolean matches(String requestPath) {

         for (String pattern : pathUrlPatterns) {
             if (pathMatcher.match(pattern, requestPath)) {
                 return  true;
            }
        }

         return  false;
    }

     @Override
     public void init(FilterConfig filterConfig) throws ServletException {
         this.delegate.init(filterConfig);
    }

     @Override

     public void destroy() {
         this.delegate.destroy();
    }

     public List getPathUrlPatterns() {
         return pathUrlPatterns;
    }

     public void setPathUrlPatterns(List urlPatterns) {
        pathUrlPatterns.clear();
        pathUrlPatterns.addAll(urlPatterns);
    }

}
这样子，PatternMappingFilterProxy装饰了真正的HttpBodyRecorderFilter，支持传入urlPatterns，从而实现像springmvc那样的ant style的匹配。例如对于以下接口： @PostMapping( "/test/{id}")
public Object test(@PathVariable(value =  "id",required =  true)  final Integer index)  {

  //do something

}
可以设置urlPattern为 /test/{id:[0-9]+} 。 ------我们创建了一个高质量的技术交流群，与优秀的人在一起，自己也会优秀起来，赶紧，享受一起成长的快乐。另外，如果你最近想跳槽的话，年前我花了2周时间收集了一波大厂面经，节后准备跳槽的可以点击这里领取！