日志框架

日志的概念

日志文件

日志文件是用于记录系统操作事件的文件集合，可分为事件日志和消息日志。具有处理历史数据、诊断问题的追踪以及理解系统的活动等重要作用

调试日志

软件开发中，我们经常需要去调试程序，做一些信息，状态的输出便于我们查询程序的运行状况。为了让我们能够更加灵话和方便的控制这些调试的信息，所有我们需要专业的日志技术。jav中寻找bug会需要重现。调试也就是debug可以在程序运行中暂停程序运行，可以查看程序在运行中的情况。日志主要是为了更方便的去重现问题。

系统日志

系统日志是记录系统中硬件、软件和系统问题的信息，同时还可以监视系统中发生的事件。用户可以通过它来检查错误发生的原因，或者寻找受到攻击时攻击者留下的痕迹。系统日志包括系统日志、应用程序日志和安全日志。

日志门面

当我们的系统变的更加复杂的时候，我们的日志就容易发生混乱。随着系统开发的进行，可能会更新不同的日志框架，造成当前系统中存在不同的日志依赖，让我们难以统一的管理和控制。所以我们需要借鉴 JDBC 的思想，为日志系统也提供一套门面，那么我们就可以面向这些接口规范来开发，避免了直接依赖具体的日志框架。这样我们的系统在日志中，就存在了日志的门面和日志的实现

常见的日志门面：JCL、Slf4j
常见的日志实现：JUL、log4j、logback、log4j2

日志门面和日志实现的关系：

alt text

👤 左侧：用户（程序员）

java

# 这是你自己编写业务代码时使用的部分，程序员调用的只是日志接口层，不直接依赖具体实现, 比如：
Logger logger = LoggerFactory.getLogger(MyClass.class);
logger.info("启动成功");

🟧 中间：日志接口（日志门面）

这是关键的抽象层，图中列出了两个主流接口：

日志接口名	说明
Commons-logging（JCL）	早期 Apache 提供的日志门面，已逐渐被淘汰
SLF4J（Simple Logging Facade for Java）	当前最主流的日志门面，统一了日志调用方式，支持桥接各种实现

你在代码中使用的是这些接口，比如 LoggerFactory.getLogger()。

好处：代码层面只依赖接口，不依赖底层实现，后期可以随时切换日志框架（比如从 Logback 换成 Log4j2），不需要改代码，只改依赖。

🟦 右侧：日志实现（日志引擎）

这个部分是真正处理日志输出的核心，SLF4J 或 Commons-logging 会将日志调用最终转发给它们：

实现名称	描述
Log4j	经典日志框架，SLF4J 需要 `slf4j-log4j12.jar` 桥接
Java.logging（JUL）	JDK 自带的日志实现，功能简单
Slf4j-nop	一个空实现，日志不会输出（用于屏蔽日志）
Slf4j-simple	简单实现，控制台输出，适合小项目或测试
Logback	SLF4J 官方推荐实现，功能强大

🔄 图中箭头解读：桥接机制图中指出了：

从 SLF4J 接口到 Log4j 实现，需要一个中间适配器包：slf4j-log4j12-xx.jar;这类桥接包负责将 SLF4J 的日志 API 转换成 Log4j 的底层实现调用

✅ 总结：图的核心含义

层级	作用	常见组件
用户层	调用日志API	`LoggerFactory.getLogger(...)`
接口层	定义统一的日志规范	SLF4J、Commons-logging
实现层	实际处理日志输出	Logback、Log4j、JUL、Slf4j-simple

JUL

JUL（Java util Logging）是 Java 原生的日志实现框架，使用时不需要另外引用第三方类库，相对其他日志框架使用方便，学习简单，能够在小型应用中灵活使用

架构

alt text

Loggers：记录器，应用程序通过获取 Logger 对象，调用其 API 来发布日志信息
Appenders：也称为 Handlers，每个 Logger 都会关联一组 Handlers，Logger 会将日志交给关联 Handlers 处理，由 Handlers 负责将日志做记录。Handlers 在此是一个抽象，其具体的实现决定了日志记录的位置可以是控制台、文件、网络上的其他日志服务或操作系统日志等
Layouts：也称为 Formatters，它负责对日志事件中的数据进行转换和格式化。Layouts 决定了数据在一条日志记录中的最终形式
Level：每条日志消息都有一个关联的日志级别，该级别粗略指导了日志消息的重要性和紧迫，可以将Level 和 Loggers、Appenders 做关联以便于我们过滤消息
Filters：过滤器，根据需要定制哪些信息会被记录，哪些信息会被放过

总结一下就是：

用户使用 Logger 来进行日志记录，Logger 持有若干个 Handler，日志的输出操作是由 Handler 完成的
Handler 在输出日志前，会经过 Filter 的过滤，判断哪些日志级别过滤放行哪些拦截，Handler 会将日志内容输出到指定位置（日志文件、控制台等）
Handler 在输出日志时会使用 Layout，将输出内容进行排版

入门案例

java

public class JULTest { 
    @Test
    public void testQuick() throws Exception {
        // 1.创建日志记录器对象
        Logger logger = Logger.getLogger("com.log.JULTest");
        // 2.日志记录输出
        logger.info("hello zuo");
        logger.log(Level.INFO, "info msg");
        String name = "jack";
        Integer age = 18;
        logger.log(Level.INFO, "用户信息：{0},{1}", new Object[]{name, age});
    }
}

日志级别

java

/**
 *  注：控制台只会输出比Info 高的日志信息，不会输出比Info低的日志信息
 */
