devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java实现日志全链路追踪.精确到一次请求的全部流程_java 链路追踪

作者：我家小花儿 | 2024-08-11 03:22:55

赞

踩

java 链路追踪

广大程序员在排除线上问题时,会经常遇见各种BUG.处理这些BUG的时候日志就格外的重要.只有完善的日志才能快速有效的定位问题.为了提高BUG处理效率.我决定在日志上面优化.实现每次请求有统一的id.通过id能获取当前接口的全链路流程走向. 

实现效果如下: 一次查询即可找到所有关键信息.不再被多线程日志进行困扰了.

1:日志打印框架log4j ->  logback

logback是springboot默认自带的日志框架。不仅速度更快，而且内存占用也更小. (如果之前没用过log4j的建议先去学习下怎么使用).

打印日志的配置文件如下:  logback.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <configuration scan="true" scanPeriod="60 seconds">
  3. <include resource="org/springframework/boot/logging/logback/base.xml"/>
  4. <jmxConfigurator/>
  5. <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
  6. <Target>System.out</Target>
  7. <encoder>
  8. <charset>UTF-8</charset>
  9. <pattern>%d - [%t] %-5p %c:%L %X - %m%n</pattern>
  10. </encoder>
  11. </appender>
  12. <appender name="DAILY_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
  13. <Append>true</Append>
  14. <!--  日志输出路径 -->
  15. <File>/opt/logs/logOut.log</File>
  16. <encoder>
  17. <charset>UTF-8</charset>
  18. <pattern>%d - [%t] %-5p %c:%L %X - %m%n</pattern>
  19. </encoder>
  20. <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  21. <fileNamePattern>/opt/logs/logOut.log.%d{yyyy-MM-dd}</fileNamePattern>
  22. <maxHistory>7</maxHistory>
  23. </rollingPolicy>
  24. <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  25. <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
  26. <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread][%X{traceId}] %-5level %logger{50} - %msg%n</pattern>
  27. </encoder>
  28. </appender>
  29. <appender name="ROLLING_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
  30. <File>/opt/logs/logOut-error.log</File>
  31. <Append>true</Append>
  32. <encoder>
  33. <charset>UTF-8</charset>
  34. <pattern>%d - [%t] %-5p %c:%L %X - %m%n</pattern>
  35. </encoder>
  36. <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
  37. <level>ERROR</level>
  38. </filter>
  39. <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
  40. <fileNamePattern>/opt/logs/logOut-error.log.%d{yyyy-MM-dd}</fileNamePattern>
  41. <maxHistory>7</maxHistory>
  42. </rollingPolicy>
  43. </appender>
  44.  
  45.  
  46.  
  47. <logger name="org.springframework" level="INFO"/>
  48. <root level="INFO">
  49. <appender-ref ref="DAILY_FILE"/>
  50. <appender-ref ref="ROLLING_FILE"/>
  51. </root>
  52. </configuration>

重点是这行代码

<!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread][%X{traceId}] %-5level %logger{50} - %msg%n</pattern>

此时的配置文件打印只能出现 年月日-线程名这些关键信息.无法获得每次请求的唯一id.所以我们需要创建一个拦截器.将每次请求生成一个id.通过id把本次请求覆盖到每个流程中.

2.1: 编写 http请求 拦截器

  1. public class TraceWebInterceptor extends HandlerInterceptorAdapter {
  2.  
  3.     private static final Logger LOGGER = LoggerFactory.getLogger(TraceWebInterceptor.class);
  4.  
  5.     @Override
  6.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  7.         request.setAttribute("startTime", System.currentTimeMillis());
  8.         //traceOrigin、traceCaller、traceId
  9.         String traceOrigin = request.getHeader(TraceConstants.LOG_TRACE_ORIGIN);
  10.         String traceCaller = request.getHeader(TraceConstants.LOG_TRACE_CALLER);
  11.         String traceId = request.getHeader(TraceConstants.LOG_TRACE_ID);
  12.  
  13.         //如果不存在traceId需要生成
  14.         if (StringUtils.isBlank(traceId)) {
  15.             boolean generate = TraceUtil.loadTraceInfo();
  16.             if(generate) {
  17.                 LOGGER.debug("[生成追踪信息]" + TraceUtil.getTraceInfoString());
  18.             }
  19.         }else {
  20.             //设置MDC
  21.             MDC.put(TraceConstants.LOG_TRACE_ORIGIN, traceOrigin);
  22.             MDC.put(TraceConstants.LOG_TRACE_CALLER, traceCaller);
  23.             MDC.put(TraceConstants.LOG_TRACE_ID, traceId);
  24.         }
  25.  
  26.         //IP
  27.         String traceIp = IpUtil.getIp(request);
  28.         MDC.put(TraceConstants.LOG_TRACE_IP, traceIp);
  29.  
  30.         //响应返回
  31.         response.setHeader(TraceConstants.LOG_TRACE_ID, TraceUtil.getTraceId());
  32.  
  33.         return super.preHandle(request, response, handler);
  34.     }
  35.  
  36.     @Override
  37.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws IOException {
  38.         if (LOGGER.isInfoEnabled()) {
  39.             long upmsStartTime = (long) request.getAttribute("startTime");
  40.             long upmsEndTime = System.currentTimeMillis();
  41.             long upmsIntervalTime = upmsEndTime - upmsStartTime;
  42.             LOGGER.info("{} {}接口耗时{}毫秒", request.getRequestURL(), request.getMethod(), upmsIntervalTime);
  43.         }
  44.         MDC.clear();
  45.     }

