20分钟搞定SpringBoot方法级全链路监控，老板直呼太香了！

前言

小伙伴们好啊！是不是经常听到老板焦急的声音：“这个接口怎么这么慢？到底是哪一步出了问题？”

然后你就开始一顿操作，加日志、重新部署、再测试…忙活半天才找到问题所在。

如果有一种方式，能让我们清晰地看到每个请求在各个方法之间的调用链路和耗时，那该多好啊！

今天，我就带着你实现SpringBoot的方法级全链路监控，让你成为团队里的"性能侦探"！

一、全链路监控是什么鬼？

1.1 概念解释

全链路监控，简单来说就是追踪一个请求从进入系统到返回结果的整个过程，记录下每个环节的调用关系、耗时等信息。

就像你点了份外卖，从商家接单、厨师做菜、骑手取餐到最终送达，全程都有记录和追踪。

1.2 为什么需要方法级的全链路监控？

• 定位性能瓶颈：哪个方法耗时最长，一目了然
• 异常追踪：出了问题，直接定位到具体方法
• 服务依赖分析：清晰了解系统内部调用关系
• 告别无效加日志：不用再到处打印日志来排查问题

  二、实现思路

  从上图我们可以看出实现全链路监控的主要步骤：先拦截请求，再用AOP拦截方法调用，收集调用链信息，存储分析数据，最后可视化展示和告警通知。

  

  那么如何才能实现这一切呢？接下来，我们会用最通俗易懂的方式，一步步带你实现这个炫酷的功能！

  三、动手实现：从零开始的监控之旅

  3.1 创建项目

  首先，我们需要创建一个SpringBoot项目，加入必要的依赖：

  
      4.0.0
      
      
          org.springframework.boot
          spring-boot-starter-parent
          2.7.8
      
      
      com.example
      method-tracer
      0.0.1-SNAPSHOT
      method-tracer
      SpringBoot方法级全链路监控
      
      
          1.8
      
      
      
          
          
              org.springframework.boot
              spring-boot-starter-web
          
          
          
          
              org.springframework.boot
              spring-boot-starter-aop
          
          
          
          
              org.projectlombok
              lombok
              true
          
          
          
          
              com.alibaba
              fastjson
              1.2.83
          
          
          
          
              org.springframework.boot
              spring-boot-starter-test
              test
          
      
      
      
          
              
                  org.springframework.boot
                  spring-boot-maven-plugin
                  
                      
                          
                              org.projectlombok
                              lombok
                          
                      
                  
              
          
      
  
  

  3.2 设计追踪上下文

  我们需要设计一个追踪上下文（TraceContext）类来保存当前请求的追踪信息：

  package com.example.methodtracer.trace;
  import lombok.Data;
  import org.slf4j.MDC;
  import java.util.Stack;
  import java.util.UUID;
  /**
   * 追踪上下文 - 保存当前请求的追踪信息
   */
  @Data
  public class TraceContext {
      // 追踪ID - 一个请求一个TraceId
      private String traceId;
      // 当前方法调用栈 - 用于记录方法调用关系
      private Stack methodStack = new Stack();
      // 请求开始时间
      private long requestStartTime;
      // 存储自定义信息的扩展字段
      private Object attachment;
      /**
       * 创建新的追踪上下文
       */
      public static TraceContext create() {
          TraceContext context = new TraceContext();
          // 生成随机TraceId (简单处理，生产环境可以使用更规范的格式)
          context.traceId = UUID.randomUUID().toString().replace("-", "");
          context.requestStartTime = System.currentTimeMillis();
          
          // 将TraceId放入MDC中，便于日志输出
          MDC.put("traceId", context.traceId);
          
          return context;
      }
      /**
       * 添加一个方法节点
       */
      public void pushMethod(String className, String methodName) {
          MethodNode node = new MethodNode();
          node.setClassName(className);
          node.setMethodName(methodName);
          node.setStartTime(System.currentTimeMillis());
          node.setLevel(methodStack.size());
          methodStack.push(node);
      }
      /**
       * 结束当前方法调用
       */
      public MethodNode popMethod() {
          if (methodStack.isEmpty()) {
              return null;
          }
          
          MethodNode node = methodStack.pop();
          node.setEndTime(System.currentTimeMillis());
          node.setCostTime(node.getEndTime() - node.getStartTime());
          return node;
      }
      /**
       * 清理资源
       */
      public void clear() {
          methodStack.clear();
          MDC.remove("traceId");
      }
      /**
       * 方法节点 - 记录方法调用信息
       */
      @Data
      public static class MethodNode {
          // 类名
          private String className;
          // 方法名
          private String methodName;
          // 开始调用时间
          private long startTime;
          // 结束调用时间
          private long endTime;
          // 调用耗时
          private long costTime;
          // 调用层级
          private int level;
          // 异常信息（如果发生异常）
          private String exceptionMsg;
          // 方法参数
          private Object[] args;
          // 返回结果
          private Object result;
      }
  }
  

  3.3 创建追踪上下文管理器

  接下来，我们创建一个管理器来管理追踪上下文，使用ThreadLocal确保每个线程拥有独立的上下文：

  package com.example.methodtracer.trace;
  /**
   * 追踪上下文管理器 - 管理当前线程的追踪上下文
   */
  public class TraceContextManager {
      // 使用ThreadLocal存储当前线程的追踪上下文
      private static final ThreadLocal TRACE_CONTEXT_THREAD_LOCAL = new ThreadLocal();
      
      /**
       * 获取当前线程的追踪上下文
       */
      public static TraceContext getContext() {
          return TRACE_CONTEXT_THREAD_LOCAL.get();
      }
      
      /**
       * 设置当前线程的追踪上下文
       */
      public static void setContext(TraceContext traceContext) {
          TRACE_CONTEXT_THREAD_LOCAL.set(traceContext);
      }
      
      /**
       * 创建新的追踪上下文并设置到当前线程
       */
      public static TraceContext createContext() {
          TraceContext context = TraceContext.create();
          setContext(context);
          return context;
      }
      
      /**
       * 清理当前线程的追踪上下文
       */
      public static void clearContext() {
          TraceContext context = getContext();
          if (context != null) {
              context.clear();
          }
          TRACE_CONTEXT_THREAD_LOCAL.remove();
      }
      
      /**
       * 检查追踪上下文是否存在
       */
      public static boolean hasContext() {
          return getContext() != null;
      }
  }
  

  3.4 实现请求拦截器

  现在，我们实现一个Filter来拦截所有请求，为每个请求创建追踪上下文：

  package com.example.methodtracer.filter;
  import com.example.methodtracer.trace.TraceContext;
  import com.example.methodtracer.trace.TraceContextManager;
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.core.annotation.Order;
  import org.springframework.stereotype.Component;
  import javax.servlet.*;
  import javax.servlet.http.HttpServletRequest;
  import java.io.IOException;
  /**
   * 请求追踪过滤器 - 拦截所有请求，创建追踪上下文
   */
  @Slf4j
  @Component
  @Order(1) // 确保该过滤器最先执行
  public class TraceFilter implements Filter {
      @Override
      public void doFilter(ServletRequest request, ServletResponse response, 
                           FilterChain chain) throws IOException, ServletException {
          // 只处理HTTP请求
          if (!(request instanceof HttpServletRequest)) {
              chain.doFilter(request, response);
              return;
          }
          HttpServletRequest httpRequest = (HttpServletRequest) request;
          String uri = httpRequest.getRequestURI();
          
          // 创建追踪上下文
          TraceContext traceContext = TraceContextManager.createContext();
          String traceId = traceContext.getTraceId();
          
          try {
              log.info("====== 请求开始 [{}] URI: {} ======", traceId, uri);
              
              // 继续执行过滤器链
              chain.doFilter(request, response);
              
              // 计算请求总耗时
              long totalCost = System.currentTimeMillis() - traceContext.getRequestStartTime();
              log.info("====== 请求结束 [{}] URI: {}, 总耗时: {}ms ======", 
                      traceId, uri, totalCost);
              
          } finally {
              // 清理上下文，防止内存泄漏
              TraceContextManager.clearContext();
          }
      }
  }
  

  3.5 方法级拦截的AOP实现

  接下来是关键部分：实现一个AOP切面，拦截方法调用并记录其执行情况：

  package com.example.methodtracer.aspect;
  import com.alibaba.fastjson.JSON;
  import com.example.methodtracer.annotation.Trace;
  import com.example.methodtracer.trace.TraceContext;
  import com.example.methodtracer.trace.TraceContext.MethodNode;
  import com.example.methodtracer.trace.TraceContextManager;
  import lombok.extern.slf4j.Slf4j;
  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.aspectj.lang.reflect.MethodSignature;
  import org.springframework.stereotype.Component;
  import java.util.Arrays;
  import java.util.stream.Collectors;
  /**
   * 方法追踪切面 - 使用AOP拦截方法调用
   */
  @Slf4j
  @Aspect
  @Component
  public class TraceAspect {
      /**
       * 定义切点 - 拦截所有Controller、Service和Repository
       */
      @Pointcut("(within(@org.springframework.web.bind.annotation.RestController *) || " +
                "within(@org.springframework.stereotype.Service *) || " +
                "within(@org.springframework.stereotype.Repository *)) || " +
                "@annotation(com.example.methodtracer.annotation.Trace)")
      public void tracePointcut() {
      }
      
      /**
       * 环绕通知 - 记录方法的执行情况
       */
      @Around("tracePointcut()")
      public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
          // 如果没有上下文，说明不是从HTTP请求进来的，忽略处理
          if (!TraceContextManager.hasContext()) {
              return joinPoint.proceed();
          }
          
          // 获取上下文和方法信息
          TraceContext context = TraceContextManager.getContext();
          MethodSignature signature = (MethodSignature) joinPoint.getSignature();
          String className = signature.getDeclaringType().getSimpleName();
          String methodName = signature.getName();
          
          // 判断是否需要记录方法参数和返回值
          boolean logParams = false;
          boolean logResult = false;
          
          // 检查是否有@Trace注解
          Trace traceAnnotation = signature.getMethod().getAnnotation(Trace.class);
          if (traceAnnotation != null) {
              logParams = traceAnnotation.logParams();
              logResult = traceAnnotation.logResult();
          }
          
          // 记录当前方法调用
          context.pushMethod(className, methodName);
          
          // 处理方法参数
          Object[] args = joinPoint.getArgs();
          if (logParams && args != null && args.length > 0) {
              // 将参数转换为安全的字符串形式
              String argsStr = Arrays.stream(args)
                      .map(arg -> arg == null ? "null" : arg.toString())
                      .collect(Collectors.joining(", "));
              log.debug("[{}] 方法参数: {}.{}({})", 
                      context.getTraceId(), className, methodName, argsStr);
          }
          
          Object result = null;
          try {
              // 执行原方法
              result = joinPoint.proceed();
              return result;
          } catch (Throwable e) {
              // 记录异常信息
              MethodNode currentMethod = context.getMethodStack().peek();
              if (currentMethod != null) {
                  currentMethod.setExceptionMsg(e.getMessage());
              }
              log.error("[{}] 方法异常: {}.{} - {}", 
                      context.getTraceId(), className, methodName, e.getMessage());
              throw e;
          } finally {
              // 方法执行完成，记录结束时间和耗时
              MethodNode completedMethod = context.popMethod();
              
              // 记录返回结果（如果需要）
              if (logResult && result != null) {
                  String resultStr;
                  try {
                      resultStr = JSON.toJSONString(result);
                      // 如果结果太长，截断显示
                      if (resultStr.length() > 200) {
                          resultStr = resultStr.substring(0, 200) + "...";
                      }
                  } catch (Exception e) {
                      resultStr = result.toString();
                  }
                  log.debug("[{}] 方法返回: {}.{} -> {}", 
                          context.getTraceId(), className, methodName, resultStr);
              }
              
              // 打印方法执行耗时
              String indentation = "-".repeat(Math.max(0, completedMethod.getLevel()));
              log.info("[{}] {}> {}.{} - 耗时: {}ms", 
                      context.getTraceId(), 
                      indentation,
                      className, 
                      methodName, 
                      completedMethod.getCostTime());
          }
      }
  }
  

  3.6 自定义注解

  为了更灵活地控制哪些方法需要被追踪，我们创建一个自定义注解：

  package com.example.methodtracer.annotation;
  import java.lang.annotation.*;
  /**
   * 方法追踪注解 - 标记需要追踪的方法
   */
  @Target({ElementType.METHOD, ElementType.TYPE})
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  public @interface Trace {
      /**
       * 是否记录方法参数
       */
      boolean logParams() default false;
      
      /**
       * 是否记录返回结果
       */
      boolean logResult() default false;
      
      /**
       * 方法类型/分组
       */
      String type() default "";
  }
  

  3.7 日志配置

  让我们配置日志格式，确保traceId能够打印在每条日志中：

  # 日志配置
  logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] [%X{traceId}] %-5level %logger{36} - %msg%n
  logging.level.com.example.methodtracer=INFO
  # 应用名称
  spring.application.name=method-tracer
  # 服务端口
  server.port=8080
  

  3.8 创建测试用例

  最后，我们创建一些测试用例来验证我们的监控功能：

  package com.example.methodtracer.service;
  import com.example.methodtracer.annotation.Trace;
  import org.springframework.stereotype.Service;
  import java.util.Random;
  @Service
  public class DemoService {
      public String processData(String input) {
          // 模拟处理时间
          sleep(100);
          
          // 调用其他方法
          String result = processStep1(input);
          result = processStep2(result);
          
          return result;
      }
      
      private String processStep1(String input) {
          // 模拟处理时间
          sleep(200);
          return input + " - processed by step1";
      }
      
      @Trace(logParams = true, logResult = true)
      private String processStep2(String input) {
          // 模拟处理时间
          sleep(300);
          
          // 模拟调用外部服务
          callExternalService();
          
          return input + " - processed by step2";
      }
      
      private void callExternalService() {
          // 模拟外部服务调用
          sleep(150);
          
          // 随机抛出异常，模拟服务调用失败
          if (new Random().nextInt(10)  
  package com.example.methodtracer.controller;
  import com.example.methodtracer.service.DemoService;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.RequestParam;
  import org.springframework.web.bind.annotation.RestController;
  @RestController
  public class DemoController {
      @Autowired
      private DemoService demoService;
      
      @GetMapping("/hello")
      public String hello(@RequestParam(defaultValue = "world") String name) {
          return "Hello, " + name + "!";
      }
      
      @GetMapping("/process")
      public String process(@RequestParam(defaultValue = "test-data") String data) {
          return demoService.processData(data);
      }
  }
   
  3.9 可视化追踪信息
   
  为了更好地展示追踪结果，我们可以创建一个简单的TraceListener来收集和处理追踪数据：
   
  package com.example.methodtracer.trace;
  import com.alibaba.fastjson.JSON;
  import com.example.methodtracer.trace.TraceContext.MethodNode;
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.stereotype.Component;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  /**
   * 追踪监听器 - 收集追踪数据并提供查询功能
   */
  @Slf4j
  @Component
  public class TraceListener {
      // 存储最近100条追踪记录
      private static final int MAX_TRACES = 100;
      private static final Map traceRecords = new ConcurrentHashMap();
      
      /**
       * 记录完成的方法调用
       */
      public void recordMethod(String traceId, MethodNode methodNode) {
          TraceRecord record = traceRecords.computeIfAbsent(traceId, k -> {
              TraceRecord r = new TraceRecord();
              r.setTraceId(traceId);
              r.setStartTime(System.currentTimeMillis());
              return r;
          });
          
          record.getMethods().add(methodNode);
          
          // 如果记录超过最大数量，清理一些旧记录
          if (traceRecords.size() > MAX_TRACES) {
              // 简单实现：删除最早的一条记录
              String oldestTraceId = traceRecords.keySet().iterator().next();
              traceRecords.remove(oldestTraceId);
          }
      }
      
      /**
       * 记录完成的请求
       */
      public void recordRequest(String traceId, String uri, long totalCost) {
          TraceRecord record = traceRecords.get(traceId);
          if (record != null) {
              record.setUri(uri);
              record.setTotalCost(totalCost);
              record.setEndTime(System.currentTimeMillis());
              
              // 在这里，我们可以将追踪数据保存到数据库或者其他存储
              log.debug("完成请求追踪记录: {}", JSON.toJSONString(record));
          }
      }
      
      /**
       * 获取所有追踪记录
       */
      public List getAllTraceRecords() {
          return new ArrayList(traceRecords.values());
      }
      
      /**
       * 获取指定TraceId的追踪记录
       */
      public TraceRecord getTraceRecord(String traceId) {
          return traceRecords.get(traceId);
      }
      
      /**
       * 清理所有追踪记录
       */
      public void clearAllRecords() {
          traceRecords.clear();
      }
      
      /**
       * 追踪记录类 - 存储一个请求的完整追踪信息
       */
      public static class TraceRecord {
          private String traceId;
          private String uri;
          private long startTime;
          private long endTime;
          private long totalCost;
          private List methods = new ArrayList();
          
          // Getters and Setters
          public String getTraceId() { return traceId; }
          public void setTraceId(String traceId) { this.traceId = traceId; }
          
          public String getUri() { return uri; }
          public void setUri(String uri) { this.uri = uri; }
          
          public long getStartTime() { return startTime; }
          public void setStartTime(long startTime) { this.startTime = startTime; }
          
          public long getEndTime() { return endTime; }
          public void setEndTime(long endTime) { this.endTime = endTime; }
          
          public long getTotalCost() { return totalCost; }
          public void setTotalCost(long totalCost) { this.totalCost = totalCost; }
          
          public List getMethods() { return methods; }
          public void setMethods(List methods) { this.methods = methods; }
      }
  }
   
  package com.example.methodtracer.controller;
  import com.example.methodtracer.trace.TraceListener;
  import com.example.methodtracer.trace.TraceListener.TraceRecord;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.PathVariable;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RestController;
  import java.util.List;
  /**
   * 追踪数据查询控制器
   */
  @RestController
  @RequestMapping("/trace")
  public class TraceController {
      @Autowired
      private TraceListener traceListener;
      
      /**
       * 获取所有追踪记录
       */
      @GetMapping("/records")
      public List getAllTraceRecords() {
          return traceListener.getAllTraceRecords();
      }
      
      /**
       * 获取指定TraceId的追踪记录
       */
      @GetMapping("/records/{traceId}")
      public TraceRecord getTraceRecord(@PathVariable String traceId) {
          return traceListener.getTraceRecord(traceId);
      }
      
      /**
       * 清理所有追踪记录
       */
      @GetMapping("/clear")
      public String clearAllRecords() {
          traceListener.clearAllRecords();
          return "All trace records cleared!";
      }
  }
   
  四、运行效果
   
  现在让我们看看运行效果。当我们访问/process?data=hello接口时，控制台会输出类似以下内容：
   
  2023-05-01 12:34:56.789 [http-nio-8080-exec-1] [a1b2c3d4e5f6g7h8i9j0] INFO  c.e.m.filter.TraceFilter - ====== 请求开始 [a1b2c3d4e5f6g7h8i9j0] URI: /process ======
  2023-05-01 12:34:56.790 [http-nio-8080-exec-1] [a1b2c3d4e5f6g7h8i9j0] INFO  c.e.m.aspect.TraceAspect - [a1b2c3d4e5f6g7h8i9j0] -> DemoController.process - 耗时: 2ms
  2023-05-01 12:34:56.892 [http-nio-8080-exec-1] [a1b2c3d4e5f6g7h8i9j0] INFO  c.e.m.aspect.TraceAspect - [a1b2c3d4e5f6g7h8i9j0] -> DemoService.processData - 耗时: 102ms
  2023-05-01 12:34:57.094 [http-nio-8080-exec-1] [a1b2c3d4e5f6g7h8i9j0] INFO  c.e.m.aspect.TraceAspect - [a1b2c3d4e5f6g7h8i9j0] --> DemoService.processStep1 - 耗时: 201ms
  2023-05-01 12:34:57.548 [http-nio-8080-exec-1] [a1b2c3d4e5f6g7h8i9j0] DEBUG c.e.m.aspect.TraceAspect - [a1b2c3d4e5f6g7h8i9j0] 方法参数: DemoService.processStep2(hello - processed by step1)
  2023-05-01 12:34:57.549 [http-nio-8080-exec-1] [a1b2c3d4e5f6g7h8i9j0] DEBUG c.e.m.aspect.TraceAspect - [a1b2c3d4e5f6g7h8i9j0] 方法返回: DemoService.processStep2 -> "hello - processed by step1 - processed by step2"
  2023-05-01 12:34:57.549 [http-nio-8080-exec-1] [a1b2c3d4e5f6g7h8i9j0] INFO  c.e.m.aspect.TraceAspect - [a1b2c3d4e5f6g7h8i9j0] --> DemoService.processStep2 - 耗时: 452ms
  2023-05-01 12:34:57.549 [http-nio-8080-exec-1] [a1b2c3d4e5f6g7h8i9j0] INFO  c.e.m.filter.TraceFilter - ====== 请求结束 [a1b2c3d4e5f6g7h8i9j0] URI: /process, 总耗时: 760ms ======
   
   
  从上图可以清晰地看到请求的调用链路和每个方法的耗时，帮助我们快速定位性能瓶颈。在这个例子中，我们可以看到processStep2方法耗时最长，可能是优化的重点。
   
  五、原理解析
   
  我们的全链路监控实现涉及了以下几个核心技术：
   
  5.1 ThreadLocal
   
   
  ThreadLocal是实现上下文传递的关键：
   
  ThreadLocal是Java提供的线程隔离机制，它为每个线程提供独立的变量副本。在我们的实现中，每个请求都由一个独立的线程处理，通过ThreadLocal，我们可以为每个请求创建专属的追踪上下文（TraceContext），线程间互不干扰。
   
  5.2 AOP（面向切面编程）
   
   
  AOP允许我们在不修改原有代码的情况下，为方法增加额外的功能。在我们的实现中，使用了Spring AOP的环绕通知（@Around），在方法执行前后添加监控逻辑：
   
  方法执行前：记录开始时间、方法参数等信息
  方法执行时：捕获异常信息
  方法执行后：记录结束时间、计算耗时、记录返回结果
  5.3 MDC（Mapped Diagnostic Context）
   
  MDC是日志框架提供的功能，允许我们在日志中添加上下文信息：
   
  // 将TraceId放入MDC
  MDC.put("traceId", context.getTraceId());
  // 日志配置中使用%X{traceId}引用
  // logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] [%X{traceId}] %-5level %logger{36} - %msg%n
   
  这样，每条日志都会包含traceId，方便我们根据traceId查找所有相关日志。
   
  六、实现扩展
   
  6.1 分布式追踪
   
  我们的实现目前只能追踪单个应用内的方法调用。在微服务架构下，我们需要扩展为分布式追踪：
   
  使用HTTP请求头传递TraceId：
  // 发送请求时
  httpRequest.setHeader("X-Trace-Id", TraceContextManager.getContext().getTraceId());
  // 接收请求时
  String traceId = httpRequest.getHeader("X-Trace-Id");
  if (traceId != null) {
      TraceContext context = TraceContext.create(traceId); // 使用传入的TraceId
      TraceContextManager.setContext(context);
  }
   
  集成分布式追踪系统： 
    
  使用Zipkin、Jaeger、SkyWalking等成熟的分布式追踪系统
  将我们的监控数据发送到这些系统，利用其可视化和分析能力
  6.2 性能优化
   
  监控本身不应该成为性能瓶颈，可以考虑以下优化：
   
  采样率控制：不必追踪所有请求，可以设置采样率
  异步处理：将数据收集和处理放到异步线程中
  批量处理：聚合一批数据后再一次性处理
  6.3 告警机制
   
  当方法执行时间超过阈值或发生异常时，自动触发告警：
   
  if (methodNode.getCostTime() > timeoutThreshold) {
      // 发送告警
      alertService.sendAlert("方法执行超时", 
          String.format("方法 %s.%s 执行时间 %dms 超过阈值 %dms", 
              className, methodName, methodNode.getCostTime(), timeoutThreshold));
  }
   
  七、面试热点问题
   
  七、面试热点问题
   
  7.1 如何确保ThreadLocal不会内存泄漏？
   
  答：ThreadLocal使用不当容易造成内存泄漏，因为它的key是弱引用，而value是强引用。
   
  // 正确的使用方式：使用完毕后务必清理
  try {
      // 创建上下文
      TraceContextManager.createContext();
      // 业务操作...
  } finally {
      // 清理上下文，防止内存泄漏
      TraceContextManager.clearContext();
  }
   
  这就是为什么我们在TraceFilter的finally块中调用TraceContextManager.clearContext()，确保请求结束后清理ThreadLocal数据。
   
  7.2 全链路监控与APM系统的区别是什么？
   
  答：
   
  

  • 全链路监控：主要关注请求在系统内的调用链路和性能数据，侧重于开发和问题排查
  • APM（应用性能监控）：更全面，除了链路追踪外，还包括：
    • 基础设施监控（CPU、内存等）
    • 异常监控和告警
    • 用户体验和业务指标
    • 根因分析和智能告警

      我们实现的方法级全链路监控可以看作是APM系统的一个核心组件。

      7.3 Spring AOP的实现原理是什么？

      答：Spring AOP主要通过动态代理实现，有两种方式：

      1. JDK动态代理：对实现了接口的类进行代理，通过Proxy.newProxyInstance()创建代理对象
      2. CGLIB代理：对没有实现接口的类进行代理，通过继承的方式创建代理类

      当Spring容器启动时，会根据切面配置创建代理对象替代原始对象，当调用方法时，会先执行代理逻辑（通知），再执行原方法。

      7.4 如何处理异步线程中的全链路追踪问题？

      答：在异步线程中，ThreadLocal会丢失，需要手动传递上下文：

      // 错误方式：直接创建新线程
      new Thread(() -> {
          // 这里无法获取到主线程的TraceContext
          service.doSomething();
      }).start();
      // 正确方式：传递上下文
      final TraceContext parentContext = TraceContextManager.getContext();
      new Thread(() -> {
          try {
              // 将父线程的上下文复制到子线程
              TraceContext childContext = parentContext.copy();
              TraceContextManager.setContext(childContext);
              
              service.doSomething();
          } finally {
              TraceContextManager.clearContext();
          }
      }).start();
      

      更好的方式是使用ThreadPoolTaskExecutor并配置TaskDecorator：

      @Configuration
      public class AsyncConfig {
          @Bean
          public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
              ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
              executor.setCorePoolSize(10);
              executor.setMaxPoolSize(20);
              executor.setTaskDecorator(new TraceContextDecorator());
              return executor;
          }
          
          static class TraceContextDecorator implements TaskDecorator {
              @Override
              public Runnable decorate(Runnable runnable) {
                  TraceContext context = TraceContextManager.getContext();
                  return () -> {
                      try {
                          if (context != null) {
                              TraceContextManager.setContext(context.copy());
                          }
                          runnable.run();
                      } finally {
                          TraceContextManager.clearContext();
                      }
                  };
              }
          }
      }
      

      7.5 全链路监控对系统性能有多大影响？

      答：全链路监控会对系统性能产生一定影响，主要来自：

      1. AOP拦截：每个方法调用都会经过AOP拦截，有额外开销
      2. 对象创建：创建和维护TraceContext等对象需要内存
      3. 日志输出：记录调用信息会增加IO负担

      一般来说，合理实现的全链路监控对性能的影响在5%以内，可以通过以下方式优化：

      • 采样率控制：只追踪部分请求
      • 过滤不重要方法：只关注核心业务方法
      • 异步处理：将数据收集和处理放到异步线程中
      • 使用更高效的数据结构：减少对象创建

        八、总结与实践建议

        8.1 重点回顾

        1. 关键概念：全链路监控追踪请求在系统中的调用链路，方便定位性能瓶颈和问题排查
        2. 核心技术：
           • ThreadLocal：线程级上下文传递
           • Spring AOP：非侵入式方法拦截
           • MDC：日志关联追踪标识
           • 实现步骤：
             • 拦截请求（Filter）
             • 创建追踪上下文（TraceContext）
             • 拦截方法调用（AOP）
             • 收集和展示追踪数据

        8.2 实践建议

        1. 先小范围试点：先在非核心系统实施，验证效果后再推广
        2. 关注核心业务：不必监控所有方法，优先关注核心业务和性能敏感点
        3. 设置合理阈值：根据业务特点设置合理的性能告警阈值
        4. 定期优化代码：根据监控数据持续优化性能瓶颈
        5. 与日志结合：确保日志中包含traceId，方便问题排查
        6. 考虑使用成熟方案：可以考虑使用SkyWalking、Zipkin等成熟的APM系统

        8.3 扩展应用

        除了性能监控，全链路追踪还可以应用于：

        1. 安全审计：记录关键操作的调用链路，用于安全审计
        2. 用户行为分析：分析用户请求链路，优化用户体验
        3. 容量规划：基于调用量和耗时，合理规划系统容量

        写在最后

        小伙伴们，全链路监控不仅是一项技术，更是一种思维方式。通过它，我们可以更深入地理解系统的运行状态，从被动应对问题转变为主动发现和解决问题。