日志体系与生产实践

// SLF4J 绑定查找过程（简化版）
public final class LoggerFactory {

    // 编译时不存在 StaticLoggerBinder 的引用
    // 运行时通过类加载器查找绑定
    private static String STATIC_LOGGER_BINDER_PATH =
            "org/slf4j/impl/StaticLoggerBinder.class";

    static {
        // 扫描类路径上所有 StaticLoggerBinder 实现
        Set<URL> binderSet = findPossibleStaticLoggerBinderPathSet();
        // 如果有多个绑定，输出警告
        if (binderSet.size() > 1) {
            reportMultipleBindingAmbiguity(binderSet);
        }
    }
}

<!-- 常用桥接器依赖 -->
<!-- 桥接 Log4j 1.x → SLF4J -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>log4j-over-slf4j</artifactId>
</dependency>

<!-- 桥接 JCL (Jakarta Commons Logging) → SLF4J -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>jcl-over-slf4j</artifactId>
</dependency>

<!-- 桥接 JUL (java.util.logging) → SLF4J -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>jul-to-slf4j</artifactId>
</dependency>

<!-- 步骤 1: 排除 Log4j 依赖 -->
<dependency>
    <groupId>some-library</groupId>
    <artifactId>some-library</artifactId>
    <exclusions>
        <exclusion>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<!-- 步骤 2: 添加桥接器（替代原 Log4j jar） -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>log4j-over-slf4j</artifactId>
</dependency>

<!-- 步骤 3: 添加 SLF4J + Logback（Spring Boot 已默认包含） -->
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
</dependency>

<!-- 控制台输出，带颜色高亮 -->
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %highlight(%-5level) [%thread] %cyan(%logger{36}) - %msg%n</pattern>
    </encoder>
</appender>

<!-- 滚动文件输出，按日期+大小滚动 -->
<appender name="ROLLING_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>${LOG_PATH}/${APP_NAME}.log</file>

    <!-- 滚动策略：按日期和大小 -->
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
        <!-- 文件名模式：%d 日期，%i 序号 -->
        <fileNamePattern>${LOG_PATH}/${APP_NAME}.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
        <!-- 单个文件最大 200MB -->
        <maxFileSize>200MB</maxFileSize>
        <!-- 保留 30 天 -->
        <maxHistory>30</maxHistory>
        <!-- 所有归档文件总大小上限 10GB -->
        <totalSizeCap>10GB</totalSizeCap>
        <!-- 启动时清理过期归档 -->
        <cleanHistoryOnStart>true</cleanHistoryOnStart>
    </rollingPolicy>

    <encoder>
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        <charset>UTF-8</charset>
    </encoder>
</appender>

<!-- 输出到远程日志服务器 -->
<appender name="SOCKET" class="ch.qos.logback.classic.net.SocketAppender">
    <remoteHost>log-server.internal</remoteHost>
    <port>4560</port>
    <reconnectionDelay>30 seconds</reconnectionDelay>
    <queueSize>1000</queueSize>
</appender>

<!-- 输出到数据库（审计日志场景） -->
<appender name="DB" class="ch.qos.logback.classic.db.DBAppender">
    <connectionSource class="ch.qos.logback.core.db.DataSourceConnectionSource">
        <dataSource class="com.zaxxer.hikari.HikariDataSource">
            <driverClassName>com.mysql.cj.jdbc.Driver</driverClassName>
            <jdbcUrl>jdbc:mysql://localhost:3306/audit_log</jdbcUrl>
            <username>log_user</username>
            <password>log_password</password>
        </dataSource>
    </connectionSource>
</appender>

/**
 * 自定义 Kafka Appender：将日志发送到 Kafka
 */
public class KafkaAppender extends UnsynchronizedAppenderBase<ILoggingEvent> {

    private String topic;
    private String bootstrapServers;
    private KafkaProducer<String, String> producer;

    // Logback 通过 setter 方法注入配置
    public void setTopic(String topic) {
        this.topic = topic;
    }

    public void setBootstrapServers(String bootstrapServers) {
        this.bootstrapServers = bootstrapServers;
    }

    @Override
    public void start() {
        // 初始化 Kafka Producer
        Properties props = new Properties();
        props.put("bootstrap.servers", bootstrapServers);
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        producer = new KafkaProducer<>(props);
        super.start();
    }

    @Override
    protected void append(ILoggingEvent event) {
        String message = event.getFormattedMessage();
        ProducerRecord<String, String> record =
                new ProducerRecord<>(topic, message);
        producer.send(record, (metadata, exception) -> {
            if (exception != null) {
                // 发送失败时添加错误状态
                addError("发送日志到 Kafka 失败", exception);
            }
        });
    }

    @Override
    public void stop() {
        if (producer != null) {
            producer.close();
        }
        super.stop();
    }
}

<!-- 在 logback-spring.xml 中使用自定义 Appender -->
<appender name="KAFKA" class="com.example.log.KafkaAppender">
    <topic>app-logs</topic>
    <bootstrapServers>kafka:9092</bootstrapServers>
</appender>

<!-- 1. PatternLayoutEncoder（最常用） -->
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
    <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    <charset>UTF-8</charset>
</encoder>

<!-- 2. LogstashEncoder（JSON 格式，ELK 集成推荐） -->
<encoder class="net.logstash.logback.encoder.LogstashEncoder">
    <customFields>{"app_name":"${APP_NAME}"}</customFields>
    <includeMdc>true</includeMdc>
    <includeContext>true</includeContext>
</encoder>

