[toc]

概述

Slf4j简介

Java的简单日志记录外观（Simple Logging Facade for Java ）可作为各种日志记录框架（例如java.util.logging，logback，log4j，log4j2）的简单外观或抽象，允许终端用户在开发时插拔所需的日志记录框架。简单来说，Slf4j定义了一种规范，java程序在记录日志时候的规范，这种规范是一个空壳，在实际开发中需要集成具体的日志框架来干活，这种具体的日志框架需要满足一些标准：符合Slf4j定义的标准；能够提供日志记录的功能。

Logback简介

一个“可靠、通用、快速而又灵活的Java日志框架”。logback是log4j的升级迭代产品，在许多地方相比于log4j有优势：

1：性能，提升近10倍，初始内存减少了许多
2：对Slf4j友好，同时引用这两个框架之后，甚至不需要额外的配置就可以很融洽的运行起来
3：自动重新加载配置文件
4：强大的研发团队和完善的文档

logback的三大核心模块：

logback-classic：log4j的一个改良版本，同时整合了对Slf4j的支持
logback-access：Servlet容器集成提供通过HTTP来访问日志的功能
logback-core：其他两个模块的基础模块

日志级别

Trace：轻微错误。
Debug：调试日志，主要用于开发过程中打印一些运行信息。
Info：突出强调应用程序的运行过程，打印一些你感兴趣的或者重要的信息。
Warn：潜在错误。其实没有发生错误，只是给编码人员一些警告和提示。
Error：虽然发生错误事件，但仍然不影响系统的继续运行，记录错误现场。
Fatal：致命错误。

常用日志级别：info，debug，error

高日志级别可以打印使用低级别记录的日志。若设置的日志级别为info，同时打印三种（debug,info,error）只可以输出info和error。这是因为Debug的日志级别比info高，低日志级别无法打印使用高级别记录的日志。

基本实践

当我们新建一个 SpringBoot 应用程序之后，可以发现已经为我们装配了 slf4j 和 logback

spring-boot-starter-logging 和 logback，slf4j 的依赖关系：

此时可以直接使用 log.info 、log.debug 、log.error 来打印日志。


@Slf4j
@SpringBootApplication
public class Slf4jLogbackApplication {
    public static void main(String[] args) {
        SpringApplication.run(Slf4jLogbackApplication.class, args);
        log.info("info-log");
        log.debug("debug-log");
        log.error("error-log");
    }
}

输出：


2023-07-03 11:32:30.256  INFO 14084 --- [           main] c.r.s.Slf4jLogbackApplication            : info-log
2023-07-03 11:32:30.256 ERROR 14084 --- [           main] c.r.s.Slf4jLogbackApplication            : error-log

可以看到控制台已经打印了我们编写的日志了，但是debug级别的日志没有打印。

此时可以通过修改日志级别将debug日志打印出来，需要修改配置文件，并新增如下内容：


logging:
  level:
    com.ramble : debug

输出：


2023-07-03 11:34:21.479  INFO 22264 --- [           main] c.r.s.Slf4jLogbackApplication            : info-log
2023-07-03 11:34:21.479 DEBUG 22264 --- [           main] c.r.s.Slf4jLogbackApplication            : debug-log
2023-07-03 11:34:21.479 ERROR 22264 --- [           main] c.r.s.Slf4jLogbackApplication            : error-log

当我们调整了日志级别之后，debug也显示出来了。

但是现在如果在项目中使用还有诸多问题，日志只能记录在控制台，无法记录在文件中。

进阶实践

logback-spring.xml

在resource下新建一个 logback-spring.xml 的配置文件