@Test
public void testLogLevel() throws Exception {
    // 1.获取日志对象
    Logger logger = Logger.getLogger("com.itheima.log.QuickTest");
    // 2.日志记录输出
    logger.severe("severe");
    logger.warning("warning");
    logger.info("info");
    logger.config("config");
    logger.fine("fine");
    logger.finer("finer");
    logger.finest("finest");
}

虽然我们测试了 7 个日志级别，但是默认只实现 info 以上的级别，info 以下不会输出，我们可以自定义日志级别配置

绝密文件，请勿展开

java

@Test
public void testLogConfig() throws Exception {
    // 创建日志记录器对象
    Logger logger = Logger.getLogger("com.itheima.log.JULTest");
    
    // 一、自定义日志级别
    // a.关闭系统默认配置
    logger.setUseParentHandlers(false);
    // b.创建handler对象
    ConsoleHandler consoleHandler = new ConsoleHandler();
    // c.创建formatter对象
    SimpleFormatter simpleFormatter = new SimpleFormatter();
    // d.进行关联
    consoleHandler.setFormatter(simpleFormatter);
    logger.addHandler(consoleHandler);
    // e.设置日志级别
    logger.setLevel(Level.ALL);
    consoleHandler.setLevel(Level.ALL);
    
    // 二、输出到日志文件
    FileHandler fileHandler = new FileHandler("d:/logs/jul.log");
    fileHandler.setFormatter(simpleFormatter);
    
    // 日志记录输出
    logger.severe("severe");
    logger.warning("warning");
    logger.info("info");
    logger.config("config");
    logger.fine("fine");
    logger.finer("finer");
    logger.finest("finest");
}

logger的父子关系

JUL 中 Logger 之间存在父子关系，这种父子关系通过树状结构存储，JUL 在初始化时会创建一个顶层 RootLogger 作为所有 Logger 父 Logger，存储上作为树状结构的根节点，父子关系通过包路径来关联

绝密文件，请勿展开

java

@Test
public void testLogParent() throws Exception {
    
    // 日志记录器对象父子关系
    Logger logger1 = Logger.getLogger("com.itheima");
    Logger logger2 = Logger.getLogger("com");
    // true
    System.out.println(logger1.getParent() == logger2);
    
    // 所有日志记录器对象的顶级父元素 class 为 java.util.logging.LogManager$RootLogger
    // logger2 parent:java.util.logging.LogManager$RootLogger,name:
    System.out.println("logger2 parent:" + logger2.getParent() + ",name" +
    logger2.getParent().getName());
    
    // 一、自定义日志级别
    // a.关闭系统默认配置
    logger2.setUseParentHandlers(false);
    // b.创建handler对象
    ConsoleHandler consoleHandler = new ConsoleHandler();
    // c.创建formatter对象
    SimpleFormatter simpleFormatter = new SimpleFormatter();
    // d.进行关联
    consoleHandler.setFormatter(simpleFormatter);
    logger2.addHandler(consoleHandler);
    // e.设置日志级别
    logger2.setLevel(Level.ALL);
    consoleHandler.setLevel(Level.ALL);
    
    // 测试日志记录器对象父子关系,这里会全部输出,因为logger1继承logger2的级别配置
    logger1.severe("severe");
    logger1.warning("warning");
    logger1.info("info");
    logger1.config("config");
    logger1.fine("fine");
    logger1.finer("finer");
    logger1.finest("finest");
}

日志的配置文件

默认配置文件路径 $JAVAHOME\jre\lib\logging.properties

java

@Test
public void testProperties() throws Exception {
    // 读取自定义配置文件 (将配置文件放在项目的Resuource 下面)
    InputStream in = JULTest.class.getClassLoader().getResourceAsStream("logging.properties");
    // 获取日志管理器对象
    LogManager logManager = LogManager.getLogManager();
    // 通过日志管理器加载配置文件
    logManager.readConfiguration(in);
    Logger logger = Logger.getLogger("com.itheima.log.JULTest");
    logger.severe("severe");
    logger.warning("warning");
    logger.info("info");
    logger.config("config");
    logger.fine("fine");
    logger.finer("finer");
    logger.finest("finest");
}

配置文件：

绝密文件，请勿展开

shell

## RootLogger使用的处理器（获取时设置）
handlers= java.util.logging.ConsoleHandler
# RootLogger日志等级
.level= INFO

# 自定义Logger
com.itheima.handlers= java.util.logging.FileHandler
# 自定义Logger日志等级
com.itheima.level= INFO
# 忽略父日志设置
com.itheima.useParentHandlers=false

## 控制台处理器
# 输出日志级别
java.util.logging.ConsoleHandler.level = ALL
# 输出日志格式
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
# 指定handler对象的字符集
java.util.logging.ConsoleHandler.encoding = UTF-8

# 指定日志消息格式
java.util.logging.SimpleFormatter.format = %4$s: %5$s [%1$tc]%n

## 文件处理器
# 输出日志级别
java.util.logging.FileHandler.level=INFO
# 输出日志格式
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
# 输出日志文件路径
# /logs/java0.log
java.util.logging.FileHandler.pattern = /logs/java%u.log
# 输出日志文件限制大小（50000字节）
java.util.logging.FileHandler.limit = 50000
# 输出日志文件限制个数
java.util.logging.FileHandler.count = 10
# 输出日志文件是否是追加
java.util.logging.FileHandler.append=true

日志原理解析

alt text

初始化 LogManager
- LogManager 加载 logging.properties 配置
- 添加 Logger 到 LogManager
从单例 LogManager 获取 Logger
设置级别 Level，并指定日志记录 LogRecord
Filter 提供了日志级别之外更细粒度的控制
Handler 是用来处理日志输出位置
Formatter 是用来格式化 LogRecord 的

