likes
comments
collection
share

Java 日志框架

作者站长头像
站长
· 阅读数 10

日志框架

设计模式

正式进入 Java 日志之前,先了解几个日志相关的设计模式。

门面模式

门面模式(Facade Pattern)是一种结构型设计模式,也称外观模式。它提供了一个统一的接口,用于访问子系统中的一群接口,隐藏了系统的复杂性,使得子系统更加易用。

在门面模式中,有三个主要角色:

  1. 门面(Facade): 提供了一个高层次的接口,该接口使用了系统中多个接口,它简化了客户端与子系统之间的交互,充当了客户端与子系统之间的中介者。门面模式的名字就来源于这个角色,门面通常是客户端与子系统之间的入口点。

  2. 子系统(Subsystems): 子系统是一组类或者模块,负责实际处理客户端的请求。子系统是门面模式的内部组成部分。

  3. 客户端(Client): 客户端是使用门面模式的类或者模块,它通过门面提供的简化接口与子系统进行交互,而不需要直接与子系统的类进行交互。

Java 日志框架

例如小米推出的小爱同学智能音箱,我们只需要对小爱同学吼一嗓子,小爱同学再去操控对应的家电(冰箱/空调/洗衣机等),小爱同学就可以视为是一个门面模式的实例。

适配模式

适配器模式(Adapter Pattern)也是一种结构型设计模式,通过非侵入的方式,允许接口不兼容的类之间进行协作,提高了系统的灵活性和可扩展性。例如各种插头、线缆的转接器。

适配器模式通常涉及三个角色:

  1. 目标接口(Target): 客户端所期待的接口,适配器模式通过实现这个接口,使得客户端可以调用目标接口中定义的方法。

  2. 适配器(Adapter): 适配器是一个类,它实现了目标接口并包装了一个需要被适配的类的对象。适配器接受客户端的调用,然后将请求委派给被适配的对象。

  3. 被适配者(Adaptee): 需要被适配的类,它拥有客户端所需的功能,但是它的接口与客户端的期望接口不兼容。

桥接模式

桥接模式(Bridge Pattern)也是一种结构型设计模式,它将抽象部分与实现部分分离,使得它们可以独立地变化。桥接模式通过将继承关系转化为组合关系,可以减少类的数量,降低系统的复杂度,提高系统的可维护性和可扩展性。

在桥接模式中,有两个独立的维度,一个是抽象部分(Abstraction),另一个是实现部分(Implementor)。抽象部分包含高层次的抽象接口,而实现部分则包含低层次的具体实现。桥接模式通过将抽象部分与实现部分分离,使得它们可以独立地变化,而不会相互影响。

发展史

接着介绍一下几种常见的 Java 日志框架的发展历史。

  • Log4j

    瑞士程序员大佬 Ceki Gülcü 于 1996年开始开发 Log4j,在 JDK 1.4 之前几乎是 Java 日志组件的唯一选择,因此近乎成为了 Java 社区的日志标准。后被捐赠给 Apache 基金会,并于 2015 年宣布不再维护。

  • JUL (Java.Util.Logging)

    2002年 Java 1.4 发布,Sun 推出了自己的日志库 Java.Util.Logging,基本是模仿了 Log4j 的实现(代码届的抄袭狗)。在 JUL 出来以前,Log4j 就已经成为一项成熟的技术,占据了很大优势,但从此开发者有了两种选择。

  • JCL (Jakarta Commons Logging)

    两种日志的使用,导致程序编码的混乱,于是 Apache 推出了 Jakarta Commons Logging。JCL 定义了一套日志接口,内部也提供一个简单实现,支持运行时动态加载日志组件的实现,默认会优先使用 Log4j,其次是 JUL 实现,最后才会使用简单日志实现。

  • Slf4J (Simple Logging Facade for Java) 和 Logback

    2006年,Log4j 之父 Ceki Gülcü 离开了 Apache,他觉得 JCL 接口设计不好,容易产生性能问题,于是先后开发了 SLF4J 日志门面,及其默认日志实现 Logback 两个项目。Slf4J 可以实现和多种日志组件无缝对接,并且功能和性能都非常优秀。

  • Log4j2

    Apache 眼看有被 Logback 反超的势头,在2012年推出了了新的项目 Log4j2,Log4j2 几乎涵盖了 Logback 的所有特性,在性能上比 Logback 更好。同时 Log4j2 也搞了分离设计,包括日志接口 Log4j-api 和日志实现 Log4j-core。Log4j2 兼容 Slf4J,但并不兼容前任 Log4j。