<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <property name="encoding" value="UTF-8"/>
    <!-- 读取application.yml中的 spring.application.name 属性，如果没有配置，默认值为 ngh -->
    <springProperty scope="context" name="applicationName" source="spring.application.name" defaultValue="app"/>
    <!--定义日志文件的存储地址 勿在LogBack的配置中使用相对路径-->
    <property name="LOG_HOME" value="./logs/${applicationName}"/>
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 过滤日志 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <!-- 如果命中就禁止这条日志 -->
            <onMatch>DENY</onMatch>
            <!-- 如果没有命中就使用这条规则 -->
            <onMismatch>ACCEPT</onMismatch>
        </filter>
        <Append>true</Append>
        <prudent>false</prudent>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%d{yyyy-MM-dd/HH:mm:ss.SSS}|%X{localIp}|%X{requestId}|%X{requestSeq}|^_^|[%t] %-5level %logger{50}%line - %m%n</pattern>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${LOG_HOME}/%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxFileSize>256MB</maxFileSize>
            <maxHistory>15</maxHistory>
            <totalSizeCap>32GB</totalSizeCap>
        </rollingPolicy>
    </appender>
    <appender name="ACCESS_LOG" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <Append>true</Append>
        <prudent>false</prudent>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%d{yyyy-MM-dd/HH:mm:ss.SSS}|%X{localIp}|%X{requestId}|%X{requestSeq}|^_^|[%t] %-5level %logger{50}%line - %m%n</pattern>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${LOG_HOME}/access-log-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxFileSize>256MB</maxFileSize>
            <maxHistory>15</maxHistory>
            <totalSizeCap>32GB</totalSizeCap>
        </rollingPolicy>
    </appender>
    <appender name="ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>ERROR</level>
        </filter>
        <Append>true</Append>
        <prudent>false</prudent>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%d{yyyy-MM-dd/HH:mm:ss.SSS}|%X{localIp}|%X{requestId}|%X{requestSeq}|^_^|[%t] %-5level %logger{50}%line - %m%n</pattern>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${LOG_HOME}/error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxFileSize>256MB</maxFileSize>
            <maxHistory>15</maxHistory>
            <totalSizeCap>32GB</totalSizeCap>
        </rollingPolicy>
    </appender>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %5p %c.%M:%L - %m%n</pattern>
        </encoder>
    </appender>
    <root additivity="false" level="INFO">
        <appender-ref ref="FILE"/>
        <appender-ref ref="ERROR"/>
        <appender-ref ref="STDOUT"/>
    </root>
    <logger name="AccessLog" additivity="false">
        <appender-ref ref="ACCESS_LOG"/>
    </logger>
</configuration>

可以显式指定配置文件路径


   logging:  
      config: classpath:logback-spring.xml

如果在 IDEA 中运行可能会发现根目录没有创建 logs 文件夹，也没有生成日志文件，尝试用命令行启动试试，或者干脆指定一个绝对路径

记录方法出入参

pom


<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.76</version>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.1</version>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.5</version>
</dependency>
<dependency>
    <groupId>commons-collections</groupId>
    <artifactId>commons-collections</artifactId>
    <version>3.2.2</version>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.7</version>
</dependency>

增加Aop

新建一个类 LogAspect ，用来自动记录方法的出入参。

logger ：实例化在logback-spring.xml 中定义的 accessLog ，将使用accessLog记录所有方法出入参的日志
ignoreMethods：某些方法可能不需要或者不允许记录到日志中，例如登录方法、修改密码方法、上传下载方法
sensitiveWords：若返回值中存在敏感词汇，将不记录到日志中
maxLimit和minLimit：如果所有的日志都记录，log文件将特别的大，很容易撑爆硬盘，方法返回值超过100k的将只记录前1k的内容
doBefore：记录入参，通过@Before可以限定此切面覆盖的方法
doAfterReturn：记录出参，通过@AfterReturning可以限定此切面覆盖的方法
使用@Component注解添加到容器


package com.ramble.slf4jlogback.aspect;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.ramble.slf4jlogback.constant.LogPropertyFilter;
import com.ramble.slf4jlogback.util.ObjectUtil;
import org.apache.commons.collections.CollectionUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.lang.reflect.Modifier;
import java.util.Collection;
import java.util.Map;

@Aspect
@Component
public class LogAspect {

    /**
     * 使用单独的  accesslog 记录
     */
    private static final Logger logger = LoggerFactory.getLogger("AccessLog");

    /**
     * 需要排除的方法
     */
    private static final String[] ignoreMethods = new String[]{"login", "changePassword", "modifyPassword", "uploadFile"};

    /**
     * 敏感词不记录
     */
    private static final String[] sensitiveWords = new String[]{"password", "token", "base64"};

    /**
     * 大于100K的log不显示
     */
    private static final Integer maxLimit = 1024 * 100;

    /**
     * 对于大于100K的log，仅仅截取前1K的数据记录到log
     */
    private static final Integer minLimit = 1024;

    /**
     * 统一记录 controller 层方法入参
     * @param jp
     */
    @Before("execution(* com.ramble..controller..*.*(..))")
    public void doBefore(JoinPoint jp) {
        Signature signature = jp.getSignature();
        if (signature != null) {
            StringBuilder log = new StringBuilder(" enter className:");
            String className = signature.getDeclaringTypeName();
            log.append(className);
            String methodName = signature.getName();
            log.append(",methodName:").append(methodName);
            if (!ignoreMethod(methodName)) {
                //region  排除含有敏感信息的参数输出逻辑
                String argStr = JSON.toJSONString(jp.getArgs(), LogPropertyFilter.LOG_FILE_FILTER, SerializerFeature.WriteClassName);
                // 排除含有敏感信息的参数输出
                if (!containsSensitiveWords(argStr)) {
                    log.append(",args:").append(argStr);
                } else {
                    log.append(",args:").append("sensitive word in args and forbidden to print.");
                }
                //endregion
//                String argStr = JSON.toJSONString(jp.getArgs(), SerializerFeature.WriteClassName);
//                log.append(",args:").append(argStr);
            } else {
                log.append(",args:").append("ignore method and forbidden to print args.");
            }
            String logStr = log.toString();
            if (Modifier.isPublic(signature.getModifiers())) {
                logger.info("####### {}", logStr);
            } else {
                logger.debug("####### {}", logStr);
            }
        }
    }


