Java 日志框架学习笔记-百木园

日志概念

1. 日志文件

日志文件是用于记录系统操作事件的文件集合

1.1 调试日志

1.2 系统日志

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

日志门面

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

常见的日志门面：JCL、Slf4j

常见的日志实现：JUL、log4j、logback、log4j2

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

使用日志门面的优势：

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

JUL

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

1. 架构

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，将输出内容进行排版

2. 入门案例

public class JULTest {
    
    @Test
    public void testQuick() throws Exception {
        // 1.创建日志记录器对象
        Logger logger = Logger.getLogger(\"com.itheima.log.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});
    }
}

3. 日志级别

JUL 中定义的日志级别：SEVERE（最高值）、WARNING、INFO（默认级别）、CONFIG、FINE、FINER、FINEST（最低值）

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

@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(\"cofnig\");
    logger.fine(\"fine\");
    logger.finer(\"finer\");
    logger.finest(\"finest\");
}

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

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

4. logger 之间的父子关系

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

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

5. 日志的配置文件

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

@Test
public void testProperties() throws Exception {
    // 读取自定义配置文件
    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\");
}

配置文件：

## 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

6. 日志原理解析

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

Log4J

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

1. 入门案例

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

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\"); // 追踪信息，记录程序的所有流程信息
    }
}

2. 日志级别

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

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

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

3. Log4j 组件

3.1 Loggers

日志记录器，负责收集处理日志记录，实例的命名就是类的全限定名

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

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

3.2 Appenders

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

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

3.3 Layouts

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

HTMLLayout：格式化日志输出为 HTML 表格形式
SimpleLayout：简单的日志输出格式化，打印的日志格式为（info - message）
PatternLayout：最强大的格式化期，可以根据自定义格式输出日志，如果没有指定转换格式，就使用默认的转换格式

4. 配置文件详解

#指定日志的输出级别与输出端
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

# 文件输出配置
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\')

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 实例）

1. 入门案例

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

public class JULTest {
    
    @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\");
    }
}

2. JCL 原理

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

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

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

1. 入门案例

<!--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>

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

2. 绑定日志的实现

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

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

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

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

<!--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

3. 桥接旧的日志框架

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

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

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

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

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

<!-- <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 等对象，将无法产生效果

4. SLF4J 原理解析

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

Logback

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

Logback 主要分为三个模块：

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

1. 入门案例

<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>

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

2. Logback 配置

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

logback.groovy
logback-test.xml
logback.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>

Log4j2

Log4j2 也是日志门面，因为它的日志实现功能非常强大，性能优越，所以一般还是将 Log4j2 看作是日志的实现

1. 入门案例

<!-- 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>

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 作为日志的实现

<!-- 使用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>

2. Log4j2 配置

log4j2 默认加载 classpath 下的 log4j2.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>

3. Log4j2 异步日志

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

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

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

使用 AsyncAppender 的方式

<?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 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>

4. 无垃圾模式

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

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

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

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

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

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

SpringBoot 日志使用

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

1. SpringBoot 的日志设计

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

依赖关系图：

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

2. SpringBoot 日志使用

在 springboot 中测试打印日志

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

修改默认日志配置

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：logging.properties

使用 SpringBoot 可以切换不同环境的日志配置，如在 logback-spring.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

<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>

来源：https://www.cnblogs.com/Yee-Q/p/16864734.html
本站部分图文来源于网络，如有侵权请联系删除。

日志概念

1. 日志文件

1.1 调试日志

1.2 系统日志

日志门面

JUL

1. 架构

2. 入门案例

3. 日志级别

4. logger 之间的父子关系

5. 日志的配置文件

6. 日志原理解析

Log4J

1. 入门案例

2. 日志级别

3. Log4j 组件

3.1 Loggers

3.2 Appenders

3.3 Layouts

4. 配置文件详解

JCL

1. 入门案例

2. JCL 原理

SLF4J

1. 入门案例

2. 绑定日志的实现

3. 桥接旧的日志框架

4. SLF4J 原理解析

Logback

1. 入门案例

2. Logback 配置

Log4j2

1. 入门案例

2. Log4j2 配置

3. Log4j2 异步日志

4. 无垃圾模式

SpringBoot 日志使用

1. SpringBoot 的日志设计

2. SpringBoot 日志使用

相关推荐

热门文章