java 开启日志 java 日志系统

一、目标

1. 日志的作用和目的
2. 日志的框架
3. JUL的使用
4. LOG4J的使用
5. JCL的使用

---

二、日志的概念

2.1 日志文件

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

在计算机中，日志文件是记录在操作系统或其他软件运行中发生的事件或在通信软件的不同用户之间的消息的文件。记录是保持日志的行为，在最简单的情况下，消息被写入单个日志文件。

许多操作系统，软件框架和程序包括日志系统。广泛使用的日志记录标准是在因特网工程任务组(IETE) RFC5424中定义的syslog。syslog标准使专用的标准化子系统能够生成，过滤，记录和分析日志消息。

---

2.1.1 调试日志

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

2.1.2 系统日志

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

系统日志的价值

系统日志策略可以在故障刚刚发生时就向你发送警告信息，系统日志帮助你在最短的时间内发现问题。

---

三、JAVA 日志框架

问题：

1. 控制日志输出的内容和格式
2. 控制日志输出的位置
3. 日志优化：异步日志、日志文件的归档和压缩
4. 日志系统的维护
5. 面向接口开发 -- 日志的门面

3.1 为什么要用日志框架

因为软件系统发展到今天已经很复杂了，特别是服务器端软件，涉及到的知识、内容、问题太多。在某些方面使用别人成熟的框架，就相当于让别人帮你完成一些基础工作，你只需要集中精力完成系统的业务逻辑设计。而且框架一般是成熟、稳键的，它可以处理系统很多细节问题，比如，事务处理、安全性，数据流控制等问题。还有框架一般都经过很多人使用，所以结构很好，所以扩展性也很好，而且它是不断升级的，你可以直接享受别人升级代码带来的好处。

3.2 现有日志框架

• JUL（java util logging）、logback、log4j、log4j2
• JCL（Jakarta Commons Logging）、slf4j（Simple Logging Facade for Java）

日志门面

JCL、slf4j

日志实现

JUL、logback、log4j、log4j2【目前性能最好的日志处理技术】

---

四、JUL 深入理解

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

4.1 JUC 入门

4.1.1 架构介绍

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

代码示例：

package com.log;

import org.junit.Test;

import java.util.logging.Level;
import java.util.logging.Logger;

public class T01_JULTest {
    // 快速入门
    @Test
    public void testQuick() {
        // 1.创建日志记录器对象
        Logger logger = Logger.getLogger("com.log.test.JULTest");
        // 2.日志记录输出
        logger.info("hello jul");

        // 通用方法进行日志记录
        logger.log(Level.INFO, "info msg");

        // 通过点位符方式进行日志记录
        String name = "jack";
        Integer age = 18;
        logger.log(Level.INFO, "用户信息：{0},{1}", new Object[]{name, age});
    }
}

---

4.2 日志的级别

// JUL日志级别测试
    @Test
    public void testLogLevel() throws Exception {
        // 1.获取日志记录器对象
        Logger logger = Logger.getLogger("com.log.T01_JULTest");
        // 2.日志记录输出
        logger.severe("server");
        logger.warning("warning");
        logger.info("info"); // jul 默认的日志级别info
        logger.config("config");
        logger.fine("fine");
        logger.finer("finer");
        logger.finest("finest");
    }

4.3 Logger 之间的父子关系

// Logger 对象父子关系
    @Test
    public void testLogParent() throws Exception {
        // todo: 日志父子关系是根据包名关系继承的
        Logger logger1 = Logger.getLogger("com.log");
        Logger logger2 = Logger.getLogger("com"); // com包没有父包的话，默认继承自RootLogger

        // 测试日志对象是否存在父子关系：答案是存在的
        System.out.println(logger1.getParent() == logger2);
        // 所有日志记录器的顶级父无素 LogManager$RootLogger, name ""
        System.out.println("logger2 Parent:" + logger2.getParent() + ", name:" + logger2.getParent().getName());


        /*
            todo: 1因为logger2是父日志级别，通过修改它的日志输出级别，就可以控制logger1的日志输出级别
            todo: 2如果关闭logger2 父日志级别则logger1不再继承自logger2
         */
        // 关闭默认配置
        logger2.setUseParentHandlers(false);
        // 自定义配置日志级别
        // 1.将日志通过 创建ConsoleHandler 控制台输出
        ConsoleHandler consoleHandler = new ConsoleHandler();
        // 创建简单格式转换对象
        SimpleFormatter simpleFormatter = new SimpleFormatter();

        // 进行关联
        consoleHandler.setFormatter(simpleFormatter);
        logger2.addHandler(consoleHandler);

        logger1.severe("server");
        logger1.warning("warning");
        logger1.info("info"); // jul 默认的日志级别info
        logger1.config("config");
        logger1.fine("fine");
        logger1.finer("finer");
        logger1.finest("finest");
    }

4.4 日志的配置文件

 

// 加载自定义配置文件：从指定配置文件中加载日志输出级别
    @Test
    public void testLogProperties() throws Exception {
        // 读取配置文件，通过类加载器
        InputStream in = T01_JULTest.class.getClassLoader().getResourceAsStream("logging.properties");
        // 创建LogManager
        LogManager logManager = LogManager.getLogManager();
        // 通过LogManager 加载配置文件；相当于将JAVA_HOME/lib/logging.properties 进行了替换
        logManager.readConfiguration(in);

        // TODO: 因为加载的是自定义日志配置文件，日志输出级别为ALL；可以运行起来验证
        // 创建日志记录器
        Logger logger = Logger.getLogger("com.log");
        logger.severe("server");
        logger.warning("warning");
        logger.info("info"); // jul 默认的日志级别info
        logger.config("config");
        logger.fine("fine");
        logger.finer("finer");
        logger.finest("finest");

        // 自定义日志记录器
        Logger logger2 = Logger.getLogger("test");
        logger2.severe("server test");
        logger2.warning("warning test");
        logger2.info("info test"); // jul 默认的日志级别info
        logger2.config("config test");
        logger2.fine("fine test");
        logger2.finer("finer test");
        logger2.finest("finest test");
    }

4.5 日志原理解析

1. 初始化LogManager

1. LogManager 加载logging.properties 配置【可以是系统的，也可以是自定义配置文件】
2. 添加Logger 到LogManager

2. 从单例LogManager 获取Logger
3. 设置级别Level，并指定日志记录LogRecord
4. Filter 提供了日志级别之外更细粒度的控制
5. Handler 是用来处理日志输出位置
6. Formatter 是用来格式化LogRecord 的

JUL 流程示意图

---

五、LOG4J 进阶

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

官方网站：http://logging.apache.org/log4j/1.2/

5.1 Log4j 入门

需要导入maven 依赖：

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

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <!-- 设置编译版本为1.8 -->
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>

        </plugins>
    </build>

示例代码：

public class Log4jTest {

    // Log4j 基础
    @Test
    public void testQuick(){
        // 初始化配置信息，在入门案例中暂不使用配置文件
        BasicConfigurator.configure();
        // 获取日志记录器对象
        Logger logger = Logger.getLogger(Log4jTest.class);
        // 日志记录输出
        logger.info("hello log4j");

        // 日志级别有6种，默认的日志级别是DEBUG
        logger.fatal("fatal"); // 严重错误，一般会造成系统崩溃并终止运行
        logger.error("error"); // 错误信息，不会影响系统运行
        logger.warn("warn");   // 警告信息，可能会发生问题
        logger.info("info");   // 运行信息，数据连接、网络连接、IO 操作等等
        logger.debug("debug"); // 调试信息，一般在开发中使用，记录程序变量参数传递信息等等
        logger.trace("trace"); // 追踪信息，记录程序所有的流程信息
    }
}

