TTL+日志的MDC实现简易链路追踪

发布于：2025-07-23 ⋅ 阅读:(18) ⋅ 点赞:(0)

通过MDC实现简单链路追踪

需要用到的依赖

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

<!-- Hutool工具包 -->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.16</version>
</dependency>

<!-- SLF4J日志 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</dependency>

<!-- Lombok 依赖 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.30</version>
<scope>provided</scope>
</dependency>

<!-- SLF4J API 依赖 -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>2.0.9</version>
</dependency>

<!-- SLF4J 实现（例如 Logback）依赖 -->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.4.11</version>
</dependency>

Spring配置类配置日志输出格式

配置输出格式，让我们自己加的TraceId可以成功输出

logging:
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %X{traceId} %logger{36} - %msg%n"

server:
  servlet:
    encoding:
      charset: UTF-8
      enabled: true
      force: true

AOP配置类

生成我们的TraceId放到我们的slf4j的MDC里面

注意为什么我们的只在Controller下往我们的MDC里面加东西呢

因为我们的MDC是共享上下文的，它会往下传递，我们不需要再匹配Service方法再生成一个ID

package com.example.threadpool.Config;

import cn.hutool.core.util.IdUtil;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class ControllerLogAspect {

    public static final String TRACE_ID = "traceId";
    private static final Logger logger = LoggerFactory.getLogger(ControllerLogAspect.class);

    // 定义切入点，匹配带有 @Controller、@RestController 或 @Service 注解的类中的所有方法
    @Pointcut("@within(org.springframework.stereotype.Controller) || @within(org.springframework.web.bind.annotation.RestController) || @within(org.springframework.stereotype.Service)")
    public void controllerAndServiceMethods() {
    }

    @Around("controllerAndServiceMethods()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        try {
            String traceId = IdUtil.objectId();
            String fullTraceId = "追踪ID:" + traceId;
            MDC.put(TRACE_ID, fullTraceId);
            logger.info("Generated traceId: {}", fullTraceId); // 调试日志
            return point.proceed();
        } finally {
            MDC.remove(TRACE_ID);
        }
    }
}

Controller测试类

package com.example.threadpool.Config;

import cn.hutool.core.util.IdUtil;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class ControllerLogAspect {

    public static final String TRACE_ID = "traceId";
    private static final Logger logger = LoggerFactory.getLogger(ControllerLogAspect.class);

    // 定义切入点，只匹配带有 @RestController 注解的类中的所有方法
    @Pointcut("@within(org.springframework.web.bind.annotation.RestController)")
    public void controllerMethods() {
    }

    @Around("controllerMethods()")
    public Object aroundController(ProceedingJoinPoint point) throws Throwable {
        try {
            String traceId = IdUtil.objectId();
            String fullTraceId = "追踪ID:" + traceId;
            MDC.put(TRACE_ID, fullTraceId);
            logger.info("Generated traceId: {}", fullTraceId); // 调试日志
            return point.proceed();
        } finally {
            MDC.remove(TRACE_ID);
        }
    }
}

Service测试类

package com.example.threadpool.Config;

public interface TestService {
    public String test();
}
package com.example.threadpool.Config;


import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Service;

@Controller
@Slf4j
public class TestServiceImpl implements TestService {
    @Override
    public String test() {
        log.info("这是Service的日志");
        return null;
    }
}

输出结果

通过拦截器和请求头实现不同服务之间TraceID的传递

package com.achobeta.intercepter;

import cn.hutool.core.util.IdUtil;
import org.slf4j.MDC;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;



@Component
public class LogInterceptor implements HandlerInterceptor {

    public static final String TRACE_ID = "traceId";

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //如果有上层调用就用上层的ID
        String traceId = request.getHeader(TRACE_ID);
        if (traceId == null) {
            traceId = IdUtil.objectId();
        }
        MDC.put(TRACE_ID, traceId);
        response.addHeader(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(TRACE_ID);
    }

}

异步情况下MDC的上下文丢失问题

MDC的底层是通过ThreadLocal来绑定到当前线程的

所以在做异步的时候要是不进行特殊处理就会造成MDC的上下文丢失

可以引入TTL来处理MDC的上下文丢失问题

TTL改进MDC实现链路追踪

引入TTL依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>transmittable-thread-local</artifactId>
    <version>2.14.2</version>
</dependency>

重写TTL构造线程池方法-线程池适配器

package com.kira.scaffoldmvc.ShutDownHook;

