java中异步日志如何记录主线程的日志上下文信息_java异步线程记录操作日志

日志场景：

如果在项目里面自定义了日志格式，比如记录链路追踪的traceId字段，当一次请求过来的时候可以通过traceId字段过滤出本次请求的完整日志。

问题描述

记录traceId字段，一般可以写一个拦截器，然后在里面获取到请求头的traceId字段将其设置到日志的上下文信息中，但是如果业务代码里面存在异步执行的情况，比如使用了线程池，异步执行的任务是无法记录到traceId信息的，原因是日志的上下文信息只存在于主线程中，子线程是无法获取。

解决方案：

解决思路首先想到的在异步执行的代码外面先获取日志的上下文信息，然后在异步执行代码里面设置获取的日志上下文信息，但是这种方法需要改每一个写了异步执行的代码，比较麻烦。如果项目上使用的是线程池，可以直接从线程池入手，这样只需要改一下线程池就行了，不需要改动任何异步代码的逻辑。
线程池的改动思路是：利用cglib创建的代理对象拦截线程池的执行方法，这里一般是execute和submit方法，无返回值和有返回值的，拦截之后把日志的上下文信息设置到其中即可。
代码如下，以springboot配置的线程池为例，这里使用springboot默认封装的线程池ThreadPoolTaskExecutor，自定义的线程池是同样的逻辑。

package com.demo;

import org.slf4j.MDC;
import org.springframework.boot.task.TaskExecutorBuilder;
import org.springframework.cglib.proxy.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;

import static org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration.APPLICATION_TASK_EXECUTOR_BEAN_NAME;
import static org.springframework.scheduling.annotation.AsyncAnnotationBeanPostProcessor.DEFAULT_TASK_EXECUTOR_BEAN_NAME;

/**
 * @author zhoule
 * @description: 自定义线程配置
 * @date 2023/9/20 10:37
 */
@Configuration
public class ThreadPoolTaskExecutorConfig implements MethodInterceptor {
	//这里只拦截execute和submit方法
    private static final List<String> METHOD_NAMES = Arrays.asList("execute", "submit");

    private ThreadPoolTaskExecutor executorService;

    @Bean(name = {APPLICATION_TASK_EXECUTOR_BEAN_NAME, DEFAULT_TASK_EXECUTOR_BEAN_NAME})
    public ThreadPoolTaskExecutor applicationTaskExecutor(TaskExecutorBuilder builder) {
        executorService = builder.build();
        executorService.initialize();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(executorService.getClass());
        enhancer.setCallbacks(new Callback[]{NoOp.INSTANCE, this});
        enhancer.setCallbackFilter(new TaskCallbackFilter());
        //利用cglib给当前线程创建一个代理对象，方便后续拦截线程池的方法
        return (ThreadPoolTaskExecutor) enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
		//自定义Runnable或者Callable并设置日志的上下文信息
        final Map<String, String> copyOfContextMap = MDC.getCopyOfContextMap();
        Object param = objects[0];
        if (param instanceof Runnable) {
            Runnable runnable = () -> {
                try {
					//利用MDC设置日志信息
                    MDC.setContextMap(copyOfContextMap);
                    ((Runnable) param).run();
                } finally {
                    MDC.clear();
                }
            };
            objects[0] = runnable;
        }
        if (param instanceof Callable) {
            Callable<Object> callable = () -> {
                try {
					//利用MDC设置日志信息
                    MDC.setContextMap(copyOfContextMap);
                    return ((Callable<?>) param).call();
                } finally {
                    MDC.clear();
                }
            };
            objects[0] = callable;
        }
        return methodProxy.invoke(executorService, objects);
    }

    static class TaskCallbackFilter implements CallbackFilter {
        @Override
        public int accept(Method method) {
            return METHOD_NAMES.contains(method.getName()) ? 1 : 0;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82