    /**
     * 统一记录 controller 层方法出参
     * @param jp
     * @param returnValue
     */
    @AfterReturning(value = "execution(* com.ramble..controller..*.*(..))", returning = "returnValue")
    public void doAfterReturn(JoinPoint jp, Object returnValue) {
        Signature signature = jp.getSignature();
        if (signature != null) {
            StringBuilder log = new StringBuilder("leave className:");
            String className = signature.getDeclaringTypeName();
            log.append(className);
            String methodName = signature.getName();
            log.append(",methodName:").append(methodName);
            // 排除含有敏感信息的log输出
            if (!ignoreMethod(methodName)) {
                String argStr = ObjectUtil.toString(jp.getArgs());
                //region
                if (!containsSensitiveWords(argStr)) {
                    log.append(",args:").append(argStr);
                } else {
                    log.append(",args:").append("sensitive word in args and forbidden to print.");
                }
                //endregion
            } else {
                log.append(",args:").append("ignore method and forbidden to print args.");
            }
            log.append(",return:");
            if (null != returnValue) {
                log.append(returnValue.getClass().getName() + ":");
                if (returnValue instanceof Collection) {
                    log.append("/size:").append(CollectionUtils.size(returnValue));
                } else if (returnValue instanceof Map) {
                    log.append("/size:").append(CollectionUtils.size(((Map) returnValue).entrySet()));
                } else {
                    String resStr = returnValue.toString();
                    //log.append(resStr);
                    //region
                    String printStr = null;
                    if (!containsSensitiveWords(resStr)) {
                        if (resStr.length() > maxLimit) {
                            printStr = resStr.substring(0, minLimit);
                        } else {
                            printStr = resStr;
                        }
                        log.append(printStr);
                    } else {
                        log.append("sensitive word in response and forbidden to print.");
                    }
                    //endregion
                }
            } else {
                log.append("");
            }
            String logStr = log.toString();
            if (Modifier.isPublic(signature.getModifiers())) {
                logger.info("####### {}", logStr);
            } else {
                logger.debug("####### {}", logStr);
            }
        }
    }


    /**
     * 过滤不记录入参出参的方法
     * @param methodName
     * @return
     */
    private boolean ignoreMethod(String methodName) {
        boolean result = false;
        if (null != ignoreMethods && ignoreMethods.length > 0) {
            for (String checkMethod : ignoreMethods) {
                if (checkMethod.equalsIgnoreCase(methodName)) {
                    result = true;
                    break;
                }
            }
        }
        return result;
    }


    /**
     * 过滤掉含有敏感信息的方法
     * @param sensiWord
     * @return
     */
    private boolean containsSensitiveWords(String sensiWord) {
        boolean result = false;
        if (null != sensitiveWords && sensitiveWords.length > 0) {
            for (String checkWord : sensitiveWords) {
                if (sensiWord.contains(checkWord)) {
                    result = true;
                    break;
                }
            }
        }
        return result;
    }


}

增加序列化过滤器

在序列化的时候需要排除文件


package com.ramble.slf4jlogback.constant;
import org.springframework.web.multipart.MultipartFile;
import com.alibaba.fastjson.serializer.PropertyFilter;

public enum LogPropertyFilter implements PropertyFilter{

    LOG_FILE_FILTER();

    @Override
    public boolean apply(Object object, String name, Object value) {
        return !(object instanceof MultipartFile);
    }
}

增加工具类

ObjectUtil


package com.ramble.slf4jlogback.util;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import java.util.Collection;
import java.util.Map;

public abstract class ObjectUtil {

