关于java:Spring-Boot-MDC-实现全链路调用日志跟踪这才叫优雅

15次阅读

共计 7555 个字符，预计需要花费 19 分钟才能阅读完成。

作者：何甜甜在吗 \
起源: juejin.cn/post/6844904101483020295

之前有一篇文章简略的介绍过 MDC，这次联合具体的案例、生产中的具体问题深刻理解一下 MDC。

MDC 介绍

1、简介：

MDC（Mapped Diagnostic Context，映射调试上下文）是 log4j、logback及 log4j2 提供的一种不便在多线程条件下记录日志的性能。MDC 能够看成是一个 与以后线程绑定的哈希表 ，能够往其中增加键值对。MDC 中蕴含的内容能够 被同一线程中执行的代码所拜访。

以后线程的子线程会继承其父线程中的 MDC 的内容。当须要记录日志时，只须要从 MDC 中获取所需的信息即可。MDC 的内容则由程序在适当的时候保留进去。对于一个 Web 利用来说，通常是在申请被解决的最开始保留这些数据。

2、API 阐明：

  • clear()：移除所有 MDC
  • get (String key)：获取以后线程 MDC 中指定 key 的值
  • getContext()：获取以后线程 MDC 的 MDC
  • put(String key, Object o)：往以后线程的 MDC 中存入指定的键值对
  • remove(String key)：删除以后线程 MDC 中指定的键值对

3、长处：

代码简洁，日志格调对立，不须要在 log 打印中手动拼写traceId，即LOGGER.info(“traceId:{} “, traceId)。

MDC 应用

1、增加拦截器

public class LogInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 如果有下层调用就用下层的 ID
        String traceId = request.getHeader(Constants.TRACE_ID);
        if (traceId == null) {traceId = TraceIdUtil.getTraceId();
        }

        MDC.put(Constants.TRACE_ID, traceId);
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
            throws Exception { }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        // 调用完结后删除
        MDC.remove(Constants.TRACE_ID);
    }
}

2、批改日志格局

<property name="pattern">[TRACEID:%X{traceId}] %d{HH:mm:ss.SSS} %-5level %class{-1}.%M()/%L - %msg%xEx%n</property>

重点是 %X{traceId}，traceId 和 MDC 中的键名称统一

简略应用就这么容易，然而在有些状况下 traceId 将获取不到。

MDC 存在的问题

  • 子线程中打印日志失落 traceId
  • HTTP 调用失落 traceId

失落 traceId 的状况，来一个再解决一个，绝不提前优化。

解决 MDC 存在的问题

子线程日志打印失落 traceId

子线程在打印日志的过程中 traceId 将失落，解决形式为重写线程池，对于间接 new 创立线程的状况不考略【理论利用中应该防止这种用法】，重写线程池无非是对工作进行一次封装。

线程池封装类：ThreadPoolExecutorMdcWrapper.java

public class ThreadPoolExecutorMdcWrapper extends ThreadPoolExecutor {
    public ThreadPoolExecutorMdcWrapper(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
                                        BlockingQueue<Runnable> workQueue) {super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    public ThreadPoolExecutorMdcWrapper(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
                                        BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
    }

    public ThreadPoolExecutorMdcWrapper(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
                                        BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
    }

    public ThreadPoolExecutorMdcWrapper(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
                                        BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,
                                        RejectedExecutionHandler handler) {super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
    }

    @Override
    public void execute(Runnable task) {super.execute(ThreadMdcUtil.wrap(task, MDC.getCopyOfContextMap()));
    }

    @Override
    public <T> Future<T> submit(Runnable task, T result) {return super.submit(ThreadMdcUtil.wrap(task, MDC.getCopyOfContextMap()), result);
    }

    @Override
    public <T> Future<T> submit(Callable<T> task) {return super.submit(ThreadMdcUtil.wrap(task, MDC.getCopyOfContextMap()));
    }

    @Override
    public Future<?> submit(Runnable task) {return super.submit(ThreadMdcUtil.wrap(task, MDC.getCopyOfContextMap()));
    }
}

阐明：

  • 继承 ThreadPoolExecutor 类，从新执行工作的办法
  • 通过 ThreadMdcUtil 对工作进行一次包装

线程 traceId 封装工具类：ThreadMdcUtil.java

public class ThreadMdcUtil {public static void setTraceIdIfAbsent() {if (MDC.get(Constants.TRACE_ID) == null) {MDC.put(Constants.TRACE_ID, TraceIdUtil.getTraceId());
        }
    }

    public static <T> Callable<T> wrap(final Callable<T> callable, final Map<String, String> context) {return () -> {if (context == null) {MDC.clear();
            } else {MDC.setContextMap(context);
            }
            setTraceIdIfAbsent();
            try {return callable.call();
            } finally {MDC.clear();
            }
        };
    }

    public static Runnable wrap(final Runnable runnable, final Map<String, String> context) {return () -> {if (context == null) {MDC.clear();
            } else {MDC.setContextMap(context);
            }
            setTraceIdIfAbsent();
            try {runnable.run();
            } finally {MDC.clear();
            }
        };
    }
}

阐明【以封装 Runnable 为例】：