import com.alibaba.ttl.TtlCallable;
import com.alibaba.ttl.TtlRunnable;
import org.slf4j.MDC;
import java.util.Map;
import java.util.concurrent.*;

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

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

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

    public TtlThreadPoolExecutor(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 command) {
        // 获取当前线程的MDC上下文
        Map<String, String> contextMap = MDC.getCopyOfContextMap();

        // 使用TtlRunnable包装，确保上下文传递
        super.execute(TtlRunnable.get(() -> {
            // 恢复MDC上下文
            if (contextMap != null) {
                MDC.setContextMap(contextMap);
            }
            try {
                command.run();
            } finally {
                // 不要在这里清除MDC，可能会影响后续任务
                // 由任务本身决定何时清理
            }
        }));
    }

    @Override
    public Future<?> submit(Runnable task) {
        return super.submit(wrapTask(task));
    }

    @Override
    public <T> Future<T> submit(Callable<T> task) {
        return super.submit(wrapTask(task));
    }

    private Runnable wrapTask(Runnable task) {
        Map<String, String> contextMap = MDC.getCopyOfContextMap();
        return TtlRunnable.get(() -> {
            if (contextMap != null) {
                MDC.setContextMap(contextMap);
            }
            try {
                task.run();
            } finally {
                MDC.clear();
            }
        });
    }

    private <T> Callable<T> wrapTask(Callable<T> task) {
        Map<String, String> contextMap = MDC.getCopyOfContextMap();
        return TtlCallable.get(() -> {
            if (contextMap != null) {
                MDC.setContextMap(contextMap);
            }
            try {
                return task.call();
            } finally {
                MDC.clear();
            }
        });
    }
}

@Bean注册线程池

package com.kira.scaffoldmvc.ShutDownHook;

import com.alibaba.ttl.threadpool.TtlExecutors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.core.annotation.Order;
import org.springframework.scheduling.annotation.Async;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

@Configuration
public class ThreadPoolConfig {

    public static final int CORE_POOL_SIZE = 5;
    public static final int MAX_POOL_SIZE = 10;
    public static final int QUEUE_CAPACITY = 100;
    public static final Long KEEP_ALIVE_TIME = 1L;

    @Bean
    public ThreadPoolExecutor kiraExecutor1() {
        return new TtlThreadPoolExecutor(
            CORE_POOL_SIZE,
            MAX_POOL_SIZE,
            KEEP_ALIVE_TIME,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(QUEUE_CAPACITY),
            new ThreadPoolExecutor.AbortPolicy()
        );
    }

    @Bean
    public ThreadPoolExecutor kiraExecutor2() {
        return new TtlThreadPoolExecutor(
            CORE_POOL_SIZE,
            MAX_POOL_SIZE,
            KEEP_ALIVE_TIME,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(QUEUE_CAPACITY),
            new ThreadPoolExecutor.AbortPolicy()
        );
    }

    @Bean
    public ThreadPoolExecutor kiraExecutor3() {
        return new TtlThreadPoolExecutor(
            CORE_POOL_SIZE,
            MAX_POOL_SIZE,
            KEEP_ALIVE_TIME,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(QUEUE_CAPACITY),
            new ThreadPoolExecutor.AbortPolicy()
        );
    }


}

AOP类，调用Controller时放入TraceId

package com.kira.scaffoldmvc.Trace;

import cn.hutool.core.util.IdUtil;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class ControllerLogAspect {

    public static final String TRACE_ID = "traceId";
    private static final Logger logger = LoggerFactory.getLogger(ControllerLogAspect.class);

    // 定义切入点，匹配带有 @Controller、@RestController 或 @Service 注解的类中的所有方法
    @Pointcut("@within(org.springframework.stereotype.Controller) || @within(org.springframework.web.bind.annotation.RestController) || @within(org.springframework.stereotype.Service)")
    public void controllerAndServiceMethods() {
    }

    @Around("controllerAndServiceMethods()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        try {
            String traceId = IdUtil.objectId();
            String fullTraceId = "追踪ID:" + traceId;
            MDC.put(TRACE_ID, fullTraceId);
            logger.info("Generated traceId: {}", fullTraceId); // 调试日志
            return point.proceed();
        } finally {
            MDC.remove(TRACE_ID);
        }
    }
}

Controller接口测试

package com.kira.scaffoldmvc.Trace;

import com.kira.scaffoldmvc.POJO.Result;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.*;

@RestController
@RequestMapping("/trace")
@Slf4j
public class TestTraceController {

    @Resource
    ThreadPoolExecutor kiraExecutor1;


    @GetMapping("/test")
    Result test(){
        log.info("测试MDC1");
        kiraExecutor1.execute(()->{
            log.info("测试MDC2");
        });
        return Result.success(true );
    }


}

测试结果

traceId没有丢失

网关生成TraceId-拦截器放入TraceId

拦截器

