java.lang.IllegalStateException: getInputStream() has already been called for this request

java.lang.IllegalStateException: getInputStream() has already been called for this request

在使用HttpServletRequest获取post请求对象的方法如下

BufferedReader reader = req.getReader();
while (null != (line = reader.readLine())){
    data.append(line);
}

当某些时候, tomcat已经读取过一次了,导致抛异常!

java.lang.IllegalStateException: getInputStream() has already been called for this request

我们初衷是希望能够拿到这个post请求对象, 而不是对 req.getReader() 做判断处理
所以解决办法是 继承 HttpServletRequestWrapper 实现我们想要的

public class MultiReadHttpServletRequestWrapper extends HttpServletRequestWrapper {
    private static final Logger LOGGER = LogManager.getLogger(LogManager.ROOT_LOGGER_NAME);

    // We include a max byte size to protect against malicious requests,
    //since this all has to be read into memory
    public static final Integer MAX_BYTE_SIZE = 1_048_576; // 1 MB

    public StringBuilder body;

    public MultiReadHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        body = new StringBuilder();
        try (InputStream bounded = new BoundedInputStream(request.getInputStream(), MAX_BYTE_SIZE);
             BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(bounded))){
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                body.append(line);
            }
        } catch(Exception e) {
            LOGGER.error(e.getMessage());
        }

    }


    @Override
    public ServletInputStream getInputStream() {
        final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body.toString().getBytes());
        return new ServletInputStream() {
            @Override
            public int read() {
                return byteArrayInputStream.read();
            }

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

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

            @Override
            public void setReadListener(ReadListener listener) {

            }
        };
    }

    @Override
    public BufferedReader getReader() {
        return new BufferedReader(new InputStreamReader(this.getInputStream()));
    }
}

然后再写到过滤器

public class MyFilter3 implements Filter {

    private static final Logger LOGGER = LogManager.getLogger(LogManager.ROOT_LOGGER_NAME);

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        LOGGER.info("过滤器filter3开始 doFilter");
        ServletRequest requestWrapper = null;
        if(request instanceof HttpServletRequest) {
            requestWrapper = new MultiReadHttpServletRequestWrapper((HttpServletRequest) request);
        }
        //获取请求中的流如何，将取出来的字符串，再次转换成流，然后把它放入到新request对象中。
        // 在chain.doFiler方法中传递新的request对象
        if(requestWrapper == null) {

            chain.doFilter(request, response);
        } else {
            chain.doFilter(requestWrapper, response);
        }
    }
}

最后加载到过滤器链路中, 最终完美解决问题