另一个大脑

主题

Java 日志框架 ​

日志体系 ​

日志框架百花齐放，比较常见就是 JUL、JCL、slf4j、logback、log4j。

JUL ​

JUL 日志框架所处包是 java.util.lang 下的 Java.util.logging.Logger。使用方法如下：

java
public class JULLogDemo {

    public static void main(String[] args) {
        Logger logger = Logger.getLogger("JUL-Log");
        logger.info("info message");
        logger.log(Level.WARNING, "warning message");
    }
}

Log4j ​

Log4j 全名为 Log for Java 一个很常用的日志框架，自带门面。
引入依赖：

xml
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

添加 log4j 配置文件，log4j.properties 或 log4j.xml

properties
# Root logger option
log4j.rootLogger=INFO, file, stdout

# Direct log messages to a log file
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/my.log
log4j.appender.file.MaxFileSize=10MB
log4j.appender.file.MaxBackupIndex=10
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

# Direct log messages to stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

使用：

java
import org.apache.log4j.Logger;

public class Log4jDemo {

    public static void main(String[] args) {
        Logger logger = Logger.getLogger("Log4j");
        logger.info("info message");
        logger.warn("warn message");
    }
}

Log4j2 ​

Log4j2 是目前主流的日志框架，自带门面，是 Log4j 的升级版，主要升级有：

  • 异常处理：在 logback 中，Appender 中的异常不会被应用感知到，但是在 log4j2 中，提供了一些异常处理机制。
  • 性能提升：log4j2 相较于 log4j 和 logback 都具有明显的性能提升，有 18 倍性能提升。
  • 自动重载配置：参考了 logback 的设计，当然会提供自动刷新参数配置，最实用的就是我们在生产上可以动态的修改日志的级别而不需要重启应用。
  • 无垃圾机制：log4j2 在大部分情况下，都可以使用其设计的一套无垃圾机制【对象重用、内存缓冲】，避免频繁的日志收集导致的 jvm gc。

引入依赖：

java
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>2.19.0</version>
</dependency>

<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.19.0</version>
</dependency>

添加配置文件 log4j2.xml：

xml
<?xml version="1.0" encoding="UTF-8"?>
<!--
    status="warn" 日志框架本身的输出日志级别，可以修改为debug
    monitorInterval="5" 自动加载配置文件的间隔时间，不低于 5秒；生产环境中修改配置文件，是热更新，无需重启应用
 -->
<configuration status="warn" monitorInterval="5">
    <!--集中配置属性进行管理使用时通过:${name}-->
    <properties>
        <property name="LOG_HOME">./logs</property>
    </properties>
    <!-- 日志处理 -->
    <Appenders>
        <!-- 控制台输出 appender，SYSTEM_OUT输出黑色，SYSTEM_ERR输出红色 -->
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] [%-5level] %c{36}:%L --- %m%n" />
        </Console>
        <!-- 日志文件输出 appender -->
        <File name="file" fileName="${LOG_HOME}/myfile.log">
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l %c{36} - %m%n" />
        </File>
        <!-- 使用随机读写流的日志文件输出 appender，性能提高 -->
        <RandomAccessFile name="accessFile" fileName="${LOG_HOME}/myAcclog.log">
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l %c{36} - %m%n" />
        </RandomAccessFile>
        <!-- 按照一定规则拆分的日志文件的appender -->  <!--
        拆分后的文件 -->
        <!-- filePattern="${LOG_HOME}/$${date:yyyy-MM-dd}/myrollog-%d{yyyy-MM-dd-HH-mm}-%i.log"> -->
        <RollingFile name="rollingFile" fileName="${LOG_HOME}/myrollog.log"
            filePattern="${LOG_HOME}/$${date:yyyy-MM-dd}/myrollog-%d{yyyy-MM-dd}-%i.log">
            <!-- 日志级别过滤器 -->
            <ThresholdFilter level="debug" onMatch="ACCEPT" onMismatch="DENY" />
            <!-- 日志消息格式 -->
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l %c{36} - %msg%n" />
            <Policies>                <!-- 在系统启动时，出发拆分规则，生产一个新的日志文件 -->
                <OnStartupTriggeringPolicy />
                <!-- 按照文件大小拆分，10MB -->
                <SizeBasedTriggeringPolicy size="2MB" />
                <!-- 按照时间节点拆分，规则根据filePattern定义的 -->
                <TimeBasedTriggeringPolicy />
            </Policies>            <!-- 在同一个目录下，文件的个限定为 30个，超过进行覆盖 -->
            <DefaultRolloverStrategy max="10" />
        </RollingFile>
    </Appenders>
    <!-- logger 定义 -->
    <Loggers>
        <!-- 使用 rootLogger 配置 日志级别 level="trace" -->
        <Root level="trace">
            <!-- 指定日志使用的处理器 -->
            <AppenderRef ref="Console" />
            <AppenderRef ref="file" />
            <AppenderRef ref="rollingFile" />
            <AppenderRef ref="accessFile" />
        </Root>
    </Loggers>
</configuration>

使用：

