springboot logback日志+异常+阿里云日志 aliyun-log-logback-appender

前言

最近有个新项目用了，springboot3.0，以前项目日志保存得方式是阿里云云服务自动读取日志文件，最近项目部署得方式可能有变化，所以新项目用logback+aliyun-log-logback-appender得方式保存到阿里云日志服务。用logback得原因主要是懒，spring默认就是这个，其他还要各种配置和兼容。

重点

通过配置MDC控制保存到阿里云的数据，logback-spring.xml要配置对应的mdcFields

通过ContentCachingRequestWrapper和ContentCachingResponseWrapper取入参和返回数据，这两个不需要太多代码

RestControllerAdvice+ExceptionHandler全局捕获异常并处理

gradle

    implementation 'com.google.protobuf:protobuf-java:2.5.0'
    implementation 'com.aliyun.openservices:aliyun-log-logback-appender:0.1.18'
    implementation 'org.slf4j:slf4j-nop:1.7.25'

阿里云日志应该只需要这么多得引入。

logback-spring.xml 日志配置

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="true">
    <!-- 项目名称 -->
    <property name="PROJECT_NAME" value="apiv3"/>

    <!-- 控制台输出 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
            <pattern>[%d{yyyy-MM-dd HH:mm:ss.SSS}] %highlight([%-5level] [%thread] %logger{50} - %msg%n)</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!--为了防止进程退出时，内存中的数据丢失，请加上此选项-->
    <shutdownHook class="ch.qos.logback.core.hook.DefaultShutdownHook"/>

    <appender name="apiv3Log" class="com.aliyun.openservices.log.logback.LoghubAppender">
        <!--必选项-->
        <!-- 账号及网络配置 -->
        <endpoint>cn-beijing.log.aliyuncs.com</endpoint>
        <accessKeyId>####</accessKeyId>
        <accessKeySecret>###</accessKeySecret>

        <!-- sls 项目配置 -->
        <project>#####</project>
        <!--开发环境区分 -->
        <springProfile name="dev">
            <logStore>####dev</logStore>
        </springProfile>
         <!--开发环境区分 -->
        <springProfile name="test">
            <logStore>###test</logStore>
        </springProfile>
        <!--必选项 (end)-->

        <!-- 可选项 -->
        <!--        <topic>your topic</topic>-->
        <!--        <source>your source</source>-->

        <!-- 可选项 详见 '参数说明'-->
        <totalSizeInBytes>104857600</totalSizeInBytes>
        <maxBlockMs>0</maxBlockMs>
        <ioThreadCount>8</ioThreadCount>
        <batchSizeThresholdInBytes>524288</batchSizeThresholdInBytes>
        <batchCountThreshold>4096</batchCountThreshold>
        <lingerMs>2000</lingerMs>
        <retries>10</retries>
        <baseRetryBackoffMs>100</baseRetryBackoffMs>
        <maxRetryBackoffMs>50000</maxRetryBackoffMs>

        <!-- 可选项 通过配置 encoder 的 pattern 自定义 log 的格式 -->
<!--        <encoder>-->
<!--            <pattern>%d %-5level [%thread] %X{traceId} %logger{0}: %msg</pattern>&ndash;&gt;-->
<!--            <pattern>[%d{yyyy-MM-dd HH:mm:ss.SSS}] %highlight([%-5level] [%thread] %logger{50} - %msg%n)</pattern>-->
<!--            <charset>UTF-8</charset>-->
<!--        </encoder>-->

        <!-- 可选项 设置 time 字段呈现的格式 -->
        <timeFormat>yyyy-MM-dd'T'HH:mmZ</timeFormat>
        <!-- 可选项 设置 time 字段呈现的时区 -->
        <timeZone>UTC+8</timeZone>
        <mdcFields>
            TraceId,#####
        </mdcFields>
    </appender>
    <!--TRACE < DEBUG < INFO < WARN < ERROR < FATAL-->
    <!-- 开发环境下的日志配置 -->
    <springProfile name="dev">
        <root level="INFO">
            <appender-ref ref="CONSOLE"/>
            <appender-ref ref="apiv3Log"/>
        </root>
    </springProfile>
    <springProfile name="test">
        <root level="INFO">
            <!--            <appender-ref ref="CONSOLE"/>-->
            <appender-ref ref="apiv3Log"/>
        </root>
    </springProfile>

    <!-- 生产环境下的日志配置 -->
    <springProfile name="prod">
        <root level="INFO">
           。。。。。。
        </root>
    </springProfile>
