Java日志框架：log4j、log4j2、logback

配置文件相关

1. properties

用来代表属性文件，通过Properties可以读写配置文件的内容。

• 构造方法
  public Properties()：用于构建Properties集合对象（空容器）
• 常用方法

测试

@Log4j2
public class TestProperties {

    public static void main(String[] args) throws Exception {
        Properties properties = new Properties();
        properties.load(new FileReader("src\\main\\resources\\user.properties"));
        properties.setProperty("like", "跳舞");
        properties.forEach((k,v)->{
            System.out.println(k + "--》" + v);
        });
    }
}

2. XMl

Extensible Markup Language，可扩展标记语言。
本质是一种数据格式，可以用来存储复杂的数据结构和数据关系。

特点：

• XML中的标签名称为一个标签或者一个元素，一般成对出现。
• XML中的标签名可以自己定义，但是需要正确的嵌套。
• XML中只能有一个根标签。
• XML中的标签可以有属性。
• 如果一个文件中放置的是XML格式的数据，这个文件就是XML文件，后缀一般要写成.xml

语法规则：

• XML文件的后缀名为：.xml，文档声明必须是第一行。
• XML中可以定义注释信息：<!-- 注释内容 -->
• XML中书写<、>可能会报错，导致冲突。可以用特殊字符代替。

• XML中可以书写CDATA数据区，里面内容不受格式限制。
  <![CDATA[ ...内容]]>

使用Dom4j解析XML

• SAXReader：Dom4j提供的解析器，可以认为是代表整个Dom4j框架。

Log4j与Log4j2

log4j2是log4j 1.x的升级版。2015年5月，apache宣布log4j 1.x停止更新。最新版本为1.2.17。

日志框架出现的历史顺序：log4j->JUL->JCL->slf4j->logback->log4j2

log4j2参考logback的一些优秀设计，并且修复了一些问题，带来一些重大提升。主要有：

1. 异常处理。在logback中，Appender中的异常不会被应用感知。但是在log4j2中提供了一些异常处理机制。
2. 性能提升。log4j2相较于log4j和logback都具有很明显的性能提升。
3. 自动重载配置。参考了logback设计，提供自动刷新参数配置，可以动态的修改日志的级别而不需要重启应用。
4. 无垃圾机制。log4j2在大部分情况下，可以使用其设计的一套无垃圾机制，避免频繁的日志收集导致的jmv gc。
   补充：
   Java虚拟机（JVM）的垃圾回收（GC）是Java语言的一个重要特性，它允许开发者编写代码时不需要手动管理内存的分配和回收。垃圾回收器（Garbage Collector，简称GC）会自动找出不再使用的对象，并将它们占用的内存回收，以供新的对象使用。

日志门面

用户可以使用日志门面，根据需求，动态选择具体的日志实现框架。可以实现所有日志实现框架有统一的规范。

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

一、Log4j

三大主要组件/对象：Loggers（记录器）、Appenders（输出源）、Layouts（布局）
每条日志语句都要设置一个等级：DEBUG、INFO、WARN、ERROR、FATAL

优先级从高到低依次为：OFF（关闭）、FATAL（严重错误信息）、ERROR（错误信息）、WARN（警告信息）、INFO（一般信息）、DEBUG（调试信息）、TRACE、 ALL（所有信息）。

1.1 Logges

在设置日志输出位置的时候，会给位置设置一个级别。只有大于此级别的日志才会打印输出到指定位置。
例如：给日志等级设置为INFO，则INFO、WARN、ERROR、FATAL级别的日志才会打印，DEBUG日志则不会打印。

1.2 Appenders

禁用和使用日志请求是log4j的基本功能，log4j允许把日志输出到不同的地方。例如：控制台（Console）、文件（Files）等。还可以根据天数或者文件大小产生新的文件，可以以流的形式将日志发送到其他地方。

常用类：

1.3 Layouts

用户可以根据自己的喜好格式化输出自己的日志文件。
Layouts提供四种日志输出样式：根据HTML样式、自由指定样式、包含日志级别与信息的样式、包含日志时间、线程、类别等信息的样式。

常用类：

1.4 使用

1. 导入POM依赖

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

2. 创建配置文件
   日志配置文件：log4j.properties文件或者logback.xml

### 日志的输出级别是debug，输出位置名字叫做stdout,D
log4j.rootLogger = debug,stdout,D

