Spring Boot项目请求日志打印

接口请求日志打印效果如图，基本符合中小型项目所需

直接上代码

• 本代码中使用了hutool的工具包，需要先导入依赖

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.16</version>
        </dependency>

• 先来一个json payload处理类

import cn.hutool.core.util.StrUtil;
import lombok.Getter;
import org.springframework.http.MediaType;

import java.nio.charset.Charset;
import java.util.Collections;
import java.util.Map;

@Getter
public class JsonPayload {
    private final String payload;
    private final Map<String, String> headers;

    public JsonPayload(String payload) {
        this.payload = payload;
        this.headers = Collections.emptyMap();
    }

    public JsonPayload(String payload, Map<String, String> headers) {
        this.payload = payload;
        this.headers = headers;
    }

    public static boolean isText(MediaType mediaType) {
        return mediaType.isCompatibleWith(MediaType.TEXT_HTML) || mediaType.isCompatibleWith(MediaType.TEXT_PLAIN);
    }

    public static boolean isJson(MediaType mediaType) {
        return mediaType.isCompatibleWith(MediaType.APPLICATION_JSON);
    }

    public static boolean isText(String contentType) {
        if (StrUtil.isBlank(contentType)) {
            return false;
        }
        try {
            return isText(MediaType.parseMediaType(contentType));
        } catch (Exception e) {
            return false;
        }
    }

    public static boolean isJson(String contentType) {
        if (StrUtil.isBlank(contentType)) {
            return false;
        }
        try {
            return isJson(MediaType.parseMediaType(contentType));
        } catch (Exception e) {
            return false;
        }
    }

    public static String toString(byte[] data, String characterEncoding) {
        if (data.length > 0) {
            Charset charset = characterEncoding == null ? Charset.defaultCharset() : Charset.forName(characterEncoding);
            return new String(data, charset);
        } else {
            return null;
        }
    }
}

• 再来一个json字符串的处理类

import java.util.Map;

public class JsonStringBuilder {
    private static final char OBJ_START = '{';
    private static final char OBJ_END = '}';
    private static final char FIELD_SPLIT = ',';
    private static final char VALUE_SPLIT = ':';
    private static final String NULL_VALUE = "null";
    public static final char WRAP = '"';
    private static final char ESCAPE_PREFIX = '\\';

    private final static int[] OUTPUT_ESCAPES;

    static {
        int[] table = new int[128];
        for (int i = 0; i < 32; ++i) {
            table[i] = -1;
        }
        table['"'] = '"';
        table['\\'] = '\\';
        table[0x08] = 'b';
        table[0x09] = 't';
        table[0x0C] = 'f';
        table[0x0A] = 'n';
        table[0x0D] = 'r';
        OUTPUT_ESCAPES = table;
    }

    private final StringBuilder stringBuilder;

    public JsonStringBuilder() {
        this(512);
    }

    public JsonStringBuilder(int capacity) {
        this.stringBuilder = new StringBuilder(capacity);
    }

    public JsonStringBuilder startObject() {
        this.stringBuilder.append(OBJ_START);
        return this;
    }

    public JsonStringBuilder endObject() {
        this._removeSplit();
        this.stringBuilder.append(OBJ_END);
        this.stringBuilder.append(FIELD_SPLIT);
        return this;
    }

    public JsonStringBuilder startObject(String name) {
        return _field(name).startObject();
    }

    public JsonStringBuilder field(String name, String value) {
        if (value == null) {
            return nullField(name);
        }
        _field(name);
        this.stringBuilder.append(WRAP);
        for (char c : value.toCharArray()) {
            if (c <= 0x7F && OUTPUT_ESCAPES[c] != 0) {
                this.stringBuilder.append(ESCAPE_PREFIX);
                this.stringBuilder.append(c);
            } else {
                this.stringBuilder.append(c);
            }
        }
        this.stringBuilder.append(WRAP);
        this.stringBuilder.append(FIELD_SPLIT);
        return this;
    }