Log4J

Log4j 是Apache 下的一款开源的日志实现框架，通过在项目中使用 Log4J，我们可以控制日志信息输出到控制台、文件、甚至是数据库中。我们可以控制每一条日志的输出格式，通过定义日志的输出级别，可以更灵活的控制日志的输出过程，方便项目调试

入门案例

shell

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

java

public class Log4jTest {
    @Test
    public void testQuick() throws Exception {
        
        // 初始化系统配置，不需要配置文件
        BasicConfigurator.configure();
        
        // 创建日志记录器对象
        Logger logger = Logger.getLogger(Log4jTest.class);
        
        // 日志记录输出
        logger.info("hello log4j");
        
        // 日志级别
        logger.fatal("fatal"); // 严重错误，一般会造成系统崩溃和终止运行
        logger.error("error"); // 错误信息，但不会影响系统运行
        logger.warn("warn"); // 警告信息，可能会发生问题
        logger.info("info"); // 程序运行信息，数据库的连接、网络、IO操作等
        logger.debug("debug"); // 调试信息，一般在开发阶段使用，记录程序的变量、参数等
        logger.trace("trace"); // 追踪信息，记录程序的所有流程信息
    }
}

日志级别

每个 Logger 都被定义了一个日志级别，用来控制日志信息的输出，日志级别从高到低分为：

fatal：指出每个严重的错误事件将会导致应用程序的退出
error：指出虽然发生错误事件，但仍然不影响系统的继续运行
warn：表明会出现潜在的错误情形
info：一般和在粗粒度级别上，强调应用程序的运行全程
debug：一般用于细粒度级别上，对调试应用程序非常有帮助
trace 是程序追踪，可以用于输出程序运行中的变量，显示执行的流程

还有两个特殊的级别：OFF 可用来关闭日志记录、ALL 启用所有消息的日志记录

Log4j组件

Loggers

Logger 的名字大小写敏感，其命名有继承机制，例如：name 为 org.apache.commons 的 logger 会继承 name 为 org.apache 的 logger

Log4J 中有一个特殊的 logger 叫做 root，他是所有 logger 的根，可以用 Logger.getRootLogger() 方法获取，其他所有的 logger 都会直接或间接地继承自 root

Appenders

Appender 用来指定日志输出到哪个地方，可以同时指定日志的输出目的地。

Log4j 常用的输出目的地有以下几种：

Appender 类型	作用描述
`ConsoleAppender`	将日志输出到控制台，常用于开发和调试阶段
`FileAppender`	将日志输出到指定文件，适合基本的文件持久化日志
`DailyRollingFileAppender`	将日志按天（或其他时间周期）切分成多个文件，适用于时间维度的日志归档
`RollingFileAppender`	将日志输出到文件，并按文件大小进行切分，适用于控制磁盘使用
`JDBCAppender`	将日志记录写入数据库表中，适合做日志持久化和后续分析

Layouts

布局器 Layouts 用于控制日志输出内容的格式，让我们可以使用各种需要的格式输出日志。

Log4j 常用的 Layouts：

Layout 类型	描述说明
`HTMLLayout`	将日志格式化为 HTML 表格形式，适合在浏览器中查看日志
`SimpleLayout`	简单的日志格式：`日志级别 - 消息`，如：`INFO - 应用启动成功`
`PatternLayout`	功能最强的格式化器，可自定义输出格式（如时间、类名、线程等），默认使用通用格式

配置文件详解

绝密文件，请勿展开

shell

#指定日志的输出级别与输出端
log4j.rootLogger=INFO,Console

# 自定义Logger
# com.itheima包下的logger使用文件输出配置
log4j.logger.com.itheima = info,file
# apache包下的logger输出error级别日志
log4j.logger.org.apache = error

# 控制台输出配置
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
# log4j 采用类似 C 语言的 printf 函数的打印格式格式化日志信息，具体的占位符及其含义如下：
# %m 输出代码中指定的日志信息
# %p 输出优先级，及 DEBUG、INFO 等
# %n 换行符（Windows平台的换行符为 "\n"，Unix 平台为 "\n"）
# %r 输出自应用启动到输出该 log 信息耗费的毫秒数
# %c 输出打印语句所属的类的全名
# %t 输出产生该日志的线程全名
# %d 输出服务器当前时间，默认为 ISO8601，也可以指定格式，如：%d{yyyy年MM月dd日
# HH:mm:ss}
# %l 输出日志时间发生的位置，包括类名、线程、及在代码中的行数。如：
# Test.main(Test.java:10)
# %F 输出日志消息产生时所在的文件名称
# %L 输出代码中的行号
# %% 输出一个 "%" 字符
# 可以在 % 与字符之间加上修饰符来控制最小宽度、最大宽度和文本的对其方式。如：
# %5c 输出category名称，最小宽度是5，category<5，默认的情况下右对齐
# %-5c 输出category名称，最小宽度是5，category<5，"-"号指定左对齐,会有空格
# %.5c 输出category名称，最大宽度是5，category>5，就会将左边多出的字符截掉，<5不会有空格
# %20.30c category名称<20补空格，并且右对齐，>30字符，就从左边交远销出的字符截掉
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n

# 文件输出配置
# 如果设置这个A名称，需要在 logger 中引用这个名称，如：log4j.rootLogger=INFO, A
log4j.appender.A = org.apache.log4j.DailyRollingFileAppender
#指定日志的输出路径
log4j.appender.A.File = D:/log.txt
log4j.appender.A.Append = true
#使用自定义日志格式化器
log4j.appender.A.layout = org.apache.log4j.PatternLayout
#指定日志的输出格式
log4j.appender.A.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [%t:%r] -
[%p] %m%n
#指定日志的文件编码
log4j.appender.A.encoding=UTF-8