<!-- 3. LoggingEventCompositeJsonEncoder（细粒度 JSON 控制） -->
<encoder class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
    <providers>
        <timestamp/>
        <logLevel/>
        <loggerName/>
        <message/>
        <stackTrace>
            <throwableConverter class="net.logstash.logback.stacktrace.ShortenedThrowableConverter">
                <maxDepthPerThrowable>20</maxDepthPerThrowable>
                <maxLength>2048</maxLength>
                <shortenedClassNameLength>30</shortenedClassNameLength>
            </throwableConverter>
        </stackTrace>
        <mdc/>
        <context/>
        <pattern>
            <pattern>{"app":"${APP_NAME}","env":"${SPRING_PROFILES_ACTIVE}"}</pattern>
        </pattern>
    </providers>
</encoder>

<!-- 1. LevelFilter：级别过滤 -->
<appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <filter class="ch.qos.logback.classic.filter.LevelFilter">
        <level>ERROR</level>
        <onMatch>ACCEPT</onMatch>      <!-- 匹配则接受 -->
        <onMismatch>DENY</onMismatch>  <!-- 不匹配则拒绝 -->
    </filter>
    <file>${LOG_PATH}/${APP_NAME}-error.log</file>
    <encoder>
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
</appender>

<!-- 2. ThresholdFilter：阈值过滤 -->
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
    <level>WARN</level>  <!-- 只记录 WARN 及以上级别 -->
</filter>

<!-- 3. EvaluatorFilter：表达式过滤 -->
<filter class="ch.qos.logback.classic.filter.EvaluatorFilter">
    <evaluator>
        <!-- 只记录包含 "SLOW" 关键字的日志 -->
        <expression>message.contains("SLOW")</expression>
    </evaluator>
    <onMatch>ACCEPT</onMatch>
    <onMismatch>DENY</onMismatch>
</filter>

<!-- 4. TurboFilter：全局过滤器（在 Logger 层面过滤，优先级最高） -->
<turboFilter class="ch.qos.logback.classic.turbo.MarkerFilter">
    <Marker>SUPERVISOR</Marker>
    <onMatch>NEUTRAL</onMatch>
</turboFilter>

<!-- logback-spring.xml 完整生产级配置 -->
<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    <!-- 引入 Spring Boot 默认配置 -->
    <include resource="org/springframework/boot/logging/logback/defaults.xml"/>

    <!-- 定义变量 -->
    <springProperty scope="context" name="APP_NAME" source="spring.application.name" defaultValue="app"/>
    <springProperty scope="context" name="LOG_PATH" source="logging.file.path" defaultValue="/var/log/app"/>
    <springProperty scope="context" name="ACTIVE_PROFILE" source="spring.profiles.active" defaultValue="dev"/>

    <!-- ========== 通用 Appender ========== -->

    <!-- 控制台输出 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %highlight(%-5level) [%thread] %cyan(%logger{36}) [trace:%X{traceId}] - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!-- INFO 级别滚动文件 -->
    <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_PATH}/${APP_NAME}-info.log</file>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>INFO</level>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${LOG_PATH}/${APP_NAME}-info.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
            <maxFileSize>200MB</maxFileSize>
            <maxHistory>30</maxHistory>
            <totalSizeCap>10GB</totalSizeCap>
            <cleanHistoryOnStart>true</cleanHistoryOnStart>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level [trace:%X{traceId}] %logger{36} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!-- ERROR 级别滚动文件 -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_PATH}/${APP_NAME}-error.log</file>
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${LOG_PATH}/${APP_NAME}-error.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
            <maxFileSize>100MB</maxFileSize>
            <maxHistory>90</maxHistory>
            <totalSizeCap>5GB</totalSizeCap>
            <cleanHistoryOnStart>true</cleanHistoryOnStart>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level [trace:%X{traceId}] %logger{36} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!-- JSON 格式文件（用于日志采集） -->
    <appender name="JSON_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_PATH}/${APP_NAME}-json.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${LOG_PATH}/${APP_NAME}-json.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
            <maxFileSize>200MB</maxFileSize>
            <maxHistory>7</maxHistory>
            <totalSizeCap>5GB</totalSizeCap>
        </rollingPolicy>
        <encoder class="net.logstash.logback.encoder.LogstashEncoder">
            <customFields>{"app_name":"${APP_NAME}"}</customFields>
        </encoder>
    </appender>

    <!-- 异步包装 -->
    <appender name="ASYNC_INFO" class="ch.qos.logback.classic.AsyncAppender">
        <queueSize>1024</queueSize>
        <discardingThreshold>0</discardingThreshold>
        <neverBlock>true</neverBlock>
        <appender-ref ref="INFO_FILE"/>
    </appender>

    <appender name="ASYNC_ERROR" class="ch.qos.logback.classic.AsyncAppender">
        <queueSize>512</queueSize>
        <discardingThreshold>0</discardingThreshold>
        <neverBlock>false</neverBlock>  <!-- ERROR 日志不允许丢弃 -->
        <appender-ref ref="ERROR_FILE"/>
    </appender>

    <appender name="ASYNC_JSON" class="ch.qos.logback.classic.AsyncAppender">
        <queueSize>2048</queueSize>
        <discardingThreshold>0</discardingThreshold>
        <neverBlock>true</neverBlock>
        <appender-ref ref="JSON_FILE"/>
    </appender>

    <!-- ========== 开发环境 ========== -->
    <springProfile name="dev">
        <root level="INFO">
            <appender-ref ref="CONSOLE"/>
        </root>
        <!-- 开发环境开启框架 DEBUG 日志 -->
        <logger name="org.springframework.web" level="DEBUG"/>
        <logger name="org.springframework.security" level="DEBUG"/>
    </springProfile>

    <!-- ========== 测试环境 ========== -->
    <springProfile name="test">
        <root level="INFO">
            <appender-ref ref="CONSOLE"/>
            <appender-ref ref="INFO_FILE"/>
            <appender-ref ref="ERROR_FILE"/>
        </root>
    </springProfile>

    <!-- ========== 生产环境 ========== -->
    <springProfile name="prod">
        <root level="INFO">
            <appender-ref ref="ASYNC_INFO"/>
            <appender-ref ref="ASYNC_ERROR"/>
            <appender-ref ref="ASYNC_JSON"/>
        </root>
        <!-- 生产环境关闭第三方框架的 DEBUG 日志 -->
        <logger name="org.springframework" level="WARN"/>
        <logger name="org.apache.kafka" level="WARN"/>
        <logger name="com.zaxxer.hikari" level="WARN"/>
    </springProfile>

