404 Not Found

国际时区转换

Mon, 25 Mar 2024 00:00:00 GMT

1，概述

1.1，需求场景

海外部署服务，用户界面展示当地时间，后端及数据库采用北京时间GMT+8时区，前端采用浏览器定位当地时区，前后端交互时需对时间进行时区转换。

1.2，实现原理

前端增加请求头 ISrmTimeZone，传入当前浏览器获取时区；后端自定义消息转换器 HttpMessageConverter，修改 Jackson 序列化配置，根据请求头 ISrmTimeZone 设置时区。

2，代码实现

2.1，自定义 HttpMessageConverter

继承 MappingJackson2HttpMessageConverter，原逻辑基础上修改 objectMapper 部分，从请求头/响应头上获取 ISrmTimeZone 设置时区。

package com.midea.srm.core.timezone;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.Type;
import java.text.SimpleDateFormat;
import java.util.List;
import java.util.Objects;
import java.util.TimeZone;
import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.util.DefaultIndenter;
import com.fasterxml.jackson.core.util.DefaultPrettyPrinter;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectWriter;
import com.fasterxml.jackson.databind.SerializationConfig;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.exc.InvalidDefinitionException;
import com.fasterxml.jackson.databind.ser.FilterProvider;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConversionException;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.http.converter.json.MappingJacksonInputMessage;
import org.springframework.http.converter.json.MappingJacksonValue;
import org.springframework.lang.NonNull;
import org.springframework.lang.Nullable;
import org.springframework.util.TypeUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

/**
 * 国际时区消息转换器
 * 请求头/响应头包含 ISrmTimeZone 时生效
 * 根据 ISrmTimeZone 动态设置 objectMapper 时区
 * {@link org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter}
 *
 * @author liwf106
 * @since 2023/12/7
 */
@Slf4j
@SuppressWarnings("all")
public class TimeZoneMessageConverter extends MappingJackson2HttpMessageConverter {
    public static final String TIME_ZONE_HEADER = "ISrmTimeZone";

    public TimeZoneMessageConverter() {
        super();
    }

    @NonNull
    @Override
    protected Object readInternal(@NonNull Class<?> clazz, HttpInputMessage inputMessage) throws IOException,
        HttpMessageNotReadableException {
        List<String> timeZone = inputMessage.getHeaders().get(TIME_ZONE_HEADER);
        ObjectMapper objectMapper = getObjectMapper(timeZone);
        JavaType javaType = getJavaType(clazz, null);
        return readJavaType(objectMapper, javaType, inputMessage);
    }

    @NonNull
    @Override
    public Object read(@NonNull Type type, Class<?> contextClass, HttpInputMessage inputMessage)
        throws IOException, HttpMessageNotReadableException {
        List<String> timeZone = inputMessage.getHeaders().get(TIME_ZONE_HEADER);
        ObjectMapper objectMapper = getObjectMapper(timeZone);
        JavaType javaType = getJavaType(type, contextClass);
        return readJavaType(objectMapper, javaType, inputMessage);
    }

    @Override
    public boolean canRead(Class<?> clazz, MediaType mediaType) {
        HttpServletResponse response =
            ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
        String timezone = response.getHeader(TimeZoneMessageConverter.TIME_ZONE_HEADER);
        return super.canRead(clazz, mediaType) && StringUtils.isNotBlank(timezone);
    }

    @Override
    public boolean canWrite(Class<?> clazz, MediaType mediaType) {
        HttpServletResponse response =
            ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
        String timezone = response.getHeader(TimeZoneMessageConverter.TIME_ZONE_HEADER);
        return super.canWrite(clazz, mediaType) && StringUtils.isNotBlank(timezone);
    }