    public JsonStringBuilder field(String name, Integer value) {
        if (value == null) {
            return nullField(name);
        }
        return fieldRawValue(name, Integer.toString(value));
    }

    public JsonStringBuilder fieldRawValue(String name, String value) {
        if (value == null) {
            return nullField(name);
        }
        _field(name);
        this.stringBuilder.append(value);
        this.stringBuilder.append(FIELD_SPLIT);
        return this;
    }

    public JsonStringBuilder field(String name, Map<String, String> value) {
        if (value == null) {
            return nullField(name);
        }
        startObject(name);
        for (Map.Entry<String, String> entry : value.entrySet()) {
            field(entry.getKey(), entry.getValue());
        }
        endObject();
        return this;
    }


    public JsonStringBuilder nullField(String name) {
        return fieldRawValue(name, NULL_VALUE);
    }

    public String build() {
        this._removeSplit();
        return this.stringBuilder.toString();
    }

    private void _removeSplit() {
        int last = this.stringBuilder.length() - 1;
        if (this.stringBuilder.charAt(last) == FIELD_SPLIT) {
            this.stringBuilder.deleteCharAt(last);
        }
    }

    private JsonStringBuilder _field(String name) {
        this.stringBuilder.append(WRAP);
        this.stringBuilder.append(name);
        this.stringBuilder.append(WRAP);
        this.stringBuilder.append(VALUE_SPLIT);
        return this;
    }


    public static byte[] compress(byte[] data) {
        int offset = 0;
        int length = data.length;
        final byte[] output = new byte[length];
        int counter = 0;
        for (int index = 0; index < length; index++) {
            byte b = data[index];
            if (b == 0x08) {
                continue;
            } else if (b == 0x09) {
                continue;
            } else if (b == 0x0C) {
                continue;
            } else if (b == 0x0A) {
                continue;
            } else if (b == 0x0D) {
                continue;
            } else {
                if (b == 0x22) {
                    counter++;
                }
                if (counter % 2 == 0) {
                    if (b == 0x20) {
                        continue;
                    }
                }
                output[offset] = b;
                offset++;
            }
        }
        if (offset == length) {
            return output;
        } else {
            byte[] dest = new byte[offset];
            System.arraycopy(output, 0, dest, 0, offset);
            return dest;
        }
    }

    public static void escape(String s, StringBuffer sb) {
        if (s == null) return;
        final int len = s.length();
        for (int i = 0; i < len; i++) {
            char ch = s.charAt(i);
            switch (ch) {
                case '"':
                    sb.append("\\\"");
                    break;
                case '\\':
                    sb.append("\\\\");
                    break;
                case '\b':
                    sb.append("\\b");
                    break;
                case '\f':
                    sb.append("\\f");
                    break;
                case '\n':
                    sb.append("\\n");
                    break;
                case '\r':
                    sb.append("\\r");
                    break;
                case '\t':
                    sb.append("\\t");
                    break;
                case '/':
                    sb.append("\\/");
                    break;
                default:
                    //Reference: http://www.unicode.org/versions/Unicode5.1.0/
                    if ((ch >= '\u0000' && ch <= '\u001F') || (ch >= '\u007F' && ch <= '\u009F') || (ch >= '\u2000' && ch <= '\u20FF')) {
                        String ss = Integer.toHexString(ch);
                        sb.append("\\u");
                        for (int k = 0; k < 4 - ss.length(); k++) {
                            sb.append('0');
                        }
                        sb.append(ss.toUpperCase());
                    } else {
                        sb.append(ch);
                    }
            }
        }//for
    }
}

• request请求体处理类

import lombok.Getter;
import org.springframework.util.StreamUtils;
import org.springframework.web.util.ContentCachingRequestWrapper;

import javax.servlet.ServletInputStream;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.Map;

@Getter
public class LogRequest extends JsonPayload {
    private final String method;
    private final String remoteAddr;
    private final String requestURI;
    private final Map<String, String> parameters;

    private static final byte[] EMPTY = new byte[0];