#mysql
log4j.appender.logDB=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.logDB.layout=org.apache.log4j.PatternLayout
log4j.appender.logDB.Driver=com.mysql.jdbc.Driver
log4j.appender.logDB.URL=jdbc:mysql://localhost:3306/test
log4j.appender.logDB.User=root
log4j.appender.logDB.Password=root
log4j.appender.logDB.Sql=INSERT INTO
log(project_name,create_date,level,category,file_name,thread_name,line,all_categ
ory,message) values('itcast','%d{yyyy-MM-dd
HH:mm:ss}','%p','%c','%F','%t','%L','%l','%m')

绝密文件，请勿展开

sql

CREATE TABLE `log` (
    `log_id` int(11) NOT NULL AUTO_INCREMENT,
    `project_name` varchar(255) DEFAULT NULL COMMENT '目项名',
    `create_date` varchar(255) DEFAULT NULL COMMENT '创建时间',
    `level` varchar(255) DEFAULT NULL COMMENT '优先级',
    `category` varchar(255) DEFAULT NULL COMMENT '所在类的全名',
    `file_name` varchar(255) DEFAULT NULL COMMENT '输出日志消息产生时所在的文件名称 ',
    `thread_name` varchar(255) DEFAULT NULL COMMENT '日志事件的线程名',
    `line` varchar(255) DEFAULT NULL COMMENT '号行',
    `all_category` varchar(255) DEFAULT NULL COMMENT '日志事件的发生位置',
    `message` varchar(4000) DEFAULT NULL COMMENT '输出代码中指定的消息',
    PRIMARY KEY (`log_id`)
);

JCL

全称为 Jakarta Commons Logging，是 Apache 提供的一个日志门面实现，为所有的 Java 日志实现提供一个统一的接口，它自身也提供一个日志的实现，但是功能较弱，它允许开发人员使用不同的具体日志实现工具，如：Log4J，JUL

JCL 有两个基本的抽象类：Log（基本记录器）和 LogFactory（负责创建 Log 实例）

alt text

入门案例

shell

<dependency>
	<groupId>commons-logging</groupId>
	<artifactId>commons-logging</artifactId>
	<version>1.2</version>
</dependency>

java

public class JULTest {
    // 如果没有导入log4j的依赖，默认使用的是jdk14 (如上图所示)
    @Test
    public void testQuick() throws Exception {
        // 创建日志对象
        Log log = LogFactory.getLog(JULTest.class);
        // 日志记录输出
        log.fatal("fatal");
        log.error("error");
        log.warn("warn");
        log.info("info");
        log.debug("debug");
    }
}

JCL原理（只支持JUL、log4j）

JCL 通过 LogFactory 动态加载 Log 实现类

alt text

获取具体的日志实现的源码如下：

java

private static final String[] classesToDiscover =
	new String[]{"org.apache.commons.logging.impl.Log4JLogger",
					"org.apache.commons.logging.impl.Jdk14Logger",
					"org.apache.commons.logging.impl.Jdk13LumberjackLogger",
					"org.apache.commons.logging.impl.SimpleLog"};


for(int i = 0; i < classesToDiscover.length && result == null; ++i) {
	result = this.createLogFromClass(classesToDiscover[i], logCategory, true);
}

classesToDiscover 数组是 JCL 支持的日志实现数组，对它进行遍历，尝试通过反射去实现

SLF4J

SLF4J（Simple Logging Facade For Java）主要是为了给 Java 日志访问提供一套标准、规范的 API 框架，其主要意义在于提供接口，具体的实现可以交由其他日志框架，例如 log4j 和 logback 等

SLF4J 也提供了功能较为简单的实现，但是一般很少用到。对于一般的 Java 项目而言，日志框架会选择 slf4j-api 作为门面，配上具体的实现框架（log4j、logback 等），中间使用桥接器完成桥接

SLF4J 的优势：

SLF4J 提供了对所有流行的日志框架的绑定，可以在部署时切换到所需的日志记录框架
无论使用哪种绑定，SLF4J 都支持参数化日志记录消息
SLF4J 提供了一个称为桥接器的工具，可以将现有项目的使用日志框架（JCL、JUL、Log4j）迁移到 SLF4J

入门案例

xml

<!--slf4j core 使用slf4j必須添加-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.27</version>
</dependency>
<!--slf4j 自带的简单日志实现 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-simple</artifactId>
    <version>1.7.27</version>
</dependency>

java

public class Slf4jTest {
    
    // 声明日志对象
    public final static Logger logger  = LoggerFactory.getLogger(Slf4jTest.class);
    
    @Test
    public void testQuick() throws Exception {  
        // 打印日志信息
        logger.error("error");
        logger.warn("warn");
        logger.info("info");
        logger.debug("debug");
        logger.trace("trace");
        
        // 使用占位符输出日志信息
        String name = "jack";
        Integer age = 18;
        logger.info("用户：{},{}", name, age);
        
        // 将系统异常信息写入日志
        try {
            int i = 1 / 0;
        } catch (Exception e) {
            // e.printStackTrace();
            logger.info("出现异常：", e);
        }
    }
}

绑定日志的实现

SLF4J 提供了用于绑定日志实现框架的 Jar 文件，每个绑定对应一个受支持的框架

使用 SLF4J 的日志绑定流程如下：