</configuration>

<!-- 滚动策略详细配置 -->
<rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
    <!--
        文件名模式解析：
        %d{yyyy-MM-dd}  → 按天滚动（也可 %d{yyyy-MM-dd_HH} 按小时）
        %i              → 同一天内的文件序号（从 0 开始）
        .gz             → 自动 GZIP 压缩归档文件
    -->
    <fileNamePattern>${LOG_PATH}/${APP_NAME}.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>

    <!-- 单个文件最大大小，超过后创建新文件 -->
    <maxFileSize>200MB</maxFileSize>

    <!-- 归档文件保留天数，超期自动删除 -->
    <maxHistory>30</maxHistory>

    <!-- 所有归档文件总大小上限，超期按时间顺序删除最旧的 -->
    <totalSizeCap>10GB</totalSizeCap>

    <!-- 应用启动时清理过期归档文件（默认 false） -->
    <cleanHistoryOnStart>true</cleanHistoryOnStart>
</rollingPolicy>

<!-- 开发环境：可读性优先，颜色高亮 -->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %highlight(%-5level) [%thread] %cyan(%logger{36}) [trace:%X{traceId}] - %msg%n</pattern>

<!-- 生产环境：信息完整，便于解析 -->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level [trace:%X{traceId}] %logger{36} - %msg%n</pattern>

<!-- 生产环境（增强版）：包含主机和应用信息 -->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [${HOSTNAME}] [%thread] %-5level [trace:%X{traceId}] [span:%X{spanId}] %logger{36} - %msg%n</pattern>

<!-- Logback AsyncAppender 配置 -->
<appender name="ASYNC_FILE" class="ch.qos.logback.classic.AsyncAppender">
    <!-- 队列容量（默认 256） -->
    <queueSize>1024</queueSize>

    <!--
        丢弃阈值：当队列剩余容量少于此值时，
        丢弃 TRACE、DEBUG、INFO 级别的日志
        设为 0 表示不丢弃任何级别的日志
    -->
    <discardingThreshold>0</discardingThreshold>

    <!--
        队列满时是否阻塞业务线程
        true：不阻塞，丢弃日志（推荐生产环境）
        false：阻塞，等待队列有空位
    -->
    <neverBlock>true</neverBlock>

    <!-- 是否包含调用者信息（%caller、%line 等），默认 false -->
    <!-- 开启会有性能损耗，因为需要创建 Throwable 获取调用栈 -->
    <includeCallerData>false</includeCallerData>

    <!-- 引用实际的 Appender -->
    <appender-ref ref="FILE"/>
</appender>

<!-- pom.xml：切换到 Log4j2 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <!-- 排除默认的 Logback -->
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<!-- 引入 Log4j2 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

<!-- Disruptor 依赖（Log4j2 异步日志需要） -->
<dependency>
    <groupId>com.lmax</groupId>
    <artifactId>disruptor</artifactId>
    <version>4.0.0</version>
</dependency>

<!-- log4j2.xml：全异步配置 -->
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    <Appenders>
        <RollingFile name="RollingFile" fileName="${sys:LOG_PATH}/app.log"
                     filePattern="${sys:LOG_PATH}/app-%d{yyyy-MM-dd}-%i.log.gz">
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="200MB"/>
            </Policies>
            <DefaultRolloverStrategy max="30"/>
        </RollingFile>
    </Appenders>

    <Loggers>
        <!--
            全异步 Logger：使用 Disruptor
            只需设置 asyncLogger 或 asyncRoot
        -->
        <AsyncRoot level="INFO">
            <AppenderRef ref="RollingFile"/>
        </AsyncRoot>
    </Loggers>
</Configuration>

<!-- ERROR 日志：保证不丢失 -->
<appender name="ASYNC_ERROR" class="ch.qos.logback.classic.AsyncAppender">
    <queueSize>512</queueSize>
    <discardingThreshold>0</discardingThreshold>
    <neverBlock>false</neverBlock>  <!-- 宁可阻塞也不丢弃 ERROR -->
    <appender-ref ref="ERROR_FILE"/>
</appender>

<!-- INFO 日志：允许丢弃 -->
<appender name="ASYNC_INFO" class="ch.qos.logback.classic.AsyncAppender">
    <queueSize>2048</queueSize>
    <discardingThreshold>20</discardingThreshold>  <!-- 队列剩余 < 20 时丢弃 INFO 及以下 -->
    <neverBlock>true</neverBlock>  <!-- 不阻塞业务线程 -->
    <appender-ref ref="INFO_FILE"/>