Java 日志框架

Java主要的日志组件都已经出场了,一个组件是门面还是实现,要分清楚,这对以后项目里到底要引入哪些依赖,实际用的是哪个日志实现很重要!

进化史

直接日志实现

在初期大家用System.out -> STDOUTSystem.error -> STDERR来打印日志,也就是只有分两类,而且无法定制,无法满足业务需求。后来 Java 应用开始选择日志实现组件进行日志记录,比如 Log4j、JUL。

Java 日志框架

接入 JCL

有了多种日志实现之后,如果一个程序的多个模块使用了不同的日志工具,那么就会产生多份日志输出。为了解决这个问题,就出现了 JCL 这样的日志门面,统一 API 接口,运行时动态加载具体的日志实现(多态思想)。

Java 日志框架

接入 Slf4J

之后又出现了 Slf4J,解决了 JCL 的一些重要缺陷(articles.qos.ch/classloader… )。同时为了抢夺 JCL 的市场,Slf4J 还提供了各种桥接组件,将对 JCL 的 API 调用重定向到自己的 API,再由SLF4J选择具体的日志实现。这下问题就变得有趣起来了,看看这些桥接包吧...

Java 日志框架

日志门面 - Slf4J

处理依赖

这么多年过去了,Java 日志门面最后以 Slf4J 一统天下而落幕,所以本文就讲讲 Slf4J,不管 JCL 了。先贴上一张 Slf4J 官网的绑定关系图(日志实现在 Slf4J 里称为 Provider/Binding):

Java 日志框架

对照这张图,可以得到常用的日志组件搭配如下:

1. 仅依赖slf4j-api,此时无有效的日志实现,无法输出日志

Java 日志框架

2. Slf4J + Logback

通过 logback.xml 配置参数,基于 Logback 打印日志。

<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.4.11</version>
</dependency>

logback-classic 以及下面 Slf4J 提供的桥接包都会间接依赖 slf4j-api,不过也可以显式声明指定版本以避免 Maven 的依赖传递产生问题。

Java 日志框架

3. Slf4J + Log4j

通过 log4j.properties 配置参数,基于 Log4j 打印日志。

<dependency>
    <!-- 对应 Log4j 1.x 的最后一个版本 1.2.17 -->
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>2.0.9</version>
</dependency>

Log4j 1.x 已经 EOL 了,因此会通过 Maven-relocation 到 slf4j-reload4j,reload4j 也是出自 Ceki Gülcü 之手,修复了 Log4j 的一些严重 bug。因此上面的依赖等同于下面:

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-reload4j</artifactId>
    <version>2.0.9</version>
</dependency>

Java 日志框架

4. Slf4J + JUL

通过 logging.porperties 配置参数,基于 JDK 内置的简单日志系统打印日志。

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-jdk14</artifactId>
    <version>2.0.9</version>
</dependency>

Java 日志框架

5. Slf4J + Simple

通过 simplelogger.porperties 配置参数,基于 Slf4J 默认实现打印日志。

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-simple</artifactId>
    <version>2.0.9</version>
</dependency>

Java 日志框架

6. Slf4J + NOP

默认丢弃所有的日志记录,不会打印日志。

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-nop</artifactId>
    <version>2.0.9</version>
</dependency>

Java 日志框架

7. Slf4J + Log4j2

通过 log4j2.xml 配置参数,基于 Log4j2 的实现打印日志,是现今最普遍使用的搭配组合。本质上是 Slf4J -> Log4j-api -> Log4j-core。

<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j-impl</artifactId>
    <version>2.21.0</version>
</dependency>


<!-- 支持 Slf4J 2.x+ SPI 加载机制的桥接包 -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j2-impl</artifactId>
    <version>2.21.0</version>
</dependency>

Java 日志框架

8. Slf4J + JCL

最后还有一种情况图中也没有,即将所有日志委托给 JCL 门面处理,具体依赖见上面的 Slf4J桥接包

绑定原理