</configuration>

这是logback-spring.xml 基本配置。放在resources目录中。

###基本都是阿里云中得一些参数信息，熟悉阿里云日志的，都明白。

mdcFields也是我最近才发现，它会把MDC中的中对应不为null的字段保存在阿里云中。

HttpFilter

因为在日志中要记录请求的参数和返回值，aop实现有点负责，所以用了HttpFilter

@Component
@WebFilter(filterName = "accessLogFilter", urlPatterns = "/*")
@Order(-9999)        // 保证最先执行
public class AccessLogFilter extends HttpFilter {

    private static final Logger logger = LoggerFactory.getLogger(AccessLogAspect.class);

    @Override
    protected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        ContentCachingRequestWrapper cachingRequestWrapper = new ContentCachingRequestWrapper(request);
        ContentCachingResponseWrapper cachingResponseWrapper = new ContentCachingResponseWrapper(response);

        UserAgent userAgent = UserAgent.parseUserAgentString(request.getHeader("user-agent"));
        // 接收到请求，记录请求内容````
        MDC.put("TraceId", TraceIDUtils.getTraceId());
        //客户端类型
        MDC.put("ClientType", userAgent.getOperatingSystem().getDeviceType().getName());
        //客户端操作系统类型
        MDC.put("OsType", userAgent.getOperatingSystem().getName());
        MDC.put("ClientMethod", request.getMethod());
        MDC.put("ClientIp", IpUtil.getIpAddress(request));
        MDC.put("ClientParam", request.getQueryString());
        MDC.put("ClientUrl", request.getRequestURL().toString());
        MDC.put("ClientUri", request.getRequestURI());
        //记录请求开始时间
        long start = RequestTimeUtil.getStart();
        MDC.put("RequestStart", String.valueOf(start));
        //请求头参数
        Map<Object, Object> headerMap = new HashMap<>();
        Enumeration<String> enumeration = cachingRequestWrapper.getHeaderNames();
        while (enumeration.hasMoreElements()) {
            String name = enumeration.nextElement();
            String value = request.getHeader(name);
            headerMap.put(name, value);
        }
        MDC.put("RequestHeader", JSON.toJSONString(headerMap));
        MDC.put("LogType", LogTypEnum.requestStart.name());
        MDC.put("LogTime", String.valueOf(System.currentTimeMillis()));
        //日志输出
        logger.info("--------------request start--------------");
        //这里清理掉MDC 防止变成下一个log输出的垃圾数据
        MDC.remove("LogTime");
        MDC.remove("ClientType");
        MDC.remove("OsType");
        MDC.remove("ClientMethod");
        MDC.remove("ClientIp");
        MDC.remove("ClientParam");
        MDC.remove("ClientUrl");
        MDC.remove("ClientUri");
        MDC.remove("RequestStart");
        MDC.remove("LogType");
        MDC.remove("RequestHeader");
        super.doFilter(cachingRequestWrapper, cachingResponseWrapper, chain);
        String responseBody = new String(cachingResponseWrapper.getContentAsByteArray(), StandardCharsets.UTF_8);