</appender>

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: health,info,loggers  # 暴露 loggers 端点
  endpoint:
    loggers:
      enabled: true

# 查看所有 Logger 的日志级别
curl http://localhost:8080/actuator/loggers

# 查看指定 Logger 的日志级别
curl http://localhost:8080/actuator/loggers/com.example

# 响应示例
{
    "configuredLevel": null,
    "effectiveLevel": "INFO"
}

# 动态调整日志级别（无需重启）
curl -X POST http://localhost:8080/actuator/loggers/com.example \
  -H "Content-Type: application/json" \
  -d '{"configuredLevel": "DEBUG"}'

# 恢复为默认日志级别（null 表示使用父 Logger 的级别）
curl -X POST http://localhost:8080/actuator/loggers/com.example \
  -H "Content-Type: application/json" \
  -d '{"configuredLevel": null}'

/**
 * 日志级别动态调整服务
 */
@Service
@Slf4j
public class LogLevelService {

    private final LoggerContext loggerContext;

    public LogLevelService() {
        // 获取 Logback 的 LoggerContext
        this.loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
    }

    /**
     * 设置指定 Logger 的日志级别
     */
    public void setLogLevel(String loggerName, Level level) {
        ch.qos.logback.classic.Logger logger =
                loggerContext.getLogger(loggerName);
        if (logger != null) {
            logger.setLevel(level);
            log.info("日志级别已调整: {} -> {}", loggerName, level);
        }
    }

    /**
     * 获取指定 Logger 的有效日志级别
     */
    public Level getEffectiveLevel(String loggerName) {
        ch.qos.logback.classic.Logger logger =
                loggerContext.getLogger(loggerName);
        return logger != null ? logger.getEffectiveLevel() : null;
    }

    /**
     * 临时开启 DEBUG 日志（指定持续时间后自动恢复）
     */
    @Async
    public void temporaryDebug(String loggerName, Duration duration) {
        setLogLevel(loggerName, Level.DEBUG);
        log.info("已临时开启 DEBUG 日志，{} 后自动恢复", duration);

        try {
            Thread.sleep(duration.toMillis());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            setLogLevel(loggerName, Level.INFO);
            log.info("DEBUG 日志已自动恢复为 INFO");
        }
    }
}

/**
 * 分布式追踪 Filter：在每个请求的 MDC 中设置 TraceId
 */
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class TraceFilter implements Filter {

    private static final String TRACE_ID = "traceId";
    private static final String TRACE_HEADER = "X-Trace-Id";

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;

        // 优先从请求头获取（链路追踪场景，上游服务传递过来）
        String traceId = httpRequest.getHeader(TRACE_HEADER);
        if (traceId == null || traceId.isEmpty()) {
            // 首次请求，生成新的 TraceId
            traceId = generateTraceId();
        }

        // 设置 MDC
        MDC.put(TRACE_ID, traceId);
        // 同时设置到响应头，方便下游排查
        ((HttpServletResponse) response).setHeader(TRACE_HEADER, traceId);

        try {
            chain.doFilter(request, response);
        } finally {
            // 请求结束，清理 MDC，防止内存泄漏
            MDC.remove(TRACE_ID);
        }
    }

    /**
     * 生成 TraceId：使用雪花算法或 UUID
     */
    private String generateTraceId() {
        return UUID.randomUUID().toString().replace("-", "");
    }
}

/**
 * HandlerInterceptor 中设置 MDC
 * 适用于需要 Spring 上下文信息的场景
 */
@Component
public class TraceInterceptor implements HandlerInterceptor {

    private static final String TRACE_ID = "traceId";

    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) {
        String traceId = request.getHeader("X-Trace-Id");
        if (traceId == null) {
            traceId = UUID.randomUUID().toString().replace("-", "");
        }
        MDC.put(TRACE_ID, traceId);

        // 记录请求信息
        MDC.put("requestUri", request.getRequestURI());
        MDC.put("requestMethod", request.getMethod());
        MDC.put("clientIp", getClientIp(request));

        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request,
                                HttpServletResponse response,
                                Object handler, Exception ex) {
        // 清理所有 MDC 信息
        MDC.clear();
    }

    private String getClientIp(HttpServletRequest request) {
        String ip = request.getHeader("X-Forwarded-For");
        if (ip == null || ip.isEmpty()) {
            ip = request.getHeader("X-Real-IP");
        }
        if (ip == null || ip.isEmpty()) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }
}

/**
 * MDC 任务装饰器：将父线程的 MDC 上下文复制到子线程
 */
public class MdcTaskDecorator implements TaskDecorator {

    @Override
    public Runnable decorate(Runnable runnable) {
        // 捕获父线程的 MDC 上下文
        Map<String, String> contextMap = MDC.getCopyOfContextMap();
        return () -> {
            try {
                // 设置到子线程
                if (contextMap != null) {
                    MDC.setContextMap(contextMap);
                }
                runnable.run();
            } finally {
                // 清理子线程的 MDC，防止线程池复用时污染
                MDC.clear();
            }
        };
    }
}

// 配置异步线程池
@Configuration
@EnableAsync
public class AsyncConfig {

    @Bean
    public TaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(50);
        executor.setQueueCapacity(200);
        executor.setThreadNamePrefix("async-");
        // 设置 MDC 装饰器
        executor.setTaskDecorator(new MdcTaskDecorator());
        executor.initialize();
        return executor;
    }
}

/**
 * 支持 MDC 传递的线程池工厂
 */
public class MdcThreadPoolExecutor {