运行示例截图：

 

---

5.2 Log4j 组件

Log4J 主要由 Loggers （日志记录器）、Appenders（输出端）和 Layout （日志格式化器）组成。其中 Loggers 控制日志的输出级别与日志是否输出：Appenders 指定日志的输出方式（输出到控制台、文件等）；Layout 控制日志信息的输出格式。

5.2.1 Loggers

日志记录器，负责收集处理日志记录，实例的命名就是类 "XX" 的 full quailied name （类的全限定名），Logger 的名字大小写敏感，其命名有继承机制：例如： name 为 org.apache.commons 的logger 会继承 name 为 org.apache 的 logger。

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

但是，自Log4J 1.2版本以来，Logger 类已经取代了 Category 类。对于熟悉早期版本的 log4j 的人来说，Logger 类可以被视为 Category 类的别名。

---

5.2.2 Appenders

Appender 用来指定日志输出到哪个地方，可以同时指定日志的输出目的地。Log4j 常用的输出目的有以下几种：

输出端类型	作用
ConsoleAppender	将日志输出到控制台
FileAppender	将日志输出到文件中
DailyRollingFileAppender	将日志输出一个日志文件中，并且每天输出到一个新的文件
RollingFileAppender	将日志信息输出到一个日志文件，并且指定文件的尺寸，当文件大小达到指定 尺寸时，会自动把文件改名，同时产生一个新的文件
JDBCAppender	把日志信息保存到数据库中

---

5.2.3 Layouts

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

格式化器类型	作用
HTMLLayout	格式化日志输出为HTML 表格形式
SimpleLayout	简单的日志输出格式化，打印的日志格式为（info - message）
PatternLayout	最强大的格式化器，可以根据自定义

代码示例：

public class Log4jTest {

    // Log4j 基础
    @Test
    public void testQuick(){
        // 初始化配置信息，在入门案例中暂不使用配置文件
        // BasicConfigurator.configure();
        // 获取日志记录器对象
        Logger logger = Logger.getLogger(Log4jTest.class);
        // 日志记录输出
        logger.info("hello log4j");

        // 日志级别有6种，默认的日志级别是DEBUG
        logger.fatal("fatal"); // 严重错误，一般会造成系统崩溃并终止运行
        logger.error("error"); // 错误信息，不会影响系统运行
        logger.warn("warn");   // 警告信息，可能会发生问题
        logger.info("info");   // 运行信息，数据连接、网络连接、IO 操作等等
        logger.debug("debug"); // 调试信息，一般在开发中使用，记录程序变量参数传递信息等等
        logger.trace("trace"); // 追踪信息，记录程序所有的流程信息
    }
}

log4j.properties 文件内容：

log4j.rootLogger = trace, console
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.layout = org.apache.log4j.SimpleLayout

---

5.3 Log4j 的内置日志记录

---

5.4 Layout 的格式

在 log4j.properties 配置文件中，我们定义了日志输出级别与输出端，在输出端中分别配置日志的输出格式。

* 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.properties 示例：

# 指定 RootLogger 顶级父元素默认配置信息
# 指定日志级别 = trace，使用的 appender 为 console，这个是由我们配置的
log4j.rootLogger = trace, console
# 指定控制台日志输出的 appender
log4j.appender.console = org.apache.log4j.ConsoleAppender
# 指定消息格式 layout
# log4j.appender.console.layout = org.apache.log4j.SimpleLayout
# log4j.appender.console.layout = org.apache.log4j.HTMLLayout
# log4j.appender.console.layout = org.apache.log4j.xml.XMLLayout
# 自定义日志输出格式使用是最多的，默认只会输出日志内容，没有产生的时间等信息
log4j.appender.console.layout = org.apache.log4j.PatternLayout
# 指定消息格式的内容
# log4j.appender.console.layout.conversionPattern = %r [%t] %p %c %x - %m%n
# log4j.appender.console.layout.conversionPattern = [%-10p]%r %c  %l  %d{yyyy-MM-dd HH:mm:ss.SSS}  %m%n
log4j.appender.console.layout.conversionPattern = [%-10p]%r %c  %l  %d{yyyy-MM-dd HH:mm:ss.SSS}  %m%n


# %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	输出代码中的行号
# %%	输出一个"%" 字符

---

5.5 Appender 的输出

控制台、文件、数据库

# 指定日志的输出级别与输出端

• 控制台

# 指定 RootLogger 顶级父元素默认配置信息
# 指定日志级别 = trace，使用的 appender 为 console，这个是由我们配置的
# log4j.rootLogger = trace, console, file, rollingFile, dailyFile
log4j.rootLogger = trace, console
# 指定控制台日志输出的 appender
log4j.appender.console = org.apache.log4j.ConsoleAppender
# 指定消息格式 layout
# log4j.appender.console.layout = org.apache.log4j.SimpleLayout
# log4j.appender.console.layout = org.apache.log4j.HTMLLayout
# log4j.appender.console.layout = org.apache.log4j.xml.XMLLayout
# 自定义日志输出格式使用是最多的，默认只会输出日志内容，没有产生的时间等信息
log4j.appender.console.layout = org.apache.log4j.PatternLayout
# 指定消息格式的内容
# log4j.appender.console.layout.conversionPattern = %r [%t] %p %c %x - %m%n
log4j.appender.console.layout.conversionPattern = [%-10p]%r %c  %l  %d{yyyy-MM-dd HH:mm:ss.SSS}  %m%n

• 文件，将日志输出到指定文件中

# 指定 RootLogger 顶级父元素默认配置信息
# 指定日志级别 = trace，使用的 appender 为 console，这个是由我们配置的
log4j.rootLogger = trace, file 

# 日志文件输出的 appender 对象
log4j.appender.file = org.apache.log4j.FileAppender
# 指定消息格式 layout
# log4j.appender.console.layout = org.apache.log4j.SimpleLayout
# log4j.appender.console.layout = org.apache.log4j.HTMLLayout
# log4j.appender.console.layout = org.apache.log4j.xml.XMLLayout
# 自定义日志输出格式使用是最多的，默认只会输出日志内容，没有产生的时间等信息
log4j.appender.file.layout = org.apache.log4j.PatternLayout
# 指定消息格式的内容
# log4j.appender.console.layout.conversionPattern = %r [%t] %p %c %x - %m%n
log4j.appender.file.layout.conversionPattern = [%-10p]%r %c  %l  %d{yyyy-MM-dd HH:mm:ss.SSS}  %m%n
# 指定日志文件保存路径
log4j.appender.file.file = log/log4j.log
# 指定日志文件的字符集
log4j.appender.file.encoding = UTF-8

• 文件，将日志按文件大小拆分输出到多个文件

# 指定 RootLogger 顶级父元素默认配置信息
# 指定日志级别 = trace，使用的 appender 为 console，这个是由我们配置的
log4j.rootLogger = trace, rollingFile 

# 按照文件大小折分的 appender 对象
# 日志文件输出的 appender 对象
log4j.appender.rollingFile = org.apache.log4j.RollingFileAppender
# 自定义日志输出格式使用是最多的，默认只会输出日志内容，没有产生的时间等信息
log4j.appender.rollingFile.layout = org.apache.log4j.PatternLayout
# 指定消息格式的内容
# log4j.appender.console.layout.conversionPattern = %r [%t] %p %c %x - %m%n
log4j.appender.rollingFile.layout.conversionPattern = [%-10p]%r %c  %l  %d{yyyy-MM-dd HH:mm:ss.SSS}  %m%n
# 指定日志文件保存路径
log4j.appender.rollingFile.file = log/log4j.log
# 指定日志文件的字符集
log4j.appender.rollingFile.encoding = UTF-8
# 指定日志文件内容的大小
log4j.appender.rollingFile.maxFileSize = 1MB
# 指定日志文件的数量，如果超过10，它按时间进行覆盖，比较久远的数据进行覆盖
log4j.appender.rollingFile.maxBackupIndex = 10