    @Override
    protected void writeInternal(@NonNull Object object, @Nullable Type type, @NonNull HttpOutputMessage outputMessage)
        throws IOException, HttpMessageNotWritableException {
        List<String> timeZone = outputMessage.getHeaders().get(TIME_ZONE_HEADER);
        ObjectMapper objectMapper = getObjectMapper(timeZone);

        MediaType contentType = outputMessage.getHeaders().getContentType();
        JsonEncoding encoding = getJsonEncoding(contentType);
        JsonGenerator generator = objectMapper.getFactory().createGenerator(outputMessage.getBody(), encoding);
        try {

            Class<?> serializationView = null;
            FilterProvider filters = null;
            Object value = object;
            JavaType javaType = null;
            if (object instanceof MappingJacksonValue) {
                MappingJacksonValue container = (MappingJacksonValue) object;
                value = container.getValue();
                serializationView = container.getSerializationView();
                filters = container.getFilters();
            }
            if (type != null && TypeUtils.isAssignable(type, value.getClass())) {
                javaType = getJavaType(type, null);
            }
            ObjectWriter objectWriter;
            if (serializationView != null) {
                objectWriter = objectMapper.writerWithView(serializationView);
            } else if (filters != null) {
                objectWriter = objectMapper.writer(filters);
            } else {
                objectWriter = objectMapper.writer();
            }
            if (javaType != null && javaType.isContainerType()) {
                objectWriter = objectWriter.forType(javaType);
            }
            SerializationConfig config = objectWriter.getConfig();
            if (contentType != null && contentType.isCompatibleWith(MediaType.TEXT_EVENT_STREAM) &&
                config.isEnabled(SerializationFeature.INDENT_OUTPUT)) {
                DefaultPrettyPrinter prettyPrinter = new DefaultPrettyPrinter();
                prettyPrinter.indentObjectsWith(new DefaultIndenter("  ", "\ndata:"));
                objectWriter = objectWriter.with(prettyPrinter);
            }
            objectWriter.writeValue(generator, value);

            generator.flush();

        } catch (InvalidDefinitionException ex) {
            throw new HttpMessageConversionException("Type definition error: " + ex.getType(), ex);
        } catch (JsonProcessingException ex) {
            throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getOriginalMessage(), ex);
        }

    }

    // 修改 objectMapper 时区
    private ObjectMapper getObjectMapper(List<String> timeZone) {
        ObjectMapper timeZoneObjectMapper = objectMapper.copy();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        timeZoneObjectMapper.setDateFormat(dateFormat);

        if (Objects.nonNull(timeZone) && !timeZone.isEmpty()) {
            timeZoneObjectMapper.setTimeZone(TimeZone.getTimeZone(timeZone.get(0)));
            log.info("set srm timezone {}", TimeZone.getTimeZone(timeZone.get(0)));
        } else {
            timeZoneObjectMapper.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
        }
        return timeZoneObjectMapper;
    }

    private Object readJavaType(ObjectMapper objectMapper, JavaType javaType, HttpInputMessage inputMessage)
        throws IOException {
        try {
            if (inputMessage instanceof MappingJacksonInputMessage) {
                Class<?> deserializationView = ((MappingJacksonInputMessage) inputMessage).getDeserializationView();
                if (deserializationView != null) {
                    return objectMapper.readerWithView(deserializationView).forType(javaType).
                        readValue(inputMessage.getBody());
                }
            }
            return objectMapper.readValue(inputMessage.getBody(), javaType);
        } catch (InvalidDefinitionException ex) {
            throw new HttpMessageConversionException("Type definition error: " + ex.getType(), ex);
        } catch (JsonProcessingException ex) {
            throw new HttpMessageNotReadableException("JSON parse error: " + ex.getOriginalMessage(), ex);
        }
    }

}

2.2，自定义 ResponseBodyAdvice

为兼容 mcomponent 的 JsonResponseBodyAdvice，仅修改 supports 方法以适配自定义 MessageConverter。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.midea.srm.core.timezone;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import com.midea.mcomponent.core.config.Settings;
import com.midea.mcomponent.core.response.Response;
import com.midea.mcomponent.core.response.SuccessResponse;
import com.midea.mcomponent.core.response.SuccessResponseData;
import com.midea.mcomponent.core.util.IPUtils;
import com.midea.mcomponent.core.util.TraceContext;
import org.apache.tomcat.util.buf.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.MethodParameter;
import org.springframework.core.annotation.Order;
import org.springframework.http.MediaType;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.util.AntPathMatcher;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

