开发前端软件素材源码教程下载网站

全部
网站模板
网页特效
网站源码
素材资源
建站学院
软件工具
mysql mysql 微信 微信 小程序 苹果 dedecms 修真图
当前位置：首页 > 建站学院 > 其他教程 >  springBoot之怎么获取接口请求数据和返回数据实现日志

springBoot之怎么获取接口请求数据和返回数据实现日志

其他教程   发布日期：2024年12月17日   浏览次数：220次

这篇文章主要介绍“springBoot之怎么获取接口请求数据和返回数据实现日志”，在日常操作中，相信很多人在springBoot之怎么获取接口请求数据和返回数据实现日志问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”springBoot之怎么获取接口请求数据和返回数据实现日志”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

    一、获取接口请求的数据

    可以在Interceptor的afterCompletion中实现但是要重写RequestWrapper

    代码记录如下：

    HttpServletRequestFilter

    1. import javax.servlet.*;
    2. import javax.servlet.annotation.WebFilter;
    3. import javax.servlet.http.HttpServletRequest;
    4.  
    5. import org.springframework.core.annotation.Order;
    6. import org.springframework.stereotype.Component;
    7.  
    8. import java.io.IOException;
    9.  
    10. @Component
    11. @WebFilter(filterName = "HttpServletRequestFilter", urlPatterns = "/")
    12. @Order(10000)
    13. public class HttpServletRequestFilter implements Filter {
    14.     @Override
    15.     public void init(FilterConfig filterConfig) throws ServletException {
    16.  
    17.     }
    18.  
    19.     @Override
    20.     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    21.         ServletRequest requestWrapper = null;
    22.         if(servletRequest instanceof HttpServletRequest) {
    23.             requestWrapper = new RequestWrapper((HttpServletRequest) servletRequest);
    24.         }
    25.         //获取请求中的流如何，将取出来的字符串，再次转换成流，然后把它放入到新request对象中
    26.         // 在chain.doFiler方法中传递新的request对象
    27.         if(null == requestWrapper) {
    28.             filterChain.doFilter(servletRequest, servletResponse);
    29.         } else {
    30.             filterChain.doFilter(requestWrapper, servletResponse);
    31.         }
    32.     }
    33.  
    34.     @Override
    35.     public void destroy() {
    36.  
    37.     }
    38.  
    39. }

    RequestWrapper

    1. import javax.servlet.ReadListener;
    2. import javax.servlet.ServletInputStream;
    3. import javax.servlet.http.HttpServletRequest;
    4. import javax.servlet.http.HttpServletRequestWrapper;
    5. import java.io.*; 
    6.  
    7. public class RequestWrapper extends HttpServletRequestWrapper {
    8.     private final String body;
    9.  
    10.     public RequestWrapper(HttpServletRequest request) {
    11.         super(request);
    12.         StringBuilder stringBuilder = new StringBuilder();
    13.         BufferedReader bufferedReader = null;
    14.         InputStream inputStream = null;
    15.         try {
    16.             inputStream = request.getInputStream();
    17.             if (inputStream != null) {
    18.                 bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
    19.                 char[] charBuffer = new char[128];
    20.                 int bytesRead = -1;
    21.                 while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
    22.                     stringBuilder.append(charBuffer, 0, bytesRead);
    23.                 }
    24.             } else {
    25.                 stringBuilder.append("");
    26.             }
    27.         } catch (IOException ex) {
    28.  
    29.         } finally {
    30.             if (inputStream != null) {
    31.                 try {
    32.                     inputStream.close();
    33.                 }
    34.                 catch (IOException e) {
    35.                     e.printStackTrace();
    36.                 }
    37.             }
    38.             if (bufferedReader != null) {
    39.                 try {
    40.                     bufferedReader.close();
    41.                 }
    42.                 catch (IOException e) {
    43.                     e.printStackTrace();
    44.                 }
    45.             }
    46.         }
    47.         body = stringBuilder.toString();
    48.     }
    49.  
    50.     @Override
    51.     public ServletInputStream getInputStream() throws IOException {
    52.         final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body.getBytes());
    53.         ServletInputStream servletInputStream = new ServletInputStream() {
    54.             @Override
    55.             public boolean isFinished() {
    56.                 return false;
    57.             }
    58.             @Override
    59.             public boolean isReady() {
    60.                 return false;
    61.             }
    62.             @Override
    63.             public void setReadListener(ReadListener readListener) {
    64.             }
    65.             @Override
    66.             public int read() throws IOException {
    67.                 return byteArrayInputStream.read();
    68.             }
    69.         };
    70.         return servletInputStream;
    71.  
    72.     }
    73.  
    74.     @Override
    75.     public BufferedReader getReader() throws IOException {
    76.         return new BufferedReader(new InputStreamReader(this.getInputStream()));
    77.     }
    78.  
    79.     public String getBody() {
    80.         return this.body;
    81.     }
    82.  
    83. }

    afterCompletion

    1.     @Override
    2.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception exception)
    3.             throws Exception {
    4.  
    5.         logger.debug("SessionInterceptor");
    6.         // 获取地址
    7.         String url = request.getRequestURL().toString();
    8.         String requestMethod = request.getMethod();
    9.         String servletPath = request.getServletPath();
    10.         String body = new RequestWrapper(request).getBody();
    11.         String contentType = request.getContentType();
    12.         Map reqMap = new HashMap();
    13.         if(requestMethod.equals("POST")) {
    14.             if(!contentType.equals("text/plain")) 
    15.                 body = "body is file,don't show.";
    16.             if(body.length()>1000) 
    17.                 body = body.substring(0, 1000);
    18.         }
    19.         if(requestMethod.equals("GET")) {
    20.             // 获取请求参数
    21.             Map ParameterMap =  request.getParameterMap();
    22.             Set<Map.Entry<String,String[]>> entry = ParameterMap.entrySet();
    23.             Iterator<Map.Entry<String,String[]>> it = entry.iterator();
    24.             while (it.hasNext()){
    25.                 Map.Entry<String,String[]>  me = it.next();
    26.                 String key = me.getKey();
    27.                 String value = me.getValue()[0];
    28.                 reqMap.put(key,value);
    29.             }
    30.         }
    31.         logger.error("url: "+url+",requestMethod: "+requestMethod+",servletPath: "+servletPath+",body: " + body+",parameterMap: "+reqMap.toString());
    32.         
    33.         
    34.     }

    二、获取接口返回的数据

    可以在filter中实现但是要重写ResponseWrapper，

    代码记录如下：

    HttpServletResponseFilter

    1. import javax.servlet.*;
    2. import javax.servlet.annotation.WebFilter;
    3. import javax.servlet.http.HttpServletRequest;
    4. import javax.servlet.http.HttpServletResponse;
    5.  
    6. import org.apache.log4j.Logger;
    7. import org.springframework.core.annotation.Order;
    8. import org.springframework.stereotype.Component;
    9.  
    10. import java.io.IOException;
    11.  
    12. @Component
    13. @WebFilter(filterName = "HttpServletResponseFilter", urlPatterns = "/")
    14. @Order(10000)
    15. public class HttpServletResponseFilter implements Filter {
    16.     static Logger logger = Logger.getLogger(HttpServletResponseFilter.class.getName());
    17.     @Override
    18.     public void init(FilterConfig filterConfig) throws ServletException {
    19.  
    20.     }
    21.  
    22.     @Override
    23.     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    24.         HttpServletRequest req = (HttpServletRequest) servletRequest;
    25.         HttpServletResponse resp = (HttpServletResponse) servletResponse;
    26.         ResponseWrapper mResp = new ResponseWrapper(resp); // 包装响应对象 resp 并缓存响应数据
    27.         filterChain.doFilter(req, mResp);
    28.         byte[] bytes = mResp.getBytes(); // 获取缓存的响应数据
    29.         logger.error(new String(bytes,"utf-8"));
    30.     }
    31.  
    32.     @Override
    33.     public void destroy() {
    34.  
    35.     }
    36.  
    37. }

    ResponseWrapper

    1. import javax.servlet.ServletOutputStream;
    2. import javax.servlet.WriteListener;
    3. import javax.servlet.http.HttpServletResponse;
    4. import javax.servlet.http.HttpServletResponseWrapper;
    5. import java.io.*;
    6.  
    7. public class ResponseWrapper extends HttpServletResponseWrapper {
    8.  
    9.     private ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    10.     private HttpServletResponse response;
    11.     private PrintWriter pwrite;
    12.  
    13.     public ResponseWrapper(HttpServletResponse response) {
    14.         super(response);
    15.         this.response = response;
    16.     }
    17.  
    18.     @Override
    19.     public ServletOutputStream getOutputStream() throws IOException {
    20.         return new MyServletOutputStream(bytes); // 将数据写到 byte 中
    21.     }
    22.  
    23.     /**
    24.      * 重写父类的 getWriter() 方法，将响应数据缓存在 PrintWriter 中
    25.      */
    26.     @Override
    27.     public PrintWriter getWriter() throws IOException {
    28.         try{
    29.             pwrite = new PrintWriter(new OutputStreamWriter(bytes, "utf-8"));
    30.         } catch(UnsupportedEncodingException e) {
    31.             e.printStackTrace();
    32.         }
    33.         return pwrite;
    34.     }
    35.  
    36.     /**
    37.      * 获取缓存在 PrintWriter 中的响应数据
    38.      * @return
    39.      */
    40.     public byte[] getBytes() {
    41.         if(null != pwrite) {
    42.             pwrite.close();
    43.             return bytes.toByteArray();
    44.         }
    45.  
    46.         if(null != bytes) {
    47.             try {
    48.                 bytes.flush();
    49.             } catch(IOException e) {
    50.                 e.printStackTrace();
    51.             }
    52.         }
    53.         return bytes.toByteArray();
    54.     }
    55.  
    56.     class MyServletOutputStream extends ServletOutputStream {
    57.         private ByteArrayOutputStream ostream ;
    58.  
    59.         public MyServletOutputStream(ByteArrayOutputStream ostream) {
    60.             this.ostream = ostream;
    61.         }
    62.  
    63.         @Override
    64.         public void write(int b) throws IOException {
    65.             ostream.write(b); // 将数据写到 stream　中
    66.         }
    67.  
    68.         @Override
    69.         public boolean isReady() {
    70.             // TODO Auto-generated method stub
    71.             return false;
    72.         }
    73.  
    74.         @Override
    75.         public void setWriteListener(WriteListener listener) {
    76.             // TODO Auto-generated method stub
    77.             
    78.         }
    79.  
    80.     }
    81.  
    82. }

    以上就是springBoot之怎么获取接口请求数据和返回数据实现日志的详细内容，更多关于springBoot之怎么获取接口请求数据和返回数据实现日志的资料请关注九品源码其它相关文章！

    相关热词： springBoot获取接口请求数据返回实现日志
    上一篇：讲一讲如何在一个页面中使用多个百度分享按钮，分享不同的文章
    下一篇：Python中的布尔类型bool怎么应用

    文章分类

    IT资讯 CMS教程 服务器 数据库 前端开发 后端开发 工具使用 其他教程

    最后更新

    热门排行

    网站首页 | 关于我们 | 免责声明 | 网站建设 | 在线工具 | 网站地图

    版权声明：本站发布的资源部分自互联网，所有资源版权归原作者所有。如果有侵犯到您的权益，请联系本站删除，谢谢合作！

    Copyright 2018-2025 ©19jp.com All Rights Reserved. 陕ICP备16002142号-1