背景介绍
甲方客户的生产系统，有安全风险预警和安全事件快速溯源要求，需要做一套日志管理规范。
要求我们接入的系统，要对用户登录、注册、密码修改等重要场景，严格按照提供的格式，输出相应的日志。
后续通过filebeat对接，收集我们系统上的日志信息。
简单来说，就是应用系统，处理接口请求时，统一打印相应日志。
问题描述
成熟且常见的日志统一打印方案，就是使用AOP技术，自定义注解，在切面上使用环绕通知@Around，拦截请求，获取Controller类上方法的入参、出参即可。
奈何业务场景使用到的接口，以前的人在实现的时候，使用了如下方式：
@RequestMapping(value = "/auth", method = { RequestMethod.POST, RequestMethod.GET, RequestMethod.OPTIONS })
public void auth(HttpServletRequest req, HttpServletResponse resp) {
authService.auth(req, resp);
}
复制代码把传参直接丢在 HttpServletRequest 中。
返回参数，又是采用 HttpServletResponse 输出。
public void printResult(HttpServletRequest req, HttpServletResponse resp,
String action, int code, String msg, Object result) {
PrintWriter p = null;
Ret ret = new Ret();
Gson gson = new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss")
.serializeNulls()
.create();
try {
p = resp.getWriter();
ret.setRspCode(code);
ret.setRspDesc(msg);
ret.setData(result);
p.write(gson.toJson(ret));
return;
} catch (Exception e) {
logger.error(e.getMessage());
} finally {
p.flush();
p.close();
}
}
复制代码不像平时熟练的做法，把具体入参和出参，用对象封装，直接放在方法上即可。
因为上面的做法，导致我们在拦截器中，想提前拦截请求获取传参，使用 request.getParameter() 等方法时，能拿到参数。 但是在具体接口业务流程中，再使用request.getParameter() 等方法，传入参数就获取不到了。
因为流只能被读一次。
因此就抛出一个问题：Request 和 Response 怎么重复读取？
解决方案
使用request.getParameter() 等方法，最终会调用getInputStream方法。
需要重写HttpServletRequestWrapper包装类，在调用getInputStream方法时，将流数据同时写到缓存。
后面想获取参数，直接读取缓存数据即可。
这样就可以实现Request的内容多次读取。
实现代码
封装request
自定义类 ContentCachingRequestWrapper
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;
/**
*
* 重写 HttpServletRequestWrapper
*
* @Author: linzengrui
* @Date: 2021/11/22 15:33
*/
public class ContentCachingRequestWrapper extends HttpServletRequestWrapper {
private final byte[] body;
public ContentCachingRequestWrapper(HttpServletRequest request) {
super(request);
StringBuilder sb = new StringBuilder();
try (BufferedReader reader = new BufferedReader(new InputStreamReader(request.getInputStream(), StandardCharsets.UTF_8))){
String line = "";
while ((line = reader.readLine()) != null) {
sb.append(line);
}
} catch (IOException e) {
e.printStackTrace();
}
body = sb.toString().getBytes(StandardCharsets.UTF_8);
}
@Override
public BufferedReader getReader() throws IOException {
return new BufferedReader(new InputStreamReader(getInputStream()));
}
@Override
public ServletInputStream getInputStream() throws IOException {
final ByteArrayInputStream inputStream = 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() throws IOException {
return inputStream.read();
}
};
}
public byte[] getBody() {
return body;
}
}
复制代码封装response
自定义类 ContentCachingResponseWrapper
import javax.servlet.ServletOutputStream;
import javax.servlet.WriteListener;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import java.io.*;
/**
*
* 重写 HttpServletResponseWrapper
*
* @Author: linzengrui
* @Date: 2021/11/22 19:45
*/
public class ContentCachingResponseWrapper extends HttpServletResponseWrapper {
private ByteArrayOutputStream byteArrayOutputStream;
private ServletOutputStream servletOutputStream;
private PrintWriter printWriter;
public ContentCachingResponseWrapper(HttpServletResponse response) {
super(response);
byteArrayOutputStream = new ByteArrayOutputStream();
servletOutputStream = new ServletOutputStream() {
@Override
public boolean isReady() {
return false;
}
@Override
public void setWriteListener(WriteListener writeListener) {
}
@Override
public void write(int b) throws IOException {
byteArrayOutputStream.write(b);
}
};
printWriter = new PrintWriter(byteArrayOutputStream);
}
@Override
public PrintWriter getWriter() {
return printWriter;
}
@Override
public ServletOutputStream getOutputStream() throws IOException {
return servletOutputStream;
}
public byte[] toByteArray() {
return byteArrayOutputStream.toByteArray();
}
}
复制代码过滤器 Filter 拦截请求
拦截器 LogFilter 使用上面封装的包装类，即可获取传参。
@Slf4j
@WebFilter(urlPatterns = "/*")
public class LogFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
// 使用 重写 HttpServletRequestWrapper 的自定义包装类
ContentCachingRequestWrapper requestWrapper = new ContentCachingRequestWrapper((HttpServletRequest)request);
// 使用 重写 HttpServletResponseWrapper 的自定义包装类
ContentCachingResponseWrapper responseWrapper = new ContentCachingResponseWrapper((HttpServletResponse) response);
// 只能执行一次获取流方法
try(ServletOutputStream outputStream = response.getOutputStream()){
// 获取传参
String requestParamJson = new String(requestWrapper.getBody());
log.info("requestParamJson --> {}", requestParamJson);
// 具体方法执行流程
chain.doFilter(requestWrapper, responseWrapper);
// 触发获取流操作后，可以从缓存多次拿数据
String respDataJson = new String(responseWrapper.toByteArray());
log.info("respDataJson <-- {}", respDataJson);
// TODO 写日志
// 需要重新写入内容，否则流无输出内容
outputStream.write(respDataJson.getBytes(StandardCharsets.UTF_8));
outputStream.flush();
}catch (Exception e){
e.printStackTrace();
}
}
@Override
public void destroy() {
}
}
复制代码springboot 启动类添加注解 @ServletComponentScan
注意：启动类要加上注解@ServletComponentScan识别上面注入的Filter。
import org.springframework.boot.SpringApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;
@ServletComponentScan
@SpringBootApplication
public class SpringBootApplication {
public static void main(String[] args) {
SpringApplication.run(SpringBootApplication.class, args);
}
}
复制代码具体业务接口，原来的逻辑保持不变，仍然可以获取到入参。