日志输出-第二章-接口级出入参的实现

阿沐沐，

已于 2024-05-29 11:55:05 修改

阅读量1k

点赞数 25

分类专栏：日志相关实现 spirng cloud springboot 文章标签： java 开发语言

于 2024-05-22 15:14:01 首次发布

本文链接：https://blog.csdn.net/qq_26103133/article/details/139120943

版权

springboot 同时被 3 个专栏收录

5 篇文章 0 订阅

订阅专栏

日志相关实现

4 篇文章 0 订阅

订阅专栏

spirng cloud

3 篇文章 0 订阅

订阅专栏

在这里插入图片描述

文章目录

日志输出-第二章-接口级出入参的实现

日志输出-第二章-接口级出入参的实现

上一章的内容为：日志输出指南

一、概述

上一章已经对日志输出的大概注意事项做了阐述，本章将介绍对应的一些统一出入参的内容

ps：仅代表个人经验嗷

一般我在使用的时候，会接入到 SkyWalking 或者是 ELK，但是不接入使用也不是不行，只是需要上服务器去抓日志文件，没那么方便。

1.1、单机时代

这个时候的出入参记录一般是分为两种粒度

接口级的出入参记录
方法级的出入参记录

根据不同的情况来选择不同的记录方式，以方便排查问题。

接口级：

一般是必备的，知道了请求的入参，这个时候在生产排查问题的时候，就可以通过入参来溯源，简化了排查的难度。

方法级：

一般是不会有的，主要问题在于如果你有一个比较优雅的编程习惯的话，正常情况下逻辑应该是非常清晰的。也就是说正常情况下你拿到了 Controller 的请求参数，然后去看逻辑的话应该是很简单方便的，除非是老代码，逻辑判断非常复杂各个方法耦合非常严重，才需要采用这种方式。

1.2、微服务时代

在微服务时代，由于存在多服务之间互相调用的问题，一般会在流量入口处（比如说 GateWay）多加一个日志。

也就是说这种情况下分为三种粒度：

网关级的出入参记录
接口级的出入参记录
方法级的出入参记录

二、实现接口级出入参记录

接口级的具体实现方式一般分为三种：

通过 HandlerInterceptor 的方式进行拦截
通过 Spring 的切面
通过 Filter

这三种的相对来说 Filter 的性能是最好的，因为它是流量的出入口，下面将采用 Nacos+Filter 来实现。

2.1、Nacos 配置类


import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

/**
 * @ClassName AutoLogConfig
 * @Author lizelin
 * @Description 日志 Nacos 动态刷新配置
 * @Date 2023/11/3 18:01
 * @Version 1.0
 */
@Data
@Configuration
@ConfigurationProperties(prefix = "auto.log")
public class AutoLogConfig {

    /**
     * 是否开启日志开关
     */
    private Boolean enabled = false;
    /**
     * 配置需要输出的 headers
     */
    private String[] headers;
    /**
     * 是否打印所有请求头
     */
    private Boolean printAllHeaders = false;
    /**
     * 排除前缀 Url
     */
    private String[] excludePrefixUrls;
}

yaml 不会写的话，可以参照 yaml书写指南

2.2、日志实现


import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.StrUtil;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Enumeration;

/**
 * @ClassName LogHandlerInterceptor
 * @Author lizelin
 * @Description 日志请求入参过滤器
 * @Date 2023/11/3 12:15
 * @Version 1.0
 */
@Slf4j
@Component
@AllArgsConstructor
public class LogRecordRequestFilter implements Filter, Ordered {

    private final AutoLogConfig autoLogConfig;

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        Boolean enabled = autoLogConfig.getEnabled();
        if (Boolean.TRUE.equals(enabled)) {
			//排除前缀
            String[] excludePrefixUrls = autoLogConfig.getExcludePrefixUrls();
            HttpServletRequest httpServletRequest = (HttpServletRequest) request;
            String requestURI = httpServletRequest.getRequestURI();

            for (String item : excludePrefixUrls) {
                if (StrUtil.startWith(requestURI,item,true)) {
                    //不处理，直接向下传递
                    chain.doFilter(request, response);
                    return;
                }
            }

            StringBuilder builder = new StringBuilder();
            builder.append(" LogRecordRequestFilter ");
            String method = httpServletRequest.getMethod();
            builder.append(method).append(" ");
            //1.对 GET 处理
            handlerBefore(builder, httpServletRequest);
            //2.对 header 处理
            handlerHeader(builder, httpServletRequest);
            //输出 request 日志
            log.info(builder.toString());

            HttpServletResponse httpServletResponse = (HttpServletResponse) response;
            chain.doFilter(httpServletRequest, httpServletResponse);

            //输出 response 日志处理
            responseLog(httpServletResponse, builder);
        } else {
            //如果不处理，则直接向下传递
            chain.doFilter(request, response);
        }

    }

    /**
     * @Param responseWrapper
     * @Param builder
     * @Return void
     * @Description 输出 response 日志
     * @Author lizelin
     * @Date 2023/11/6 12:15
     **/
    private void responseLog(HttpServletResponse response, StringBuilder builder) throws IOException {
        int status = response.getStatus();
        builder.append(" HTTP status: ");
        builder.append(status);
        builder.append(" ContentType: ");
        builder.append(response.getContentType());
        //输出 response 日志
        log.info(builder.toString());
    }

    /**
     * @Param
     * @Return void
     * @Description 前置处理
     * @Author lizelin
     * @Date 2023/11/3 18:51
     **/
    private void handlerBefore(StringBuilder builder, HttpServletRequest requestWrapper) {
        //生成完整 URL
        String requestURI = requestWrapper.getRequestURI();
        String queryString = requestWrapper.getQueryString();
        builder.append("URL : ").append(requestURI);
        if (StrUtil.isNotEmpty(queryString)) {
            builder.append("?");
            builder.append(queryString);
        }
        builder.append("");
    }

    /**
     * @Param builder
     * @Param request
     * @Return void
     * @Description 对 header 进行处理
     * @Author lizelin
     * @Date 2023/11/3 18:57
     **/
    private void handlerHeader(StringBuilder builder, HttpServletRequest request) {
        String[] headers = autoLogConfig.getHeaders();
        Boolean printAllHeaders = autoLogConfig.getPrintAllHeaders();
        //打印所有
        if (Boolean.TRUE.equals(printAllHeaders)) {
            builder.append(" header : ");
            Enumeration<String> headerNames = request.getHeaderNames();
            while (headerNames.hasMoreElements()) {
                String headerName = headerNames.nextElement();
                String header = request.getHeader(headerName);
                builder.append(headerName).append("=").append(header).append(", ");
            }
            builder.append(" ");
        }else if (ArrayUtil.isNotEmpty(headers)) {
            //打印指定
            builder.append(" header : ");
            for (String item : headers) {
                String header = request.getHeader(item);
                if (StrUtil.isNotEmpty(header)) {
                    builder.append(item).append("=").append(header).append(", ");
                }
            }
            builder.append(" ");
        }
    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;
    }
}