本文介绍如何基于 spring boot 获取、传递、使用一次会话的全局参数，并在所有链路日志中打印。

支持场景

  • 微服务中使用 traceId 实现跨应用日志追踪 。
  • 用户认证信息传递。
  • 和全局参数有关的日志追踪。

    具体实现

    TraceId 获取

    在决定在什么位置获取 traceId 之前先看一下 Tomcat 容器中 Servlet、Filter 、 Listener 和 Interceptor 的关系：

图片来源：https://blog.csdn.net/xuemengrui12/article/details/98783715
在选择获取 traceId 的时候我希望他是一个全局的，对所有请求生效的配置，因此放在 Filter 层，下面尝试在 Filter 中打印出 traceId:
ContextFilter.java

  1. @Component
  2. @Order(Ordered.HIGHEST_PRECEDENCE)
  3. @Slf4j
  4. public class ContextFilter implements Filter {
  5.     @Override
  6.     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
  7.         throws IOException, ServletException {
  8.         HttpServletRequest request = (HttpServletRequest) servletRequest;
  9.         Enumeration<String> headerNames = request.getHeaderNames();
  10.         String traceId = request.getHeader("Trace-Id");
  11.         if (StringUtils.isNotBlank(traceId)) {
  12.             log.info(traceId);
  13.         }
  14.         filterChain.doFilter(servletRequest, servletResponse);
  15.     }
  16.     @Override
  17.     public void init(FilterConfig filterConfig) throws ServletException {
  18.     }
  19.     @Override
  20.     public void destroy() {
  21.     }
  22. }

全局参数传递

验证完获取 traceId 之后，我们需要把 traceId 在一个次会话中传递，先使用 Thread local 实现：
AppContext.java

  1. public class AppContext implements Serializable {
  2.     public static final String TRACE_ID_HEADER = "Trace-Id";
  3.     private static final long serialVersionUID = -979220111440953115L;
  4.     private String traceId;
  5.     private static final ThreadLocal<AppContext> LOCAL = ThreadLocal.withInitial(AppContext::new);
  6.     public static AppContext getContext() {
  7.         return LOCAL.get();
  8.     }
  9.     public static void setContext(AppContext context) {
  10.         LOCAL.set(context);
  11.     }
  12.     public static void removeContext() {
  13.         LOCAL.remove();
  14.     }
  15.     public String getTraceId() {
  16.         return traceId;
  17.     }
  18.     public void setTraceId(String traceId) {
  19.         this.traceId = traceId;
  20.     }
  21. }

有了 Thread local 对象，就可以实现随用随取了，类似的，用户信息也可以用这种方式隐式传递。

  1. AppContext.getContext().setTraceId(traceId); # 在 Filter 中将 traceId 存入 thread local
  2. AppContext.getContext().getTraceId();        # 在 controller 中取出 traceId

多线程全局参数传递

Thread local 可以优雅地实现 Session 管理，但仅仅局限在一个封闭线程内，在使用线程池等会池化复用线程的执行组件情况下 Thread local 的信息就会丢失，例如我们在获取用户信息的地方加入一个线程池：
UserService.java

  1. private static final ExecutorService SAVE_USER_THREAD_POOL = Executors.newFixedThreadPool(5);
  2. public User getUser(Long userId) throws InterruptedException, ExecutionException {
  3.         log.info("[{}]Get user by id={}", AppContext.getContext().getTraceId(), userId);
  4.         try {
  5.             return GET_USER_THREAD_POOL.submit(() -> userRepository.getUserById(userId)).get();
  6.         } catch (ExecutionException e) {
  7.             Throwable t = e.getCause();
  8.             if (t instanceof CommonException) {
  9.                 throw (CommonException)t;
  10.             }
  11.             throw e;
  12.         }
  13.     }

这时候再来测试一下：

  1. curl -H 'Trace-Id:123' localhost:8080/user?id=3