java
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class Log4j2Demo {

    public static void main(String[] args) {
        Logger logger = LogManager.getLogger("Log4j2");
        logger.info("info message");
        logger.warn("warn message");
        logger.error("error message");

    }
}

Log4j2 异步日志 ​

Log4j2 提供了两种实现异步日志的方式，一种是 AsyncAppender，一种是 AsyncLogger。AsyncAppender 的性能比较低下，AsyncLogger 的性能比较好，生产一般用 AsyncLogger。
使用异步日志需要添加依赖：

xml
<dependency>
    <groupId>com.lmax</groupId>
    <artifactId>disruptor</artifactId>
    <version>3.4.4</version>
</dependency>
1. AsyncAppender ​

修改配置文件 log4j2.xml 的内容：

  1. 在 Appenders 节点下添加日志处理器
xml
<Async name="Async">
    <AppenderRef ref="Console"/>
</Async>
  1. 在 loggers.root 节点下添加日志处理器
xml
<Root level="trace">
    <!-- 指定日志使用的处理器 -->
    <AppenderRef ref="Console"/>
    <AppenderRef ref="file"/>
    <AppenderRef ref="rollingFile"/>
    <AppenderRef ref="accessFile"/>
    <AppenderRef ref="Async"/>
</Root>
2. AsyncLogger ​

AsyncLogger 提供了两种异步方式，一种是全局异步，一种是混合异步。

2.1 全局异步 ​

开启全部异步后，所有日志都异步的记录，所有配置都不需要改动，只需要添加一个配置文件  log4j2.component.properties：

properties
Log4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector
2.2 混合异步 ​

在配置文件 log4j2.xml 的 Loggers 节点添加异步日志器

xml
<!-- 自定义 logger 对象
    includeLocation="false" 关闭日志记录的行号信息，开启的话会严重影响异步输出的性能
    additivity="false" 不再继承 rootlogger对象
 -->
<AsyncLogger name="com.log" level="trace" includeLocation="false" additivity="false">
    <AppenderRef ref="Console"/>
</AsyncLogger>
AsyncLogger 注意点 ​

全局异步和混合异步不能同时使用。

Logback ​

Logback 是目前常用的日志框架，不带门面，只提供了实现，一般搭配日志门面 JCL 或 SLFJ4 使用。
引入依赖：

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

添加 Logback 配置文件 logback.xml：

xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，比如: 如果设置为WARN，则低于WARN的信息都不会输出 -->
<!-- scan:当此属性设置为true时，配置文档如果发生改变，将会被重新加载，默认值为true -->
<!-- scanPeriod:设置监测配置文档是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
<!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
<configuration scan="true" scanPeriod="10 seconds" debug="false">
    <!-- 尽量别用绝对路径，如果带参数不同容器路径解释可能不同,以下配置参数在pom.xml里 -->
    <!-- 日志级别 -->
    <property name="log.root.level" value="info"/>
    <!-- 其他日志级别 -->
    <property name="log.other.level" value="info"/>
    <!-- 日志路径，这里是相对路径，web项目eclipse下会输出到eclipse的安装目录下，如果部署到linux上的tomcat下，会输出到tomcat/bin目录 下 -->
    <property name="log.base" value="logs"/>
    <!-- 模块名称， 影响日志配置名，日志文件名 -->
    <property name="log.moduleName" value="2020-edge-barnacle-application"/>
    <!-- 日志文件大小 -->
    <property name="log.max.size" value="500MB"/>
    <!-- 定义日志输出格式-->
    <property name="log.pattern"
              value="%date{ISO8601} %-1level [%thread] %logger{56}.%method:%L -%msg%n"/>
    <property name="log.charset" value="UTF-8"/>

    <!--控制台输出 -->
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <!-- 用来定义日志的格式 -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${log.pattern}</pattern>
            <charset>${log.charset}</charset>
        </encoder>    </appender>
    <!-- 日志文件输出 -->
    <appender name="infoFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 设置日志不超过${log.max.size}时的保存路径，注意如果 是web项目会保存到Tomcat的bin目录 下 -->
        <file>${log.base}/info/${log.moduleName}_info.log</file>
        <!-- 日志输出的文件的格式  -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%date{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread]%logger{56}.%method:%L -%msg%n</pattern>
            <charset>${log.charset}</charset>
        </encoder>        <!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件。-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!--按天回滚-->
            <fileNamePattern>${log.base}/info/archive/${log.moduleName}_info_%d{yyyy-MM-dd}.%i.log.zip</fileNamePattern>
            <!--日志最大存储天数-->
            <maxHistory>60</maxHistory>
            <!-- 当天的日志大小 超过${log.max.size}时,压缩日志并保存 -->
            <maxFileSize>${log.max.size}</maxFileSize>
        </rollingPolicy>        <!--过滤器，只记录INFO级别的日志-->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>INFO</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>    </appender>
    <!-- 日志文件输出 -->
    <appender name="warnFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 设置日志不超过${log.max.size}时的保存路径，注意如果 是web项目会保存到Tomcat的bin目录 下 -->
        <file>${log.base}/warn/${log.moduleName}_warn.log</file>
        <!-- 日志输出的文件的格式  -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%date{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread]%logger{56}.%method:%L -%msg%n</pattern>
        </encoder>        <!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件。-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${log.base}/warn/archive/${log.moduleName}_warn_%d{yyyy-MM-dd}.%i.log.zip
            </fileNamePattern>
            <!--日志最大存储天数-->
            <maxHistory>60</maxHistory>
            <!-- 当天的日志大小 超过${log.max.size}时,压缩日志并保存 -->
            <maxFileSize>${log.max.size}</maxFileSize>
        </rollingPolicy>        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>WARN</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>    </appender>
    <!-- 日志文件输出 -->
    <appender name="errorFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 设置日志不超过${log.max.size}时的保存路径，注意如果 是web项目会保存到Tomcat的bin目录 下 -->
        <file>${log.base}/error/${log.moduleName}_error.log</file>
        <!-- 日志输出的文件的格式  -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%date{yyyy-MM-dd HH:mm:ss.SSS} %-5level [%thread]%logger{56}.%method:%L -%msg%n</pattern>
        </encoder>        <!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件。-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${log.base}/error/archive/${log.moduleName}_error_%d{yyyy-MM-dd}.%i.log.zip</fileNamePattern>
            <!--日志最大存储天数-->
            <maxHistory>60</maxHistory>
            <!-- 当天的日志大小 超过${log.max.size}时,压缩日志并保存 -->
            <maxFileSize>${log.max.size}</maxFileSize>
        </rollingPolicy>        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>    </appender>

    <!-- 为某个包下的所有类的指定Appender 这里也可以指定类名称例如：com.aa.bb.ClassName -->
    <logger name="org.springframework.aop.framework.CglibAopProxy" additivity="false">
        <level value="info" />
        <appender-ref ref="stdout" />
    </logger>    <!-- root将级别为“DEBUG”及大于“DEBUG”的日志信息交给已经配置好的名为“Console”的appender处理，“Console”appender将信息打印到Console -->
    <root level="info">
        <appender-ref ref="stdout" /> <!-- 标识这个appender将会添加到这个logger -->
        <appender-ref ref="infoFile" />
        <appender-ref ref="warnFile" />
        <appender-ref ref="errorFile" />
    </root></configuration>