#### 输出DEBUG级别以上的日志到控制台
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
# 指定日志级别
log4j.appender.stdout.Threshold = DEBUG
# 是否即时生效
log4j.appender.stdout.ImmediateFlush = true
# 日志编码格式
log4j.appender.stdout.Encoding = UTF-8
# 以特定格式输出日志
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
# 设置日志格式，%d，%m是输出代码中指定的消息的占位符
log4j.appender.stdout.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p:%F:%L ]  %m%n

#### 输出WARNING级别以上的日志到文件
log4j.appender.D=org.apache.log4j.FileAppender
# 日志路径
log4j.appender.D.File =D:/logtest/error.log
# 日志以追加方式输入
log4j.appender.D.Append = true
# 指定日志级别
log4j.appender.D.Threshold = WARN
# 是否即时生效
log4j.appender.D.ImmediateFlush = true
# 日志编码格式
log4j.appender.D.Encoding = UTF-8
# 以特定格式输出日志
log4j.appender.D.layout = org.apache.log4j.PatternLayout
# 设置日志格式，%d，%m是输出代码中指定的消息的占位符
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p:%F:%L ]  %m%n

3. 测试

package com.example.log;

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

public class TestLog {

    // 获取日志记录器，此纪录器将负责控制日志信息。Name一般是当前类的名字
    Logger logger = Logger.getLogger(TestLog.class);

    @Test
    public void testLog() {
        logger.debug("这是一条debug信息");
        logger.info("这是一条info信息");
        logger.warn("这是一条warn信息");
        logger.error("这是一条error信息");
        logger.fatal("这是一条fatal信息");

        try {
            int i = 12 / 0;
        } catch (Exception e) {
            logger.error(e.getMessage());
        }
    }
}

4. 效果
   
   

1.5 配置文件详解

1.5.1 配置根目录

log4j.rootLogger = [level],appenderName,appenderName...

• level：是日志记录的优先级，分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或自定义的级别。
  log4j建议只使用4个级别，优先级从高到低分别是：EOOR、WARN、INFO、DEBUG。通过级别定义，可以控制到应用程序中相应级别日志信息的开关。例如定义了INFO级别，则应用程序中所有DEBUG日志信息将不会被打印出来。
• appenderName：指定日志信息输出到什么地方，可以同时指定多个输出目的地。

1.5.2 配置日志信息输出目的地Appender

log4j提供的appender有以下几种：

• ConsoleAppender选项：

  Threshold=WARN;指定日志消息输出的最低层次。
  ImmediateFlush=true;默认是true，所有消息是否立即输出。
  Target=System.err;默认情况下是System.out，指定输出到控制台。
  

• FileAppender选项：

  Threshold=WARN;指定日志消息输出的最低层次。
  ImmediateFlush=true;默认是true，所有消息是否立即输出。
  File=mylog.txt;指定消息输出到mylog.txt文件。
  Append=false;默认是true，即消息追加到指定文件中，false指将消息覆盖指定的文件内容。
  

• DailyRollingFileAppender选项：

  Threshold=WARN;指定日志消息输出的最低层次。
  ImmediateFlush=true;默认是true，所有消息是否立即输出。
  File=mylog.txt;指定消息输出到mylog.txt文件。
  Append=false;默认是true，即消息追加到指定文件中，false指将消息覆盖指定的文件内容。
  DatePattern='.'yyyy-ww 每周滚动一次文件，即每周产生一个新的文件。
  	1)'.'yyyy-MM：每月
  	2)'.'yyyy-ww：每周
  	3)'.'yyyy-MM-dd：每天
  	4)'.'yyyy-MM-dd-a：每天两次
  	5)'.'yyyy-MM-dd-HH：每小时
  	6)'.'yyyy-MM-dd-HH-mm：每分钟
  

• RollingFileAppender选项：

  Threshold=WARN;指定日志消息输出的最低层次。
  ImmediateFlush=true;默认是true，所有消息是否立即输出。
  File=mylog.txt;指定消息输出到mylog.txt文件。
  Append=false;默认是true，即消息追加到指定文件中，false指将消息覆盖指定的文件内容。
  MaxFileSize=100KB;后缀可以是KB，MB或者GB。在文件日志到达该大小时，将会自动滚动，即将原来的内容移动到mylog.log.1文件。
  MaxBackupIndex=2;指定可以产生的滚动文件的最大数
  