• 文件，将日志按时间拆分输出到多个文件中，生产环境一天一个文件

# 指定 RootLogger 顶级父元素默认配置信息
# 指定日志级别 = trace，使用的 appender 为 console，这个是由我们配置的
log4j.rootLogger = trace, dailyFile

# 按照时间规则拆分的 appender 对象
# 日志文件输出的 appender 对象
log4j.appender.dailyFile = org.apache.log4j.DailyRollingFileAppender
# 自定义日志输出格式使用是最多的，默认只会输出日志内容，没有产生的时间等信息
log4j.appender.dailyFile.layout = org.apache.log4j.PatternLayout
# 指定消息格式的内容
# log4j.appender.console.layout.conversionPattern = %r [%t] %p %c %x - %m%n
log4j.appender.dailyFile.layout.conversionPattern = [%-10p]%r %c  %l  %d{yyyy-MM-dd HH:mm:ss.SSS}  %m%n
# 指定日志文件保存路径
log4j.appender.dailyFile.file = log/log4j.log
# 指定日志文件的字符集
log4j.appender.dailyFile.encoding = UTF-8
# 指定日期拆分规则
log4j.appender.dailyFile.datePattern = '.'yyyy-MM-dd-HH-mm-ss

---

5.6 Log4j 的JDBCAppender 配置

先创建数据库、表

-- 创建java_log数据库。注意：库名与应用名称保持一致
CREATE DATABASE IF NOT EXISTS `java_log`;

-- 使用java_log
USE java_log;