【20200222】Spring boot 全局参数传递和追踪 - 图1
可以看到，进入线程池之前的 UserService 中是可以打印出 traceId 的，但是在线程池中的 UserRepository 渠道的 traceId 则为 null，正是由于 Thread local 无法实现跨线程传递。TTL 帮我们解决了这个问题，可以把把任务提交给线程池时的 Thread local 值传递到 任务执行时：
AppContext.java

  1. private static final TransmittableThreadLocal<AppContext> LOCAL = new TransmittableThreadLocal<AppContext>() {
  2.         @Override
  3.         protected AppContext initialValue() {
  4.             return new AppContext();
  5.         }
  6.     };

再运行一次，可以看到线程池中也可以获取到全局变量 traceId 了：
【20200222】Spring boot 全局参数传递和追踪 - 图2

单元测试

TTL 好用，可是当隐式传递的 Session 信息无孔不入地被应用到业务逻辑的时候，如果对 Thread local 对象添加单元测试成了不得不面对的问题，下面给出一种方式：Mock Context 对象的静态方法：
pom.xml

  1. <dependency>
  2.             <groupId>junit</groupId>
  3.             <artifactId>junit</artifactId>
  4.             <version>4.12</version>
  5.             <scope>test</scope>
  6.         </dependency>
  7.         <dependency>
  8.             <groupId>org.powermock</groupId>
  9.             <artifactId>powermock-module-junit4</artifactId>
  10.             <version>2.0.4</version>
  11.             <scope>test</scope>
  12.         </dependency>
  13.         <dependency>
  14.             <groupId>org.powermock</groupId>
  15.             <artifactId>powermock-api-mockito2</artifactId>
  16.             <version>2.0.4</version>
  17.             <scope>test</scope>
  18.         </dependency>

UserServiceTest.java

  1. @RunWith(PowerMockRunner.class)
  2. @PrepareForTest(AppContext.class)
  3. public class UserServiceTest {
  4.     private static final long CONTEXT_USER_ID = 123L;
  5.     private static final String CONTEXT_TRACE_ID = "trace-id";
  6.     @InjectMocks
  7.     private UserService userService;
  8.     @Mock
  9.     private UserRepository userRepository;
  10.     @Before
  11.     public void setUp() throws Exception {
  12.         AppContext context = new AppContext();
  13.         context.setTraceId(CONTEXT_TRACE_ID);
  14.         context.setUserId(CONTEXT_USER_ID);
  15.         PowerMockito.mockStatic(AppContext.class);
  16.         BDDMockito.given(AppContext.getContext()).willReturn(context);
  17.     }
  18.     @Test
  19.     public void shouldReturnUserWhenUserIdInContext() throws ExecutionException, InterruptedException {
  20.         // given
  21.         when(userRepository.getUserById(eq(CONTEXT_USER_ID))).thenReturn(new User(CONTEXT_USER_ID, "userName"));
  22.         // when
  23.         User user = userService.getCurrentUser();
  24.         // then
  25.         Assert.assertEquals(Long.valueOf(123), user.getId());
  26.         Assert.assertEquals("userName", user.getName());
  27.     }
  28. }

日志中打印全局参数