    /**
     * 创建支持 MDC 传递的线程池
     */
    public static ThreadPoolExecutor newMdcExecutor(
            int corePoolSize, int maxPoolSize, String prefix) {
        return new ThreadPoolExecutor(
                corePoolSize, maxPoolSize,
                60L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(200),
                new ThreadFactoryBuilder().setNameFormat(prefix + "-%d").build()
        ) {
            @Override
            public void execute(Runnable command) {
                // 包装 Runnable，传递 MDC
                super.execute(MdcTaskDecorator.decorate(command));
            }
        };
    }
}

/**
 * CompletableFuture 中传递 MDC 的工具方法
 */
public class MdcCompletableFuture {

    /**
     * 包装 Supplier，传递 MDC 上下文
     */
    public static <T> Supplier<T> wrapSupplier(Supplier<T> supplier) {
        Map<String, String> contextMap = MDC.getCopyOfContextMap();
        return () -> {
            try {
                if (contextMap != null) {
                    MDC.setContextMap(contextMap);
                }
                return supplier.get();
            } finally {
                MDC.clear();
            }
        };
    }

    /**
     * 包装 Runnable，传递 MDC 上下文
     */
    public static Runnable wrapRunnable(Runnable runnable) {
        Map<String, String> contextMap = MDC.getCopyOfContextMap();
        return () -> {
            try {
                if (contextMap != null) {
                    MDC.setContextMap(contextMap);
                }
                runnable.run();
            } finally {
                MDC.clear();
            }
        };
    }
}

// 使用示例
CompletableFuture<Order> future = CompletableFuture
    .supplyAsync(
        MdcCompletableFuture.wrapSupplier(() -> orderService.getOrder(orderId)),
        executor
    )
    .thenApplyAsync(
        MdcCompletableFuture.wrapSupplier(order -> enrichOrder(order)),
        executor
    );

/**
 * 日志脱敏转换器：自动处理敏感信息
 */
public class SensitiveDataConverter extends MessageConverter {

    // 手机号正则：1开头11位数字
    private static final Pattern PHONE_PATTERN =
            Pattern.compile("(1[3-9]\\d)\\d{4}(\\d{4})");
    // 身份证号正则
    private static final Pattern ID_CARD_PATTERN =
            Pattern.compile("([1-9]\\d{5})(\\d{8})(\\d{4})");
    // 银行卡号正则
    private static final Pattern BANK_CARD_PATTERN =
            Pattern.compile("(\\d{4})\\d{8,12}(\\d{4})");
    // 邮箱正则
    private static final Pattern EMAIL_PATTERN =
            Pattern.compile("(\\w{2})\\w+@(\\w+\\.\\w+)");

    @Override
    public String convert(ILoggingEvent event) {
        String message = super.convert(event);
        return maskSensitiveData(message);
    }

    private String maskSensitiveData(String message) {
        if (message == null) return null;

        // 手机号脱敏：138****1234
        message = PHONE_PATTERN.matcher(message)
                .replaceAll("$1****$2");
        // 身份证脱敏：110108********1234
        message = ID_CARD_PATTERN.matcher(message)
                .replaceAll("$1********$3");
        // 银行卡脱敏：6222****1234
        message = BANK_CARD_PATTERN.matcher(message)
                .replaceAll("$1****$2");
        // 邮箱脱敏：te**@example.com
        message = EMAIL_PATTERN.matcher(message)
                .replaceAll("$1**@$2");

        return message;
    }
}

<!-- 在 logback-spring.xml 中注册转换器 -->
<configuration>
    <!-- 注册自定义转换器 -->
    <conversionRule conversionWord="msg" converterClass="com.example.log.SensitiveDataConverter"/>
</configuration>

/**
 * 脱敏注解
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Sensitive {

    /**
     * 脱敏策略
     */
    SensitiveStrategy value();

    /**
     * 是否脱敏（默认 true）
     */
    boolean enabled() default true;
}

/**
 * 脱敏策略枚举
 */
public enum SensitiveStrategy {
    PHONE,      // 手机号：138****1234
    ID_CARD,    // 身份证：110108********1234
    BANK_CARD,  // 银行卡：6222****1234
    EMAIL,      // 邮箱：te**@example.com
    NAME,       // 姓名：张*
    ADDRESS,    // 地址：北京市****
    PASSWORD    // 密码：******
}

/**
 * 脱敏工具类
 */
public class SensitiveUtils {

    /**
     * 对对象进行脱敏处理（返回脱敏后的 JSON 字符串）
     */
    public static String toJson(Object obj) {
        if (obj == null) return "null";

        try {
            // 使用 Jackson 自定义序列化器
            ObjectMapper mapper = new ObjectMapper();
            mapper.registerModule(new SensitiveModule());
            return mapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            return obj.toString();
        }
    }

    /**
     * 手机号脱敏
     */
    public static String maskPhone(String phone) {
        if (phone == null || phone.length() < 7) return "***";
        return phone.substring(0, 3) + "****" + phone.substring(phone.length() - 4);
    }

    /**
     * 身份证脱敏
     */
    public static String maskIdCard(String idCard) {
        if (idCard == null || idCard.length() < 8) return "***";
        return idCard.substring(0, 6) + "********" + idCard.substring(idCard.length() - 4);
    }

    /**
     * 姓名脱敏
     */
    public static String maskName(String name) {
        if (name == null || name.isEmpty()) return "***";
        if (name.length() == 1) return "*";
        return name.charAt(0) + "*".repeat(name.length() - 1);
    }

    /**
     * 密码脱敏
     */
    public static String maskPassword() {
        return "******";
    }
}

