getReader() has already been called for this request

新开发的模块需要记录当前的接口的请求IP,参数,耗时等信息，网上大多数是AOP实现的接口耗时记录方法，今天想以不一样的方式实现，但是过程中产生了问题

问题

在记录post请求的参数时发现报错

getReader() has already been called for this request

原因

request.getInputStream()只能被读取一次

解决

查阅了网上大量的博文，解决是继承HttpServletRequestWrapper，拷贝request.getInputStream()中的body参数，但是调用过一次，其实标识当前流每次流读取的位置已经移至末尾了，
实际的controller层@RequestBody依然会报错，请求体miss，解决思路就是将流中的参数读取完之后再写回！！！

代码如下：

1.自定义过滤器doFilter实现ContentCachingRequestWrapper(自定义)

代码如下（示例）：

import com.traffic.manage.infrastructure.config.ContentCachingRequestWrapper;
import lombok.extern.java.Log;
import org.springframework.stereotype.Component;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@Component
public class SignValidateFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        ContentCachingRequestWrapper requestWrapper = new ContentCachingRequestWrapper((HttpServletRequest) request);
        chain.doFilter(requestWrapper, response);
    }

    @Override
    public void destroy() {

    }
}

2.自定义ContentCachingRequestWrapper中对数据进行了拷贝了重新回写

import org.apache.commons.io.IOUtils;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class ContentCachingRequestWrapper extends HttpServletRequestWrapper {

    private byte[] body;

    private BufferedReader reader;

    private ServletInputStream inputStream;

    public ContentCachingRequestWrapper(HttpServletRequest request) throws IOException{
        super(request);
        loadBody(request);
    }

    private void loadBody(HttpServletRequest request) throws IOException{
        body = IOUtils.toByteArray(request.getInputStream());
        inputStream = new RequestCachingInputStream(body);
    }

    public byte[] getBody() {
        return body;
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        if (inputStream != null) {
            return inputStream;
        }
        return super.getInputStream();
    }

    @Override
    public BufferedReader getReader() throws IOException {
        if (reader == null) {
            reader = new BufferedReader(new InputStreamReader(inputStream, getCharacterEncoding()));
        }
        return reader;
    }

    private static class RequestCachingInputStream extends ServletInputStream {

        private final ByteArrayInputStream inputStream;

        public RequestCachingInputStream(byte[] bytes) {
            inputStream = new ByteArrayInputStream(bytes);
        }
        @Override
        public int read() throws IOException {
            return inputStream.read();
        }

        @Override
        public boolean isFinished() {
            return inputStream.available() == 0;
        }

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

        @Override
        public void setReadListener(ReadListener readlistener) {
        }

    }

}

3.自定义BootInterceptor 拦截器，使用ContentCachingRequestWrapper（自定义）中拷贝的post请求体的参数进行接口请求数据记录

import com.traffic.manage.infrastructure.config.ContentCachingRequestWrapper;
import com.traffic.manage.infrastructure.util.IpUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.springframework.http.HttpMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/***
 * 拦截器
 */
@Slf4j
public class BootInterceptor implements HandlerInterceptor {

    private static final ThreadLocal<Map<String, Object>> threadLocal = new ThreadLocal<>();

    /* 1 */
    public boolean preHandle(HttpServletRequest req, HttpServletResponse resp, Object arg2) throws IOException {
        long beginTime = System.currentTimeMillis();
        Map<String, Object> map = new HashMap<>();
        String realIp = IpUtil.getIpAddr(req);
        String method = req.getMethod();

        StringBuilder sb = new StringBuilder();
        if (HttpMethod.GET.matches(method)) {
            Map<String, String[]> parameterMap = req.getParameterMap();
            for (Map.Entry<String, String[]> m : parameterMap.entrySet()) {
                sb.append(m.getKey()).append(":");
                for (String s : m.getValue()) {
                    sb.append(s);
                }
                sb.append(",");
            }
        } else if (HttpMethod.POST.matches(method)) {

            ContentCachingRequestWrapper requestWapper = (ContentCachingRequestWrapper) req;
            String body = IOUtils.toString(requestWapper.getBody(), requestWapper.getCharacterEncoding());

            sb.append(body);
        }
        map.put("beginTime", beginTime);
        map.put("param", sb.toString());
        map.put("realIp", realIp);
        threadLocal.set(map);
        return true;
    }

    /* 2 */
    public void postHandle(HttpServletRequest req, HttpServletResponse resp, Object arg2, ModelAndView arg3) {

    }

    /* 3 */
    @SuppressWarnings("unchecked")
    public void afterCompletion(HttpServletRequest req, HttpServletResponse resp, Object arg2, Exception arg3) {
        Map<String, Object> map = threadLocal.get();
        long beginTime = (long) map.get("beginTime");
        String realIp = (String) map.get("realIp");
        String param = (String) map.get("param");
        long interval = System.currentTimeMillis() - beginTime;
        String uri = req.getRequestURI();
        log.info("当前接口:{} 请求参数:{}", uri, param);
        log.info("当前接口:{} 请求耗时:{}ms", uri, interval);
        log.info("当前接口:{} 请求IP:{}", uri, realIp);
        threadLocal.remove();
    }
}