1.5.3 输出格式设置

在配置文件中通过log4j.appender.A1.layout.ConversionPattern设置日志的输出格式。

二、Log4j2

log4j 2.x版本不再支持像1.x中的.properties后缀的文件配置方式。2.x版本常用.xml后缀的文件进行配置，除此之外还包含.json和.jsn配置文件。

• log4j2虽然采用xml风格进行配置，依然包含三大组件。Logger（记录器）、Appender（输出目的地）、Layout（日志布局）。
• 配置文件的位置：log4j2默认会在classpath目录下寻找log4j2.xml、log4j.json、log4j.jsn等名称的文件。

2.1 XML配置文件解析

1. 根节点Configuration有两个属性：status和monitorinteval，有两个子节点Appenders和Loggers（可以定义多个Appender和Logger）
   • stataus：指定log4j本身的打印日志的级别
   • monitorinterval：为log4j 2.x 新特性，自动重载配置，指定自动重载配置的间隔时间，单位是s，最小是5s。
2. Appenders节点，常见的有三种子节点：Console、File、RollingFile
   • Console节点：定义输出到控制台的Appender。
   • File节点：定义输出到指定位置的文件的Appender。
   • RollingFile节点： 定义超过指定大小自动删除旧的创建新的Appender。

通过在子节点加入<patternLayout pattern=”自定义信息格式“/> 进行日志布局。

其他常用占位符有：

3. Loggers节点

常见的Loggers节点有两种：Root和Logger

• Root节点用来指定项目的根日志，如果没有单独指定Logger，那么就会默认使用该Root日志输出
• Logger节点用来单独指定日志的形式，比如要为指定报下的class指定不同的日志级别等。

2.2 使用

测试是新建的SpringBoot项目

1. 导入POM依赖

<!-- 排除 Spring-boot-starter 默认的日志配置 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- 引入log4j2依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>

2. 创建配置文件
   2.1 如果配置文件名是log4j2-spring.xml，则不用再另外配置，会自动检测到该配置文件
   2.2 如果配置文件名是自定义的，需要在application.yml中另外配置

   logging:
   	config: log4j2.xml
   	level:
   		cn.jay.repository: trace
   

   

3. 配置文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!--Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，你会看到log4j2内部各种详细输出-->
<!--monitorInterval：Log4j能够自动检测修改配置 文件和重新配置本身，设置间隔秒数-->
<configuration monitorInterval="5">
    <!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
    <!--变量配置-->
    <Properties>
        <!-- 格式化输出：%date表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %msg：日志消息，%n是换行符-->
        <!-- %logger{36} 表示 Logger 名字最长36个字符 -->
        <property name="LOG_PATTERN" value="%date{HH:mm:ss.SSS} [%thread] %-5level %logger{36} [第%L行] - %msg%n" />
        <!-- 定义日志存储的路径 -->
        <property name="FILE_PATH" value="D:\logtest" />
        <property name="FILE_NAME" value="testlog" />
    </Properties>

    <appenders>

        <console name="Console" target="SYSTEM_OUT">
            <!--输出日志的格式-->
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <!--控制台只输出level及其以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
        </console>

        <!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，适合临时测试用-->
        <File name="FileLog" fileName="${FILE_PATH}/test.log" append="false">
            <PatternLayout pattern="${LOG_PATTERN}"/>
        </File>

        <!-- 这个会打印出所有的info及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileInfo" fileName="${FILE_PATH}/info.log" filePattern="${FILE_PATH}/${FILE_NAME}-INFO-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

        <!-- 这个会打印出所有的warn及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileWarn" fileName="${FILE_PATH}/warn.log" filePattern="${FILE_PATH}/${FILE_NAME}-WARN-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

        <!-- 这个会打印出所有的error及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileError" fileName="${FILE_PATH}/error.log" filePattern="${FILE_PATH}/${FILE_NAME}-ERROR-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

    </appenders>

    <!--Logger节点用来单独指定日志的形式，比如要为指定包下的class指定不同的日志级别等。-->
    <!--然后定义loggers，只有定义了logger并引入的appender，appender才会生效-->
    <loggers>

        <!--过滤掉spring和mybatis的一些无用的DEBUG信息-->
        <logger name="org.mybatis" level="info" additivity="false">
            <AppenderRef ref="Console"/>
        </logger>
        <!--监控系统信息-->
        <!--若是additivity设为false，则 子Logger 只会在自己的appender里输出，而不会在 父Logger 的appender里输出。-->
        <Logger name="org.springframework" level="info" additivity="false">
            <AppenderRef ref="Console"/>
        </Logger>

        <root level="info">
            <appender-ref ref="Console"/>
            <appender-ref ref="FileLog"/>
            <appender-ref ref="RollingFileInfo"/>
            <appender-ref ref="RollingFileWarn"/>
            <appender-ref ref="RollingFileError"/>
        </root>
    </loggers>
