springboot 解决过滤器 HttpServletRequest body IO流只能读取一次的问题

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest httpRequest = (HttpServletRequest) request;
    // 直接读取原始流并打印（错误！）
    String body = IOUtils.toString(httpRequest.getInputStream(), StandardCharsets.UTF_8);
    System.out.println("Filter打印body：" + body);
    // 此时流已被消耗，控制器无法读取
    chain.doFilter(request, response); 
}

@Component
@0rder(o)
@Slf4j
public class WebFilter extends OncePerRequestFilter {

@0verride
protected void dofilterInternal(HttpservletRequest request, HttpservletResponse response, Filterchain filterchain)throws servletException, I0Exception{
// 正确示例：基于包装类的缓存打印，不消耗原始流
    if (request instanceof HttpServletRequest) {
        // 先包装请求，缓存body
        CachedServletRequestWrapper wrappedRequest = new CachedServletRequestWrapper((HttpServletRequest) request);
        // 从包装类的缓存中读取并打印（不影响原始流）
        String body = new String(wrappedRequest.getCachedBody(), StandardCharsets.UTF_8);
        System.out.println("Filter打印body：" + body);
        // 传递包装后的请求，控制器可从缓存中读取
        chain.doFilter(wrappedRequest, response);
    } else {
        chain.doFilter(request, response);
    }
}

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.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;

/**
 * 缓存请求体的包装类，解决ServletRequest输入流只能读取一次的问题
 */
public class CachedServletRequestWrapper extends HttpServletRequestWrapper {

    // 缓存的请求体字节数组
    private final byte[] cachedBody;

    /**
     * 构造方法：读取原始请求的输入流并缓存
     */
    public CachedServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        this.cachedBody = readRequestBody(request);
    }

    /**
     * 读取原始请求的输入流并转换为字节数组
     */
    private byte[] readRequestBody(HttpServletRequest request) throws IOException {
        // GET/DELETE等方法通常没有请求体，直接返回空数组
        String method = request.getMethod();
        if ("GET".equalsIgnoreCase(method) || "DELETE".equalsIgnoreCase(method)) {
            return new byte[0];
        }

        // 读取输入流并缓存
        try (InputStream inputStream = request.getInputStream();
             ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {

            byte[] buffer = new byte[1024];
            int length;
            while ((length = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, length);
            }
            return outputStream.toByteArray();
        }
    }

    /**
     * 重写getInputStream()，返回基于缓存的输入流
     */
    @Override
    public ServletInputStream getInputStream() throws IOException {
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(cachedBody);
        return new ServletInputStream() {
            @Override
            public int read() throws IOException {
                return byteArrayInputStream.read();
            }

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

            @Override
            public boolean isReady() {
                return true; // 同步读取时始终就绪
            }

            @Override
            public void setReadListener(ReadListener listener) {
                // 异步场景可忽略，同步场景无需实现
            }
        };
    }

    /**
     * 重写getReader()，基于缓存的输入流构建字符读取器
     */
    @Override
    public java.io.BufferedReader getReader() throws IOException {
        return new java.io.BufferedReader(
            new java.io.InputStreamReader(getInputStream(), StandardCharsets.UTF_8)
        );
    }

    /**
     * 提供获取缓存的请求体字节数组的方法（方便过滤器/拦截器直接使用）
     */
    public byte[] getCachedBody() {
        return cachedBody;
    }

    /**
     * 提供获取缓存的请求体字符串的方法（简化使用）
     */
    public String getCachedBodyAsString() {
        return new String(cachedBody, StandardCharsets.UTF_8);
    }
}