下面分析一下 Slf4J 门面绑定日志实现的过程,特别说明,Slf4J 1.8 版本之前基于 COC (Convention over Configuration 约定大于配置),利用 StaticLoggerBinder 初始化。但 1.8 版本之后利用的是 Java SPI (Service Provider Interface) 机制实现,我们后面就只看新版的实现原理。


通常,我们会通过下面这条语句为类设置一个日志器。

private static final org.slf4j.Logger LOGGER = org.slf4j.LoggerFactory.getLogger(Main.class);

进入 LoggerFactory,可以看到主要分为两步:

  1. 通过 SLF4JServiceProvider 初始化并返回 ILoggerFacotry
  2. 从工厂生产 Logger 并返回
public static Logger getLogger(String name) {
    ILoggerFactory iLoggerFactory = getILoggerFactory();
    return iLoggerFactory.getLogger(name);
}

接着依次进入方法:getILoggerFactory -> getProvider -> performInitialization -> bind 完成绑定行为。而在 findServiceProviders 中,利用 JDK 的 ServcieLoader#load 加载类路径特定目录下(META-INF/services/org.slf4j.spi.SLF4JServiceProvider)所有实现了 SLF4JServiceProvider 的 SPI 配置类,反射实例化后加入 providerList 返回。

// org.slf4j.LoggerFactory#bind
private final static void bind() {
    List<SLF4JServiceProvider> providersList = findServiceProviders();

    if (providersList != null && !providersList.isEmpty()) {
        PROVIDER = providersList.get(0);
        PROVIDER.initialize();
        INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION;
    } else {
        INITIALIZATION_STATE = NOP_FALLBACK_INITIALIZATION;
    }
    postBindCleanUp();
}


// org.slf4j.LoggerFactory#findServiceProviders
static List<SLF4JServiceProvider> findServiceProviders() {
    ClassLoader classLoaderOfLoggerFactory = LoggerFactory.class.getClassLoader();
    // 负责扫描 SPI 配置类
    ServiceLoader<SLF4JServiceProvider> serviceLoader = getServiceLoader(classLoaderOfLoggerFactory);
    List<SLF4JServiceProvider> providerList = new ArrayList();
    Iterator<SLF4JServiceProvider> iterator = serviceLoader.iterator();

    while(iterator.hasNext()) {
        safelyInstantiate(providerList, iterator);
    }

    return providerList;
}

回到 bind() 后默认取列表里第一个 SLF4JServiceProvider 执行 initialize() 得到 ILoggerFactory 实例,最后 getLogger() 获得 Logger 实例作为最终的日志器,具体怎么从日志工厂生产出 Logger 就由各个实现类去完成了。

特殊的,如果找到了多个日志实现,具体绑定的是哪个依赖于类加载的顺序;如果 SPI 没有找到任何实现类,将使用 NOP_FallbackServiceProvider 兜底。

Slf4J -> Log4j 2.x 的桥接包是 Log4j 官方提供的,没有跟进 Slf4J,依然使用的是 1.8 之前的 StaticLoggerBinder 实现。 这时候如果手动引入了 Slf4J 1.8 之后的版本,将默认使用 NOP,而不是 Log4j2。

补充:经查证 Log4j 提供了新的桥接包以支持 SPI 机制的 Slf4J

<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j2-impl</artifactId>
    <version>2.21.0</version>
</dependency>

API

Slf4J 的 API 十分简单:

// 获取日志记录器
Logger log = LoggerFactory.getLogger(HelloWorld.class);

// 五种级别日志
log.error("error", ex);
log.warn("warn");
log.info("info");
log.debug("debug:{}", arg);
log.trace("trace");

// Fluent API
log.atError().setMessage("Msg: {}").addArgument("arg").log();

日志实现 - Log4j2

Slf4J 在日志门面中一统天下,而在日志实现方面,Logback 和 Log4j2 依然难分伯仲,不过这里就只简单聊聊 Log4j 了。

Java 日志框架

建议使用最新版本,2.17 以下有重大安全漏洞!详见:logging.apache.org/log4j/2.x/s…

配置

Log4j2 根据项目根目录下的 log4j2.xml 文件进行日志配置,详细的配置解析可以参考 Log4j2配置文件详解

Configuration

<configuration status="WARN" monitorInterval="30">
    ...
</configuration>

配置的根节点,status 控制 Log4j2 框架本身的日志级别,monitorInterval 控制每隔多少秒重新加载配置。

Appenders

