springboot Controller层返回的结果，日志添加traceId ，方便对日志的追踪查询

要解决的问题？

接口报错，如何快速定位问题？这个需要日志的辅助，一般错误日志中有详细的堆栈信息，具体是哪行代码报错，都可以看到。

要想快速定位问题，前提是要能够快速定位日志。

海量日志，如何定位呢？

日志量一般都是很大的，如何能够从大量日志中找到自己需要的日志呢？

解决方案

1、服务端入口处可以生成一个唯一的id，记做：traceId

2、日志中均需要输出traceId的值

3、接口返回值中，添加一个通用的字段：traceId，将上面的traceId作为这个字段的值

4、这样前端发现接口有问题的时候，直接将这个traceId提供给我们，我们便可以在日志中快速查询出对应的日志。
 

具体实现步骤

0 pom.xml

       <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

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

1 ThreadLocal工具类

import org.slf4j.MDC;

public class TraceUtils {
    public static final String TRACE_ID = "traceId";
    public static ThreadLocal<String> traceIdThreadLocal = new ThreadLocal<>();

    public static String getTraceId() {
        return traceIdThreadLocal.get();
    }

    public static void setTraceId(String traceId) {
        traceIdThreadLocal.set(traceId);
        MDC.put(TRACE_ID, traceId);
    }

    public static void removeTraceId() {
        traceIdThreadLocal.remove();
        MDC.remove(TRACE_ID);
    }

}

2 创建一个Filter过滤器，拦截所有请求，入口生成一个唯一的traceId，放到ThreadLocal中

import cn.hutool.core.util.IdUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Order(Ordered.HIGHEST_PRECEDENCE)
@WebFilter(urlPatterns = "/**", filterName = "TraceFilter")
@Component
public class TraceFilter extends OncePerRequestFilter {
    public static Logger logger = LoggerFactory.getLogger(TraceFilter.class);

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String traceID = IdUtil.fastSimpleUUID();
        TraceUtils.setTraceId(traceID);
        long st = System.currentTimeMillis();
        try {
            filterChain.doFilter(request, response);
        } finally {
            long et = System.currentTimeMillis();
            logger.info("请求地址:{},耗时(ms):{}", request.getRequestURL().toString(), (et - st));
            TraceUtils.removeTraceId();
        }
    }
}

3 日志中输出traceId

需要在MDC中设置一下traceId：MDC.put("traceId", traceId);

MDC是logback为我们提供的一个扩展的入口，可以向里面放入一些键值对，然后在logback中的日志中就可以通过这个traceId获取到对应的值

如下，logback.xml中使用%X{traceId}可以获取到MDC中设置的traceId

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss} [%thread] [traceId:%X{traceId}] - %msg%n</pattern>
        </encoder>
    </appender>

    <logger name="com.beijing.web" level="info" />

    <root level="info">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

4 返回值中添加通用字段traceId

我们这里使用的是通用返回值Result，也就是所有接口的返回值均是Result类型，定义如下，我们在里面添加了一个traceId字段，这个值如何写入呢？看后面

public class Result<T> {
    /**
     * 请求是否处理成功？
     */
    private boolean success;
    /**
     * 数据，泛型类型，后端需要返回给前端的业务数据可以放到这个里面
     */
    public T data;
    /**
     * 提示消息，如success为false的时给用户的提示信息
     */
    private String msg;
    /**
     * 错误编码，某些情况下，后端可以给前端提供详细的错误编码，前端可以根据不同的编码做一些不同的操作
     */
    private String code;

    /**
     * 链路追踪id
     */
    private String traceId;


    public Result(boolean success, T data, String msg) {
        this.success = success;
        this.data = data;
        this.msg = msg;
    }

    public Result(boolean success, T data, String code, String msg) {
        this.success = success;
        this.data = data;
        this.code = code;
        this.msg = msg;
    }

}

5 通过aop将traceId写入响应结果的Result中

下面我们使用aop创建了一个环绕通知，会拦截controller的所有方法，以及全局异常处理器的方法，对Result类型的返回值进行统一处理，将traceId设置到Result中traceId字段中，其中 GlobalExceptionHandler 类是全局异常处理类（
@RestControllerAdvice，

@ExceptionHandler(Exception.class)
public Result handleException(Exception e, HttpServletRequest request)

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Aspect
@Component
@Order
public class ResultTraceIdAspect {
    
    @Pointcut("execution(* com.example.demo_22..*(..)) || execution(* com.example.demo_22.GlobalExceptionHandler.*(..))")
    public void pointCut() {
    }

    @Around("pointCut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        Object object = pjp.proceed();
        if (object instanceof Result) {
            ((Result<?>) object).setTraceId(TraceUtils.getTraceId());
        }
        return object;
    }

}

6 Controller层，写两个方法用于测试

import com.example.demo_22.sg.Result;
import com.example.demo_22.sg.ResultUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.TimeUnit;

@RestController
public class HelloController {
    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @GetMapping
    public Result<String> hello() throws InterruptedException {
        logger.info("开始执行业务");
        TimeUnit.MILLISECONDS.sleep(500);
        logger.info("业务执行结束");
        return ResultUtils.success("你好");
    }

    @GetMapping("/exception")
    public Result<String> exception() throws InterruptedException {
        logger.info("开始执行业务");
        //这里模拟了一个错误，10/0，会报错
        System.out.println(10 / 0);
        logger.info("业务执行结束");
        return ResultUtils.success("你好");
    }
}

测试，效果如下