添加 slf4j-api 的依赖
使用 slf4j 的 API 在项目中进行统一的日志记录
绑定具体的日志实现框架
- 绑定已经实现了 slf4j 的日志框架，可直接添加对应依赖
- 绑定没有实现 slf4j 的日志框架，先添加日志的适配器，再添加实现类的依赖
slf4j 有且仅有一个日志实现框架的绑定（如果出现多个默认使用第一个依赖日志实现）

通过 maven 引入常见的日志实现框架：

绝密文件，请勿展开

xml

<!--slf4j core 使用slf4j必須添加-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.27</version>
</dependency>

<!-- log4j 适配器 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.27</version>
</dependency>
<!-- log4j 依赖 -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

<!-- jul 适配器 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-jdk14</artifactId>
    <version>1.7.27</version>
</dependency>
<!-- jul 是 jdk 自带的日志实现,不需要引入依赖 -->

<!-- logback 依赖 -->
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>

要切换日志框架，只需替换类路径上的 slf4j 绑定，例如，要从 java.util.logging 切换到 log4j，只需将 java.util.logging 的依赖替换为 log4j 的依赖即可

如果出现多个日志实现。默认加载第一个实现，也就是会使用 log4j

桥接旧的日志框架

项目初期使用了一个简单的日志实现框架，如 Log4J，后续需要升级成 Slf4J + Logback，但又不想修改原有 Log4J 的代码，因此可以使用桥接器，将原本对 Log4J 的 API 调用重定向到 Slf4J 的实现

例如，最初的项目使用了 Log4J

xml

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

java

public class Log4jTest {
    // 声明日志对象
    public final static Logger logger = Logger.getLogger(Log4jTest.class);
    
    @Test
    public void test01() throws Exception {
        // 打印日志信息
        logger.info("hello log4j");
    }
}

如果我们要使用 SLF4J 的桥接器，替换原有的日志框架，那么我们需要做的第一件事情，就是删除掉原有项目中的日志框架的依赖，然后替换成 SLF4J 提供的桥接器

xml

<!-- <dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency> -->

<!-- log4j 桥接器 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>log4j-over-slf4j</artifactId>
    <version>1.7.27</version>
</dependency>

注意的问题：

log4j-over-slf4j.jar 和 slf4j-log4j12.jar 不能同时出现，前一个 jar 文件将导致 log4j 将日志系统的选择委托给 slf4j，后一个 jar 文件将导致 slf4j 将日志系统的选择委托给 log4j，从而导致无限循环，其他日志实现框架同理
所有的桥接都只对 Logger 日志记录器对象有效，如果程序中调用了内部的配置类或者是 Appender、Filter 等对象，将无法产生效果

✅ 两个桥接包的作用与方向对比表

Jar 包名	类型	作用描述	调用方向
`log4j-over-slf4j.jar`	桥接器（适配）	将原 Log4j API（如 `org.apache.log4j.Logger`）调用转发到 SLF4J 接口	Log4j → SLF4J
`slf4j-log4j12.jar`	绑定实现	将 SLF4J 接口的调用绑定到 Log4j 1.x，作为最终日志实现输出	SLF4J → Log4j

🧨 为什么不能共存？（死循环分析表）

触发点	转发路径	结果
Log4j 打日志	Log4j → SLF4J → Log4j	导致循环调用
最终表现	日志无限循环调用，栈溢出	`StackOverflowError`
异常信息（典型报错）	`at org.slf4j.impl.Log4jLoggerAdapter...`	出现死循环、性能崩溃

SLF4J 原理解析

SLF4J 通过 LoggerFactory 加载日志具体的实现对象
LoggerFactory 在初始化的过程中，会通过 performInitialization() 方法绑定具体的日志实现
在绑定具体实现的时候，通过类加载器，加载 org/slf4j/impl/StaticLoggerBinder.class
所以，只要是一个日志实现框架，在 org.slf4j.impl 包中提供一个自己的StaticLoggerBinder类，在其中提供具体日志实现的 LoggerFactory 就可以被 SLF4J 所加载

日志门面好处

面向接口开发，不在依赖具体的实现类。减少代码的耦合
项目通过导入不同的日志实现类，可以灵活的切换日志框架
统一API，方面开发者学习和使用
统一配置便于项目日志的管理

Logback

Logback 是由 log4j 创始人设计的另一个开源日志组件，性能优于 log4j

Logback 主要分为三个模块：

logback-core：其它两个模块的基础模块
logback-classic：它是 log4j 的一个改良版本，同时它完整实现了 slf4j API
logback-access：访问模块与 Servlet 容器集成提供通过 Http 来访问日志的功能

入门案例

xml

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.25</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>

java

public class LogBackTest {
    
    //定义日志对象
	public final static Logger LOGGER = LoggerFactory.getLogger(LogBackTest.class);

    @Test
    public void testSlf4j(){
        //打印日志信息
        LOGGER.error("error");
        LOGGER.warn("warn");
        LOGGER.info("info");
        LOGGER.debug("debug");
        LOGGER.trace("trace");
    }
}

Logback 配置

Logback 会依次读取以下类型配置文件，如果均不存在会采用默认配置：

logback.groovy
logback-test.xml
logback.xml

logback 组件之间的关系

Logger: 日志的记录器，把它关联到应用的对应的context上之后，主要用于存放日志对象，也可以定义日志类型、级别。
Appender:用于指定日志输出的目的地，目的地可以是控制台、文件、数据库等等。
Layout:负责把时间转化为字符串，格式化的日志信息的输出。在logback 中Layout 对象被封装在enconding 中。

基本配置信息如下：

