spring boot过滤器中获取Url请求中的参数（打印接口参数日志）

￡神魔★判官ぃ 2023-07-01 08:53 20阅读 0赞

最近有一个需要从接口请求参数后，打印日志，进行接口参数记录。

这里记录一下处理过程中出现的问题。  
首先想到的就是request.getParameter(String )方法，但是这个方法只能在get请求中取到参数，post是不行的，后来想到了使用流的方式，调用request.getInputStream()获取流，然后从流中读取参数，如下代码所示：

String body = "";
    StringBuilder stringBuilder = new StringBuilder();
    BufferedReader bufferedReader = null;
    InputStream inputStream = null;
    try {
        inputStream = request.getInputStream();
        if (inputStream != null) {
            bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            char[] charBuffer = new char[128];
            int bytesRead = -1;
            while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
                stringBuilder.append(charBuffer, 0, bytesRead);
            }
        } else {
            stringBuilder.append("");
        }
    } catch (IOException ex) {
        e.printStackTrace();
    } finally {
        if (inputStream != null) {
            try {
                inputStream.close();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (bufferedReader != null) {
            try {
                bufferedReader.close();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    body = stringBuilder.toString();

代码中的body就是request中的参数，我这里传的是JSON数据：\{"page": 1, "pageSize": 10\}，那么body就是：body = "\{"page": 1, "pageSize": 10\}"，一个JSON字符串。这样是可以成功获取到post请求的body，但是，经过过滤器后，参数经过@RequestBody注解赋值给controller中的方法的时候，却抛出了一个这样的异常：

> org.springframework.http.converter.HttpMessageNotReadableException: Required request body is missing

在网上查找资料后发现，request的输入流只能读取一次，那么这是为什么呢？下面是答案：

> 那是因为流对应的是数据，数据放在内存中，有的是部分放在内存中。read 一次标记一次当前位置（mark position），第二次read就从标记位置继续读（从内存中copy）数据。 所以这就是为什么读了一次第二次是空了。 怎么让它不为空呢？只要inputstream 中的pos 变成0就可以重写读取当前内存中的数据。javaAPI中有一个方法public void reset() 这个方法就是可以重置pos为起始位置，但是不是所有的IO读取流都可以调用该方法！ServletInputStream是不能调用reset方法，这就导致了只能调用一次getInputStream()。
> 
> 摘自：[https://blog.csdn.net/sdut406/article/details/81369983][https_blog.csdn.net_sdut406_article_details_81369983]

那么有什么办法可以用户解决呢？上面这篇博客中提到了解决方案，就是重写HttpServletRequestWrapper把request保存下来，然后通过过滤器把保存下来的request再填充进去，这样就可以多次读取request了。步骤如下所示：

①写一个类，继承HttpServletRequestWrapper

import javax.servlet.ReadListener;
    import javax.servlet.ServletInputStream;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletRequestWrapper;
    import java.io.*;
    
    public class RequestWrapper extends HttpServletRequestWrapper {
        private final String body;
    
        public RequestWrapper(HttpServletRequest request) {
            super(request);
            StringBuilder stringBuilder = new StringBuilder();
            BufferedReader bufferedReader = null;
            InputStream inputStream = null;
            try {
                inputStream = request.getInputStream();
                if (inputStream != null) {
                    bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                    char[] charBuffer = new char[128];
                    int bytesRead = -1;
                    while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
                        stringBuilder.append(charBuffer, 0, bytesRead);
                    }
                } else {
                    stringBuilder.append("");
                }
            } catch (IOException ex) {
    
            } finally {
                if (inputStream != null) {
                    try {
                        inputStream.close();
                    }
                    catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (bufferedReader != null) {
                    try {
                        bufferedReader.close();
                    }
                    catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            body = stringBuilder.toString();
        }
    
        @Override
        public ServletInputStream getInputStream() throws IOException {
            final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body.getBytes());
            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;
    
        }
    
        @Override
        public BufferedReader getReader() throws IOException {
            return new BufferedReader(new InputStreamReader(this.getInputStream()));
        }
    
        public String getBody() {
            return this.body;
        }
    
    }

②过滤器Filter，用来把request传递下去

import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
import org.springframework.core.annotation.Order;  
import org.springframework.web.filter.OncePerRequestFilter;

import com.cetc.common.utils.CommonUtils;

import javax.servlet.\*;  
import javax.servlet.annotation.WebFilter;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;

import java.io.BufferedReader;  
import java.io.IOException;  
import java.util.Date;  
import java.util.Map;

/\*\*  
\* @program: springboot  
\* @description:  
\* @author: Sid  
\* @date: 2018-11-19 09:21  
\* @since: 1.0  
\*\*/  
@Order(0)  
/\*\*  
\* 注册过滤器  
\* \*/  
@WebFilter(filterName = "RequestResponseLogFilter", urlPatterns = "/\*")  
public class RequestFilter extends OncePerRequestFilter \{  
private static final Logger logger = LoggerFactory.getLogger(RequestFilter.class);

@Override  
 protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)  
throws ServletException, IOException \{   
try \{  
RequestWrapper requestWrapper = new RequestWrapper(request);  
String body = requestWrapper.getBody();  
String parameterStr =  
"接收到请求 时间:" + CommonUtils.DEFAULT\_DTF.format(new Date()) + ". 地址:" + request.getRequestURI()  
\+ "request ContentType: " + request.getContentType() + ". 参数:" + body;  
  
logger.debug(parameterStr);  
 filterChain.doFilter(requestWrapper, response);  
\} catch (Exception e) \{  
logger.error("权限判断出错", e);  
\}  
\}

③在启动类中注册过滤器

import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.web.servlet.MultipartConfigFactory;
    import org.springframework.boot.web.servlet.ServletComponentScan;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    
    @SpringBootApplication
    @ServletComponentScan  //注册过滤器注解
    @Configuration
    public class WebApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(WebApplication.class, args);
        }
    }

经测试，问题解决

[https_blog.csdn.net_sdut406_article_details_81369983]: https://links.jianshu.com/go?to=https%3A%2F%2Fblog.csdn.net%2Fsdut406%2Farticle%2Fdetails%2F81369983