    public LogRequest(ContentCachingRequestWrapper request) {
        super(getPayload(request, request.getCharacterEncoding(), request.getContentType()), getHeaders(request));
        this.method = request.getMethod();
        this.remoteAddr = request.getRemoteAddr();
        this.requestURI = request.getRequestURI();
        this.parameters = getRequestParam(request);
    }

    public static Map<String, String> getHeaders(ContentCachingRequestWrapper request) {
        LinkedHashMap<String, String> singleValueMap = new LinkedHashMap<>();
        for (Enumeration<String> names = request.getHeaderNames(); names.hasMoreElements(); ) {
            String headerName = names.nextElement();
            singleValueMap.put(headerName, request.getHeader(headerName));
        }
        return singleValueMap;
    }

    private static Map<String, String> getRequestParam(ContentCachingRequestWrapper request) {
        Map<String, String[]> parameters = request.getParameterMap();
        LinkedHashMap<String, String> singleValueMap = new LinkedHashMap<>(parameters.size());
        parameters.forEach((key, valueList) -> singleValueMap.put(key, valueList == null ? null : valueList[0]));
        return singleValueMap;
    }

    private static String getPayload(ContentCachingRequestWrapper request, String characterEncoding, String contentType) {
        if (!isJson(contentType)) {
            return null;
        }
        return toString(getPayload(request), characterEncoding);
    }

    private static byte[] getPayload(ContentCachingRequestWrapper request) {
        try {
            ServletInputStream is = request.getRequest().getInputStream();
            byte[] rawData;
            if (is.isFinished()) {
                rawData = request.getContentAsByteArray();
            } else {
                rawData = StreamUtils.copyToByteArray(request.getInputStream());
            }
            return JsonStringBuilder.compress(rawData);
        } catch (Exception e) {
            return EMPTY;
        }
    }
}

• response响应体处理类

import lombok.Getter;
import org.springframework.web.util.ContentCachingResponseWrapper;

import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map;

@Getter
public final class LogResponse extends JsonPayload {
    private final int status;

    public LogResponse(ContentCachingResponseWrapper response) {
        super(getPayload(response, response.getCharacterEncoding(), response.getContentType()), getHeaders(response));
        this.status = response.getStatus();
    }

    public static Map<String, String> getHeaders(ContentCachingResponseWrapper response) {
        LinkedHashMap<String, String> singleValueMap = new LinkedHashMap<>();
        Collection<String> names = response.getHeaderNames();
        for (String headerName : names) {
            singleValueMap.put(headerName, response.getHeader(headerName));
        }
        return singleValueMap;
    }

    private static String getPayload(ContentCachingResponseWrapper response, String characterEncoding, String contentType) {
        if (!isJson(contentType)) {
            if (isText(contentType)) {
                StringBuffer sb = new StringBuffer();
                sb.append(JsonStringBuilder.WRAP);
                JsonStringBuilder.escape(toString(response.getContentAsByteArray(), characterEncoding), sb);
                sb.append(JsonStringBuilder.WRAP);
                return sb.toString();
            } else {
                return null;
            }
        }
        return toString(response.getContentAsByteArray(), characterEncoding);
    }
}

• filter拦截器处理类

import cn.hutool.json.JSONUtil;
import com.ximen.cocktailserver.utils.JsonStringBuilder;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;
import org.springframework.web.filter.OncePerRequestFilter;
import org.springframework.web.util.ContentCachingRequestWrapper;
import org.springframework.web.util.ContentCachingResponseWrapper;
import org.springframework.web.util.WebUtils;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;

@Component
@Slf4j(topic = "request.log")
public final class LogFilter extends OncePerRequestFilter {