绝密文件，请勿展开

xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
	<!-- 
		格式化输出：
			%d:日期
			%thread:线程名
			%-5level:级别从左显示5个字符宽度
			%n:换行符
			%d{yyyy-MM-dd HH:mm:ss.SSS}:日期
			%c:类的完整名称
			%M:方法名
            %L:行号
            %thread:线程名称
            %m或%msg:日志信息
	-->
	<property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss} %c %M %L [%thread] %m %n"/>
    
	<!-- 
		Appender:设置日志信息的去向,常用的有以下几个:
			ch.qos.logback.core.ConsoleAppender (控制台)
			ch.qos.logback.core.rolling.RollingFileAppender (文件大小到达指定尺寸的时候产生一个新文件)
			ch.qos.logback.core.FileAppender (文件)
	-->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <!-- 输出流对象默认 System.out 改为 System.err-->
        <target>System.err</target>
        <!--日志格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
        	<pattern>${pattern}</pattern>
        </encoder>
    </appender>

	<!-- 日志文件存放目录 -->
	<property name="log_dir" value="d:/logs"></property>

    <!-- 日志文件输出 appender 对象 -->
    <appender name="file" class="ch.qos.logback.core.FileAppender">
        <!-- 日志格式配置 -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
        	<pattern>${pattern}</pattern>
        </encoder>
        <!-- 日志输出路径 -->
        <file>${log_dir}/logback.log</file>
    </appender>
    
    <!-- 生成 html 格式 appender 对象 -->
    <appender name="htmlFile" class="ch.qos.logback.core.FileAppender">
        <!-- 日志格式配置 -->
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
        	<layout class="ch.qos.logback.classic.html.HTMLLayout">
        		<pattern>${pattern}</pattern>
        	</layout>
        </encoder>
        <!--日志输出路径-->
        <file>${log_dir}/logback.html</file>
    </appender>
    
    <!-- 日志文件拆分和归档的appender对象-->
    <appender name="rollFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!--日志格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
        	<pattern>${pattern}</pattern>
        </encoder>
        <!--日志输出路径-->
        <file>${log_dir}/roll_logback.log</file>
        <!--指定日志文件拆分和压缩规则-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!--通过指定压缩文件名称，来确定分割文件方式-->
            <fileNamePattern>${log_dir}/rolling.%d{yyyy-MMdd}.log%i.gz</fileNamePattern>
            <!--文件拆分大小-->
            <maxFileSize>1MB</maxFileSize>
        </rollingPolicy>
        <!-- 日志级别过滤 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 日志级别 -->
            <level>error</level>
            <!-- 对error级别及以上的日志进行记录 -->
            <onMatch>ACCEPT</onMatch>
            <!-- 拦截error级别以下的日志 -->
			<onMismatch>DENY</onMismatch>
		</filter>
    </appender>
    
    <!-- 开启异步日志记录,提升性能 -->
    <appender name="async" class="ch.qos.logback.classic.AsyncAppender">
    	<appender-ref ref="rollFile"/>
    </appender>
    
    <!-- RootLogger 对象 -->
    <!-- level:用来设置打印级别,大小写无关:TRACE,DEBUG,INFO,WARN,ERROR,ALL,OFF,默认debug -->
    <!-- <root>可以包含零个或多个<appender-ref>元素,标识这个appender将会添加到这个logger-->
    <root level="all">
        <appender-ref ref="console"/>
        <appender-ref ref="file"/>
        <appender-ref ref="htmlFile"/>
    </root>
    
    <!--自定义 logger -->
    <!-- name:指定受此logger约束的某一个包或者具体的某一个类 -->
    <!-- level:用来设置打印级别，大小写无关：TRACE,DEBUG,INFO,WARN,ERROR,ALL,OFF,默认继承父级的级别 -->
    <!-- additivity:是否从 rootLogger 继承配置 -->
    <logger name="com.itheima" level="debug" additivity="false">
    	<appender-ref ref="async"/>
    </logger>
    
</configuration>

特别注意：： Logback 中的 Appender 可以将 ERROR 级别的日志输出到 error.log 文件中，并按照日期进行归档管理。（今天生成的error日志在error.log中，昨天以及之前的日志会生成对应的日志文件）

当天的日志保存在 error.log 中；
第二天凌晨，旧的 error.log 会被重命名为 error-2025-06-21.log（按日期归档）；
然后重新生成一个新的 error.log 接着写当天的新日志。

Log4j2

目前市面上最主流的日志门面就是SLF4j,虽然Log4j2也是日志门面，因为它的日志实现功能非常强大，性能优越。所以大家一般还是将Log4j2 看作是日志的实现，SLF4j + Log4j2 应该就是未来的大势所趋

入门案例

xml

<!-- Log4j2 门面API-->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>2.11.1</version>
</dependency>
<!-- Log4j2 日志实现 -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.11.1</version>
</dependency>

java

public class Log4j2Test {
    
    // 定义日志记录器对象
    public static final Logger logger = LogManager.getLogger(Log4j2Test.class);
    
    @Test
    public void testQuick() throws Exception {
        logger.fatal("fatal");
        logger.error("error");
        logger.warn("warn");
        logger.info("info");
        logger.debug("debug");
        logger.trace("trace");
    }
}

也可以使用 slf4j 作为日志的门面，log4j2 作为日志的实现

xml

<!-- 使用slf4j作为日志的门面,使用log4j2来记录日志 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.25</version>
</dependency>
<!-- log4j2的适配器 -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j-impl</artifactId>
    <version>2.10.0</version>
</dependency>

