关于java:Spring-Boot-实现日志链路追踪无需引入组件让日志定位更方便

34次阅读

共计 7301 个字符，预计需要花费 19 分钟才能阅读完成。

起源：blog.csdn.net/qq_35387940/article/details/125062368

前言

从文章题目就晓得，这篇文章是介绍些什么。

这是我一位敌人的问题反馈：

如同是的，的确这种景象是普遍存在的。

有时候一个业务调用链场景，很长，调了各种各样的办法，看日志的时候，各个接口的日志交叉，的确让人头大。

含糊匹配搜寻日志能解决吗？能解决一点点。然而不能齐全呈现出整个链路相干的日志。

那要做到不便，很显然，咱们须要的是把同一次的业务调用链上的日志串起来。

什么成果？先看一个实现后的效果图：

这样下来，咱们再配合含糊匹配查找日志，成果不就刚刚的了。

cat -n info.log |grep "a415ad50dbf84e99b1b56a31aacd209c"

或者 

grep -10 'a415ad50dbf84e99b1b56a31aacd209c' info.log（10 是指高低 10 行）

不多说，开整。

注释

常规，先看一眼这次实战最终工程的构造：

Spring Boot 根底就不介绍了，举荐看这个收费教程：

https://github.com/javastacks/spring-boot-best-practice

①pom.xml 依赖 

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-logging</artifactId>
    </dependency>
    <!--lombok 配置 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.10</version>
    </dependency>
</dependencies>

②整合 logback，打印日志，logback-spring.xml (简略配置下)

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
    <!-- 日志存储门路 -->
    <property name="log" value="D:/test/log" />
    <!-- 控制台输入 -->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!-- 输入格式化 -->
            <pattern>[%X{TRACE_ID}]  %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
    </appender>
    <!-- 按天生成日志文件 -->
    <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日志文件名 -->
            <FileNamePattern>${log}/%d{yyyy-MM-dd}.log</FileNamePattern>
            <!-- 保留天数 -->
            <MaxHistory>30</MaxHistory>
        </rollingPolicy>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>[%X{TRACE_ID}]  %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
        <!-- 日志文件最大的大小 -->
        <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
            <MaxFileSize>10MB</MaxFileSize>
        </triggeringPolicy>
    </appender>
 
    <!-- 日志输入级别 -->
    <root level="INFO">
        <appender-ref ref="console" />
        <appender-ref ref="file" />
    </root>
</configuration>

application.yml

server:
  port: 8826
logging:
  config: classpath:logback-spring.xml

③自定义日志拦截器 LogInterceptor.java

用处：每一次链路，线程维度，增加最终的链路 ID TRACE_ID。

import org.slf4j.MDC;
import org.springframework.lang.Nullable;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.HandlerInterceptor;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.UUID;
 
/**
 * @Author: JCccc
 * @Date: 2022-5-30 10:45
 * @Description:
 */
public class LogInterceptor implements HandlerInterceptor {
 
    private static final String TRACE_ID = "TRACE_ID";
 
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {String tid = UUID.randomUUID().toString().replace("-", "");
        // 能够思考让客户端传入链路 ID，但需保障肯定的复杂度唯一性；如果没应用默认 UUID 主动生成
        if (!StringUtils.isEmpty(request.getHeader("TRACE_ID"))){tid=request.getHeader("TRACE_ID");
        }
        MDC.put(TRACE_ID, tid);
        return true;
    }
 
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
                                @Nullable Exception ex) {MDC.remove(TRACE_ID);
    }
 
}

MDC(Mapped Diagnostic Context) 诊断上下文映射，是 @Slf4j 提供的一个反对动静打印日志信息的工具。

WebConfigurerAdapter.java 增加拦截器 

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
/**
 * @Author: JCccc
 * @Date: 2022-5-30 10:47
 * @Description:
 */
@Configuration
public class WebConfigurerAdapter implements WebMvcConfigurer {
    @Bean
    public LogInterceptor logInterceptor() {return new LogInterceptor();
    }
 
    @Override
    public void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(logInterceptor());
        // 能够具体制订哪些须要拦挡，哪些不拦挡，其实也能够应用自定义注解更灵便实现
//                .addPathPatterns("/**")
//                .excludePathPatterns("/testxx.html");
    }
}

ps: 其实这个拦挡的局部改为应用自定义注解 +aop 也是很灵便的。

到这时候，其实曾经实现，就是这么简略。

咱们写个测试接口，看下成果：

@PostMapping("doTest")
public String doTest(@RequestParam("name") String name) throws InterruptedException {log.info("入参 name={}",name);
    testTrace();
    log.info("调用完结 name={}",name);
    return "Hello,"+name;
}
private void testTrace(){log.info("这是一行 info 日志");
    log.error("这是一行 error 日志");
    testTrace2();}