在上文的日志中我使用 log.("[{}]", traceId)的方式在日志中加入全局参数，事实上很多情况下我们是想随时知道全局参数的变量值的，怎么避免每次重复地写打印全局变量日志的方式呢？log4j 和 logback 提供的一种方便在多线程条件下记录日志的功能：MDC（Mapped Diagnostic Context，映射调试上下文） 。
只需要在日志模板中加入 %X{traceId}，再在适当的位置把 traceId 放入 org.slf4j.MDC 中即可：
logback-spring.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <configuration>
  3.     <!-- https://github.com/spring-projects/spring-boot/blob/v1.5.13.RELEASE/spring-boot/src/main/resources/org/springframework/boot/logging/logback/defaults.xml -->
  4.     <include resource="org/springframework/boot/logging/logback/defaults.xml" />
  5.     <property name="FILE_LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss.SSS} ${LOG_LEVEL_PATTERN:-%5p} [%t] [traceId:%X{traceId}] %-40.40logger{39} : %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}"/>
  6.     <property name="CONSOLE_LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss.SSS} ${LOG_LEVEL_PATTERN:-%5p} [%t] [traceId:%X{traceId}] %-40.40logger{39} : %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}"/>
  7.     <property name="APP_NAME" value="global-param-trace" />
  8.     <property name="LOG_PATH" value="${user.home}/${APP_NAME}/logs" />
  9.     <property name="LOG_FILE" value="${LOG_PATH}/application.log" />
  10.     <appender name="APPLICATION"
  11.               class="ch.qos.logback.core.rolling.RollingFileAppender">
  12.         <file>${LOG_FILE}</file>
  13.         <encoder>
  14.             <pattern>${FILE_LOG_PATTERN}</pattern>
  15.         </encoder>
  16.         <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
  17.             <fileNamePattern>${LOG_FILE}.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
  18.             <maxHistory>7</maxHistory>
  19.             <maxFileSize>50MB</maxFileSize>
  20.             <totalSizeCap>20GB</totalSizeCap>
  21.         </rollingPolicy>
  22.     </appender>
  23.     <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
  24.         <encoder>
  25.             <pattern>${CONSOLE_LOG_PATTERN}</pattern>
  26.             <charset>utf8</charset>
  27.         </encoder>
  28.     </appender>
  29.     <root level="INFO">
  30.         <appender-ref ref="CONSOLE" />
  31.         <appender-ref ref="APPLICATION" />
  32.     </root>
  33. </configuration>

这里我选择使用 Interceptor 来放入MDC，给 Session 信息补偿和权限判定预留空间：
MdcInterceptor.java

  1. @Component
  2. public class MdcInterceptor implements HandlerInterceptor {
  3.     @Override
  4.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
  5.         throws Exception {
  6.         MDC.put(AppContext.KEY_TRACE_ID, AppContext.getContext().getTraceId());
  7.         return true;
  8.     }
  9.     @Override
  10.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
  11.         ModelAndView modelAndView) throws Exception {
  12.     }
  13.     @Override
  14.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
  15.         throws Exception {
  16.     }
  17. }

在 Configuration 中注册 Interceptor:
AppConfiguration.java

  1. @Configuration
  2. public class AppConfiguration extends WebMvcConfigurerAdapter {
  3.     @Autowired
  4.     private MdcInterceptor mdcInterceptor;
  5.     @Override
  6.     public void addInterceptors(InterceptorRegistry registry) {
  7.         registry.addInterceptor(mdcInterceptor);
  8.     }
  9. }

把日志中的 [{}] 移除，尝试请求 API，可以看到日志中已经可以出现 traceId了：
【20200222】Spring boot 全局参数传递和追踪 - 图3

使用 AOP 在多线程日志中打印全局参数

上一步中打印出来的 traceId 在线程池中再次丢失了，这是因为与第一个实现 Context 的方式类似，MDC 也是使用 thread local，无法跨线程传递，要解决这个问题可以使用一个切面，讲 TTL 中的全局参数补偿到 DMC 中：
定义一个注解：
MdcCompensation.java

  1. @Documented
  2. @Target(ElementType.METHOD)
  3. @Retention(RetentionPolicy.RUNTIME)
  4. public @interface MdcCompensation {
  5. }

将注解和包的位置添加到切面的切点：
MdcAspect.java

  1. @Aspect
  2. @Component
  3. public class MdcAspect {
  4.     @Pointcut("execution(* com.adu21.spring.boot.global.param.trace.repository..*.*(..))")
  5.     public void service() {}
  6.     @Before(value = "service() && @annotation(mdcCompensation)")
  7.     public void doBefore(MdcCompensation mdcCompensation) {
  8.         MDC.put(AppContext.KEY_TRACE_ID, AppContext.getContext().getTraceId());
  9.     }
  10. }

使用切面，注意这个地方由于 Spring 基于动态代理生成代理类的方式让客户端调用代理类而达到织入的效果，因此使用注解的方法只有在被外部类调用的时候才会生效：
UserRepository.java

  1. @MdcCompensation
  2. public User getUserById(Long userId) {
  3.     ...
  4. }

再次运行，可以看到所有链路都能打印出 traceId 了：
【20200222】Spring boot 全局参数传递和追踪 - 图4

代码示例

文中使用的代码，完整版在这里：https://github.com/ADU-21/global-param-trace