<!-- Log4j2 门面API-->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>2.11.1</version>
</dependency>
<!-- Log4j2 日志实现 -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.11.1</version>
</dependency>

Log4j2 配置

log4j2 默认加载 classpath 下的 log4j2.xml 文件中的配置

xml

<?xml version="1.0" encoding="UTF-8"?>
<!--
	status:日志本身的输出日志级别
	monitorInterval:检查配置文件是否更新的间隔时间
-->
<Configuration status="warn" monitorInterval="5">
    
    <!-- 配置属性管理,使用时通过 ${name} 来引用 -->
	<properties>
		<property name="LOG_HOME">D:/logs</property>
	</properties>
    
    <!-- 日志处理 -->
    <Appenders>
        
        <!-- 控制台输出 -->
		<Console name="Console" target="SYSTEM_OUT">
			<PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] [%-5level] %c{36}:%L --- %m%n" />
		</Console>
        
        <!-- 日志文件输出 -->
		<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>
        
        <!-- 使用随机读写流的日志文件输出 -->
		<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>
        
        <!-- 按照规则拆分日志文件输出 -->
		<RollingFile name="rollingFile" fileName="${LOG_HOME}/myrollog.log" filePattern="D:/logs/$${date:yyyy-MM-dd}/myrollog-%d{yyyy-MM-dd-HH-mm}-%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 />
                <!-- 按照指定的大小拆分 -->
                <SizeBasedTriggeringPolicy size="10 MB" />
                <!-- 按照时间节点拆分,规则由filePattern定义 -->
                <TimeBasedTriggeringPolicy />
            </Policies>
            <!-- 同一目录下,文件个数限定为30个,超过将进行覆盖 -->
			<DefaultRolloverStrategy max="30" />
		</RollingFile>
        
        <!-- logger 定义 -->
        <Loggers>
            <!-- rootLogger 配置 -->
            <Root level="trace">
            	<AppenderRef ref="Console" />
                <AppenderRef ref="file" />
                <AppenderRef ref="accessFile" />
                <AppenderRef ref="rollingFile" />
            </Root>
        </Loggers>
        
</Appenders>

Log4j2 异步日志

异步日志：log4j2 最大的特点就是异步日志，其性能的提升也是从异步日志中受益

同步日志流程

alt text

异步日志流程

alt text

Log4j2 提供了两种实现日志的方式，一个是通过 AsyncAppender，一个是通过 AsyncLogger，分别对应前面的 Appender 组件和 Logger 组件

配置异步日志需要添加依赖

xml

<!-- 异步日志依赖 -->
<dependency>
    <groupId>com.lmax</groupId>
    <artifactId>disruptor</artifactId>
    <version>3.3.4</version>
</dependency>

使用 AsyncAppender 的方式

xml

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn">
    
	<properties>
		<property name="LOG_HOME">D:/logs</property>
	</properties>
    
	<Appenders>
		<File name="file" fileName="${LOG_HOME}/myfile.log">
			<PatternLayout>
				<Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
			</PatternLayout>
		</File>
		<Async name="Async">
			<AppenderRef ref="file"/>
		</Async>
	</Appenders>
    
	<Loggers>
		<Root level="error">
			<AppenderRef ref="Async"/>
		</Root>
	</Loggers>
    
</Configuration>

AsyncLogger 是官方推荐的异步方式，它可以使得调用 Logger.log 返回得更快，并且有两种选择：全局异步和混合异步

全局异步：所有的日志都异步记录，配置文件上不用做任何改动，只需要在类路径添加一个名为 log4j2.component.properties 配置文件，并包含如下内容：

Log4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector

混合异步：可以在应用中同时使用同步日志和异步日志，这使得日志的配置方式更加灵活，如下配置： com.itheima 日志是异步的，root 日志是同步的

xml

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    
	<properties>
		<property name="LOG_HOME">D:/logs</property>
	</properties>
    
	<Appenders>
		<File name="file" fileName="${LOG_HOME}/myfile.log">
			<PatternLayout>
				<Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
			</PatternLayout>
		</File>
	</Appenders>
    
	<Loggers>
        <!-- 自定义异步 logger 对象 -->
        <!--
			includeLocation="false":关闭日志记录的行号信息,打印位置信息会急剧降低异步日志的性能
 		-->
		<AsyncLogger name="com.itheima" level="trace" includeLocation="false" additivity="false">
			<AppenderRef ref="file"/>
		</AsyncLogger>
		<Root level="info" includeLocation="true">
			<AppenderRef ref="file"/>
		</Root>
	</Loggers>
    
</Configuration>

使用异步日志需要注意的问题：

如果使用异步日志，AsyncAppender、AsyncLogger 和全局日志，不要同时出现。性能会和AsyncAppender 一致，降至最低
设置includeLocation="false"，打印位置信息会急剧降低异步日志的性能，比同步日志还要慢

无垃圾模式

垃圾收集暂停是延迟峰值的常见原因，并且对于许多系统而言，花费大量精力来控制这些暂停

许多日志库（包括以前版本的 Log4j）在稳态日志记录期间分配临时对象，如日志事件对象、字符串、字符数组、字节数组等。这会对垃圾收集器造成压力并增加 GC 暂停发生的频率

从 2.6 版本开始，默认情况下 Log4j 以无垃圾模式运行，重用对象和缓冲区，尽可能不分配临时对象

还有一个低垃圾模式，它不是完全无垃圾，但不使用 ThreadLocal 字段，Log4j 2.6 中的无垃圾日志记录部分通过重用 ThreadLocal 字段中的对象来实现，部分通过在将文本转换为字节时重用缓冲区来实现