    @Override
    protected boolean shouldNotFilterAsyncDispatch() {
        return false;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        // 白名单的路径不做处理
        if (writeList(String.valueOf(request.getRequestURI()))) {
            filterChain.doFilter(request, response);
            return;
        }
        long cost = 0;
        HttpServletRequest requestToUse = request;
        if (!isAsyncDispatch(request) && !(request instanceof ContentCachingRequestWrapper)) {
            requestToUse = new ContentCachingRequestWrapper(request);
        }
        HttpServletResponse responseToUse = response;
        if (!isAsyncDispatch(request) && !(response instanceof ContentCachingResponseWrapper)) {
            responseToUse = new ContentCachingResponseWrapper(response);
        }
        try {
            StopWatch watch = new StopWatch();
            watch.start();
            filterChain.doFilter(requestToUse, responseToUse);
            watch.stop();
            cost = watch.getTotalTimeMillis();
        } finally {
            if (!isAsyncStarted(requestToUse)) {
                LogRequest logRequest = new LogRequest((ContentCachingRequestWrapper) requestToUse);
                LogResponse logResponse = new LogResponse((ContentCachingResponseWrapper) responseToUse);
                boolean isJson = JSONUtil.isTypeJSON(logResponse.getPayload());
                // 根据自己的情况，判断什么时候需要打印日志，我是把错误的请求日志才打印出来
                if (logResponse.getStatus() != 200 || (isJson && JSONUtil.parseObj(logResponse.getPayload()).getInt("code", 1001) != 200)) {
                    log.info(logFormatter(logRequest, logResponse, cost));
                }
                ContentCachingResponseWrapper wrapper = WebUtils.getNativeResponse(responseToUse, ContentCachingResponseWrapper.class);
                if (wrapper != null) {
                    wrapper.copyBodyToResponse();
                }
            }
        }
    }

    private String logFormatter(LogRequest request, LogResponse response, long spendTime) {
        JsonStringBuilder jsonBuilder = new JsonStringBuilder(2000);
        jsonBuilder.startObject()
                .field("timestamp", LocalDateTime.now().atZone(ZoneId.systemDefault()).format(DateTimeFormatter.ISO_ZONED_DATE_TIME))
                .field("uri", request.getRequestURI())
                .field("method", request.getMethod())
                .field("refer", request.getRemoteAddr())
                .field("status", response.getStatus())
                .field("time", spendTime + "ms")
                .startObject("request")
                .fieldRawValue("body", request.getPayload())
                .field("param", request.getParameters())
                .field("header", request.getHeaders())
                .endObject()
                .fieldRawValue("response", response.getPayload())
                .endObject();
        return jsonBuilder.build();
    }

    private boolean writeList(String path) {
        return path.equals("/") ||
                path.startsWith("/actuator") ||
                path.startsWith("/plumelog") ||
                path.startsWith("/doc.html") ||
                path.startsWith("/swagger-resources") ||
                path.startsWith("/v2/api-docs") ||
                path.equals("/swagger-ui.html") ||
                path.startsWith("/webjars");
    }

}

白名单这块自己根据情况去加吧，equals就是某个全路径，startsWith就是以什么开始的路径。（这里的路径都指的是除去localhost端口号那些，看代码应该就能知道）

• 如果日志打印出来的编码有问题，可以设置下yml配置文件

server:
  servlet:
    encoding:
      charset: UTF-8
      force-response: true

本栏目推荐文章
• 基于VueCli自定义创建项目
• spring与设计模式之三代理模式
• IDEA项目名称后面出现中括号，模块Modules的名子和文件夹名称不同，可以右键修改名称也可以在File->Project Structure 修改Modules的Name(快捷键ctrl+Shift+Alt+s)
• 去年最火的 JS 开源项目「GitHub 热点速览」
• 深入理解spring框架：剖析多线程模式下数据库连接
• oracle清除日志
• 用jacoco统计JAVA项目测试代码覆盖率
• 第二章 Spring Boot 整合 Kafka消息队列 生产者
• Spring表达式语言（SPEL）学习（03）
• Spring事务状态处理

项目 Spring 日志 Boot项目spring日志boot 框架spring日志boot 乱码spring日志boot 文件spring日志boot spring slf4j日志boot 日志spring系统boot2 项目spring mysql boot spring-boot时报 错误 项目 openfeign项目spring boot 参数 项目spring boot2