/**
 * Jackson 自定义序列化器：基于 @Sensitive 注解脱敏
 */
public class SensitiveSerializer extends JsonSerializer<String> {

    private final SensitiveStrategy strategy;

    public SensitiveSerializer(SensitiveStrategy strategy) {
        this.strategy = strategy;
    }

    @Override
    public void serialize(String value, JsonGenerator gen,
                          SerializerProvider provider) throws IOException {
        String maskedValue = switch (strategy) {
            case PHONE -> SensitiveUtils.maskPhone(value);
            case ID_CARD -> SensitiveUtils.maskIdCard(value);
            case NAME -> SensitiveUtils.maskName(value);
            case PASSWORD -> SensitiveUtils.maskPassword();
            case EMAIL -> value == null ? "***" :
                    value.substring(0, 2) + "**@" + value.split("@")[1];
            default -> "***";
        };
        gen.writeString(maskedValue);
    }
}

/**
 * Jackson Module：注册脱敏序列化器
 */
public class SensitiveModule extends SimpleModule {

    @Override
    public void setupModule(SetupContext context) {
        // 需要在 BeanPropertyWriter 级别处理注解
        // 这里使用注解处理器的方式
    }
}

// 使用示例
@Service
@Slf4j
public class UserService {

    public void register(UserDTO user) {
        // 使用脱敏工具输出日志
        log.info("用户注册: {}", SensitiveUtils.toJson(user));

        // 或者手动脱敏特定字段
        log.info("用户注册，手机号: {}, 姓名: {}",
                SensitiveUtils.maskPhone(user.getPhone()),
                SensitiveUtils.maskName(user.getName()));
    }
}

/**
 * 请求日志过滤器：过滤敏感参数
 */
@Component
@Slf4j
public class RequestLoggingFilter extends OncePerRequestFilter {

    // 需要脱敏的参数名（不区分大小写）
    private static final Set<String> SENSITIVE_PARAMS = Set.of(
            "password", "passwd", "pwd",
            "token", "accesstoken", "refresh_token",
            "secret", "apikey", "api_key",
            "creditcard", "credit_card"
    );

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain)
            throws ServletException, IOException {

        ContentCachingRequestWrapper wrappedRequest =
                new ContentCachingRequestWrapper(request);

        try {
            filterChain.doFilter(wrappedRequest, response);
        } finally {
            // 记录脱敏后的请求信息
            logRequest(wrappedRequest);
        }
    }

    private void logRequest(ContentCachingRequestWrapper request) {
        String uri = request.getRequestURI();
        String method = request.getMethod();
        String queryString = maskQueryString(request.getQueryString());
        String body = maskBody(new String(
                request.getContentAsByteArray(), StandardCharsets.UTF_8));

        log.info("HTTP {} {} qs={} body={}", method, uri, queryString, body);
    }

    /**
     * 对查询参数中的敏感值脱敏
     */
    private String maskQueryString(String queryString) {
        if (queryString == null || queryString.isEmpty()) return "";
        StringBuilder sb = new StringBuilder();
        for (String param : queryString.split("&")) {
            String[] kv = param.split("=", 2);
            if (SENSITIVE_PARAMS.contains(kv[0].toLowerCase())) {
                sb.append(kv[0]).append("=***");
            } else {
                sb.append(param);
            }
            sb.append("&");
        }
        return sb.length() > 0 ? sb.substring(0, sb.length() - 1) : "";
    }

    /**
     * 对请求体中的敏感字段脱敏（JSON 格式）
     */
    private String maskBody(String body) {
        if (body == null || body.isEmpty()) return "";
        try {
            ObjectMapper mapper = new ObjectMapper();
            JsonNode node = mapper.readTree(body);
            maskJsonNode(node);
            return mapper.writeValueAsString(node);
        } catch (Exception e) {
            // 解析失败，返回固定长度摘要
            return body.length() > 200 ? body.substring(0, 200) + "..." : body;
        }
    }

    private void maskJsonNode(JsonNode node) {
        if (node.isObject()) {
            ObjectNode obj = (ObjectNode) node;
            Iterator<String> fields = obj.fieldNames();
            while (fields.hasNext()) {
                String field = fields.next();
                if (SENSITIVE_PARAMS.contains(field.toLowerCase())) {
                    obj.put(field, "***");
                } else {
                    maskJsonNode(obj.get(field));
                }
            }
        } else if (node.isArray()) {
            for (JsonNode element : node) {
                maskJsonNode(element);
            }
        }
    }
}

<!-- LogstashEncoder：最简单的 JSON 日志配置 -->
<appender name="JSON_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>${LOG_PATH}/${APP_NAME}-json.log</file>
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
        <fileNamePattern>${LOG_PATH}/${APP_NAME}-json.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
        <maxFileSize>200MB</maxFileSize>
        <maxHistory>7</maxHistory>
        <totalSizeCap>5GB</totalSizeCap>
    </rollingPolicy>
    <encoder class="net.logstash.logback.encoder.LogstashEncoder">
        <!-- 添加自定义字段 -->
        <customFields>{"app_name":"${APP_NAME}","env":"${ACTIVE_PROFILE}"}</customFields>
        <!-- 包含 MDC -->
        <includeMdc>true</includeMdc>
        <!-- 包含调用者信息 -->
        <includeCallerData>false</includeCallerData>
        <!-- 短化异常堆栈 -->
        <throwableConverter class="net.logstash.logback.stacktrace.ShortenedThrowableConverter">
            <maxDepthPerThrowable>30</maxDepthPerThrowable>
            <maxLength>4096</maxLength>
            <shortenedClassNameLength>30</shortenedClassNameLength>
            <exclude>sun\.reflect|java\.lang\.reflect|org\.springframework|org\.tomcat</exclude>
        </throwableConverter>
    </encoder>