2.2 编写Config类, 将拦截器TraceWebInterceptor添加到容器

  1. @Configuration
  2. @ConditionalOnClass({HandlerInterceptorAdapter.class, MDC.class, HttpServletRequest.class})
  3. public class TraceWebAutoConfiguration implements WebMvcConfigurer {
  4.  
  5.     private static List<String> EXCLUDE_PATHS = new ArrayList<>();
  6.  
  7.     @Value("${" + TraceConstants.CONFIG_TRACE_EXCLUDE_PATHS + ":}")
  8.     private String excludePaths;
  9.  
  10.     @Bean
  11.     public TraceWebInterceptor traceWebInterceptor() {
  12.         return new TraceWebInterceptor();
  13.     }
  14.  
  15.     @Override
  16.     public void addInterceptors(InterceptorRegistry registry) {
  17.         EXCLUDE_PATHS.add("/error");
  18.         EXCLUDE_PATHS.add("/actuator/**");
  19.  
  20.         if (StringUtils.isNotBlank(excludePaths)) {
  21.             if (excludePaths.contains(",")) {
  22.                 String[] split = excludePaths.split(",");
  23.                 EXCLUDE_PATHS.addAll(Arrays.asList(split));
  24.             } else {
  25.                 EXCLUDE_PATHS.add(excludePaths);
  26.             }
  27.         }
  28.  
  29.         //该方式不能过全部过滤掉
  30.         registry.addInterceptor(traceWebInterceptor()).order(-100).excludePathPatterns(EXCLUDE_PATHS);
  31.     }
  32. }