        MDC.put("LogType", LogTypEnum.requestEnd.name());
        MDC.put("RequestParamMap", JSON.toJSONString(cachingRequestWrapper.getParameterMap()));
        String requestBodyParam = new String(cachingRequestWrapper.getContentAsByteArray(), StandardCharsets.UTF_8);
        MDC.put("RequestBodyParam", requestBodyParam);
        MDC.put("ReturnData", responseBody);
        long end = RequestTimeUtil.getEnd();
        MDC.put("RequestEnd", String.valueOf(end));
        MDC.put("RequestProcessTime", String.valueOf(end - start));
        MDC.put("LogTime", String.valueOf(System.currentTimeMillis()));
        logger.info("--------------request end--------------");
        // 这一步很重要，把缓存的响应内容，输出到客户端
        cachingResponseWrapper.copyBodyToResponse();
        MDC.clear();
        RequestTimeUtil.remove();
        TraceIDUtils.remove();
    }

找了很久才找到ContentCachingRequestWrapper和ContentCachingResponseWrapper这两个可以取入参和返回数据的类，不用动其他代码就可以实现了。

其实到这里最基础的请求日志，已经实现了。

大概就是这样子的。

其他aop的日志也是差不多的方式去处理。

异常处理

RestControllerAdvice+ExceptionHandler全局捕获异常，ResultError是自定义异常，主要处理一些assert抛出的错误。


@RestControllerAdvice
public class ExceptionControllerAdvice {

    private static final Logger logger = LoggerFactory.getLogger(AccessLogAspect.class);

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Result MethodArgumentNotValidExceptionHandler(MethodArgumentNotValidException e) {
        // 从异常对象中拿到ObjectError对象
        ObjectError objectError = e.getBindingResult().getAllErrors().get(0);
        // 然后提取错误提示信息进行返回
        return Result.fail(GlobalResultEnum.fail.getCode(), objectError.getDefaultMessage());
    }


    @ExceptionHandler(ResultError.class)
    public Result<Object> APIExceptionHandler(ResultError e) {
        MDC.put("ResponseStatus", String.valueOf(e.getResultEnum().getCode()));
        MDC.put("ResponseGlobalStatus", String.valueOf(e.getResultEnum().getGlobalStatus()));
        MDC.put("ResponseMsg", e.getResultEnum().getMsg());
        MDC.put("LogType", LogTypEnum.resultError.name());
        MDC.put("LogTime", String.valueOf(System.currentTimeMillis()));
        logger.info(JSON.toJSONString(e.getErrorMessage()));
        MDC.remove("LogTime");
        MDC.remove("ResponseStatus");
        MDC.remove("ResponseGlobalStatus");
        MDC.remove("ResponseMsg");
        MDC.remove("LogType");
        return Result.of(e);
    }

}

public class ResultError extends RuntimeException {

    @Getter
    private ResultEnum resultEnum;
    @Getter
    private Object errorMessage;

    public ResultError(ResultEnum resultEnum) {
        super(resultEnum.getMsg());
        this.resultEnum = resultEnum;
    }

    public ResultError(ResultEnum resultEnum, Object errorMessage) {
        super(resultEnum.getMsg());
        this.resultEnum = resultEnum;
        this.errorMessage = errorMessage;
    }

}

public interface ResultEnum {

    /**
     * 状态码
     * @return int
     */
    int getCode();

    /**
     * 全局状态码
     * @return int
     */
    int getGlobalStatus();

    /**
     * 描述信息
     * @return String
     */
    String getMsg();

}

ResultEnum 是全局状态接口，所有的状态都可以继承这个类，实现类似这样。

public enum GlobalResultEnum implements ResultEnum {
    success(100, "success"),
    fail(99, "fail");

    private final int code;
    private final int globalStatus = 0;
    private final String msg;

    GlobalResultEnum(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }


    /**
     * 状态码
     *
     * @return int
     */
    @Override
    public int getCode() {
        return code;
    }

    /**
     * 全局状态码
     *
     * @return int
     */
    @Override
    public int getGlobalStatus() {
        return globalStatus + code;
    }

    /**
     * 描述信息
     *
     * @return String
     */
    @Override
    public String getMsg() {
        return msg;
    }
}

全局定义唯一状态码（globalStatus），定义全局状态接口（ResultEnum）

也挺麻烦，还需要优化。

写的不是很清晰，欢迎讨论。