/**
 * {@link com.midea.mcomponent.web.common.advice.JsonResponseBodyAdvice}
 *
 * @author liwf106
 * @since 2023/12/7
 */
@Order(-1)
@ControllerAdvice
@SuppressWarnings("all")
public class TJsonResponseBodyAdvice implements ResponseBodyAdvice<Object> {
    protected final Logger logger = LoggerFactory.getLogger(TJsonResponseBodyAdvice.class);
    private static final List<String> DEFAULT_UN_WARP_PATHS =
        Arrays.asList("/**/configuration/ui", "/**/swagger-resources", "/**/v2/api-docs", "/**/configuration/security");
    @Autowired
    private Settings settings;

    public TJsonResponseBodyAdvice() {
    }

    public Object beforeBodyWrite(Object object, MethodParameter methodParameter, MediaType mediaType, Class clazz,
                                  ServerHttpRequest request, ServerHttpResponse response) {
        ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse()
            .setHeader("Cache-Control", "no-cache,no-store");
        String uri = request.getURI().getPath();
        boolean isRecord = new Boolean(TraceContext.getLocaleWeb());
        if (this.isUnWarpPath(uri)) {
            return object;
        } else {
            if (object instanceof SuccessResponseData) {
                ((SuccessResponseData) object).setProviderSpans(
                    isRecord ? StringUtils.join(TraceContext.getSpans()) : null);
                ((SuccessResponseData) object).setWebIpAddress(IPUtils.getLocalIpAddress());
                ((SuccessResponseData) object).setTraceId(TraceContext.getTraceId());
            }
            if (object instanceof Response) {
                return object;
            } else if (object == null) {
                return SuccessResponse.newInstance();
            } else {
                SuccessResponseData data = SuccessResponseData.newInstance(object);
                data.setProviderSpans(isRecord ? StringUtils.join(TraceContext.getSpans()) : null);
                data.setWebIpAddress(IPUtils.getLocalIpAddress());
                data.setTraceId(TraceContext.getTraceId());
                return data;
            }
        }
    }

    private boolean isUnWarpPath(String path) {
        AntPathMatcher matcher = new AntPathMatcher();
        Iterator var4 = DEFAULT_UN_WARP_PATHS.iterator();
        String pattern;
        while (var4.hasNext()) {
            pattern = (String) var4.next();
            if (org.apache.commons.lang.StringUtils.isNotEmpty(pattern) && matcher.match(pattern, path)) {
                return true;
            }
        }
        if (this.settings.getUnwarpUrls() != null && this.settings.getUnwarpUrls().size() > 0) {
            var4 = this.settings.getUnwarpUrls().iterator();
            while (var4.hasNext()) {
                pattern = (String) var4.next();
                if (org.apache.commons.lang.StringUtils.isNotEmpty(pattern) && matcher.match(pattern, path)) {
                    return true;
                }
            }
        }
        return false;
    }

    public boolean supports(MethodParameter methodParameter, Class clazz) {
        return clazz.equals(TimeZoneMessageConverter.class);
    }
}

2.3，替换 MappingJackson2HttpMessageConverter

使用自定义 MessageConverter 替换掉项目原来默认处理 json 类型报文的 MappingJackson2HttpMessageConverter。若不确定项目默认消息转换器可在此方法下断点判断：

org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport#addDefaultHttpMessageConverters

package com.midea.srm.core.timezone;

import java.util.List;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * 配置国际时区转换器
 *
 * @author liwf106
 * @since 2023/12/7
 */
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        int index = converters.size();
        for (int i = 0; i < converters.size(); i++) {
            if (converters.get(i) instanceof MappingJackson2HttpMessageConverter) {
                index = i;
                break;
            }
        }
        converters.add(index, new TimeZoneMessageConverter());
    }
}

2.4，响应头设置 ISrmTimeZone & 特殊传参处理