    public static String toString(Object[] array) {
        StringBuilder sb = new StringBuilder("[");
        if (ArrayUtils.isNotEmpty(array)) {
            for (Object obj : array) {
                if (null != obj) {
                    if (obj instanceof Collection) {
                        sb.append(obj.getClass().getName());
                        sb.append("/size:").append(CollectionUtils.size(obj));
                    } else if (obj instanceof Map) {
                        sb.append(obj.getClass().getName());
                        sb.append("/size:").append(CollectionUtils.size(((Map) obj).entrySet()));
                    } else {
                        sb.append(obj.toString());
                    }
                    sb.append(", ");
                }
            }
        }
        String str = StringUtils.trim(sb.toString());
        if (StringUtils.endsWithIgnoreCase(str, ",")) {
            str = StringUtils.substringBeforeLast(str, ",");
        }
        return str + "]";
    }
}

增加一个controller


@Slf4j
@RestController
@RequestMapping("/test")
public class TestController {

    @GetMapping("/case1/{id}")
    public String case1(@PathVariable("id") String id) {
        log.info("coming - case1 ");
        return "ok";
    }

    @GetMapping("/login")
    public String login() {
        return "ok";
    }

    @GetMapping("/token")
    public String getToken() {
        return "token=123456";
    }
}

当分别调用这三个接口，将在 access-log-2023-07-03.0.log 文件中记录如下内容：


2023-07-03/16:49:53.219||||^_^|[http-nio-9009-exec-1] INFO  AccessLog93 - #######  enter className:com.ramble.slf4jlogback.controller.TestController,methodName:case1,args:["888"]
2023-07-03/16:49:53.236||||^_^|[http-nio-9009-exec-1] INFO  AccessLog157 - ####### leave className:com.ramble.slf4jlogback.controller.TestController,methodName:case1,args:[888],return:java.lang.String:ok
2023-07-03/16:50:06.806||||^_^|[http-nio-9009-exec-3] INFO  AccessLog93 - #######  enter className:com.ramble.slf4jlogback.controller.TestController,methodName:login,args:ignore method and forbidden to print args.
2023-07-03/16:50:06.807||||^_^|[http-nio-9009-exec-3] INFO  AccessLog157 - ####### leave className:com.ramble.slf4jlogback.controller.TestController,methodName:login,args:ignore method and forbidden to print args.,return:java.lang.String:ok
2023-07-03/16:50:10.827||||^_^|[http-nio-9009-exec-2] INFO  AccessLog93 - #######  enter className:com.ramble.slf4jlogback.controller.TestController,methodName:getToken,args:[]
2023-07-03/16:50:10.827||||^_^|[http-nio-9009-exec-2] INFO  AccessLog157 - ####### leave className:com.ramble.slf4jlogback.controller.TestController,methodName:getToken,args:[],return:java.lang.String:sensitive word in response and forbidden to print.

通过输出的日志可以观察到：

自动记录了出入参
可以设置白名单，即白名单中的方法不会记录日志
可以设置敏感词，一旦检测到敏感词不会记录到日志中
可以设置出参记录到文件中的大小限制，避免资源过渡消耗、影响程序性能

业务日志聚合

在实际开发中是否遇到过这样的问题：

当日志很多的时候，我们很难从info或者debug日志文件中找出我们想看的日志
所有业务模块的日志都输出到了同一个日志文件中，日志和业务模块无法区分
......

如果我们能将日志文件的管理维度更加细化，也许可以减轻查看日志时候的痛苦，一种办法是采用业务日志分类聚合，另一种办法是搭建一个日志管理系统，例如使用filebeat+es+kibana。

对于业务日志分类聚合可以使用如下的方式：

在 logback-spring.xml 文件中定义不同的 logger
在特定业务代码中实例化基于业务划分的 logger ，并用此logger记录日志
或者，使用 slf4j("logger")方式指定此类中要使用的logger

代码参考：


private static final Logger logger = LoggerFactory.getLogger("AccessLog");

@Slf4j("AccessLog")

思考

如何使用 Filebeat 将日志文件（指硬盘中存储的 xxx.log 文件）同步到 ElasticSearch ？
无论何种方式将日志同步到 ElasticSearch ，如何引入消息队列来削峰？
ElasticSearch 中存储的日志数据，如何给开发同事浏览（kibana？自建日志查看系统？）

引用

logback-elasticsearch-appender官网：https://github.com/internetitem/logback-elasticsearch-appender

SpringBoot程序日志极简教程

概述

Slf4j简介

Logback简介

日志级别

基本实践

进阶实践

logback-spring.xml

记录方法出入参

pom

增加Aop

增加序列化过滤器

增加工具类

增加一个controller

业务日志聚合

思考

引用

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

SpringBoot程序日志极简教程

概述

Slf4j简介

Logback简介

日志级别

基本实践

进阶实践

logback-spring.xml

记录方法出入参

pom

增加Aop

增加序列化过滤器

增加工具类

增加一个controller

业务日志聚合

思考

引用

热门文章

最新文章

相关课程

相关电子书

相关实验场景