使用：

java
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LogbackDemo {

    public static void main(String[] args) {
        Logger logger = LoggerFactory.getLogger("Logback");
        logger.info("info message");
        logger.warn("warn message");
    }
}

JCL ​

全名：Jakarta Commons Logging（JCL）,提供能简单的日志功能以及解耦（即只提供了接口，需提供实现）。 引入依赖：

xml
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.0.3</version>
</dependency>
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging-api</artifactId>
    <version>1.1</version>
</dependency>

使用：

java
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class JCLDemo {

    public static void main(String[] args) {
        Log log = LogFactory.getLog("JCL");
        log.debug("debug message");
        log.info("info message");
        log.error("error message");
    }
}

slf4j ​

slf4j 全名 simple Logging Facade For Java 是目前比较常见的日志框架，slf4j 并没有单独的日志实现，仅提供了日志的解耦操作，即只提供了接口。 引入依赖：

xml
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>2.0.4</version>
</dependency>

使用：

java
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Slf4jDemo {

    public static void main(String[] args) {
        Logger logger = LoggerFactory.getLogger("slf4j");
        logger.info("info message");
        logger.warn("warn message");
        logger.error("error message");
    }
}

总结 ​

  • JUL 是 java.util.logging.Logger 下的提供简单日志功能的日志框架。
  • JCL 全名 Jakarta Commons Logging，提供了日志门面，一般搭配日志实现框架使用。Spring 使用了 JCL 加载日志实现框架。
  • SLFJ4 全名 simple Logging Facade For Java，提供了日志门面，一般搭配日志实现框架使用。Spring Boot 使用 JCL+SLFJ4+Logback 实现日志功能。
  • Logback 是一款常用的日志框架，只提供了日志的具体实现，需要搭配日志门面框架使用。
  • Log4j 全名为 Log for Java 一个很常用的日志框架，自带门面，亦可搭配 SLFJ4 使用。
  • Log4j2 是 log4j 的升级版，提供了异步日志功能，是目前主流的日志框架。
java
//JUL
private static final java.util.logging.Logger julLogger = java.util.logging.Logger.getLogger("JUL");
//JCL
private static final org.apache.commons.logging.Log jclLog = org.apache.commons.logging.LogFactory.getLog("JCL");
//SLFJ4
private static final org.slf4j.Logger slf4jLogger = org.slf4j.LoggerFactory.getLogger("SLFJ4");
//Log4j
private static final org.apache.log4j.Logger log4jLogger = org.apache.log4j.Logger.getLogger("Log4j");
//log4j2
private static final org.apache.logging.log4j.Logger log4j2Logger = org.apache.logging.log4j.LogManager.getLogger("Log4j2");

Powered by VitePress

Copyright © 2024-present Evan Chen