使用 AOP 拦截需要进行时区转换的接口，将请求头 ISrmTimeZone 设置到响应头中以供自定义 messageConverter 获取时区。修改 objectMapper 时区仅适用于 Java 对象传参，若使用形如 Map<String, String>的方式传参则无法获取到 Date 类型而无法转换时区，因此可在 AOP 内酌情判断并手动转换时区。

package com.midea.srm.core.timezone;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;
import java.util.TimeZone;
import cn.hutool.json.JSONUtil;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
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.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

/**
 * 国际时区转换处理
 * 处理 Map 等特殊入参形式
 *
 * @author liwf106
 * @since 2023/12/6
 */
@Slf4j
@Aspect
@Component
@SuppressWarnings("all")
public class TimeZoneConvertAspect {
    // 国内时区
    public static final SimpleDateFormat SH_SDF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    // 国内时区-日期
    public static final SimpleDateFormat SH_SDF_DATE = new SimpleDateFormat("yyyy-MM-dd");
    // 国际时区
    public static final SimpleDateFormat GLOBAL_SDF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    // 国际时区-日期
    public static final SimpleDateFormat GLOBAL_SDF_DATE = new SimpleDateFormat("yyyy-MM-dd");

    @Autowired
    private ObjectMapper objectMapper;

    public TimeZoneConvertAspect(ObjectMapper objectMapper) {
        SH_SDF.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
        SH_SDF_DATE.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
        this.objectMapper = objectMapper;
    }

    @Pointcut("@within(org.springframework.web.bind.annotation.RestController) && within(com.midea.srm..*)")
    public void point() {
    }

    @Around("point()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        try {
            HttpServletRequest request =
                ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            String timeZone = request.getHeader(TimeZoneMessageConverter.TIME_ZONE_HEADER);
            if (StringUtils.isNotBlank(timeZone)) {
                HttpServletResponse response =
                    ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
                response.addHeader(TimeZoneMessageConverter.TIME_ZONE_HEADER, timeZone);
                // 根据请求头设置国际时区
                GLOBAL_SDF.setTimeZone(TimeZone.getTimeZone(timeZone));
                GLOBAL_SDF_DATE.setTimeZone(TimeZone.getTimeZone(timeZone));
                // 入参
                Object[] args = joinPoint.getArgs();
                log.info("原始请求参数为{}", args);
                for (Object arg : args) {
                    log.info("参数:{}", JSONUtil.toJsonStr(arg));
                    // 仅处理 Map 形式入参
                    if (arg instanceof Map) {
                        ((Map) arg).forEach((k, v) -> {
                            if (v instanceof String && StringUtils.isNotBlank((String) v) && isDateFieldName((String) k)) {
                                try {
                                    log.info("传参含date字段:[{}],[{}]", k, v);
                                    Date date;
                                    String format;
                                    // 仅年月日
                                    if ((((String) v)).length() == 10) {
                                        date = GLOBAL_SDF_DATE.parse((String) v);
                                        format = SH_SDF_DATE.format(date);
                                    } else {
                                        date = GLOBAL_SDF.parse((String) v);
                                        format = SH_SDF.format(date);
                                    }
                                    ((Map) arg).put(k, format);
                                    log.info("传参含date字段转换结果:[{}],[{}]", k, format);
                                } catch (ParseException e) {
                                    log.error("解析失败", e);
                                }
                            }
                        });
                    }
                }
            }
        } catch (Exception e) {
            log.error("时区转换失败", e);
        }
        return joinPoint.proceed();
    }

    /**
     * 根据字段名猜测是否为日期
     *
     * @param fieldName 字段名
     * @return isDateFieldName
     */
    private boolean isDateFieldName(String fieldName) {
        return fieldName.contains("date") || fieldName.contains("Date");
    }
}

3，逻辑验证

前端验证可修改浏览器位置信息模拟海外场景
后端验证手动添加请求头，若不生效可关注所有已注册的 HttpMessageConverter 响应的 contentType 和注册顺序

附：注意事项