拦截器放入TraceId或者生成TraceId

package com.kira.scaffoldmvc.Config;

import com.kira.scaffoldmvc.CommonPool.RtaProxyContextInterceptor;
import com.kira.scaffoldmvc.Interceptor.LoginInterceptor;
import com.kira.scaffoldmvc.Trace.TraceInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

//配置我们的拦截器
@Configuration
public class WebConfig implements WebMvcConfigurer {

    //这个是在配置类里面来注册我们的拦截器


    @Autowired
    private TraceInterceptor traceInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        registry.addInterceptor(traceInterceptor).order(1)
        .excludePathPatterns("/xxxx/xxxx","/xxxx/xxxx")//配置放行路径
        .addPathPatterns("/**");//拦截路径，/**拦截所有

    }
}


重写TTL构造线程池方法-线程池适配器

package com.kira.scaffoldmvc.ShutDownHook;

import com.alibaba.ttl.TtlCallable;
import com.alibaba.ttl.TtlRunnable;
import org.slf4j.MDC;
import java.util.Map;
import java.util.concurrent.*;

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

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

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

    public TtlThreadPoolExecutor(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 command) {
        // 获取当前线程的MDC上下文
        Map<String, String> contextMap = MDC.getCopyOfContextMap();

        // 使用TtlRunnable包装，确保上下文传递
        super.execute(TtlRunnable.get(() -> {
            // 恢复MDC上下文
            if (contextMap != null) {
                MDC.setContextMap(contextMap);
            }
            try {
                command.run();
            } finally {
                // 不要在这里清除MDC，可能会影响后续任务
                // 由任务本身决定何时清理
            }
        }));
    }

    @Override
    public Future<?> submit(Runnable task) {
        return super.submit(wrapTask(task));
    }

    @Override
    public <T> Future<T> submit(Callable<T> task) {
        return super.submit(wrapTask(task));
    }

    private Runnable wrapTask(Runnable task) {
        Map<String, String> contextMap = MDC.getCopyOfContextMap();
        return TtlRunnable.get(() -> {
            if (contextMap != null) {
                MDC.setContextMap(contextMap);
            }
            try {
                task.run();
            } finally {
                MDC.clear();
            }
        });
    }

    private <T> Callable<T> wrapTask(Callable<T> task) {
        Map<String, String> contextMap = MDC.getCopyOfContextMap();
        return TtlCallable.get(() -> {
            if (contextMap != null) {
                MDC.setContextMap(contextMap);
            }
            try {
                return task.call();
            } finally {
                MDC.clear();
            }
        });
    }
}

@Bean注册线程池

package com.kira.scaffoldmvc.ShutDownHook;

import com.alibaba.ttl.threadpool.TtlExecutors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.core.annotation.Order;
import org.springframework.scheduling.annotation.Async;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

@Configuration
public class ThreadPoolConfig {

    public static final int CORE_POOL_SIZE = 5;
    public static final int MAX_POOL_SIZE = 10;
    public static final int QUEUE_CAPACITY = 100;
    public static final Long KEEP_ALIVE_TIME = 1L;

    @Bean
    public ThreadPoolExecutor kiraExecutor1() {
        return new TtlThreadPoolExecutor(
            CORE_POOL_SIZE,
            MAX_POOL_SIZE,
            KEEP_ALIVE_TIME,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(QUEUE_CAPACITY),
            new ThreadPoolExecutor.AbortPolicy()
        );
    }

    @Bean
    public ThreadPoolExecutor kiraExecutor2() {
        return new TtlThreadPoolExecutor(
            CORE_POOL_SIZE,
            MAX_POOL_SIZE,
            KEEP_ALIVE_TIME,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(QUEUE_CAPACITY),
            new ThreadPoolExecutor.AbortPolicy()
        );
    }

    @Bean
    public ThreadPoolExecutor kiraExecutor3() {
        return new TtlThreadPoolExecutor(
            CORE_POOL_SIZE,
            MAX_POOL_SIZE,
            KEEP_ALIVE_TIME,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(QUEUE_CAPACITY),
            new ThreadPoolExecutor.AbortPolicy()
        );
    }


}

Controller接口测试

package com.kira.scaffoldmvc.Trace;

import com.kira.scaffoldmvc.POJO.Result;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.*;

@RestController
@RequestMapping("/trace")
@Slf4j
public class TestTraceController {

    @Resource
    ThreadPoolExecutor kiraExecutor1;


    @GetMapping("/test")
    Result test(){
        log.info("测试MDC1");
        kiraExecutor1.execute(()->{
            log.info("测试MDC2");
        });
        return Result.success(true );
    }


}

测试结果

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布