</appender>

{
    "@timestamp": "2026-06-07T12:00:00.001+08:00",
    "@version": "1",
    "message": "创建订单成功",
    "logger_name": "com.example.OrderService",
    "thread_name": "http-nio-8080-exec-1",
    "level": "INFO",
    "level_value": 20000,
    "traceId": "abc123def456",
    "spanId": "span001",
    "app_name": "order-service",
    "env": "prod",
    "stack_hash": "5a3b2c1d"
}

/**
 * 结构化日志工具类：方便添加业务字段
 */
public class StructuredLog {

    /**
     * 使用 MDC 添加结构化字段
     */
    public static void withFields(Runnable action, Object... keyValues) {
        try {
            for (int i = 0; i < keyValues.length; i += 2) {
                MDC.put(String.valueOf(keyValues[i]),
                        String.valueOf(keyValues[i + 1]));
            }
            action.run();
        } finally {
            for (int i = 0; i < keyValues.length; i += 2) {
                MDC.remove(String.valueOf(keyValues[i]));
            }
        }
    }
}

// 使用示例
@Service
@Slf4j
public class OrderService {

    public Order createOrder(OrderDTO dto) {
        // 在 MDC 中添加业务字段，JSON 日志会自动包含
        StructuredLog.withFields(() -> {
            log.info("创建订单");
            // 业务逻辑...
        }, "userId", dto.getUserId(),
           "productId", dto.getProductId(),
           "orderAmount", dto.getAmount());
    }
}

// 输出的 JSON 日志会包含：
// { "message": "创建订单", "userId": "U001", "productId": "P001", "orderAmount": "99.9" }

