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

发布时间：2023-04-08 17:48:20 作者：iii
来源：亿速云阅读：197

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

一、获取接口请求的数据

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

代码记录如下：

HttpServletRequestFilter

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
 
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
 
import java.io.IOException;
 
@Component
@WebFilter(filterName = "HttpServletRequestFilter", urlPatterns = "/")
@Order(10000)
public class HttpServletRequestFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
 
    }
 
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        ServletRequest requestWrapper = null;
        if(servletRequest instanceof HttpServletRequest) {
            requestWrapper = new RequestWrapper((HttpServletRequest) servletRequest);
        }
        //获取请求中的流如何，将取出来的字符串，再次转换成流，然后把它放入到新request对象中
        // 在chain.doFiler方法中传递新的request对象
        if(null == requestWrapper) {
            filterChain.doFilter(servletRequest, servletResponse);
        } else {
            filterChain.doFilter(requestWrapper, servletResponse);
        }
    }
 
    @Override
    public void destroy() {
 
    }
 
}

RequestWrapper

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;
    }
 
}

afterCompletion

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception exception)
            throws Exception {
 
        logger.debug("SessionInterceptor");
        // 获取地址
        String url = request.getRequestURL().toString();
        String requestMethod = request.getMethod();
        String servletPath = request.getServletPath();
        String body = new RequestWrapper(request).getBody();
        String contentType = request.getContentType();
        Map reqMap = new HashMap();
        if(requestMethod.equals("POST")) {
            if(!contentType.equals("text/plain")) 
                body = "body is file,don't show.";
            if(body.length()>1000) 
                body = body.substring(0, 1000);
        }
        if(requestMethod.equals("GET")) {
            // 获取请求参数
            Map ParameterMap =  request.getParameterMap();
            Set<Map.Entry<String,String[]>> entry = ParameterMap.entrySet();
            Iterator<Map.Entry<String,String[]>> it = entry.iterator();
            while (it.hasNext()){
                Map.Entry<String,String[]>  me = it.next();
                String key = me.getKey();
                String value = me.getValue()[0];
                reqMap.put(key,value);
            }
        }
        logger.error("url: "+url+",requestMethod: "+requestMethod+",servletPath: "+servletPath+",body: " + body+",parameterMap: "+reqMap.toString());
        
        
    }

二、获取接口返回的数据

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

代码记录如下：

HttpServletResponseFilter

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.apache.log4j.Logger;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
 
import java.io.IOException;
 
@Component
@WebFilter(filterName = "HttpServletResponseFilter", urlPatterns = "/")
@Order(10000)
public class HttpServletResponseFilter implements Filter {
    static Logger logger = Logger.getLogger(HttpServletResponseFilter.class.getName());
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
 
    }
 
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) servletRequest;
        HttpServletResponse resp = (HttpServletResponse) servletResponse;
        ResponseWrapper mResp = new ResponseWrapper(resp); // 包装响应对象 resp 并缓存响应数据
        filterChain.doFilter(req, mResp);
        byte[] bytes = mResp.getBytes(); // 获取缓存的响应数据
        logger.error(new String(bytes,"utf-8"));
    }
 
    @Override
    public void destroy() {
 
    }
 
}

ResponseWrapper

import javax.servlet.ServletOutputStream;
import javax.servlet.WriteListener;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import java.io.*;
 
public class ResponseWrapper extends HttpServletResponseWrapper {
 
    private ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    private HttpServletResponse response;
    private PrintWriter pwrite;
 
    public ResponseWrapper(HttpServletResponse response) {
        super(response);
        this.response = response;
    }
 
    @Override
    public ServletOutputStream getOutputStream() throws IOException {
        return new MyServletOutputStream(bytes); // 将数据写到 byte 中
    }
 
    /**
     * 重写父类的 getWriter() 方法，将响应数据缓存在 PrintWriter 中
     */
    @Override
    public PrintWriter getWriter() throws IOException {
        try{
            pwrite = new PrintWriter(new OutputStreamWriter(bytes, "utf-8"));
        } catch(UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return pwrite;
    }
 
    /**
     * 获取缓存在 PrintWriter 中的响应数据
     * @return
     */
    public byte[] getBytes() {
        if(null != pwrite) {
            pwrite.close();
            return bytes.toByteArray();
        }
 
        if(null != bytes) {
            try {
                bytes.flush();
            } catch(IOException e) {
                e.printStackTrace();
            }
        }
        return bytes.toByteArray();
    }
 
    class MyServletOutputStream extends ServletOutputStream {
        private ByteArrayOutputStream ostream ;
 
        public MyServletOutputStream(ByteArrayOutputStream ostream) {
            this.ostream = ostream;
        }
 
        @Override
        public void write(int b) throws IOException {
            ostream.write(b); // 将数据写到 stream　中
        }
 
        @Override
        public boolean isReady() {
            // TODO Auto-generated method stub
            return false;
        }
 
        @Override
        public void setWriteListener(WriteListener listener) {
            // TODO Auto-generated method stub
            
        }
 
    }
 
}

到此，关于“springBoot之怎么获取接口请求数据和返回数据实现日志”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注亿速云网站，小编会继续努力为大家带来更多实用的文章！