private void testTrace2(){log.info("这也是一行 info 日志");

}

成果（OK 的）：

还没完。

接下来看一个场景，应用子线程的场景：

成心写一个异步线程，退出这个调用外面：

再次执行看开成果，显然子线程失落了 trackId：

所以咱们须要针对子线程应用情景，做调整，思路：将父线程的 trackId 传递上来给子线程即可。

①ThreadPoolConfig.java 定义线程池，交给 spring 治理 

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import java.util.concurrent.Executor;
 
/**
 * @Author: JCccc
 * @Date: 2022-5-30 11:07
 * @Description:
 */
@Configuration
@EnableAsync
public class ThreadPoolConfig {
    /**
     * 申明一个线程池
     *
     * @return 执行器
     */
    @Bean("MyExecutor")
    public Executor asyncExecutor() {MyThreadPoolTaskExecutor executor = new MyThreadPoolTaskExecutor();
        // 外围线程数 5：线程池创立时候初始化的线程数
        executor.setCorePoolSize(5);
        // 最大线程数 5：线程池最大的线程数，只有在缓冲队列满了之后才会申请超过外围线程数的线程
        executor.setMaxPoolSize(5);
        // 缓冲队列 500：用来缓冲执行工作的队列
        executor.setQueueCapacity(500);
        // 容许线程的闲暇工夫 60 秒：当超过了外围线程出之外的线程在闲暇工夫达到之后会被销毁
        executor.setKeepAliveSeconds(60);
        // 线程池名的前缀：设置好了之后能够不便咱们定位解决工作所在的线程池
        executor.setThreadNamePrefix("asyncJCccc");
        executor.initialize();
        return executor;
    }
}

② MyThreadPoolTaskExecutor.java 是咱们本人写的，重写了一些办法：

import org.slf4j.MDC;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
 
/**
 * @Author: JCccc
 * @Date: 2022-5-30 11:13
 * @Description:
 */
public final class MyThreadPoolTaskExecutor  extends ThreadPoolTaskExecutor  {public MyThreadPoolTaskExecutor() {super();
    }
    
    @Override
    public void execute(Runnable task) {super.execute(ThreadMdcUtil.wrap(task, MDC.getCopyOfContextMap()));
    }
 
 
    @Override
    public <T> Future<T> submit(Callable<T> task) {return super.submit(ThreadMdcUtil.wrap(task, MDC.getCopyOfContextMap()));
    }
 
    @Override
    public Future<?> submit(Runnable task) {return super.submit(ThreadMdcUtil.wrap(task, MDC.getCopyOfContextMap()));
    }
}

③ThreadMdcUtil.java

import org.slf4j.MDC;
 
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.Callable;
 
/**
 * @Author: JCccc
 * @Date: 2022-5-30 11:14
 * @Description:
 */
public final class ThreadMdcUtil {
    private static final String TRACE_ID = "TRACE_ID";
 
    // 获取唯一性标识
    public static String generateTraceId() {return UUID.randomUUID().toString();}
 
    public static void setTraceIdIfAbsent() {if (MDC.get(TRACE_ID) == null) {MDC.put(TRACE_ID, generateTraceId());
        }
    }
 
    /**
     * 用于父线程向线程池中提交工作时，将本身 MDC 中的数据复制给子线程
     *
     * @param callable
     * @param context
     * @param <T>
     * @return
     */
    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 callable.call();
            } finally {MDC.clear();
            }
        };
    }
 
    /**
     * 用于父线程向线程池中提交工作时，将本身 MDC 中的数据复制给子线程
     *
     * @param runnable
     * @param context
     * @return
     */
    public static Runnable wrap(final Runnable runnable, final Map<String, String> context) {return () -> {if (context == null) {MDC.clear();
            } else {MDC.setContextMap(context);
            }
            setTraceIdIfAbsent();
            try {runnable.run();
            } finally {MDC.clear();
            }
        };
    }
}

OK，重启服务，再看看成果：

能够看的，子线程的日志也被串起来了。

近期热文举荐：

1.1,000+ 道 Java 面试题及答案整顿 (2022 最新版)

2. 劲爆！Java 协程要来了。。。

3.Spring Boot 2.x 教程，太全了！

4. 别再写满屏的爆爆爆炸类了，试试装璜器模式，这才是优雅的形式！！

5.《Java 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！

正文完
java
发表至： java
2023-02-27
 0
关于java:惊了这是一篇IOC说明书
你有没有想过: Java 虚拟机是如何判断两个对象是否相同的？判断的流程是什么？
Spring-Boot-2-实战mock测试你的web应用
字典树的实现和介绍