# filebeat.yml
filebeat.inputs:
  - type: log
    enabled: true
    paths:
      - /var/log/app/*-json.log
    json.keys_under_root: true        # JSON 字段放在顶层
    json.add_error_key: true           # 解析错误时添加 error 字段
    json.message_key: message          # 消息字段名
    fields:                            # 添加额外字段
      service: order-service
      environment: production

output.logstash:
  hosts: ["logstash:5044"]
  index: filebeat

# 或者直接输出到 Elasticsearch
# output.elasticsearch:
#   hosts: ["elasticsearch:9200"]
#   index: "app-logs-%{+yyyy.MM.dd}"

# logstash.conf
input {
  beats {
    port => 5044
  }
}

filter {
  # 解析 JSON 日志
  json {
    source => "message"
    remove_field => ["message"]
  }

  # 添加 geoip 信息（基于 IP 字段）
  geoip {
    source => "clientIp"
  }

  # 日志级别标记
  mutate {
    add_field => { "log_level" => "%{level}" }
  }
}

output {
  elasticsearch {
    hosts => ["elasticsearch:9200"]
    # 按日期分索引
    index => "app-logs-%{+YYYY.MM.dd}"
  }
}

# promtail.yml
server:
  http_listen_port: 9080
  grpc_listen_port: 0

positions:
  filename: /tmp/positions.yaml

clients:
  - url: http://loki:3100/loki/api/v1/push

scrape_configs:
  - job_name: app-logs
    static_configs:
      - targets:
          - localhost
        labels:
          job: app
          env: production
          __path__: /var/log/app/*-json.log
    pipeline_stages:
      # 解析 JSON 日志
      - json:
          expressions:
            level: level
            logger_name: logger_name
            message: message
            traceId: traceId
            app_name: app_name
      # 从 JSON 中提取标签
      - labels:
          level:
          app_name:
      # 设置日志时间
      - timestamp:
          source: "@timestamp"
          format: RFC3339

@Service
@Slf4j
public class OrderService {

    public Order createOrder(OrderDTO dto) {
        // √ INFO：关键业务操作
        log.info("创建订单，用户: {}, 商品: {}", dto.getUserId(), dto.getProductId());

        try {
            Order order = doCreateOrder(dto);
            // √ INFO：业务操作结果
            log.info("订单创建成功，订单号: {}", order.getOrderNo());
            return order;
        } catch (InsufficientStockException e) {
            // √ WARN：业务异常（非系统错误，但需要关注）
            log.warn("库存不足，用户: {}, 商品: {}", dto.getUserId(), dto.getProductId());
            throw e;
        } catch (Exception e) {
            // √ ERROR：系统错误（最后一个参数是异常对象，自动打印堆栈）
            log.error("订单创建失败，用户: {}", dto.getUserId(), e);
            throw new BusinessException("订单创建失败");
        }
    }

    private Order doCreateOrder(OrderDTO dto) {
        // √ DEBUG：调试信息（生产环境关闭）
        log.debug("开始创建订单，参数: {}", dto);
        // ... 业务逻辑
        log.debug("库存校验通过，可用库存: {}", getStock(dto.getProductId()));
        // ... 更多逻辑
        return order;
    }
}

@Service
@Slf4j
public class LogExample {

    // √ 好的日志：包含关键业务标识
    public void goodLog() {
        // 1. 包含业务主键，便于追踪
        log.info("订单支付成功，订单号: {}, 支付金额: {}", orderNo, amount);

        // 2. 使用参数化日志（{} 占位符），避免字符串拼接
        log.info("用户登录，userId: {}", userId);

        // 3. 包含足够的上下文信息
        log.info("发送邮件成功，to: {}, subject: {}, 耗时: {}ms",
                email, subject, duration);
    }

    // × 差的日志
    public void badLog() {
        // 1. 无意义的日志
        log.info("开始处理");  // 处理什么？
        log.info("处理完成");  // 谁的处理？成功还是失败？

        // 2. 字符串拼接（即使日志级别不匹配也会执行拼接）
        log.info("用户登录: " + userId);  // 浪费性能

        // 3. 缺少上下文
        log.error("操作失败");  // 什么操作？哪个用户？什么原因？

        // 4. 敏感信息明文
        log.info("用户登录，密码: {}", password);  // 严禁！
    }
}

@Service
@Slf4j
public class ExceptionLogExample {

    // √ 正确的异常日志写法
    public void correctExceptionLog() {
        try {
            riskyOperation();
        } catch (BusinessException e) {
            // 业务异常：WARN 级别，包含错误码和用户信息
            log.warn("业务异常，错误码: {}, 用户: {}, 原因: {}",
                    e.getCode(), userId, e.getMessage());
        } catch (IOException e) {
            // 系统异常：ERROR 级别，异常对象作为最后一个参数
            log.error("文件读取失败，文件: {}", filePath, e);
        } catch (Exception e) {
            // 未知异常：ERROR 级别，包含尽可能多的上下文
            log.error("未知异常，操作: {}, 参数: {}", operation, params, e);
        }
    }

    // × 错误的异常日志写法
    public void wrongExceptionLog() {
        try {
            riskyOperation();
        } catch (Exception e) {
            // 错误 1：只记录消息，丢失堆栈
            log.error("操作失败: " + e.getMessage());

            // 错误 2：异常对象作为占位符参数（不会打印堆栈）
            log.error("操作失败", e.getMessage());

            // 错误 3：异常对象和占位符混用（堆栈会作为 msg 的参数）
            log.error("操作失败: {}", e.getMessage(), e);
            // 这种写法虽然能打印堆栈，但 e.getMessage() 可能重复

            // 错误 4：吞掉异常，不记录日志
            // （什么都没做）
        }
    }
}

# ElastAlert 配置示例：ERROR 日志频率告警
name: error-log-alert
type: frequency
index: app-logs-*

# 5 分钟内出现 10 次 ERROR 日志即告警
num_events: 10
timeframe:
  minutes: 5

filter:
  - term:
      level: "ERROR"

# 排除已知的非关键错误
query_key:
  - app_name
  - logger_name

alert:
  - "slack"
  - "email"

slack:
  slack_webhook_url: "https://hooks.slack.com/services/xxx"

email:
  - "oncall@example.com"

# Grafana Alert 配置示例：基于 Loki 日志的告警
# LogQL 查询：统计 5 分钟内 ERROR 日志数量
# {app="order-service"} | json | level="ERROR" | line_format "{{.message}}"
#
# 告警规则：5 分钟内 ERROR 日志 > 5 次
# for: 5m
# annotations:
#   summary: "订单服务 ERROR 日志异常"
#   description: "最近 5 分钟内出现 {{ $value }} 次 ERROR 日志"

{
    "policy": {
        "phases": {
            "hot": {
                "min_age": "0ms",
                "actions": {
                    "rollover": {
                        "max_size": "50gb",
                        "max_age": "1d"
                    }
                }
            },
            "warm": {
                "min_age": "7d",
                "actions": {
                    "shrink": { "number_of_shards": 1 },
                    "forcemerge": { "max_num_segments": 1 },
                    "allocate": { "require": { "storage_type": "warm" } }
                }
            },
            "cold": {
                "min_age": "30d",
                "actions": {
                    "allocate": { "require": { "storage_type": "cold" } }
                }
            },
            "delete": {
                "min_age": "90d",
                "actions": {
                    "delete": {}
                }
            }
        }
    }
}

/**
 * 慢操作日志切面：自动记录超过阈值的操作
 */
@Aspect
@Component
@Slf4j
public class SlowOperationAspect {

    // 默认慢操作阈值：500ms
    private static final long DEFAULT_THRESHOLD = 500;

    @Around("@annotation(slowOperation)")
    public Object around(ProceedingJoinPoint joinPoint,
                         SlowOperation slowOperation) throws Throwable {
        long start = System.currentTimeMillis();
        String methodName = joinPoint.getSignature().toShortString();

        try {
            Object result = joinPoint.proceed();
            long duration = System.currentTimeMillis() - start;
            long threshold = slowOperation.value();

            if (duration > threshold) {
                // 超过阈值，记录 WARN 日志
                log.warn("SLOW 操作耗时: {}ms（阈值: {}ms），方法: {}",
                        duration, threshold, methodName);
                // 在 MDC 中标记，方便日志系统告警
                MDC.put("slowOperation", "true");
                MDC.put("slowDuration", String.valueOf(duration));
            } else {
                log.debug("操作耗时: {}ms，方法: {}", duration, methodName);
            }
            return result;
        } catch (Throwable e) {
            long duration = System.currentTimeMillis() - start;
            log.error("操作异常，耗时: {}ms，方法: {}", duration, methodName, e);
            throw e;
        } finally {
            MDC.remove("slowOperation");
            MDC.remove("slowDuration");
        }
    }
}

/**
 * 慢操作注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SlowOperation {
    /** 慢操作阈值（毫秒），默认 500ms */
    long value() default 500;
}

// 使用示例
@Service
public class OrderQueryService {

    @SlowOperation(1000)  // 超过 1 秒记录慢操作日志
    public OrderPageResult queryOrders(OrderQueryDTO query) {
        return orderMapper.selectPage(query);
    }
}