2.3 编写工具类

  1. import javax.servlet.http.HttpServletRequest;
  2.  
  3.  
  4. public class IpUtil {
  5.     private static final String UNKNOWN = "unknown";
  6.  
  7.     public static String getIp(HttpServletRequest request) {
  8.         if (request == null) {
  9.             return UNKNOWN;
  10.         }
  11.         String ip = request.getHeader("x-forwarded-for");
  12.         if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
  13.             ip = request.getHeader("Proxy-Client-IP");
  14.         }
  15.         if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
  16.             ip = request.getHeader("X-Forwarded-For");
  17.         }
  18.         if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
  19.             ip = request.getHeader("WL-Proxy-Client-IP");
  20.         }
  21.         if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
  22.             ip = request.getHeader("X-Real-IP");
  23.         }
  24.         if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
  25.             ip = request.getRemoteAddr();
  26.         }
  27.         return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
  28.     }
  29. }
  1.  
  2. public class TraceConstants {
  3.     public static final String LOG_TRACE_ORIGIN = "traceOrigin";
  4.     public static final String LOG_TRACE_CALLER = "traceCaller";
  5.     public static final String LOG_TRACE_IP = "traceIp";
  6.     public static final String LOG_TRACE_ID = "traceId";
  7.  
  8.     public static final String CONFIG_TRACE_EXCLUDE_PATHS = "trace.exclude.paths";
  9.  
  10.     public TraceConstants() {
  11.     }
  12. }
  1.  
  2. import org.apache.commons.lang3.StringUtils;
  3. import org.slf4j.MDC;
  4.  
  5. import java.util.UUID;
  6.  
  7. public class TraceUtil {
  8.     private static boolean simbaHttpClientInterceptorFlag = true;
  9.     private static boolean sdkInterceptorFlag = false;
  10.     private static String applicationName;
  11.  
  12.     public TraceUtil() {
  13.     }
  14.  
  15.     public static void setApplicationName(String applicationName) {
  16.         TraceUtil.applicationName = applicationName;
  17.     }
  18.  
  19.     public static String getApplicationName() {
  20.         return applicationName;
  21.     }
  22.  
  23.     public static boolean getSimbaHttpClientInterceptorFlag() {
  24.         return simbaHttpClientInterceptorFlag;
  25.     }
  26.  
  27.     public static void setSimbaHttpClientInterceptorFlag(boolean simbaHttpClientInterceptorFlag) {
  28.         TraceUtil.simbaHttpClientInterceptorFlag = simbaHttpClientInterceptorFlag;
  29.     }
  30.  
  31.     public static boolean getSdkInterceptorFlag() {
  32.         return sdkInterceptorFlag;
  33.     }
  34.  
  35.     public static void setSdkInterceptorFlag(boolean sdkInterceptorFlag) {
  36.         TraceUtil.sdkInterceptorFlag = sdkInterceptorFlag;
  37.     }
  38.  
  39.     public static void setTraceCaller(String traceCaller) {
  40.         MDC.put("traceCaller", traceCaller);
  41.     }
  42.  
  43.     public static String getTraceCaller() {
  44.         return MDC.get("traceCaller");
  45.     }
  46.  
  47.     public static void setTraceOrigin(String traceOrigin) {
  48.         MDC.put("traceOrigin", traceOrigin);
  49.     }
  50.  
  51.     public static String getTraceOrigin() {
  52.         return MDC.get("traceOrigin");
  53.     }
  54.  
  55.     public static void setTraceId(String traceId) {
  56.         MDC.put("traceId", traceId);
  57.     }
  58.  
  59.     public static void removeTraceId() {
  60.         MDC.remove("traceId");
  61.     }
  62.  
  63.     public static void clearMdc() {
  64.         MDC.clear();
  65.     }
  66.  
  67.     public static String getTraceId() {
  68.         return MDC.get("traceId");
  69.     }
  70.  
  71.     public static String genTraceId() {
  72.         return UUID.randomUUID().toString().replace("-", "");
  73.     }
  74.  
  75.     public static String getTraceIp() {
  76.         return MDC.get("traceIp");
  77.     }
  78.  
  79.     public static void setTraceIp(String traceIp) {
  80.         MDC.put("traceIp", traceIp);
  81.     }
  82.  
  83.     public static boolean loadTraceInfo() {
  84.         boolean generate = false;
  85.         String traceId = getTraceId();
  86.         if (StringUtils.isBlank(traceId)) {
  87.             traceId = genTraceId();
  88.             generate = true;
  89.         }
  90.  
  91.         setTraceId(traceId);
  92.         return generate;
  93.     }
  94.  
  95.     public static String getTraceInfoString() {
  96.         return "TraceId:" + getTraceId() + ". traceCaller:" + getTraceCaller() + ". traceOrigin:" + getTraceOrigin();
  97.     }
  98. }
  1.  
  2. import org.apache.commons.lang3.StringUtils;
  3. import org.slf4j.MDC;
  4. import org.springframework.beans.factory.annotation.Value;
  5. import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  9. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  10. import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
  11.  
  12. import javax.servlet.http.HttpServletRequest;
  13. import java.util.ArrayList;
  14. import java.util.Arrays;
  15. import java.util.List;
  16.  
  17. @Configuration
  18. @ConditionalOnClass({HandlerInterceptorAdapter.class, MDC.class, HttpServletRequest.class})
  19. public class TraceWebAutoConfiguration implements WebMvcConfigurer {
  20.  
  21.     private static List<String> EXCLUDE_PATHS = new ArrayList<>();
  22.  
  23.     @Value("${" + TraceConstants.CONFIG_TRACE_EXCLUDE_PATHS + ":}")
  24.     private String excludePaths;
  25.  
  26.     @Bean
  27.     public TraceWebInterceptor traceWebInterceptor() {
  28.         return new TraceWebInterceptor();
  29.     }
  30.  
  31.     @Override
  32.     public void addInterceptors(InterceptorRegistry registry) {
  33.         EXCLUDE_PATHS.add("/error");
  34.         EXCLUDE_PATHS.add("/actuator/**");
  35.  
  36.         if (StringUtils.isNotBlank(excludePaths)) {
  37.             if (excludePaths.contains(",")) {
  38.                 String[] split = excludePaths.split(",");
  39.                 EXCLUDE_PATHS.addAll(Arrays.asList(split));
  40.             } else {
  41.                 EXCLUDE_PATHS.add(excludePaths);
  42.             }
  43.         }
  44.  
  45.         //该方式不能过全部过滤掉
  46.         registry.addInterceptor(traceWebInterceptor()).order(-100).excludePathPatterns(EXCLUDE_PATHS);
  47.     }
  48. }
  1.  
  2. import org.apache.commons.lang3.StringUtils;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.slf4j.MDC;
  6. import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
  7.  
  8. import javax.servlet.http.HttpServletRequest;
  9. import javax.servlet.http.HttpServletResponse;
  10. import java.io.IOException;
  11.  
  12. public class TraceWebInterceptor extends HandlerInterceptorAdapter {
  13.  
  14.         private static final Logger LOGGER = LoggerFactory.getLogger(TraceWebInterceptor.class);
  15.  
  16.         @Override
  17.         public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  18.                 request.setAttribute("startTime", System.currentTimeMillis());
  19.                 //traceOrigin、traceCaller、traceId
  20.                 String traceOrigin = request.getHeader(TraceConstants.LOG_TRACE_ORIGIN);
  21.                 String traceCaller = request.getHeader(TraceConstants.LOG_TRACE_CALLER);
  22.                 String traceId = request.getHeader(TraceConstants.LOG_TRACE_ID);
  23.  
  24.                 //如果不存在traceId需要生成
  25.                 if (StringUtils.isBlank(traceId)) {
  26.                         boolean generate = TraceUtil.loadTraceInfo();
  27.                         if (generate) {
  28.                                 LOGGER.debug("[生成追踪信息]" + TraceUtil.getTraceInfoString());
  29.                         }
  30.                 } else {
  31.                         //设置MDC
  32.                         MDC.put(TraceConstants.LOG_TRACE_ORIGIN, traceOrigin);
  33.                         MDC.put(TraceConstants.LOG_TRACE_CALLER, traceCaller);
  34.                         MDC.put(TraceConstants.LOG_TRACE_ID, traceId);
  35.                 }
  36.  
  37.                 //IP
  38.                 String traceIp = IpUtil.getIp(request);
  39.                 MDC.put(TraceConstants.LOG_TRACE_IP, traceIp);
  40.  
  41.                 //响应返回
  42.                 response.setHeader(TraceConstants.LOG_TRACE_ID, TraceUtil.getTraceId());
  43.  
  44.                 return super.preHandle(request, response, handler);
  45.         }
  46.  
  47.         @Override
  48.         public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws IOException {
  49.                 if (LOGGER.isInfoEnabled()) {
  50.                         long upmsStartTime = (long) request.getAttribute("startTime");
  51.                         long upmsEndTime = System.currentTimeMillis();
  52.                         long upmsIntervalTime = upmsEndTime - upmsStartTime;
  53.                         LOGGER.info("{} {}接口耗时{}毫秒", request.getRequestURL(), request.getMethod(), upmsIntervalTime);
  54.                 }
  55.                 MDC.clear();
  56.         }
  57. }
  1.  
  2. import org.slf4j.MDC;
  3.  
  4. import java.util.Map;
  5. import java.util.concurrent.*;
  6.  
  7. public class WrapUtil {
  8.  
  9.     public static <T> Callable<T> wrap(final Callable<T> callable, final Map<String, String> context) {
  10.         return () -> {
  11.             if (context == null) {
  12.                 MDC.clear();
  13.             } else {
  14.                 MDC.setContextMap(context);
  15.             }
  16.             TraceUtil.loadTraceInfo();
  17.             try {
  18.                 return callable.call();
  19.             } finally {
  20.                 MDC.clear();
  21.             }
  22.         };
  23.     }
  24.  
  25.     public static <T> Callable<T> wrap(final Callable<T> callable) {
  26.         return wrap(callable, MDC.getCopyOfContextMap());
  27.     }
  28.  
  29.     public static Runnable wrap(final Runnable runnable, final Map<String, String> context) {
  30.         return () -> {
  31.             if (context == null) {
  32.                 MDC.clear();
  33.             } else {
  34.                 MDC.setContextMap(context);
  35.             }
  36.             TraceUtil.loadTraceInfo();
  37.             try {
  38.                 runnable.run();
  39.             } finally {
  40.                 MDC.clear();
  41.             }
  42.         };
  43.     }
  44.  
  45.     public static Runnable wrap(final Runnable runnable) {
  46.         return wrap(runnable, MDC.getCopyOfContextMap());
  47.     }
  48.  
  49.     public static ThreadPoolExecutor newThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
  50.                                                            BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,
  51.                                                            RejectedExecutionHandler handler) {
  52.         return new ThreadPoolExecutorMdcWrapper(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
  53.     }
  54.  
  55.     public static ThreadPoolExecutor newThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
  56.                                                            BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
  57.         return new ThreadPoolExecutorMdcWrapper(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
  58.     }
  59.  
  60.     public static ThreadPoolExecutor newThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
  61.                                                            BlockingQueue<Runnable> workQueue) {
  62.         return new ThreadPoolExecutorMdcWrapper(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
  63.     }
  64.  
  65.     public static ThreadPoolExecutor newThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
  66.                                                            BlockingQueue<Runnable> workQueue,
  67.                                                            RejectedExecutionHandler handler) {
  68.         return new ThreadPoolExecutorMdcWrapper(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
  69.     }
  70.  
  71.  
  72.     public static ForkJoinPool newForkJoinPool() {
  73.         return new ForkJoinPoolMdcWrapper();
  74.     }
  75.  
  76.     public static class ThreadPoolExecutorMdcWrapper extends ThreadPoolExecutor {
  77.         public ThreadPoolExecutorMdcWrapper(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
  78.                                             BlockingQueue<Runnable> workQueue) {
  79.             super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
  80.         }
  81.  
  82.         public ThreadPoolExecutorMdcWrapper(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
  83.                                             BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
  84.             super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
  85.         }
  86.  
  87.         public ThreadPoolExecutorMdcWrapper(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
  88.                                             BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
  89.             super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
  90.         }
  91.  
  92.         public ThreadPoolExecutorMdcWrapper(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
  93.                                             BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,
  94.                                             RejectedExecutionHandler handler) {
  95.             super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
  96.         }
  97.  
  98.         @Override
  99.         public void execute(Runnable task) {
  100.             super.execute(WrapUtil.wrap(task, MDC.getCopyOfContextMap()));
  101.         }
  102.  
  103.         @Override
  104.         public <T> Future<T> submit(Runnable task, T result) {
  105.             return super.submit(WrapUtil.wrap(task, MDC.getCopyOfContextMap()), result);
  106.         }
  107.  
  108.         @Override
  109.         public <T> Future<T> submit(Callable<T> task) {
  110.             return super.submit(WrapUtil.wrap(task, MDC.getCopyOfContextMap()));
  111.         }
  112.  
  113.         @Override
  114.         public Future<?> submit(Runnable task) {
  115.             return super.submit(WrapUtil.wrap(task, MDC.getCopyOfContextMap()));
  116.         }
  117.     }
  118.  
  119.     public static class ForkJoinPoolMdcWrapper extends ForkJoinPool {
  120.         public ForkJoinPoolMdcWrapper() {
  121.             super();
  122.         }
  123.  
  124.         public ForkJoinPoolMdcWrapper(int parallelism) {
  125.             super(parallelism);
  126.         }
  127.  
  128.         public ForkJoinPoolMdcWrapper(int parallelism, ForkJoinWorkerThreadFactory factory,
  129.                                       Thread.UncaughtExceptionHandler handler, boolean asyncMode) {
  130.             super(parallelism, factory, handler, asyncMode);
  131.         }
  132.  
  133.         @Override
  134.         public void execute(Runnable task) {
  135.             super.execute(WrapUtil.wrap(task, MDC.getCopyOfContextMap()));
  136.         }
  137.  
  138.         @Override
  139.         public <T> ForkJoinTask<T> submit(Runnable task, T result) {
  140.             return super.submit(WrapUtil.wrap(task, MDC.getCopyOfContextMap()), result);
  141.         }
  142.  
  143.         @Override
  144.         public <T> ForkJoinTask<T> submit(Callable<T> task) {
  145.             return super.submit(WrapUtil.wrap(task, MDC.getCopyOfContextMap()));
  146.         }
  147.     }
  148. }

把工具类加上后.此时运行项目. 如果报错就处理下依赖导包. 不报错就说明可以正常使用了. 然后发布代码.运行方法.去查看日志吧. 此时每次请求都已经生成唯一ID了.

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/961937
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号