java 记录传参和返回值

古城微笑少年丶 2024-03-31 14:29 68阅读 0赞

本文介绍的拦截器是基于 Filter 的实现，没有使用 spring AOP 切面的技术

场景：在实际开发中，部分接口是通过 jar 包引入的，由于 Pointcut 切入的是工程包内的方法，所以引入的接口并不好覆盖。例如引入 spring security 后拥有的 /oauth/token 请求

## 传参 ##

自定义包装类

*  继承：HttpServletRequest 有个特性，就是 getReader() 方法获取一次之后，便无法再次获取，所以这里使用包装类，继承 HttpServletRequestWrapper
 *  构造方法：传入 HttpServletRequest ，判断是否文件流，是则不做处理
 *  获取 body：读取流 getReader()，获取 body 传参
 *  获取 params：通过自定义方法 getParams() 获取，使用了 cn.hutool.json 的 JSONObject 类

import cn.hutool.json.JSONObject;
    import org.apache.commons.fileupload.servlet.ServletFileUpload;
    import javax.servlet.ReadListener;
    import javax.servlet.ServletInputStream;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletRequestWrapper;
    import java.io.BufferedReader;
    import java.io.ByteArrayInputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.nio.charset.StandardCharsets;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Optional;
    import java.util.Set;
    
    public class RequestWrapper extends HttpServletRequestWrapper {
        
    
        private byte[] body;
        private Map<String, String[]> paramMap;
    
        public RequestWrapper(HttpServletRequest request) throws IOException {
        
            super(request);
            if (ServletFileUpload.isMultipartContent(request)) {
        
                return;
            }
            StringBuilder sb = new StringBuilder();
            String line;
            BufferedReader reader = request.getReader();
            while ((line = reader.readLine()) != null) {
        
                sb.append(line);
            }
            String body = sb.toString();
            this.body = body.getBytes(StandardCharsets.UTF_8);
    
            this.paramMap=request.getParameterMap();
        }
    
        public String getBody() {
        
            return new String(this.body, StandardCharsets.UTF_8);
        }
    
        @Override
        public ServletInputStream getInputStream() {
        
            final ByteArrayInputStream bais = new ByteArrayInputStream(body);
            return new ServletInputStream() {
        
                @Override
                public boolean isFinished() {
        
                    return false;
                }
    
                @Override
                public boolean isReady() {
        
                    return false;
                }
    
                @Override
                public void setReadListener(ReadListener readListener) {
        
                }
    
                @Override
                public int read() {
        
                    return bais.read();
                }
            };
        }
    
        @Override
        public BufferedReader getReader() {
        
            return new BufferedReader(new InputStreamReader(this.getInputStream()));
        }
    
        public String getParams() {
        
            Map<String, String[]> map = this.paramMap;
            JSONObject obj = new JSONObject();
            if (Optional.ofNullable(map).isPresent()) {
        
                Set<String> set = map.keySet();
                Iterator iterator = set.iterator();
                while (iterator.hasNext()) {
        
                    Object key = iterator.next();
                    String[] arr = map.get(key);
                    if (Optional.ofNullable(arr).isPresent()) {
        
                        for (String v : arr) {
        
                            obj.putOnce((String) key, v);
                        }
                    }
    
                }
            }
            return obj.toString();
        }
    }

## 返回值 ##

自定义包装类

*  继承：继承 HttpServletResponseWrapper
 *  构造方法：传入 HttpServletResponse
 *  获取返回值字节流：getContent()
 *  获取 params：通过自定义方法 getParams() 获取，使用了 cn.hutool.json 的 JSONObject 类

import javax.servlet.ServletOutputStream;
    import javax.servlet.WriteListener;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpServletResponseWrapper;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    
    public class ResponseWrapper extends HttpServletResponseWrapper {
        
    
        private ByteArrayOutputStream buffer;
    
        private ServletOutputStream out;
    
        public ResponseWrapper(HttpServletResponse httpServletResponse) {
        
            super(httpServletResponse);
            buffer = new ByteArrayOutputStream();
            out = new WrapperOutputStream(buffer);
        }
    
        @Override
        public ServletOutputStream getOutputStream() throws IOException {
        
            return out;
        }
    
        @Override
        public void flushBuffer() throws IOException {
        
            if (out != null) {
        
                out.flush();
            }
        }
    
        public byte[] getContent() throws IOException {
        
            flushBuffer();
            return buffer.toByteArray();
        }
    
        public String getResponseContent() {
        
            return new String(buffer.toByteArray());
        }
    
        class WrapperOutputStream extends ServletOutputStream {
        
            private ByteArrayOutputStream bos;
    
            public WrapperOutputStream(ByteArrayOutputStream bos) {
        
                this.bos = bos;
            }
    
            @Override
            public void write(int b) throws IOException {
        
                bos.write(b);
            }
    
            @Override
            public boolean isReady() {
        
                return false;
            }
    
            @Override
            public void setWriteListener(WriteListener arg0) {
        
    
            }
        }
    
    }

## 过滤器 ##

对于一般的传入参记录，我们需要记录以下字段

*  接口 uri
 *  接口方法 method
 *  传参 params，即问号传参
 *  传参 body，即 Content-Type = application/json

自定义过滤器，实现接口 Filter

*  urlPatterns：过滤相应规则的 url，可设置多个，传参为字符串数组
 *  POINT：url 含有字符串点的不过滤，例如脚本、图片（.jsp、.jpg） 等
 *  doFilter：传入 RequestWrapper 和 ResponseWrapper
 *  ServletResponse：返回输出流，若不设置，返回值为空

import cn.hutool.json.JSONUtil;
    import com.njc.java.property.KafkaTopicProperty;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.kafka.core.KafkaTemplate;
    import org.springframework.stereotype.Component;
    import javax.annotation.Resource;
    import javax.servlet.*;
    import javax.servlet.annotation.WebFilter;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
     
    @Slf4j
    @Component
    @WebFilter(filterName = "channelFilter", urlPatterns = {
        "/*"})
    public class ChannelFilter implements Filter {
        
    
        private static final String POINT = ".";
    
        @Override
        public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
        
            HttpServletRequest httpRequest = (HttpServletRequest) request;
            String uri = httpRequest.getRequestURI();
    
            if (uri.contains(POINT)) {
        
                try {
        
                    chain.doFilter(request, response);
                } catch (Exception e) {
        
                    log.error(e.getMessage());
                }
    
            } else {
        
                try {
        
                    RequestWrapper requestWrapper = new RequestWrapper(httpRequest);
                    ResponseWrapper responseWrapper = new ResponseWrapper((HttpServletResponse) response);
    
                    String method = httpRequest.getMethod();
                    String paramBody = requestWrapper.getBody();
                    String param = requestWrapper.getParams();
    
                    chain.doFilter(requestWrapper, responseWrapper);
    
                    String msgStr = responseWrapper.getResponseContent();
                    ServletOutputStream out = response.getOutputStream();
                    out.write(responseWrapper.getContent());
                    out.flush();
    
                } catch (Exception e) {
        
                    log.error(e.getMessage());
                }
            }
        }
    }

## 日志收集 ##

*  一般做法可以把日志收集到当前服务的数据库中
 *  若使用微服务架构开发，建议规划日志收集服务，通过 kafka 统一收集日志，用 MongoDB 存储日志信息