</configuration>

5. 测试

package com.example.log;

import lombok.extern.log4j.Log4j2;

@Log4j2
public class TestLog {

    public static void main(String[] args) {
        for (int i = 0; i < 2; i++) {
            log.trace("这是一个trace日志");
            log.debug("这是一个debug日志");
            log.info("这是一个info日志");
            log.warn("这是一个warn日志");
            log.error("这是一个error日志");
            log.fatal("这是一个严重错误日志");
        }
    }
}

三、LogBack

官网网站

3.1 logback模块

• logback-core：其他两个模块的基础模块
• logback-class：log4j的改良版本，完整实现了Slf4j API
• logback-access：访问模块于servlet容器集成提供通过Http来访问日志的功能

3.2 logback组件

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

3.3 logback配置

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

1. logback.grovy
2. logback-test.xml
3. logback.xml

3.4 使用

spring-boot-starter其中包含了 spring-boot-starter-logging，该依赖内容就是 Spring Boot 默认的日志框架 Logback+SLF4J。而 spring-boot-starter-web 包含了spring-boot-starte，所以只需要引入web组件即可。

1. 引入POM依赖

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

2. resources下新建logback.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- 日志存放路径 -->
    <property name="log.path" value="./logs" />
    <!-- 日志输出格式 -->
    <property name="log.pattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{26} - [%method,%line] - %msg%n" />

    <!-- 控制台输出 -->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${log.pattern}</pattern>
        </encoder>
    </appender>

    <!-- 系统日志输出 -->
    <appender name="file_info" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${log.path}/sys-info.log</file>
        <!-- 循环政策：基于时间创建日志文件 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日志文件名格式 -->
            <fileNamePattern>${log.path}/sys-info.%d{yyyy-MM-dd}.log</fileNamePattern>
            <!-- 日志最大的历史 60天 -->
            <maxHistory>60</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>${log.pattern}</pattern>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 过滤的级别 优先级从高到低依次为：OFF（关闭）、FATAL（严重错误信息）、ERROR（错误信息）、WARN（警告信息）、INFO（一般信息）、DEBUG（调试信息）、TRACE、 ALL（所有信息）-->
            <level>INFO</level>
            <!-- 匹配时的操作：接收（记录） -->
            <onMatch>ACCEPT</onMatch>
            <!-- 不匹配时的操作：拒绝（不记录） -->
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <appender name="file_error" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${log.path}/sys-error.log</file>
        <!-- 循环政策：基于时间创建日志文件 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日志文件名格式 -->
            <fileNamePattern>${log.path}/sys-error.%d{yyyy-MM-dd}.log</fileNamePattern>
            <!-- 日志最大的历史 60天 -->
            <maxHistory>60</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>${log.pattern}</pattern>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 过滤的级别 -->
            <level>ERROR</level>
            <!-- 匹配时的操作：接收（记录） -->
            <onMatch>ACCEPT</onMatch>
            <!-- 不匹配时的操作：拒绝（不记录） -->
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <root level="trace">
        <appender-ref ref="console" />
    </root>

    <!--系统操作日志-->
    <root level="info">
        <appender-ref ref="file_info" />
        <appender-ref ref="file_error" />
    </root>

    <!-- 系统模块日志级别控制  -->
    <logger name="com.example.demo" level="trace" />
    <!-- Spring日志级别控制  -->
    <logger name="org.springframework" level="warn" />
</configuration>

3. 测试

public class TestLog {

    private static final Logger log = LoggerFactory.getLogger(TestLog.class);

    public static void main(String[] args) {
        log.trace("trace");
        log.debug("debug");
        log.info("info");
        log.warn("warn");
        log.error("error");
    }
}