spring boot项目，在过滤器、拦截器或自定义aop做统一处理时，获取了request中的inputstream来获取RequestBody里数据，获取之后在Controller里使用@RequestBody注解再获取就报错：Stream closed。这是因为HttpServletRequest中的inputstream是不可重复读的。

这块有个疑问：监听器、过滤器、 拦截器、 AOP的执行顺序是什么呢？？？

如果监听器、过滤器、 拦截器、 AOP都存在，则它们的执行顺序为：监听器 => 过滤器=> 拦截器=> AOP。

完整的执行顺序是：过滤前=> 拦截前=> AOP=> Controller=> AOP=> 拦截后=> 过滤后


更多参考 >> https://www.cnblogs.com/better-farther-world2099/articles/16145309.html

好了，回到正题。利用过滤器在将request中的inputstream缓存起来，方便下次使用。修改方式如下：

1、自定义RequestWrapper

package com.jyd.common.request;

import lombok.extern.slf4j.Slf4j;
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.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * @author create by Fearless
 * @version v1.0
 * @description ResquestWrapper
 * @date 2022/5/6 15:07
 */
@Slf4j
public class RequestWrapper extends HttpServletRequestWrapper {

    private final byte[] body;

    /**
     * @description 将request中输入流中的内容保存起来
     * @param request HttpServletRequest
     */
    public RequestWrapper(HttpServletRequest request) {
        super(request);
        byte[] bytes = null;
        InputStream inputStream = null;
        try {
            inputStream = request.getInputStream();
            bytes = IOUtils.toByteArray(inputStream);
        } catch (IOException e) {
            log.error("requestWrapper error", e);
        } finally {
            IOUtils.closeQuietly(inputStream);
        }
        body = bytes;
    }

    /**
     * @description 重写getInputStream，返回保存在属性中的body
     * @return javax.servlet.ServletInputStream
     */
    @Override
    public ServletInputStream getInputStream() {
        final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body);
        ServletInputStream servletInputStream = new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }

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

            @Override
            public void setReadListener(ReadListener readListener) {

            }

            @Override
            public int read() throws IOException {
                return byteArrayInputStream.read();
            }
        };
        return servletInputStream;
    }
}

2、定义请求体公用的过滤器

package com.jyd.common.request;

import org.springframework.boot.web.servlet.ServletComponentScan;
import org.springframework.stereotype.Component;

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

/**
 * @author create by Fearless
 * @version v1.0
 * @description CacheHttpServletRequestFilter
 * @date 2022/5/6 15:19
 */
//获取请求中的流，将取出来的，再次转换成流，然后把它放入到新request对象中
//必须保证在所有过滤器之前执行,否则就会出现问题(按照首字母进行过滤器优先级A>B>C)
@Component
@ServletComponentScan
public class CacheHttpServletRequestFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    /**
     * @description 将自定义的ServletRequest替换进filterChain中，使request可以重复读取
     * @param servletRequest servletRequest
     * @param servletResponse servletResponse
     * @param filterChain filterChain
     */
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        ServletRequest request = null;
        if (servletRequest instanceof HttpServletRequest) {
            request = new RequestWrapper((HttpServletRequest) servletRequest);
        }
        if (request != null) {
            filterChain.doFilter(request, servletResponse);
        } else {
            filterChain.doFilter(servletRequest, servletResponse);
        }
    }

    @Override
    public void destroy() {

    }
}