以上方案仅处理前后端交互报文，未处理 excel 导入导出场景
以上方案会替换处理 json 的默认 HttpMessageConverter，建议根据实际情况评估影响范围（例如本例中影响了 com.midea.mcomponent.web.common.advice.JsonResponseBodyAdvice）
2.4 中特殊传参处理仅考虑了传参为 Map 的场景

硬盘挂载

Tue, 12 Mar 2024 00:00:00 GMT

1.查看硬盘挂载情况

fdisk -l

2.查看当前分区情况

df -l

3.给新硬盘添加新分区（可选）

_fdisk _/dev/vdb

4.分区完成，查询所有设备的文件系统类型

blkid

5.格式化分区

先查看当前系统支持格式化成什么类型，输入mkfs，然后按两下tab键

mkfs.xfs /dev/vdb1
blkid

6.挂载

mkdir /mnt/storage
mount /dev/vdb1 /mnt/storage/

7.设置自动挂载

磁盘被手动挂载之后都必须把挂载信息写入 /etc/fstab 这个文件中，否则下次开机启动时仍然需要重新挂载。系统开机时会主动读取 /etc/fstab 这个文件中的内容，根据文件里面的配置挂载磁盘。这样我们只需要将磁盘的挂载信息写入这个文件中我们就不需要每次开机启动之后手动进行挂载了。

首先通过 blkid 命令将分区的 uuid 查询出来并复制 uuid（往/etc/fstab中追加挂载信息时建议使用uuid）

vim /etc/fstab

MinIO 安装运行

Mon, 11 Mar 2024 00:00:00 GMT

使用Docker 运行单点模式

docker run -p 9000:9000 -di \
  --name minio \
  -v /data/minio:/data \
  -e "MINIO_ACCESS_KEY=HI3UNHSHXG2A0IR35YZO" \
  -e "MINIO_SECRET_KEY=bzXKoRrrqbpQ+1ezmJkBKxusVc5JZc02cBNm5vEd" \
  minio/minio server /data

Parameter	Description
-p	端口映射，将外部端口映射到容器内部端口
--name	自定义容器名称
-di	后台运行的方式运行
--restart=always	一旦docker重启或者开启时，也自动启动镜像
-e	设置系统变量，在这里是设置Minio的ACCESS_KEY和SECRET_KEY
-v	挂载文件，将系统文件映射到容器内部对应的文件夹

以普通用户身份运行MinIO Docker

Docker提供了标准化的机制，可以以非root用户身份运行docker容器。

mkdir -p ${HOME}/data
docker run -p 9000:9000 \
  --user $(id -u):$(id -g) \
  --name minio1 \
  -e "MINIO_ACCESS_KEY=AKIAIOSFODNN7EXAMPLE" \
  -e "MINIO_SECRET_KEY=wJalrXUtnFEMIK7MDENGbPxRfiCYEXAMPLEKEY" \
  -v ${HOME}/data:/data \
  minio/minio server /data

使用二进制文件运行

wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
./minio server /data

MinIO客户端

下载二进制文件

wget -P /bin https://dl.min.io/client/mc/release/linux-amd64/mc
chmod +x /bin/mc
mc --help

添加一个云存储服务，也可直接修改~/.mc/config.json

# API签名为可选项 默认S3v4
mc alias set <ALIAS> <YOUR-S3-ENDPOINT> <YOUR-ACCESS-KEY> <YOUR-SECRET-KEY> --api <API-SIGNATURE> --path <BUCKET-LOOKUP-TYPE>
# 示例 MinIO本地存储
mc alias set minio http://localhost:9000 HI3UNHSHXG2A0IR35YZO bzXKoRrrqbpQ+1ezmJkBKxusVc5JZc02cBNm5vEd
# 示例 MinIO云存储
mc alias set minio http://192.168.1.51 BKIKJAA5BMMU2RHO6IBB V7f1CwQqAcwo80UEIJEjc5gVQUSSx5ohQ9GSrr12
# 示例 Amazon S3云存储
mc alias set s3 https://s3.amazonaws.com BKIKJAA5BMMU2RHO6IBB V7f1CwQqAcwo80UEIJEjc5gVQUSSx5ohQ9GSrr12
# 示例 Google云存储
mc alias set gcs  https://storage.googleapis.com BKIKJAA5BMMU2RHO6IBB V8f1CwQqAcwo80UEIJEjc5gVQUSSx5ohQ9GSrr12