有两个单独的系统属性可用于手动控制 Log4j 用于避免创建临时对象的机制：

log4j2.enableThreadlocals：如果为 true（默认），对象存储在 ThreadLocal 字段中并重新使用，否则将为每个日志事件创建新对象
log4j2.enableDirectEncoders：如果为 true（默认），日志事件转换为文本，则将此文本转换为字节而不创建临时对象。注意：由于共享缓冲区上的同步，在此模式下多线程应用程序的同步日志记录性能可能更差，如果您的应用程序是多线程的并且日志记录性能很重要，请考虑使用异步记录器

SpringBoot 日志使用

Springboot 默认使用 SLF4J 作为日志门面，logback 作为日志实现来记录日志

SpringBoot 的日志设计

xml

<dependency>
    <artifactId>spring-boot-starter-logging</artifactId>
    <groupId>org.springframework.boot</groupId>
</dependency>

依赖关系图：

alt text

Springboot 底层默认使用 logback 作为日志实现，并提供了其他日志实现框架的桥接器进行转换
Springboot 使用了 SLF4J 作为日志门面，也可以使用如 Log4j2 等日志门面，但最终还是通过 slf4j 进行调用 logback

SpringBoot 日志使用

在SpringBoot 中测试打印日志

java

@SpringBootTest
class SpringbootLogApplicationTests {
	//记录器
	public static final Logger LOGGER = LoggerFactory.getLogger(SpringbootLogApplicationTests.class);
    
    @Test
    public void contextLoads() {
        // 打印日志信息
        LOGGER.error("error");
        LOGGER.warn("warn");
        LOGGER.info("info"); // 默认日志级别
        LOGGER.debug("debug");
        LOGGER.trace("trace");
    }
}

修改默认日志配置

shell

logging.level.com.itheima=trace
# 在控制台输出的日志的格式 同logback
logging.pattern.console=%d{yyyy-MM-dd} [%thread] [%-5level] %logger{50} - %msg%n
# 指定文件中日志输出的格式
logging.file=D:/logs/springboot.log
logging.pattern.file=%d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n

给类路径下放上每个日志框架自己的配置文件，SpringBoot 就不使用默认配置的了

日志框架	配置文件名
Logback	`logback-spring.xml`，`logback.xml`
Log4j2	`log4j2-spring.xml`，`log4j2.xml`
JUL（Java Util Logging）	`logging.properties`

使用 SpringBoot 可以切换不同环境的日志配置，如在 logback-spring.xml 添加如下内容：

xml

<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
	<springProfile name="dev">
		<pattern>${pattern}</pattern>
	</springProfile>
	<springProfile name="pro">
		<pattern>%d{yyyyMMdd:HH:mm:ss.SSS} [%thread] %-5level %msg%n</pattern>
	</springProfile>
</encoder>

application.properties 配置如下：

spring.profiles.active=dev

将日志切换为 log4j2

xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <!-- 排除 logback -->
        <exclusion>
            <artifactId>spring-boot-starter-logging</artifactId>
            <groupId>org.springframework.boot</groupId>
        </exclusion>
	</exclusions>
</dependency>
<!-- 添加log4j2 -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

对比总结

框架/组件	类型	是否抽象接口	是否推荐	是否还在维护	与其他框架关系
JUL（`java.util.logging`）	日志实现	❌	❌ 一般	✅ 是 JDK 一部分	比较基础，性能和灵活性较差
Log4j (1.x)	日志实现	❌	❌ 不推荐	❌ 已停止维护	被 Log4j2 替代
Log4j2	日志实现	❌	✅ 推荐	✅	可以作为 SLF4J 实现
JCL (Commons Logging)	日志门面（抽象层）	✅	❌ 过时	❌ 几乎无人维护	可桥接 Log4j 等实现
SLF4J	日志门面（抽象层）	✅	✅ 强烈推荐	✅	可桥接 Log4j2、Logback、JUL
Logback	日志实现	❌	✅ 推荐	✅ SLF4J 官方推荐实现	默认用于 Spring Boot

日志框架 ​

日志的概念 ​

日志文件 ​

日志门面 ​

JUL ​

架构 ​

入门案例 ​

日志级别 ​

logger的父子关系 ​

日志的配置文件 ​

日志原理解析 ​

Log4J ​

入门案例 ​

日志级别 ​

Log4j组件 ​

配置文件详解 ​

JCL ​

入门案例 ​

JCL原理（只支持JUL、log4j） ​

SLF4J ​

入门案例 ​

绑定日志的实现 ​

桥接旧的日志框架 ​

SLF4J 原理解析 ​

日志门面好处 ​

Logback ​

入门案例 ​

Logback 配置 ​

Log4j2 ​

入门案例 ​

Log4j2 配置 ​

Log4j2 异步日志 ​

无垃圾模式 ​

SpringBoot 日志使用 ​

SpringBoot 的日志设计 ​

SpringBoot 日志使用 ​

对比总结 ​

日志框架

日志的概念

日志文件

日志门面

JUL

架构

入门案例

日志级别

logger的父子关系

日志的配置文件

日志原理解析

Log4J

入门案例

日志级别

Log4j组件

配置文件详解

JCL

入门案例

JCL原理（只支持JUL、log4j）

SLF4J

入门案例

绑定日志的实现

桥接旧的日志框架

SLF4J 原理解析

日志门面好处

Logback

入门案例

Logback 配置

Log4j2

入门案例

Log4j2 配置

Log4j2 异步日志

无垃圾模式

SpringBoot 日志使用

SpringBoot 的日志设计

SpringBoot 日志使用

对比总结