附加器,定义日志输出的目的地。Log4j2 支持多种输出源,例如:

  • ConsoleAppender
  • FileAppender
  • AsyncAppender
  • RandomAccessFileAppender
  • RollingFileAppender
<appenders>
    <!--输出到控制台-->
    <console name="Console" target="SYSTEM_OUT">
        <!--输出日志的格式-->
        <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
    </console>

    <!--输出到文件-->
    <File name="log" fileName="log/test.log" append="false">
        <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
    </File>

    <!-- 输出到文件,并自动归档旧日志-->
    <RollingFile name="RollingFileInfo" fileName="${sys:user.home}/logs/info.log"
                    filePattern="${sys:user.home}/logs/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
        <!--决定日志是否输出的过滤器-->
        <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
        <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
        <Policies>
            <!-- 基于时间的滚动策略 -->
            <TimeBasedTriggeringPolicy/>
            <!-- 基于文件大小的滚动策略 -->
            <SizeBasedTriggeringPolicy size="100 MB"/>
        </Policies>
    </RollingFile>
</appenders>

过滤器的结果有三种:

  • Accept:不再调用其他过滤器,执行 event
  • Deny:忽略 event,将控制权交还给调用者
  • Neutral:传递给其它过滤器,如果没有过滤器可以传递则执行 event

Loggers

日志记录器,里面关联着所用的 Appenders。常见的有两种节点:

  • Logger 可以有多个,针对不同的包名或类名配置不同的日志记录器
  • Root 兜底的默认日志记录器
<loggers>
    <logger name="org.springframework" level="INFO" additivity="false"></logger>
    <logger name="包名" level="级别" additivity="是否传递给父级"></logger>
    
    <root level="all">
        <appender-ref ref="Console"/>
        <appender-ref ref="RollingFileInfo"/>
    </root>
</loggers>

日志级别

日志框架会输出大于或等于指定等级的所有日志,优先级从高到低依次为:

  • OFF:最具体,不记录
  • FATAL:严重错误,将阻止应用继续;非常具体,数据很少
  • ERROR:严重错误,可能可以恢复
  • WARN:可能有害的消息
  • INFO:信息性消息,突出强调应用程序的运行过程
  • DEBUG:常规调试事件
  • TRACE:不太具体,很多数据,通常捕获通过应用的流
  • ALL:最不具体,用于打开所有日志记录

Java 日志框架

最佳实践

SLF4J 门面 + Log4j2 实现 已经是Java应用中最为流行的日志技术方案。一方面,使用 SLF4J 门面可以统一日志处理方式,有利于项目日志的维护;另一方面又可以享受 Log4j2 的卓越性能。阿里巴巴 Java 开发手册“日志规约”部分的第一条便是强制依赖日志框架SLF4J的API。

Java 日志框架

  1. 每个类的日志实例声明为static final,这样每次日志打印时不用再创建日志对象,提升效率

    private static final Logger logger= LoggerFactory.getLogger(DeliveryConfigQueryAction.class);
    
  2. 配合 Lombok 注解,更加方便清晰

    @Slf4j
    public class UserController { ... }
    

    编译后:

    public class UserController {
        private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(UserController.class);
    }
    
  3. 日志打印设置为非阻塞模式

    采用非阻塞模式后,底层可以发挥 Log4j2 所采用的 Disruptor 高性能框架,在不同的场景下会有几倍到几十倍的日志写入性能提升。

    <Async name="ScribeAsyncAppender" blocking="false">
    
  4. 日志打印采用占位符

    推荐使用占位符{}打印日志,这样只在日志级别满足打印需求时,才会进行参数的拼接,降低性能损耗。注意占位符的转义。

    logger.error("xxx error, id: {}" , userId, e);
    logger.debug("File name is C:\\\\{}.", "file.zip");
    
  5. 避免重复打印日志,浪费磁盘空间

    <logger name="com.taobao.dubbo.config" additivity="false">
    
  6. 异常信息应包括两类:案发现场信息和异常堆栈信息,并且禁止使用 Json 工具转换。如果不处理,那么通过关键字 throws 往上抛出。

    logger.error("inputParams: {} and errorMessage: {}", 各类参数或者对象 toString(), e.getMessage(), e);
    

参考

原文地址:xchanper.github.io/coding/Logg…

转载自:https://juejin.cn/post/7312035246391574537
评论
请登录