MinIO Admin命令指南

官方文档

异步场景日志链路追踪

Wed, 06 Mar 2024 00:00:00 GMT

1，概述

线上环境排查问题需要对某次请求的所有日志进行链路追踪。logback 的 MDC 提供的日志追踪方案仅支持单个线程内的追踪，这是因为 MDC 是基于 ThreadLocal 实现，无法跨线程传递 traceId。阿里开源的TransmittableThreadLocal 基于 InheritableThreadLocal 扩展，支持线程池跨线程传递变量。借此重写 MDCAdapter 即可实现异步场景下的日志链路追踪。

2，MDC 改造

2.0，依赖引入

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

2.1，重写 MDCAdapter

MDC 存储线程变量的逻辑位于 MDCAdapter

package org.slf4j;


import com.alibaba.ttl.TransmittableThreadLocal;
import org.slf4j.spi.MDCAdapter;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * 重写logback的LogbackMDCAdapter，用TransmittableThreadLocal替换ThreadLocal，解决异步线程traceId传递
 *
 * @author liwf106
 * @since 2024/1/25
 */
@SuppressWarnings("all")
public class TtlMDCAdapter implements MDCAdapter {

    private final ThreadLocal<Map<String, String>> copyOnInheritThreadLocal = new TransmittableThreadLocal<>();

    private static final int WRITE_OPERATION = 1;
    private static final int MAP_COPY_OPERATION = 2;

    static TtlMDCAdapter mtcMDCAdapter;

    static {
        mtcMDCAdapter = new TtlMDCAdapter();
        // 替换MDC的MDCAdapter
        MDC.mdcAdapter = mtcMDCAdapter;
    }

    public static MDCAdapter getInstance() {
        return mtcMDCAdapter;
    }

    final ThreadLocal<Integer> lastOperation = new ThreadLocal<Integer>();

    private Integer getAndSetLastOperation(int op) {
        Integer lastOp = lastOperation.get();
        lastOperation.set(op);
        return lastOp;
    }

    private boolean wasLastOpReadOrNull(Integer lastOp) {
        return lastOp == null || lastOp.intValue() == MAP_COPY_OPERATION;
    }

    private Map<String, String> duplicateAndInsertNewMap(Map<String, String> oldMap) {
        Map<String, String> newMap = Collections.synchronizedMap(new HashMap<String, String>());
        if (oldMap != null) {
            // we don't want the parent thread modifying oldMap while we are
            // iterating over it
            synchronized (oldMap) {
                newMap.putAll(oldMap);
            }
        }

        copyOnInheritThreadLocal.set(newMap);
        return newMap;
    }

    /**
     * Put a context value (the <code>val</code> parameter) as identified with the
     * <code>key</code> parameter into the current thread's context map. Note that
     * contrary to log4j, the <code>val</code> parameter can be null.
     * <p/>
     * <p/>
     * If the current thread does not have a context map it is created as a side
     * effect of this call.
     *
     * @throws IllegalArgumentException in case of the "key" parameter is null
     */
    @Override
    public void put(String key, String val) throws IllegalArgumentException {
        if (key == null) {
            throw new IllegalArgumentException("key cannot be null");
        }

        Map<String, String> oldMap = copyOnInheritThreadLocal.get();
        Integer lastOp = getAndSetLastOperation(WRITE_OPERATION);

        if (wasLastOpReadOrNull(lastOp) || oldMap == null) {
            Map<String, String> newMap = duplicateAndInsertNewMap(oldMap);
            newMap.put(key, val);
        } else {
            oldMap.put(key, val);
        }
    }

