使用MDC跟踪日志

1.概念

MDC（Mapped Diagnostic Context，映射调试上下文）是 log4j 和 logback 提供的一种方便在多线程条件下记录日志的功能，也可以说是一种轻量级的日志跟踪工具。
MDC使用的是ThreadLocal记录数据，把数据和当前线程进行绑定,一次请求进来的所有操作都能看到

2.使用:

在用户请求进来的时候生成当前请求的traceId(使用拦截器在请求进来的时候生成，traceId要唯一)，放到MDC中

拦截器

@Component
@Slf4j
public class MDCInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String tractId = MDC.get(Constants.TRACE_ID);
        if (tractId == null) {
            tractId = TraceIdUtil.getTraceId();
        }
        MDC.put(Constants.TRACE_ID, tractId);
        return true;
    }

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

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

配置拦截器

@Autowired
	private MDCInterceptor mdcInterceptor;
	
@Override
	public void addInterceptors(InterceptorRegistry registry) {
		registry.addInterceptor(mdcInterceptor).excludePathPatterns("/login");
	}

2.在日志配置文件中配置打印traceId

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

配置完之后打印一个日志就能看到traceId

3.MDC传递值给子线程

MDC.getCopyOfContextMap() 该方法获取当前线程MDC中的数据，再把获取到的数据放到子线程中即可，项目中我们一般不会直接new一个thread，而是使用线程池，所以这里继承ThreadPoolExecutor重写线程池，在线程池的线程中进行设置

线程池代码

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 runnable) {
        super.execute(MDCUtil.wrap(runnable,MDC.getCopyOfContextMap()));
    }

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

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

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

MDC工具类

public class MDCUtil {
    public static Runnable wrap(final Runnable runnable, final Map<String, String> context) {
        return () -> {
            if (context == null) {
                MDC.clear();
            }else {
                MDC.setContextMap(context);
            }
            //如果不是子线程的话先生成traceId
            setTraceIdIfAbsent();
            try {
                runnable.run();
            }finally {
                MDC.clear();
            }
        };
    }


    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 ((T) callable.call());
            }finally {
                MDC.clear();
            }
        };

    }

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

把线程池交给spring管理

@Configuration
public class BeanConfig {

    @Bean
    public ThreadPoolExecutorMdcWrapper getThreadPoolExecutorMdcWrapper() {
        return new ThreadPoolExecutorMdcWrapper(5,
                10,
                5,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(5)
        );
    }
}

测试

@GetMapping("getIp")
	public String getIp() {
		log.info("getIp");
		threadPoolExecutorMdcWrapper.execute(()->{
			log.info("子线程  getIp");
		});
		return "getIp";
	}

打印出来的traceId一致

4.使用restTemplate进行http调用MDC传值

restTemplate拦截器

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

配置拦截器

 @Bean
    public RestTemplate restTemplate( ) {
        RestTemplateBuilder restTemplateBuilder = new RestTemplateBuilder();
        RestTemplate restTemplate = restTemplateBuilder.build();
        //设置Resttemplate的拦截器
        restTemplate.setInterceptors(Collections.singletonList(new RestTemplateTraceIdInterceptor()));
        return restTemplate;
    }