  • 判断以后线程对应 MDC 的 Map 是否存在，存在则设置
  • 设置 MDC 中的 traceId 值，不存在则新生成，针对不是子线程的状况，如果是子线程，MDC 中 traceId 不为 null
  • 执行 run 办法

代码等同于以下写法，会更直观

public static Runnable wrap(final Runnable runnable, final Map<String, String> context) {return new Runnable() {
            @Override
            public void run() {if (context == null) {MDC.clear();
                } else {MDC.setContextMap(context);
                }
                setTraceIdIfAbsent();
                try {runnable.run();
                } finally {MDC.clear();
                }
            }
        };
    }

从新返回的是包装后的 Runnable，在该工作执行之前【runnable.run()】先将主线程的 Map 设置到以后线程中【即MDC.setContextMap(context)】，这样子线程和主线程 MDC 对应的 Map 就是一样的了。

HTTP 调用失落 traceId

在应用 HTTP 调用第三方服务接口时 traceId 将失落，须要对 HTTP 调用工具进行革新，在发送时在 request header 中增加 traceId，在上层被调用方增加拦截器获取 header 中的 traceId 增加到 MDC 中。

HTTP 调用有多种形式，比拟常见的有HttpClient、OKHttp、RestTemplate，所以只给出这几种 HTTP 调用的解决形式。

1、HttpClient：

实现 HttpClient 拦截器：

public class HttpClientTraceIdInterceptor implements HttpRequestInterceptor {
    @Override
    public void process(HttpRequest httpRequest, HttpContext httpContext) throws HttpException, IOException {String traceId = MDC.get(Constants.TRACE_ID);
        // 以后线程调用中有 traceId，则将该 traceId 进行透传
        if (traceId != null) {
            // 增加申请体
            httpRequest.addHeader(Constants.TRACE_ID, traceId);
        }
    }
}

实现 HttpRequestInterceptor 接口并重写 process 办法

如果调用线程中含有 traceId，则须要将获取到的 traceId 通过 request 中的 header 向下透传下去。

为 HttpClient 增加拦截器：

private static CloseableHttpClient httpClient = HttpClientBuilder.create()
            .addInterceptorFirst(new HttpClientTraceIdInterceptor())
            .build();

通过 addInterceptorFirst 办法为 HttpClient 增加拦截器。

2、OKHttp：

实现 OKHttp 拦截器：

public class OkHttpTraceIdInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {String traceId = MDC.get(Constants.TRACE_ID);
        Request request = null;
        if (traceId != null) {
            // 增加申请体
            request = chain.request().newBuilder().addHeader(Constants.TRACE_ID, traceId).build();}
        Response originResponse = chain.proceed(request);

        return originResponse;
    }
}

实现 Interceptor 拦截器，重写 interceptor 办法，实现逻辑和 HttpClient 差不多，如果可能获取到以后线程的 traceId 则向下透传。

为 OkHttp 增加拦截器：

  private static OkHttpClient client = new OkHttpClient.Builder()
            .addNetworkInterceptor(new OkHttpTraceIdInterceptor())
            .build();

调用 addNetworkInterceptor 办法增加拦截器。

3、RestTemplate：

实现 RestTemplate 拦截器：

public class RestTemplateTraceIdInterceptor implements ClientHttpRequestInterceptor {
    @Override
    public ClientHttpResponse intercept(HttpRequest httpRequest, byte[] bytes, ClientHttpRequestExecution clientHttpRequestExecution) throws IOException {String traceId = MDC.get(Constants.TRACE_ID);
        if (traceId != null) {httpRequest.getHeaders().add(Constants.TRACE_ID, traceId);
        }

        return clientHttpRequestExecution.execute(httpRequest, bytes);
    }
}

实现 ClientHttpRequestInterceptor 接口，并重写 intercept 办法，其余逻辑都是一样的不反复阐明。

为 RestTemplate 增加拦截器：

restTemplate.setInterceptors(Arrays.asList(new RestTemplateTraceIdInterceptor()));

调用 setInterceptors 办法增加拦截器。

4、第三方服务拦截器：

HTTP 调用第三方服务接口全流程 traceId 须要第三方服务配合，第三方服务须要增加拦截器拿到 request header 中的 traceId 并增加到 MDC 中。

public class LogInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 如果有下层调用就用下层的 ID
        String traceId = request.getHeader(Constants.TRACE_ID);
        if (traceId == null) {traceId = TraceIdUtils.getTraceId();
        }
        
        MDC.put("traceId", traceId);
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
            throws Exception { }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {MDC.remove(Constants.TRACE_ID);
    }
}

阐明：

  • 先从 request header 中获取 traceId
  • 从 request header 中获取不到 traceId 则阐明不是第三方调用，间接生成一个新的 traceId
  • 将生成的 traceId 存入 MDC 中

除了须要增加拦截器之外，还须要在日志格局中增加 traceId 的打印，如下：

 <property name="pattern">[TRACEID:%X{traceId}] %d{HH:mm:ss.SSS} %-5level %class{-1}.%M()/%L - %msg%xEx%n</property>

留神：须要增加 %X{traceId}

近期热文举荐：

1.1,000+ 道 Java 面试题及答案整顿(2022 最新版)

2. 劲爆！Java 协程要来了。。。

3.Spring Boot 2.x 教程，太全了！

4.20w 程序员红包封面，快快支付。。。

5.《Java 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！

正文完
java
发表至： java
2022-03-02
 0
AbstractQueuedSynchronizer源码分析
关于java:spring-boot-传Date类型数据报错无法读取JSON无法从String构造javautilDate实例
关于java:从负二代到富二代你只需要一份打工人书单
关于java:什么是云组态