    /**
     * Remove the the context identified by the <code>key</code> parameter.
     * <p/>
     */
    @Override
    public void remove(String key) {
        if (key == null) {
            return;
        }
        Map<String, String> oldMap = copyOnInheritThreadLocal.get();
        if (oldMap == null)
            return;

        Integer lastOp = getAndSetLastOperation(WRITE_OPERATION);

        if (wasLastOpReadOrNull(lastOp)) {
            Map<String, String> newMap = duplicateAndInsertNewMap(oldMap);
            newMap.remove(key);
        } else {
            oldMap.remove(key);
        }
    }

    /**
     * Clear all entries in the MDC.
     */
    @Override
    public void clear() {
        lastOperation.set(WRITE_OPERATION);
        copyOnInheritThreadLocal.remove();
    }

    /**
     * Get the context identified by the <code>key</code> parameter.
     * <p/>
     */
    @Override
    public String get(String key) {
        final Map<String, String> map = copyOnInheritThreadLocal.get();
        if ((map != null) && (key != null)) {
            return map.get(key);
        } else {
            return null;
        }
    }

    /**
     * Get the current thread's MDC as a map. This method is intended to be used
     * internally.
     */
    public Map<String, String> getPropertyMap() {
        lastOperation.set(MAP_COPY_OPERATION);
        return copyOnInheritThreadLocal.get();
    }

    /**
     * Returns the keys in the MDC as a {@link Set}. The returned value can be
     * null.
     */
    public Set<String> getKeys() {
        Map<String, String> map = getPropertyMap();

        if (map != null) {
            return map.keySet();
        } else {
            return null;
        }
    }

    /**
     * Return a copy of the current thread's context map. Returned value may be
     * null.
     */
    @Override
    public Map<String, String> getCopyOfContextMap() {
        Map<String, String> hashMap = copyOnInheritThreadLocal.get();
        if (hashMap == null) {
            return null;
        } else {
            return new HashMap<>(hashMap);
        }
    }

    @Override
    public void setContextMap(Map<String, String> contextMap) {
        lastOperation.set(WRITE_OPERATION);

        Map<String, String> newMap = Collections.synchronizedMap(new HashMap<String, String>());
        newMap.putAll(contextMap);

        // the newMap replaces the old one for serialisation's sake
        copyOnInheritThreadLocal.set(newMap);
    }
}

2.2，加载TtlMDCAdapter

定义初始化方法

package com.midea.escm.core.config;

import org.slf4j.TtlMDCAdapter;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;

/**
 * 初始化自定义MDCAdapter
 *
 * @author liwf106
 * @since 2024/1/25
 */
@SuppressWarnings("all")
public class TtlMDCAdapterInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {

    @Override
    public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
        // 加载自定义的MDCAdapter
        TtlMDCAdapter.getInstance();
    }
}

启动类里增加 initializer （ApplicationContextInitializer另有两种使用方法，在此不赘述）

public static void main(String[] args) {
    SpringApplication springApplication = new SpringApplication(VbpApplication.class);

    springApplication.addInitializers(new TtlMDCAdapterInitializer());

    springApplication.run(args);
}

3，MDC 使用

3.1 添加 traceId

在web请求拦截器用调用 MDC.put 添加traceId

public void addInterceptors(InterceptorRegistry registry) {

    registry.addWebRequestInterceptor(new WebRequestInterceptor() {

        @Override
        public void preHandle(WebRequest request) throws Exception {
            String cookie = request.getHeader("Cookie");
            TokenUtil.setToken(cookie);
            MDC.put("traceId", TraceContext.getTraceId());
        }

        @Override
        public void postHandle(WebRequest request, ModelMap model) throws Exception {
        }

        @Override
        public void afterCompletion(WebRequest request, Exception ex) throws Exception {
            TokenUtil.removeToken();
        }
    });
}

3.2 日志打印

在 logback-spring.xml 的输出格式中使用 %X{traceId} 获取 traceId 的值

<property name="log.colorPattern"
          value="%date{yyyy-MM-dd HH:mm:ss} | %cyan(%-5level) | %yellow(%thread) | %red([TraceId:%X{traceId}] | %magenta(%file:%line) | %green(%logger{96}) | (%msg%n%n)"/>

附： https://github.com/alibaba/transmittable-thread-local