-- 创建log 表
CREATE TABLE IF NOT EXISTS `log` (
  `id` BIGINT UNSIGNED AUTO_INCREMENT COMMENT '主键',
  `create_time` DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  
  `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 (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

-- INSERT INTO `log`(project_name, create_date, level, category, file_name, thread_name, line, all_category, message) values ('java_log', '%d{yyyy-MM-dd HH:mm:ss}', '%p', '%c', '%F', '%t', '%L', '%l', '%m')

配置log4j.properties 文件

# 指定 RootLogger 顶级父元素默认配置信息
# 指定日志级别 = trace，使用的 appender 为 console，这个是由我们配置的
# log4j.rootLogger = trace, console, file, rollingFile, dailyFile
log4j.rootLogger = trace, logDB


# 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/java_log
log4j.appender.logDB.User=root
log4j.appender.logDB.Password=1234
log4j.appender.logDB.Sql=INSERT INTO `log`(project_name, create_date, level, category, file_name, thread_name, line, all_category, message) values ('java_log', '%d{yyyy-MM-dd HH:mm:ss}', '%p', '%c', '%F', '%t', '%L', '%l', '%m')

添加maven 依赖

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

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.44</version>
        </dependency>

 编写示例代码、并运行它：

public class Log4jTest {

    // Log4j 基础
    @Test
    public void testQuick(){
        // 开启 log4j 内置日志记录，如果开启内置日志记录则日志输出会更多
        LogLog.setInternalDebugging(true);

        // 初始化配置信息，在入门案例中暂不使用配置文件
        // BasicConfigurator.configure();
        // 获取日志记录器对象
        Logger logger = Logger.getLogger(Log4jTest.class);
        // 日志记录输出
        logger.info("hello log4j");

        for (int i = 0; i < 10000; i++) {
            // 日志级别有6种，默认的日志级别是DEBUG
            logger.fatal("fatal"); // 严重错误，一般会造成系统崩溃并终止运行
            logger.error("error"); // 错误信息，不会影响系统运行
            logger.warn("warn");   // 警告信息，可能会发生问题
            logger.info("info");   // 运行信息，数据连接、网络连接、IO 操作等等
            logger.debug("debug"); // 调试信息，一般在开发中使用，记录程序变量参数传递信息等等
            logger.trace("trace"); // 追踪信息，记录程序所有的流程信息
        }
    }
}

运行结果：单元测试中的 testQuick() 方法会不断向 java_log 数据库中的 log 表添加数据。

---

5.7 Log4j 的自定义 logger

作用：好处就是开发人员可以根据不同的业务、模块灵活地输出日志；比如向文件输出我们自己编写的业务日志；向控制台只输出第三方插件的错误日志。

# 自定义 logger 对象设置 【PropertyConfigurator.class 源码位置】；其中com.log 是来自于我们业务所在的包名
# 好处就是不同的业务、模块灵活输出日志
log4j.logger.com.log = info,file
log4j.logger.org.apache = error

运行结果截图： 

---

六、JCL 入门

全称为Jakarta Commons Logging，是Apache 提供的一个通用日志API。就是我们的日志门面技术。

它是为 "所有的Java 日志实现" 提供一个统一的接口，它自身也提供一个日志的实现，但是功能非常常弱（SimpleLog）。所以一般不会单独使用它。他允许开发人员使用不同的具体日志实现工具：Log4j， Jdk 自带的日志（JUL）。

JCL 有两个基本的抽象类：Log（基本记录器）和 LogFactory（负责创建Log 实例）。默认实现 jdk14，就是jdk 自带的

---

6.1 JCL 入门

1. 建立maven 工程

2. 添加依赖

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

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

3、编写测试代码
 

public class JCLTest {

    @Test
    public void testQuick(){
        // 获取 log 日志记录器对象
        Log log = LogFactory.getLog(JCLTest.class);
        // 日志记录输出
        log.info("hello jcl");
    }
}

运行结果截图：

---

如果我在maven 依赖中添加log4j 依赖项，代码保持不变，继续看日志输出

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

        <!-- 如果我们导入log4j的依赖，再来看看日志输出，则不再走jdk14 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

添加log4j 日志输出截图如下： 

小结：通过上述实验，我们发现面向接口的日志实现业务代码保持不变，只是maven 依赖稍变更而已。更加稳定、高效。

---

我们为什么要使用日志门面：

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

---

6.2 JCL 原理

1、通过LogFactory 动态加载 Log 实现类

2、日志门面支持的日志实现数组

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"};

3、获取具体的日志实现

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

JCL 缺点：由于JCL 实现类已经写死，如果需要扩展的话就得修改JCL 源码，成本很大。这种技术被淘汰了，后来Apache 设计了更加高效的方式来实现日志门面技术

 

JUL 技术是JDK 自带的，不需要导入第三方依赖，但功能点单一。

第二，Log4j 也是相对老牌的日志处理，功能相对上述的话强大很多；但如果前期项目使用JUL 技术来开发的话，后期通过Log4j 来做很多API 不兼容，需要修改大量的代码。

然后，我们又继续研究的统一API 的日志门面技术 JCL，只需要调用统一的API 即可实现日志。但它也是有缺陷的，它当时只考虑了主流的日志实现框架（JCL、Log4j），随着技术的发展，后面出现了很多优秀的日志技术，但JCL 是不支持的，需要修改JCL 源代码进行扩展，一般在企业级开发中，我们不会这么做。所以已经JCL 这种技术已经被淘汰了。

---

接下来，重点介绍主流的日志技术：

1. 日志门面和日志体系
2. SLF4J
3. logback 的使用
4. log4j2 的使用
5. Spring Boot 中的日志使用

七、日志门面

当我们的系统变的更加复杂的时候，我们的日志就容易发生混乱。随着系统开发的进行，可能会更新不同的日志框架，造成当前系统中存在不同的日志依赖，让我们难以统一的管理和控制。就算我们强制要求所有的模块使用相同的日志框架，系统中也难以避免使用其他类似 spring, mybatis 等其他的第三方框架，它们依赖于我们规定不同的日志框架，而且他们自身的日志系统就有着不一致性，依然会出来日志体系的混乱。

所以我们需要借鉴JDBC 的思想，为日志系统也提供一套门面，那么我们就可以面向这些接口规范来开，避免了直接依赖具体的日志框架。这样我们的系统在日志中，就存在了日志的门面和日志的实现。

常见的日志门面：

• JCL(已经被淘汰了)、slf4j(目前主流)

常见的日志实现：

• JUL、log4j、logback、log4j2

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

日志框架出现的历史顺序：

目前主流使用日志是采用日志门面技术：slf4j + logback  或  slf4j + log4j2

---

八、SLF4J 的使用

8.1 SFL4J 入门

简单日志门面（Simple Logging Facade For Java） SLF4J 主要是为了给 Java 日志访问提供一个标准、规范的API框架，其主要意义在于提供接口，具体的实现可以交由其他日志框架，例如log4j 和 logback 等。当然 slf4j 自己也提供了功能较为简单的实现。但是一般很少用到。对于一般的 Java 项目而言，日志框架会选择 slf4j-api 作为门面，配上具体的实现框架（log4j、logback等），中间使用桥接器完成桥接。

官方网站：https://www.slf4j.org/

 

SLF4J 是目前 市面上最流行的日志门面。现在的项目中，基本上都是使用SLF4J 作为我们的日志系统。SLF4J 日志门面主要提供两大功能：

1. 日志框架的绑定
2. 日志框架的桥接

---

8.2 SFL4J 绑定日志的实现（Binding）

如前所述，SLF4J 支持各种日志框架。SLF4J 发行版本附带了几件称为"SLF4J绑定" 的jar 文件，每个绑定对应一个受支持的框架。

 

使用slf4j 的日志绑定流程：

1. 添加slf4j-api 的依赖
2. 使用slf4j 的API 在项目中进行统一的日志记录
3. 绑定具体的日志实现框架

1. 绑定已经实现了slf4j 的日志框架，直接添加对应依赖
2. 绑定没有实现 slf4j 的日志框架，先添加日志的适配器，再添加实现类的依赖

4. slf4j 有且仅有一个日志实现框架的绑定（如果出现多个默认使用第一个依赖日志实现）

 

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

首先，我们先通过 slf4j 官网查看日志框架组织形式，官网链接：http://www.slf4j.org/manual.html

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

SLF4J 不依赖于任何特殊的类状载。实际上，每个SLF4J 绑定在编译时都是硬连线的，以使用一个且只有一个特定的日志记录框架。例如，slf4j-log4j12-1.7.27.jar 绑定在编译时绑定以使用log4j。在您的代码中，除了sfl4j-api-1.7.27.jar 之外，您只需将您选择的一个且只有一个绑定放到相应的类路径位置。不要在类路劲上放置多个绑定。以下是一般概念的图解说明。

 

通过官网的slf4j 日志框架组织，可以看出有很多组织形式

1. slf4j日志门面接口 + slf4j-simple具体实现类
2. sfl4j日志门面接口 + logback-classic具体实现类
3. sfl4j日志门面接口 + slf4j-nop 具体实现类 
4. sfl4j日志门面接口 + slf4j-log4j12【log4j适配器】 + log4j【实现类】
5. sfl4j日志门面接口 + slf4j-log4j12【jdk14适配器】 + jdk14【实现类】

---

A、slf4j日志门面接口 + slf4j-simple具体实现类

1、添加依赖

<!-- slf4j 日志门面 它只是一个日志接口，还需要导入具体的日志实现 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>

        <!-- slf4j 内置的简单实现 -->
        <!-- 如果只有门面，没有实现的话是运行不起来的 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.21</version>
        </dependency>

        <!-- junit 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

2、编写代码，示例：

public class Slf4jTest {

    // 为了保证使用时，不需要每次都去创建logger 对象，我们声明静态常量
    public static final Logger LOGGER = LoggerFactory.getLogger(Slf4jTest.class);

    // 快速入门
    @Test
    public void testQuick(){
        // 日志输出
        LOGGER.error("error");
        LOGGER.warn("warning");
        LOGGER.info("info");    // 默认的日志级别信息
        LOGGER.debug("debug");
        LOGGER.trace("trace");  // 追踪信息

        // 使用占位符输出日志信息
        String name = "java_log";
        Integer age = 18;
        LOGGER.info("用户：{}，{}", name, age);

        // 将系统的异常信息输出
        try {
            int i = 1 / 0;
        } catch (Exception e){
            // e.printStackTrace();
            LOGGER.error("出现异常：", e);
        }
    }
}

3、运行结果截图：

---

B、sfl4j日志门面接口 + logback-classic具体实现类：

1）修改maven 依赖

<!-- slf4j 日志门面 它只是一个日志接口，还需要导入具体的日志实现 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>

        <!-- slf4j 内置的简单实现 -->
        <!-- 如果只有门面，没有实现的话是运行不起来的
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.21</version>
        </dependency>   -->

        <!-- 通过logback 日志实现 ; 如果slf4j-simple依赖也在的话，优先使用它，则需要将此依赖进行移除即可 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

        <!-- junit 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

2）代码示例

public class Slf4jTest {

    // 为了保证使用时，不需要每次都去创建logger 对象，我们声明静态常量
    public static final Logger LOGGER = LoggerFactory.getLogger(Slf4jTest.class);

    // 快速入门
    @Test
    public void testQuick(){
        // 日志输出
        LOGGER.error("error");
        LOGGER.warn("warning");
        LOGGER.info("info");    // 默认的日志级别信息
        LOGGER.debug("debug");
        LOGGER.trace("trace");  // 追踪信息

        // 使用占位符输出日志信息
        String name = "java_log";
        Integer age = 18;
        LOGGER.info("用户：{}，{}", name, age);

        // 将系统的异常信息输出
        try {
            int i = 1 / 0;
        } catch (Exception e){
            // e.printStackTrace();
            LOGGER.error("出现异常：", e);
        }
    }
}

3）运行结果截图：

---

C、sfl4j日志门面接口 + slf4j-nop 具体实现类：

1) 修改依赖

<!-- slf4j 日志门面 它只是一个日志接口，还需要导入具体的日志实现 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>

        <!-- slf4j 内置的简单实现 -->
        <!-- 如果只有门面，没有实现的话是运行不起来的
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.21</version>
        </dependency>   -->

        <!-- 通过logback 日志实现 ; 如果slf4j-simple依赖也在的话，优先使用它，则需要将此依赖进行移除即可
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>  -->

        <!-- nop 日志开关 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-nop</artifactId>
            <version>1.7.25</version>
        </dependency>

        <!-- junit 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

2）编写代码

public class Slf4jTest {

    // 为了保证使用时，不需要每次都去创建logger 对象，我们声明静态常量
    public static final Logger LOGGER = LoggerFactory.getLogger(Slf4jTest.class);

    // 快速入门
    @Test
    public void testQuick(){
        // 日志输出
        LOGGER.error("error");
        LOGGER.warn("warning");
        LOGGER.info("info");    // 默认的日志级别信息
        LOGGER.debug("debug");
        LOGGER.trace("trace");  // 追踪信息

        // 使用占位符输出日志信息
        String name = "java_log";
        Integer age = 18;
        LOGGER.info("用户：{}，{}", name, age);

        // 将系统的异常信息输出
        try {
            int i = 1 / 0;
        } catch (Exception e){
            // e.printStackTrace();
            LOGGER.error("出现异常：", e);
        }
    }
}

3）运行结果

---

D、sfl4j日志门面接口 + slf4j-log4j12【log4j适配器】 + log4j【实现类】

1）修改maven 依赖

<!-- slf4j 日志门面 它只是一个日志接口，还需要导入具体的日志实现 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>

        <!-- 绑定 log4j 日志实现，需要导入适配器 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.12</version>
        </dependency>
        <!-- 导入适配器后，再导入具体的实现类 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <!-- junit 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

2）编写log4j.properties 日志配置文件

# 指定 RootLogger 顶级父元素默认配置信息
# 指定日志级别 = trace，使用的 appender 为 console，这个是由我们配置的
# log4j.rootLogger = trace, console, file, rollingFile, dailyFile
log4j.rootLogger = trace, console

# 指定控制台日志输出的 appender
log4j.appender.console = org.apache.log4j.ConsoleAppender
# 指定消息格式 layout
# log4j.appender.console.layout = org.apache.log4j.SimpleLayout
# log4j.appender.console.layout = org.apache.log4j.HTMLLayout
# log4j.appender.console.layout = org.apache.log4j.xml.XMLLayout
# 自定义日志输出格式使用是最多的，默认只会输出日志内容，没有产生的时间等信息
log4j.appender.console.layout = org.apache.log4j.PatternLayout
# 指定消息格式的内容
# log4j.appender.console.layout.conversionPattern = %r [%t] %p %c %x - %m%n
log4j.appender.console.layout.conversionPattern = [%-10p]%r %c  %l  %d{yyyy-MM-dd HH:mm:ss.SSS}  %m%n

3）编写代码

public class Slf4jTest {

    // 为了保证使用时，不需要每次都去创建logger 对象，我们声明静态常量
    public static final Logger LOGGER = LoggerFactory.getLogger(Slf4jTest.class);

    // 快速入门
    @Test
    public void testQuick(){
        // 日志输出
        LOGGER.error("error");
        LOGGER.warn("warning");
        LOGGER.info("info");    // 默认的日志级别信息
        LOGGER.debug("debug");
        LOGGER.trace("trace");  // 追踪信息

        // 使用占位符输出日志信息
        String name = "java_log";
        Integer age = 18;
        LOGGER.info("用户：{}，{}", name, age);

        // 将系统的异常信息输出
        try {
            int i = 1 / 0;
        } catch (Exception e){
            // e.printStackTrace();
            LOGGER.error("出现异常：", e);
        }
    }
}

4）运行结果截图

---

E、sfl4j日志门面接口 + slf4j-log4j12【jdk14适配器】 + jdk14【实现类】

1) 修改maven 依赖

<!-- slf4j 日志门面 它只是一个日志接口，还需要导入具体的日志实现 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>

        <!-- 绑定 JUL 日志实现，需要导入适配器 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-jdk14</artifactId>
            <version>1.7.25</version>
        </dependency>

        <!-- junit 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

2）编写业务代码

public class Slf4jTest {

    // 为了保证使用时，不需要每次都去创建logger 对象，我们声明静态常量
    public static final Logger LOGGER = LoggerFactory.getLogger(Slf4jTest.class);

    // 快速入门
    @Test
    public void testQuick(){
        // 日志输出
        LOGGER.error("error");
        LOGGER.warn("warning");
        LOGGER.info("info");    // 默认的日志级别信息
        LOGGER.debug("debug");
        LOGGER.trace("trace");  // 追踪信息

        // 使用占位符输出日志信息
        String name = "java_log";
        Integer age = 18;
        LOGGER.info("用户：{}，{}", name, age);

        // 将系统的异常信息输出
        try {
            int i = 1 / 0;
        } catch (Exception e){
            // e.printStackTrace();
            LOGGER.error("出现异常：", e);
        }
    }
}

3）运行结果截图

---

8.3 桥接旧的日志框架（Bridging）

通常，您依赖的某些依赖于SLF4J 以外的日志记录API。您也可以假设这些组件在不久的将来不会切换到SLF4J。为了解决这种情况，SLF4J附带了几个桥接模块，这些模块将对log4j，JCL 和 java.util.logging API 的调用重定向，就好像它们是对SLF4J API 一样。

桥接解决的是项目中日志的遗留问题，当系统中存在之前的日志API，可以通过桥接转换到slf4j 的实现

1. 先去除之前老的日志框架的依赖
2. 添加SLF4J 提供的桥接组件
3. 为项目添加SLF4J 的具体实现

下面演示的是日志老系统

1）maven 依赖

<!-- 导入适配器后，再导入具体的实现类 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <!-- junit 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

2）编写代码

public class Log4jTest {
    // 定义 log4j 日志记录器
    public static final Logger LOGGER = Logger.getLogger(Log4jTest.class);
    
    // 测试桥接器
    @Test
    public void test01(){
        LOGGER.info("hello log4j");
    }
}

3）运行结果截图

---

需求：由于老的日志系统无法满足功能需求，需要从log4j 日志升级到 logback。则需要通过以下操作完成

1）修改maven 依赖

<!-- slf4j 日志门面 它只是一个日志接口，还需要导入具体的日志实现 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>
        <!-- 通过logback 日志实现 ; 如果slf4j-simple依赖也在的话，优先使用它，则需要将此依赖进行移除即可  -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        <!-- 导入适配器后，再导入具体的实现类
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>  -->
        <!-- junit 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

2）我们发现之前使用log4j 的代码报错了，如下图所示：

3）修改源码可以解决报错问题，工作量太大；另外一个slf4j 可以导入桥接器依赖解决此问题。来看slf4j 官网：http://slf4j.org/images/legacy.png

通过上图，我们可以添加log4j 日志框架适配器，以适应slf4j 日志系统

<!-- 配置log4j 的桥接器 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>log4j-over-slf4j</artifactId>
            <version>1.7.25</version>
        </dependency>

添加log4j-over-slf4j 依赖后，我们发现代码不报错了。并运行发现日志输出与log4j 不一样了

注意问题：

1. jcl-over-slf4j.jar 和 slf4j-jcl.jar 不能同时部署。前一个jar 文件将导致JCL 将日志系统的选择委托给SLF4J，后一个jar 文件将导致SLF4J 将日志系统的选择委托给JCL，从而导致无限循环。报：java.lang.StackOverflowError
2. log4j-over-slf4j.jar 和 slf4j-log4j12.jar 不能同时出现
3. jul-to-slf4j.jar 和 slf4j-jdk14.jar 不能同时出现
4. 所有的桥接都只对Logger 日志记录器对象有效，如果程序中调用了内部的配置类或者是Appender、Filter 等对象，将无法产生效果。

---

8.4 SLF4J 原理解析

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

---

九、Logback 的使用

Logback 是由log4j 创始人设计的另一个开源日志组件，性能比log4j 要好。官方网站：https://logback.qos.ch/index.html

Logback 主要分为三个模块：

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

后续的日志代码都是通过SLF4J 日志门面搭建日志系统，所以在代码是没有区别，主要是通过修改配置文件和pom.xml 依赖。

---

9.1 logback 入门

1）添加依赖

<!-- slf4j 日志门面 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>

        <!-- logback 日志实现 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

        <!-- junit 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

2）编写代码

public class LogbackTest {
    public static final Logger LOGGER = LoggerFactory.getLogger(LogbackTest.class);

    // 快速入门
    @Test
    public void testQuick() throws Exception {
        // 日志输出
        LOGGER.error("error");
        LOGGER.warn("warning");
        LOGGER.info("info");
        LOGGER.debug("debug");  // 默认的日志级别信息
        LOGGER.trace("trace");  // 追踪信息
    }
}

3）运行结果截图

---

9.2 logback 配置

logback 会依次读取以下类型配置文件：

• logback.groovy
• logback-test.xml  测试环境下的配置文件
• logback.xml 如果均不存在会采用默认配置

1、logback 组件之间的关系

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

2、基本配置信息

A maven 依赖

<!-- slf4j 日志门面 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>

        <!-- logback 日志实现 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

        <!-- junit 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

B logback.xml 配置文件

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <!--
        配置集中管理属性
        我们可以直接改属性的 value 值
        格式：${name}
    -->
    <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %L [%thread] %m%n"></property>
    <!--
    日志输出格式：
        %-5level
        %d{yyyy-MM-dd HH:mm:ss.SSS}日期
        %c类的完整信息
        %M为method
        %L为行号
        %thread线程名称
        %m或者%msg 为信息
        %n换行
    -->

    <!-- 控制台日志输出的 appender -->
    <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>

    <!-- root logger 配置 -->
    <root level="ALL">
        <appender-ref ref="console"></appender-ref>
    </root>
</configuration>

C 编写代码

public class LogbackTest {
    public static final Logger LOGGER = LoggerFactory.getLogger(LogbackTest.class);

    // 快速入门
    @Test
    public void testQuick() throws Exception {
        // 日志输出
        LOGGER.error("error");
        LOGGER.warn("warning");
        LOGGER.info("info");
        LOGGER.debug("debug");  // 默认的日志级别信息
        LOGGER.trace("trace");  // 追踪信息
    }
}

D 运行结果截图

---

上述是通过logback 将日志输出到控制台，实际生产环境，我们更希望将日志写入到日志文件中去。接下来，我们一起操作一下。

1）编写依赖

<!-- slf4j 日志门面 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>

        <!-- logback 日志实现 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

        <!-- junit 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

2）logback.xml 配置可向控制台、文件、html文件输出

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <!--
        配置集中管理属性
        我们可以直接改属性的 value 值
        格式：${name}
    -->
    <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %L [%thread] %m%n"></property>
    <!--
    日志输出格式：
        %-5level
        %d{yyyy-MM-dd HH:mm:ss.SSS}日期
        %c类的完整信息
        %M为method
        %L为行号
        %thread线程名称
        %m或者%msg 为信息
        %n换行
    -->

    <!-- 定义日志文件保存路径属性 -->
    <property name="log_dir" value="logs"></property>

    <!-- 控制台日志输出的 appender -->
    <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>

    <!-- 日志文件输出的 appender -->
    <appender name="file" class="ch.qos.logback.core.FileAppender">
        <!-- 日志文件保存路径 -->
        <file>${log_dir}/logback.log</file>
        <!-- 日志消息格式配置，默认格式 -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <!-- html 格式日志文件输出 appender 【查阅较为方便】 -->
    <appender name="htmlFile" class="ch.qos.logback.core.FileAppender">
        <!-- 日志文件保存路径 -->
        <file>${log_dir}/logback.html</file>
        <!-- html 消息格式配置 -->
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="ch.qos.logback.classic.html.HTMLLayout">
                <!--<pattern>${pattern}</pattern>-->
                <pattern>%-5level%d{yyyy-MM-dd HH:mm:ss.SSS}%c%M%L%thread%m</pattern>
            </layout>
        </encoder>
    </appender>

    <!-- root logger 配置 -->
    <root level="ALL">
        <appender-ref ref="console"/> <!-- 控制台输出 -->
        <appender-ref ref="file"/>    <!-- 文件输出 -->
        <appender-ref ref="htmlFile"/>    <!-- 文件输出 -->
    </root>
</configuration>

3）编写代码

public class LogbackTest {
    public static final Logger LOGGER = LoggerFactory.getLogger(LogbackTest.class);

    // 快速入门
    @Test
    public void testQuick() throws Exception {
        // 日志输出
        LOGGER.error("error");
        LOGGER.warn("warning");
        LOGGER.info("info");
        LOGGER.debug("debug");  // 默认的日志级别信息
        LOGGER.trace("trace");  // 追踪信息
    }
}

4）运行结果截图

文件logback.log 日志数据

文件logback.html 日志数据，使用浏览器打开截图

---

但我们在实际生产环境上，需要按时间、文件大小进行拆分。需要怎么做呢？请继续往下看

1）编写maven 依赖

<!-- slf4j 日志门面 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>

        <!-- logback 日志实现 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

        <!-- junit 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

2）配置按文件大小、时间输出的日志策略

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <!--
        配置集中管理属性
        我们可以直接改属性的 value 值
        格式：${name}
    -->
    <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %L [%thread] %m%n"></property>
    <!--
    日志输出格式：
        %-5level
        %d{yyyy-MM-dd HH:mm:ss.SSS}日期
        %c类的完整信息
        %M为method
        %L为行号
        %thread线程名称
        %m或者%msg 为信息
        %n换行
    -->

    <!-- 定义日志文件保存路径属性 -->
    <property name="log_dir" value="logs"></property>

    <!-- 控制台日志输出的 appender -->
    <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>

    <!-- 日志文件输出的 appender -->
    <appender name="file" class="ch.qos.logback.core.FileAppender">
        <!-- 日志文件保存路径 -->
        <file>${log_dir}/logback.log</file>
        <!-- 日志消息格式配置，默认格式 -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <!-- html 格式日志文件输出 appender 【查阅较为方便】 -->
    <appender name="htmlFile" class="ch.qos.logback.core.FileAppender">
        <!-- 日志文件保存路径 -->
        <file>${log_dir}/logback.html</file>
        <!-- html 消息格式配置 -->
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="ch.qos.logback.classic.html.HTMLLayout">
                <!--<pattern>${pattern}</pattern>-->
                <pattern>%-5level%d{yyyy-MM-dd HH:mm:ss.SSS}%c%M%L%thread%m</pattern>
            </layout>
        </encoder>
    </appender>

    <!-- 日志拆分和归档压缩的 appender 对象 -->
    <appender name="rollFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 日志文件保存路径 -->
        <file>${log_dir}/roll_logback.log</file>
        <!-- 日志消息格式配置 -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
        <!-- 指定拆分规则 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!-- 按照时间和压缩格式声明拆分的文件名 -->
            <fileNamePattern>${log_dir}/rolling.%d{yyyy-MM-dd-HH-mm-ss}.log%i.log</fileNamePattern>
            <!-- 按照文件大小拆分 -->
            <maxFileSize>1MB</maxFileSize>
        </rollingPolicy>
    </appender>

    <!-- root logger 配置 -->
    <root level="ALL">
        <appender-ref ref="console"/> <!-- 控制台输出 -->
        <appender-ref ref="file"/>    <!-- 文件输出 -->
        <appender-ref ref="htmlFile"/>    <!-- html文件输出 -->
        <appender-ref ref="rollFile"/>    <!-- 拆分文件输出 -->
    </root>
</configuration>

3）编写代码

public class LogbackTest {
    public static final Logger LOGGER = LoggerFactory.getLogger(LogbackTest.class);

    // 快速入门
    @Test
    public void testQuick() throws Exception {
        for (int i = 0; i < 10000; i++) {
            // 日志输出
            LOGGER.error("error");
            LOGGER.warn("warning");
            LOGGER.info("info");
            LOGGER.debug("debug");  // 默认的日志级别信息
            LOGGER.trace("trace");  // 追踪信息
        }
    }
}

4）运行结果截图

---

有些时候，我们需要设置一下日志的过滤级别。比如，只输出ERROR 级别的日志

<!-- 日志拆分和归档压缩的 appender 对象 -->
    <appender name="rollFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 日志文件保存路径 -->
        <file>${log_dir}/roll_logback.log</file>
        <!-- 日志消息格式配置 -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
        <!-- 指定拆分规则 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!-- 按照时间和压缩格式声明拆分的文件名 -->
            <fileNamePattern>${log_dir}/rolling.%d{yyyy-MM-dd-HH-mm-ss}.log%i.log</fileNamePattern>
            <!-- 按照文件大小拆分 -->
            <maxFileSize>1MB</maxFileSize>
        </rollingPolicy>
        <!-- 日志级别过滤器 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 日志过滤规则 -->
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

---

为了提升日志输出性能，往往需要异步日志输出

<!-- 异步日志 -->
    <appender name="async" class="ch.qos.logback.classic.AsyncAppender">
        <!-- 指定某个具体的 appender -->
        <appender-ref ref="rollFile"/>
    </appender>

全部配置

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <!--
        配置集中管理属性
        我们可以直接改属性的 value 值
        格式：${name}
    -->
    <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %L [%thread] %m%n"></property>
    <!--
    日志输出格式：
        %-5level
        %d{yyyy-MM-dd HH:mm:ss.SSS}日期
        %c类的完整信息
        %M为method
        %L为行号
        %thread线程名称
        %m或者%msg 为信息
        %n换行
    -->

    <!-- 定义日志文件保存路径属性 -->
    <property name="log_dir" value="logs"></property>

    <!-- 控制台日志输出的 appender -->
    <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>

    <!-- 日志文件输出的 appender -->
    <appender name="file" class="ch.qos.logback.core.FileAppender">
        <!-- 日志文件保存路径 -->
        <file>${log_dir}/logback.log</file>
        <!-- 日志消息格式配置，默认格式 -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <!-- html 格式日志文件输出 appender 【查阅较为方便】 -->
    <appender name="htmlFile" class="ch.qos.logback.core.FileAppender">
        <!-- 日志文件保存路径 -->
        <file>${log_dir}/logback.html</file>
        <!-- html 消息格式配置 -->
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="ch.qos.logback.classic.html.HTMLLayout">
                <!--<pattern>${pattern}</pattern>-->
                <pattern>%-5level%d{yyyy-MM-dd HH:mm:ss.SSS}%c%M%L%thread%m</pattern>
            </layout>
        </encoder>
    </appender>

    <!-- 日志拆分和归档压缩的 appender 对象 -->
    <appender name="rollFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 日志文件保存路径 -->
        <file>${log_dir}/roll_logback.log</file>
        <!-- 日志消息格式配置 -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
        <!-- 指定拆分规则 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!-- 按照时间和压缩格式声明拆分的文件名 -->
            <fileNamePattern>${log_dir}/rolling.%d{yyyy-MM-dd-HH-mm-ss}.log%i.log</fileNamePattern>
            <!-- 按照文件大小拆分 -->
            <maxFileSize>1MB</maxFileSize>
        </rollingPolicy>
        <!-- 日志级别过滤器 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 日志过滤规则 -->
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 异步日志 -->
    <appender name="async" class="ch.qos.logback.classic.AsyncAppender">
        <!-- 指定某个具体的 appender -->
        <appender-ref ref="rollFile"/>
    </appender>

    <!-- root logger 配置 -->
    <root level="ALL">
        <appender-ref ref="console"/> <!-- 控制台输出 -->
        <appender-ref ref="file"/>    <!-- 文件输出 -->
        <appender-ref ref="htmlFile"/>    <!-- html文件输出 -->
        <!--<appender-ref ref="rollFile"/>  -->  <!-- 拆分文件输出 -->
        <appender-ref ref="async"/>
    </root>
</configuration>

---

logback 可将log4j 配置转成logback.xml，官网链接：http://logback.qos.ch/index.html

---

9.3 logback-access 的使用

logback-access 模块与Servlet 容器（如Tomcat 和 Jetty）集成，以提供HTTP 访问日志功能。我们可以使用logback-access 模块来替换tomcat 的访问日志。

1、将logback-access.jar 与 logback-core.jar 复制到 $TOMCAT_HOME/lib/目录下；这两个jar 可通过maven 依赖下载下来

可通过我上传的jar 文件下载，免费的。下载链接：logback-core 和logback-access 1.2.3.zip

<!-- logback 日志实现 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/ch.qos.logback/logback-access -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-access</artifactId>
            <version>1.2.3</version>
        </dependency>

2、修改$TOMCAT_HOME/conf/server.xml 中的Host 元素中添加：

<Value className="ch.qos.logback.access.tomcat.LogbackValue" />

3、logback 默认会在$TOMCAT_HOME/conf 下查找件 logback-access.xml 配置文件，我们在conf 目录下创建logback-access.xml 文件，添加如下内容：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- always a good activate OnConsoleStatusListener -->
    <statusListtener class="ch.qos.logback.core.status.OnConsoleStatusListener"/>

    <!-- 日志保存路径 -->
    <property name="LOG_DIR" value="${catalina.base}/logs"/>

    <!-- 日志拆分和归档压缩的 appender 对象 -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 日志文件保存路径 -->
        <file>${LOG_DIR}/access.log</file>

        <!-- 指定拆分规则：以天为单位的拆分规则，将其进行压缩 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>access.%d{yyyy-MM-dd}.log.zip</fileNamePattern>
        </rollingPolicy>

        <encoder>
            <!-- 日志消息格式表达式 -->
            <pattern>%h %l %u [%t] "%r" %s %b "%i{Referer}" "%i{User-Agent}"</pattern>
            <!--<pattern>combined</pattern>-->
        </encoder>
    </appender>

    <appender-ref ref="FILE"/>
</configuration>

4、官方配置：https://logback.qos.ch/access.html#configuration

修改好配置后，需要重新启动tomcat；再次打开tomcat界面并点击某些按钮，查看在logs目录下是否有：日志生成access.log 文件

---

log4j2 的使用

Apache Log4j2 是对Log4j 的升级版本，参考了logback 的一些优秀的设计，并且修复了一些问题，因此带来了一些重大的提升，主要有：

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

官网：https://logging.apache.org/log4j/2.x/

---

一. Log4j2 入门

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

1.添加依赖

<dependencies>
        <!-- log4j2 日志门面 -->
        <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>
        <!-- junit 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

2.编写代码

package com.log;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.Test;

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");
    }
}

3.运行结果截图

上述报错是因为没有找到日志配置文件，需要添加 log4j2.xml 配置文件到 resource 目录下【classpath】下。log4j2 默认加载classpath 下的 log4j2.xml 文件中的配置

<?xml version="1.0" encoding="UTF-8" ?>
<configuration status="warn" monitorInterval="5">
    <properties>
        <property name="LOG_HOME">E:/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="E:/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" />
                <TimeBasedTriggeringPolicy />
            </Policies>
            <DefaultRolloverStrategy max="30" />
        </RollingFile>

    </Appenders>

    <Loggers>
        <Root level="trace">
            <AppenderRef ref="Console" />
        </Root>
    </Loggers>
</configuration>

---

实际生产中，我们往往需要 slf4j + log4j2 进行日志管理；就需要导入slf4j 日志门面、log4j2 适配器；然后使用 slf4j 方法接口名称来输出日志

<dependencies>
        <!-- 使用slf4j 作为日志门面 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>
        <!-- 使用 log4j2 的适配器进行绑定 -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.9.1</version>
        </dependency>

        <!-- log4j2 日志门面 -->
        <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>
        <!-- junit 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

 编写 slf4j + log4j2 代码

package com.log;

import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Slf4jTest {

    // 为了保证使用时，不需要每次都去创建logger 对象，我们声明静态常量
    public static final Logger LOGGER = LoggerFactory.getLogger(Slf4jTest.class);

    // 快速入门
    @Test
    public void testQuick(){
        // 日志输出
        LOGGER.error("error");
        LOGGER.warn("warning");
        LOGGER.info("info");    // 默认的日志级别信息
        LOGGER.debug("debug");
        LOGGER.trace("trace");  // 追踪信息

        // 使用占位符输出日志信息
        String name = "java_log";
        Integer age = 18;
        LOGGER.info("用户：{}，{}", name, age);

        // 将系统的异常信息输出
        try {
            int i = 1 / 0;
        } catch (Exception e){
            // e.printStackTrace();
            LOGGER.error("出现异常：", e);
        }
    }
}

log4j2    vs   slf4j + log4j2 日志输出对比：

---

二、Log4j2 配置

log4j2 默认加载classpath 下的 log4j2.xml 文件中的配置。下面通过log4j2.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">D:/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>

编写代码：

package com.log;

import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Slf4jTest {

    // 为了保证使用时，不需要每次都去创建logger 对象，我们声明静态常量
    public static final Logger LOGGER = LoggerFactory.getLogger(Slf4jTest.class);

    // 快速入门
    @Test
    public void testQuick(){
        // 日志输出
        for (int i = 0; i < 1000000; i++) {
            LOGGER.error("error");
            LOGGER.warn("warning");
            LOGGER.info("info");    // 默认的日志级别信息
            LOGGER.debug("debug");
            LOGGER.trace("trace");  // 追踪信息
        }


        // 使用占位符输出日志信息
        /*String name = "java_log";
        Integer age = 18;
        LOGGER.info("用户：{}，{}", name, age);

        // 将系统的异常信息输出
        try {
            int i = 1 / 0;
        } catch (Exception e){
            // e.printStackTrace();
            LOGGER.error("出现异常：", e);
        }*/
    }
}

运行结果截图：

 

---

三、Log4j2 异步日志

异步日志

log4j2 最大的特点就是异步日志，其性能的提升主要也是从异步日志中受益，我们来看看如何使用log4j2 的异步日志。

• 同步日志

• 异步日志

Log4j2 提供了两种实现日志的方式，一个是通过AsyncAppender【几乎没人用】，一个是通过AsyncLogger【主要是这个】，分别对应前面我们说的Appender 组件和Logger 组件。

官网详细介绍：http://logging.apache.org/log4j/2.x/performance.html

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

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

1、AsyncAppender 方式【生产上几乎不使用，因为性能低下】

<?xml version="1.0" encoding="UTF-8" ?>
<!--
    status="warn" 日志框架本身的输出日志级别，可以修改为debug
    monitorInterval="5" 自动加载配置文件的间隔时间，不低于 5秒；生产环境中修改配置文件，是热更新，无需重启应用
 -->
<configuration status="warn" monitorInterval="5">
    <!--
    集中配置属性进行管理
    使用时通过:${name}
    -->
    <properties>
        <property name="LOG_HOME">D:/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" />-->
            <PatternLayout pattern="%d %p %c{1.} [%t] %m%n" />
        </File>

        <Async name="Async">
            <AppenderRef ref="file" />
        </Async>
    </Appenders>

    <!-- logger 定义 -->
    <Loggers>
        <!-- 使用 rootLogger 配置 日志级别 level="trace" -->
        <Root level="trace">
            <!-- 指定日志使用的处理器 -->
            <AppenderRef ref="Console" />
            <!-- 使用异步 appender -->
            <AppenderRef ref="Async" />
        </Root>
    </Loggers>
</configuration>

2、编写代码

package com.log;

import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Slf4jTest {

    // 为了保证使用时，不需要每次都去创建logger 对象，我们声明静态常量
    public static final Logger LOGGER = LoggerFactory.getLogger(Slf4jTest.class);

    // 快速入门
    @Test
    public void testQuick(){
        // 日志输出
        LOGGER.error("error");
        LOGGER.warn("warning");
        LOGGER.info("info");    // 默认的日志级别信息
        LOGGER.debug("debug");
        LOGGER.trace("trace");  // 追踪信息
    }
}

3、运行结果截图，下面就是异步日志输出

---

2、AsyncLogger 方式【生产上用得多，因为性能高】

AsyncLogger 才是log4j2 的重头戏，也是官方推荐的异步方式。它可以调用Logger.log 返回的更快。你可以有两种选择：全局异步和混合异步。

• 全局异步就是，所有日志都异步的记录，在配置文件上不用做任何改动，只需要添加一个 log4j2.component.properties 配置到 resources；

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

则此时，向控制台、文件都是异步方式日志输出

---

• 混合异步就是，你可以在应用中同时使用同步日志和异步日志，这使得日志的配置方式更加灵活，按如下配置主要是添加截图部分即可：

<?xml version="1.0" encoding="UTF-8" ?>
<!--
    status="warn" 日志框架本身的输出日志级别，可以修改为debug
    monitorInterval="5" 自动加载配置文件的间隔时间，不低于 5秒；生产环境中修改配置文件，是热更新，无需重启应用
 -->
<configuration status="debug" monitorInterval="5">
    <!--
    集中配置属性进行管理
    使用时通过:${name}
    -->
    <properties>
        <property name="LOG_HOME">D:/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" />-->
            <PatternLayout pattern="%d %p %c{1.} [%t] %m%n" />
        </File>

        <Async name="Async">
            <AppenderRef ref="file" />
        </Async>
    </Appenders>

    <!-- logger 定义 -->
    <Loggers>
        <!-- 自定义 logger 对象
            includeLocation="false" 关闭日志记录的行号信息，开启的话会严重影响异步输出的性能
            additivity="false" 不再继承 rootlogger对象
         -->
        <AsyncLogger name="com.log" level="trace" includeLocation="false" additivity="false">
            <AppenderRef ref="Console" />
        </AsyncLogger>
        <!-- 使用 rootLogger 配置 日志级别 level="trace" -->
        <Root level="trace">
            <!-- 指定日志使用的处理器 -->
            <AppenderRef ref="Console" />
            <!-- 使用异步 appender -->
            <AppenderRef ref="Async" />
        </Root>
    </Loggers>
</configuration>

同时，AsyncLogger 混合异动日志输出需要将log4j2.component.properties 内容进行注释【因为这个是配置AsyncLogger全局异步日志输出】

如下配置：com.log 日志是异步的， root 日志是同步的。

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

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

---

四、Log4j2 的性能

Log4j2 最牛的地方在于异步输出日志时的性能表现，Log4j2 在多线程的环境下吞吐量与 Log4j 和 Logback 的比较如下图。下图比较中 Log4j2 有三种模式：

1. 全局使用异步模式；
2. 部分Logger采用异步模式；
3. 异步Appenderf。

可以看出在前两种模式下，Log4j2 的性能较之 Log4j 和Logback有很大的优势。

无垃圾记录

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

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

从版本2.6 开始，默认情况下 Log4j 以“无垃圾” 模式运行，其中重用对象和缓冲区，并且尽可能不分配临时对象。还有一个“低垃圾”模式，它不是完全无垃圾，但不使用ThreadLocal 字段。

Log4j 2.6 中的无垃圾日志记录部分通过重用ThreadLocal 字段中的对象来实现，部分通过在将文件转换为字节时重用缓冲区来实现。

使用Log4j 2.5：内存分配速度809 MB / 秒，141个无效集合。

Log4j 2.6没有分配临时对象：0（零）垃圾回收。

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

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

真诚的建议：如果您的应用程序是多线程的并且日志记录性能很重要，请考虑使用异步记录器。

---