Springboot日志打印、SpringBoot集成Log4j2（附源码）、异步日志

文章目录

一、Log4j2介绍
- 1.1、常用日志框架
- 1.2、为什么选用log4j2
二、Log4j2整合步骤
- 2.1、引入jar包
- 2.2、配置文件
- 2.3、配置文件模版
三、配置参数简介
- 3.1、日志级别
- 3.2、日志格式（PatternLayout）
- 3.3、Appenders组件列表
- - 3.3.1、Console
  - 3.3.2、File
  - 3.3.3、RollingFile/RollingFileAppender
  - - 3.3.3.1、Filter（ThresholdFilter）
    - 3.3.3.2、Policies
    - 3.3.3.3、Strategy
- 3.4、Loggers
- - 3.4.1、Logger 等级实验
四、异步日志
- 4.1、引入disruptor
- 4.2、修改启动类
- 4.3、修改日志文件的内容
- 4.4、再次进行测试
五、可能遇到的问题
- 5.1、日志打印不生效？
- 5.2、日志重复打印问题
六、总结
- 6.1、Policy & Strategy
- 6.2、源码文件

spring boot支持的日志框架有，logback，Log4j，Log4j2和Java Util Logging，默认使用的是logback日志框架。

之前整理过springboot集成logback日志，具体参考《springboot集成logback》。本文将整理springboot集成log4j2日志框架。

一、Log4j2介绍

1.1、常用日志框架

首先slf4j是一个简单的门面模式，意思就是说这只是一个日志标准，并不是日志系统的具体实现，slf4j只做两件事：提供日志接口和提供获取具体日志对象的方法。

java.util.logging：是JDK在1.4版本中引入的Java原生日志框架
Log4j：Apache的一个开源项目，可以控制日志信息输送的目的地是控制台、文件、GUI组件等，可以控制每一条日志的输出格式，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。目前已经停止维护了。
LogBack：是Log4j的一个改良版本，是slf4j的原生实现，目前是springboot的默认日志组件
Log4j2：Log4j2已经不仅仅是Log4j的一个升级版本了，它从头到尾都被重写了。据说采用了一些新技术（无锁异步、等等），使得日志的吞吐量、性能比log4j 1.x提高10倍 ,还提供了异步日志功能，所以这里重点介绍下log4j2的使用以及一些概念

1.2、为什么选用log4j2

相比与其他的日志系统，log4j2丢数据这种情况少；disruptor技术(即异步日志)在多线程环境下，性能高于logback等10倍以上；利用jdk1.5并发的特性，减少了死锁的发生；

在这列举一下一些网上其他博文中对它们的性能评测：
在这里插入图片描述

可以看到在同步日志模式下, Logback的性能是最糟糕的.
log4j2的性能无论在同步日志模式还是异步日志模式下都是最佳的.

log4j2优越的性能其原因在于log4j2使用了LMAX,一个无锁的线程间通信库代替了logback和log4j之前的队列. 并发性能大大提升。

二、Log4j2整合步骤

2.1、引入jar包

springboot默认是用logback的日志框架的，所以需要排除logback，不然会出现jar依赖冲突的报错。具体依赖包是spring-boot-starter-logging，一般存在于spring-boot-starter-web、actuator等依赖中。

排除springboot默认的logback依赖包并引入

<dependency>  
    <groupId>org.springframework.boot</groupId>  
    <artifactId>spring-boot-starter-web</artifactId>  
    <exclusions><!-- 去掉springboot默认配置 -->  
        <exclusion>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter-logging</artifactId>  
        </exclusion>  
    </exclusions>  
</dependency> 

<dependency> <!-- 引入log4j2依赖 -->  
    <groupId>org.springframework.boot</groupId>  
    <artifactId>spring-boot-starter-log4j2</artifactId>  
</dependency>

2.2、配置文件

需要在application或yml中指定log4j2使用的xml文件

1、如果自定义了文件名，需要在application.yml中配置

logging:
  config: classpath:log4j2.xml

2、默认名log4j2-spring.xml，就省下了在application.yml中配置

2.3、配置文件模版

log4j是通过一个.properties的文件作为主配置文件的，而现在的log4j2则已经弃用了这种方式，采用的是.xml，.json或者.jsn这种方式来做，可能这也是技术发展的一个必然性，因为properties文件的可阅读性真的是有点差。这里给出博主自配的一个模版，供大家参考。

<?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{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n" />
        <!-- 定义日志存储的路径 -->
        <property name="FILE_PATH" value="./logs" />
        <property name="FILE_NAME" value="demo" />
    </Properties>

    <appenders>

        <console name="Console" target="SYSTEM_OUT">
            <!--输出日志的格式及颜色-->
            <PatternLayout pattern="[%style{%d}{bright,yellow}][%style{%t}{bright,blue}][%highlight{%p}][%style{%C}{bright,green}]: %msg%n%style{%throwable}{red}"
                           disableAnsi="false" noConsoleNoAnsi="false"/>
        </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}/$${date:yyyy-MM-dd}/info-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="debug" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，此处单位是1 天
					单位是由于filePattern中的最小单位决定的，本示例中filePattern的格式是年月日，所以最小单位是天。若filePattern格式是时分秒，则TimeBasedTriggeringPolicy的单位是秒。
				-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="30MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy fileIndex="nomax">
                <!--删除${FILE_PATH}目录及子目录下 180天前的.log.gz后缀的文件 -->
                <Delete basePath="${FILE_PATH}" maxDepth="2">
                    <IfFileName glob="*/*.log.gz"/>
                    <IfLastModified age="180d"/>
                </Delete>
            </DefaultRolloverStrategy>
        </RollingFile>

        <!-- 这个会打印出所有的warn及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileWarn" fileName="${FILE_PATH}/warn.log" filePattern="${FILE_PATH}/$${date:yyyy-MM-dd}/warn-%d{yyyy-MM-dd}_%i.log.gz">
            <Filters>
                <!--过滤掉error及更高级别日志-->
                <ThresholdFilter level="error" onMatch="DENY" onMismatch="NEUTRAL"/>
            </Filters>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，此处单位是1 天-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="30MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy fileIndex="nomax">
                <!--删除${FILE_PATH}目录及子目录下 180天前的.log.gz后缀的文件 -->
                <Delete basePath="${FILE_PATH}" maxDepth="2">
                    <IfFileName glob="*/*.log.gz"/>
                    <IfLastModified age="180d"/>
                </Delete>
            </DefaultRolloverStrategy>
        </RollingFile>

        <!-- 这个会打印出所有的error及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileError" fileName="${FILE_PATH}/error.log" filePattern="${FILE_PATH}/$${date:yyyy-MM-dd}/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="30MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy fileIndex="nomax">
                <!--删除${FILE_PATH}目录及子目录下 180天前的.log.gz后缀的文件 -->
                <Delete basePath="${FILE_PATH}" maxDepth="2">
                    <IfFileName glob="*/*.log.gz"/>
                    <IfLastModified age="180d"/>
                </Delete>
            </DefaultRolloverStrategy>
        </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="true">
            <!--<AppenderRef ref="Console"/>-->
        </Logger>

        <!-- additivity:是否向上级logger传递打印信息。默认是true。-->
        <!-- name="com.example"修改为自己的项目目录 -->
        <!--[需修改] level: 若需要打印sql日志则需要修改为debug级别；否则为info级别。 -->
        <Logger name="com.example" level="debug" additivity="true">
        </Logger>

        <root level="info">
            <appender-ref ref="Console" />
            <!--<appender-ref ref="Filelog"/>-->
            <appender-ref ref="RollingFileInfo"/>
            <appender-ref ref="RollingFileWarn" level="warn"/>
            <appender-ref ref="RollingFileError"/>
        </root>
    </loggers>


</configuration>

上述模版实现了控制台及log文件中会打印sql日志。若不想打印sql日志，则修改为

<Logger name="com.example" level="info" additivity="true"/>

使用注意事项：
1、修改配置文件中以下几个地方
在这里插入图片描述
2、root标签中引入了Filelog配置项，此处是为了测试使用的，会把所有日志都打印在同一个文件中，可以删除掉。即：

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

测试代码

package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import io.swagger.annotations.*;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;


@RestController(value = "/user")
@Api(value = "用户管理功能集", tags = "用户管理")
@Slf4j
public class UserController {
    private static final Logger logger = LoggerFactory.getLogger(UserController.class);
    
    @Autowired
    private UserMapper userMapper;

    @GetMapping(value = "/getUser")
    public List<User> getUser(){
        logger.info("===========进入方法===========");
        List<User> list = userMapper.getAllUser();
        log.info("===========查询结束===========");
        return list;
    }

}

打印后日志格式：

 .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.4.7)

[2024-12-23 14:55:23,870][main][INFO][org.springframework.boot.StartupInfoLogger]: Starting MainApplication using Java 1.8.0_202 on LAPTOP-9UHA7CHR with PID 44836 (D:\WorkSpace\springboot-bucket\springboot-log4j2\target\classes started by 13488 in D:\WorkSpace\springboot-bucket)
[2024-12-23 14:55:23,874][main][DEBUG][org.springframework.boot.StartupInfoLogger]: Running with Spring Boot v2.4.7, Spring v5.3.8
[2024-12-23 14:55:23,875][main][INFO][org.springframework.boot.SpringApplication]: No active profile set, falling back to default profiles: default
[2024-12-23 14:55:24,323][main][DEBUG][org.apache.ibatis.logging.LogFactory]: Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
[2024-12-23 14:55:24,494][main][INFO][org.springframework.boot.web.embedded.tomcat.TomcatWebServer]: Tomcat initialized with port(s): 8080 (http)
[2024-12-23 14:55:24,499][main][INFO][org.apache.juli.logging.DirectJDKLog]: Initializing ProtocolHandler ["http-nio-8080"]
[2024-12-23 14:55:24,499][main][INFO][org.apache.juli.logging.DirectJDKLog]: Starting service [Tomcat]
[2024-12-23 14:55:24,500][main][INFO][org.apache.juli.logging.DirectJDKLog]: Starting Servlet engine: [Apache Tomcat/9.0.46]

在这里插入图片描述

三、配置参数简介

在这里简单介绍下常用的配置参数，详情可参考Log4j2配置官网地址：https://logging.apache.org/log4j/2.x/manual/configuration.html#AutomaticConfiguration

3.1、日志级别

机制：如果一条日志信息的级别大于等于配置文件的级别，就记录。
日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL

all: 用于打开所有日志记录。
trace：追踪，就是程序推进一下，可以写个trace输出
debug：调试，一般作为最低级别，trace基本不用。
info：输出重要的信息，使用较多
warn：警告，有些信息不是错误信息，但也要给程序员一些提示。
error：错误信息。用的也很多。
fatal：致命错误。
OFF: 用于关闭所有日志记录。

3.2、日志格式（PatternLayout）

SimpleLayout：以简单的形式显示
HTMLLayout：以HTML表格显示
PatternLayout：自定义形式显示

PatternLayout示例如下：

<Console name="STDOUT" target="SYSTEM_ERR">
	<PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} %t %5p [%c:%L] - %m%n" />
</Console>

关于pattern 的格式参考官网：
https://logging.apache.org/log4j/2.x/manual/pattern-layout.html

参数	描述
%c或%logger	输出logName，如 Logger log = LoggerFactory.getLogger(“com.test.logName”); 则输出为“com.test.logName” ，如果格式为%c{参数}，则输出内容参考官网：
%d{pattern}或%date{pattern}	输出时间，其中pattern可以是保留字，也可以是SimpleDateFormat中的字符。如%d{yyyy-MM-dd HH:mm:ss.SSS} --> 2020-03-31 23:25:13.321 详见log4j PatternLayout
%C或%class	输出为所在类的全路径名如：com.example.demo.controller.UserController
%l	输出语句所在的行数, 包括类名、方法名、文件名、行数(这个比较强大) ，如，com.test.LogTest.testLog(LogTest.java:31)
%F或%file	输出所在类名.java，如所在类为com.test.LogTest.java，则输出为LogTest.java
%L	输出行号
%m或%msg或%message	输出log.error(text)中的text内容
%M或%method	输出方法名
%n	换行符
%t或%thread	输出线程名
%T或%tid或%threadId	输出线程id
%t或%tn或%thread或%threadName	输出线程名称
hostName	本地机器名
hostAddress	本地ip地址

我们举几个例子，假如我们配置文件这么写

<RollingFile name="RollingFileInfo" fileName="${FILE_PATH}/info.log" filePattern="${FILE_PATH}/${FILE_NAME}-INFO-%d{yyyy-MM-dd}_%i.log.gz">
    <PatternLayout pattern="%date{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"/>
</RollingFile>    

打印日志格式如下：
2024-12-24 10:37:12.744 [main] INFO  org.apache.catalina.core.AprLifecycleListener - Loaded Apache Tomcat Native library [1.2.31] using APR version [1.7.0].
2024-12-24 10:37:12.744 [main] INFO  org.apache.catalina.core.AprLifecycleListener - APR capabilities: IPv6 [true], sendfile [true], accept filters [false], random [true].

如果配置文件如下

<PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} |-%-5level [%t] %c{1.} %M [%L] -| %msg%n"/>
输出的结果就为
2024-12-24 20:18:06.833 |-INFO  [main] c.d.Main main [11] -| This is a Main info message.

其中，%c{1.} 表示输出日志事件相关的类名，只取最右边的类名，前面的层级，只输出一个字母；如果配置文件如下

<PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} |-%-5level [%t] %c{2.} [%l] -| %msg%n"/>
输出的结果就为
2024-12-24 20:21:00.753 |-INFO  [main] co.de.Main [com.demo.Main.main(Main.java:11)] -| This is a Main info message.

官方示例如下：https://logging.apache.org/log4j/2.x/manual/pattern-layout.html#converters

Configuration

Configuration为根节点，配置log4j2基础属性，如status，monitorInterval等

<Configuration status="WARN" monitorInterval="30">

status: 用于控制log4j2日志框架本身的日志级别，有“trace”, “debug”, “info”…“fatal” 和"off"属性，如果将status设置为较低的级别就会看到很多关于log4j2本身的日志，如加载log4j2配置文件的路径等信息
monitorInterval: 含义是每隔多少秒重新读取配置文件，可以不重启应用的情况下修改配置

3.3、Appenders组件列表

常见的有三种Appender: Console、RollingFile、File。

append	标签	描述
AsyncAppender	`<Async>`	用于接受其他类型appender的引用，并使用单独线程异步写入log
ConsoleAppender	`<Console>`	其日志写入System.out或System.err，默认为System.out
FileAppender	`<File>`	将日志写入文件，使用FileManager执行io
RollingFileAppender	`<RollingFile>`	将日志写入文件，并根据TriggeringPolicy和RolloverPolicy规则将文件归档、清理
RollingRandomAccessFileAppender	`<RollingRandomAccessFile>`	与RollingFileAppender相比，使用的I/O实现类不同，RollingFileAppender使用FileOutputStream，RollingRandomAccessFileAppender使用RandomAccessFile。bufferedIO=true(默认是true)时，性能提高20-200％。

注意点：

多个 appender 不能指向同一个日志文件，否则会报错：Configuration has multiple incompatible Appenders pointing to the same resource 'logs/warn.log'
ImmediateFlush=true，一旦有新日志写入，立马将日志写入到磁盘的文件中。当日志很多，这种频繁操作文件显然性能很低下
immediateFlush：log4j2接收到日志事件时，是否立即将日志刷到磁盘。默认为true。
BufferedIO: 文件流写出是否使用缓冲，true表示使用，默认值为false即不使用缓冲。测试显示，即使在启用immediateFlush的情况下，设置bufferedIO=true也能提高性能。

3.3.1、Console

<?xml version="1.0" encoding="UTF-8"?>
<Configuration monitorInterval="5">
  <Appenders>
    <Console name="STDOUT" target="SYSTEM_OUT">
      <PatternLayout pattern="%m%n"/>
    </Console>    
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="STDOUT"/>
    </Root>
  </Loggers>
</Configuration>

Console节点用来定义输出到控制台的Appender.

name:指定Appender的名字.
target: SYSTEM_OUT 或 SYSTEM_ERR,一般只设置默认:SYSTEM_OUT.
PatternLayout:输出格式，不设置默认为:%m%n

3.3.2、File

File节点用于将日志输出到指定文件，一般不用该节点，而是使用RollingFile节点。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration >
  <Appenders>
     <!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，适合临时测试用-->
    <File name="Filelog" fileName="logs/app.log" append="false">
      <PatternLayout>
        <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
      </PatternLayout>
    </File>
  </Appenders>
  <Loggers>
    <Root level="debug">
      <AppenderRef ref="Filelog"/>
    </Root>
  </Loggers>
</Configuration>

name:指定Appender的名字.
fileName:指定输出日志的目的文件带全路径的文件名.
append: 每次重启后是否追加日志到原先文件中，true：追加；false:不追加(即每次重启都清空原文件)
PatternLayout:输出格式，不设置默认为:%m%n.

3.3.3、RollingFile/RollingFileAppender

RollingFile节点用于实现日志文件更动更新的Appender，当满足条件（日志大小、指定时间等）重命名或打包原日志文件进行归档，生成新日志文件用于日志写入。

我们可以设置ALL、DEBUG、 INFO、 WARN、 ERROR这些级别的RollingFileAppender。

<?xml version="1.0" encoding="UTF-8"?>
<Configuration >
  <Appenders>
    <RollingFile name="RollingFile" fileName="logs/app.log"
                 filePattern="logs/$${date:yyyy-MM}/app-%d{yyyy-MM-dd-HH}-%i.log.gz">
      <PatternLayout>
        <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
      </PatternLayout>
      <Policies>
        <TimeBasedTriggeringPolicy interval="6" modulate="true"/>
        <SizeBasedTriggeringPolicy size="100 MB"/>
      </Policies>
    </RollingFile>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="RollingFile"/>
    </Root>
  </Loggers>
</Configuration>

上述模板中，日志先写入logs/app.log中，每当文件大小达到100MB或者当时间间隔到达6小时（时间单位由%d{yyyy-MM-dd-HH}决定），触发日志归档操作，按照在logs/yyyy-MM/目录下以app-yyyy-MM-dd-1.log.gz格式对该日志进行压缩重命名并归档，并生成新的文件app.log进行日志写入。

• name:指定Appender的名字.
• fileName:指定输出日志的目的文件带全路径的文件名.
• filePattern : 指定当发生Rolling时，文件的转移和重命名规则.
• PatternLayout:输出格式，不设置默认为:%m%n.
• Policies:指定滚动日志的策略，就是什么时候进行新建日志文件输出日志.
• TimeBasedTriggeringPolicy:Policies子节点，基于时间的滚动策略，interval属性用来指定多久滚动一次，默认是1 hour。modulate=true用来调整时间：比如现在是早上3am，interval是4，那么第一次滚动是在4am，接着是8am，12am…而不是7am.
• SizeBasedTriggeringPolicy:Policies子节点，基于指定文件大小的滚动策略，size属性用来定义每个日志文件的大小.
• DefaultRolloverStrategy:用来指定同一个文件夹下最多有几个日志文件时开始删除最旧的，创建新的(通过max属性)。

3.3.3.1、Filter（ThresholdFilter）

Filters 决定日志事件能否被输出。过滤条件有三个值：ACCEPT(接受)，DENY(拒绝)，NEUTRAL(中立/放行)。

常用的Filter实现类有：

LevelRangeFilter
TimeFilter
ThresholdFilter：匹配至少与配置级别一样严重的日志事件。(即>=配置级别的放行)

简单说就是log4j2中的过滤器 ACCEPT 和 DENY 之后，后续的过滤器就不会执行了，只有在 NEUTRAL 的时候才会执行后续的过滤器

ThresholdFilter

属性	描述
level	日志级别。例如，level="ERROR"表示只有错误级别的日志会被过滤。
onMatch	匹配成功。日志级别 >= level 就算匹配上了 . 可选值为`ACCEPT`、`DENY`和`NEUTRAL`。默认值为`NEUTRAL`.
onMismatch	匹配失败。对不符合过滤级别的日志的操作。可选值为ACCEPT、DENY和NEUTRAL。默认值为`DENY`。

ACCEPT：日志会被立即处理，不再经过剩余过滤器
DENY：日志将立即被抛弃不再经过其他过滤器；
NEUTRAL：有序列表里的下个过滤器过接着处理日志；（该级别既不处理，也不抛弃，相当于没有任何处理，日志会被保存下来并在本appender被执行）

为了更好理解onMatch与onMismatch，接下来我们看几个示例。

示例一：

<console name="Console" target="SYSTEM_OUT">
	<PatternLayout pattern="%date{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"/>
	<!--控制台只输出level及其以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
	<ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
</console>

上述示例中日志级别info及以上的配置为接受，其他的配置为拒绝，所以只接受info、warn、error、fatal级别的日志，其他的都拒绝。

示例二：

<RollingFile name="RollingFileInfo" fileName="${FILE_PATH}/info.log" filePattern="${FILE_PATH}/${FILE_NAME}-INFO-%d{yyyy-MM-dd}_%i.log.gz">
    <!--
        设置 onMismatch="NEUTRAL" 可以让日志经过后续的过滤器
        最后一个过滤器建议设置 onMismatch="DENY", 不然日志就输出了。
    -->
    <Filters>
        <!-- >= error 的 FATAL、ERROR 被 DENY，< error 的 WARN、INFO、DEBUG、TRACE不拒绝不接受，直接放行让后序filter处理-->
		    <ThresholdFilter level="error" onMatch="DENY" onMismatch="NEUTRAL"/>
		    <!-- >= info 的 FATAL、ERROR、WARN、INFO 被 ACCEPT，< info 的 DEBUG、TRACE拒绝-->
		    <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
    </Filters>
    <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" charset="UTF-8"/>
</RollingFile >

日志级别一共有FATAL、ERROR、WARN、INFO、 DEBUG、TRACE 结合上述示例：

ThresholdFilter 第一次时： >= error 的 FATAL、ERROR 被 DENY(拒绝)，< error 的 WARN、INFO、DEBUG、TRACE不拒绝不接受，直接放行让后序filter处理
ThresholdFilter 第二次时： >= info 的 FATAL、ERROR、WARN、INFO 被 ACCEPT，< info 的 DEBUG、TRACE拒绝

所以上述示例中最后只有WARN、INFO两个级别的日志被写入到info.log文件中。

示例三：

<RollingFile name="RollingFileInfo" fileName="${FILE_PATH}/info.log" filePattern="${FILE_PATH}/${FILE_NAME}-INFO-%d{yyyy-MM-dd}_%i.log.gz">
    <!--
        设置 onMismatch="NEUTRAL" 可以让日志经过后续的过滤器
        最后一个过滤器建议设置 onMismatch="DENY", 不然日志就输出了。
    -->
    <Filters>
        <!-- 从大到小：error, warn, info, debug, trace -->
        <LevelRangeFilter minLevel="error" maxLevel="info" onMatch="ACCEPT" onMismatch="NEUTRAL" />        
        <!-- 只允许在每天的 8点~8点半 之间输出日志 -->
        <TimeFilter start="08:00:00" end="08:30:00" onMatch="ACCEPT" onMismatch="DENY" />
    </Filters>
    <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" charset="UTF-8"/>
</RollingFile >

LevelRangeFilter 对它们进行了 ACCEPT，而剩下的 trace Msg 和 debug Msg 则会经过下一个过滤器

3.3.3.2、Policies

Policy 是用来控制日志文件何时(When)进行 Rolling/滚动的；

所谓「日志滚动」就是当达到设定的条件后，日志文件进行切分。比如：工程师想让系统中的日志按日进行切分，并且按月归档。

Policy下的任意一个条件满足后都会触发日志归档。

<RollingFile name="RollingFile" fileName="logs/app.log"
                 filePattern="logs/$${date:yyyy-MM}/app-%d{yyyy-MM-dd-HH}-%i.log.gz">
 <PatternLayout>
    <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
  </PatternLayout>
  <Policies>
    <!-- 每 5s 翻滚一次 -->
    <!--<CronTriggeringPolicy schedule="0/5 * * * * ?" />-->

    <!--
        filePattern中最具体的时间单位是 秒。
        这里用 TimeBasedTriggeringPolicy 替换 CronTriggeringPolicy

        注意：modulate属性是指从启动时间开始算5秒，还是从0秒开始算5秒，运行一下就明白了。
        modulate: true(默认值) // 会从启动时间开始算 5秒
        modulate: false // 从 0秒开始算
    -->
    <TimeBasedTriggeringPolicy interval="5" modulate="true"/>
    <SizeBasedTriggeringPolicy size="100 MB"/>
  </Policies>
</RollingFile>

Policy常用的实现类:

SizeBasedTriggeringPolicy，根据日志文件的大小进行滚动。单位有：KB，MB，GB
CronTriggeringPolicy，使用 Cron 表达式进行日志滚动，很灵活
TimeBasedTriggeringPolicy，这个配置需要和filePattern结合使用，注意 filePattern 中配置的文件重命名规则。滚动策略依赖于 filePattern 中配置的最具体的时间单位，根据最具体的时间单位进行滚动。这种方式比较简洁。CronTriggeringPolicy 策略更强大
- 在 TimeBasedTriggeringPolicy 标签中加上了 modulate 属性并设置为 true，该属性的意思是是否对日志生成时间进行调制。若为 true，则日志时间将以 0 点为边界进行偏移计算。例如第一次日志保存时间是 3 点，modulate为 true，interval 是 4h。那么下次生成日志时间是 4点，08:00，12:00……。

3.3.3.3、Strategy

Strategy是用来控制日志文件如何(How)进行 Rolling/滚动的。

Strategy常用的实现类：

DefaultRolloverStrategy
DirectWriteRolloverStrategy

DefaultRolloverStrategy 默认的 max为 7。

<DefaultRolloverStrategy max="7"/>

max 参数指定了计数器的最大值。一旦计数器达到了最大值，过旧的文件将被删除。

注意：不要认为 max 参数是需要保留的日志文件的最大数目。

max 参数是与 filePattern 中的计数器 %i 配合起作用的，其具体作用方式与 filePattern 的配置密切相关。

1.如果filePattern中仅含有date/time pattern，每次rollover时，将用当前的日期和时间替换文件中的日期格式对文件进行重命名。max参数将不起作用。

如，filePattern="logs/app-%d{yyyy-MM-dd}.log"

2.如果 filePattern 中仅含有整数计数器（即%i ），每次 rollover 时，文件重命名时的计数器将每次加1（初始值为1），若达到 max 的值，将删除旧的文件。

如，filePattern="logs/app-%i.log"

3.如果 filePattern 中既含有 date/time pattern，又含有 %i，每次 rollover 时，计数器将每次加 1，若达到 max 的值，将删除旧的文件，直到 data/time pattern 不再符合，被替换为当前的日期和时间，计数器再从1开始。

如，filePattern="logs/app-%d{yyyy-MM-dd HH-mm}-%i.log"

3.4、Loggers

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

    <!-- additivity:是否向上级logger传递打印信息。默认是true。-->
    <!--[需修改] level: 若需要打印sql日志则需要修改为debug级别；否则为info级别。 -->
    <Logger name="com.example" level="debug" additivity="true">
    </Logger>

    <!--指定日志级别为info级别及以上-->
    <root level="info">
        <appender-ref ref="Console" />
        <!--指定日志级别为warn级别，只有warn及以上级别的日志会进入到RollingFileWarn中-->
        <appender-ref ref="RollingFileWarn" level="warn"/>
        <appender-ref ref="RollingFileError"/>
    </root>
</loggers>

节点
常见的有两种类型:root和logger, root实际上是一种特殊的logger。root节点用来指定项目的根日志，如果没有单独指定logger，那么就会默认使用该root日志输出。

root 标签有以下属性：
• level:日志输出级别
• appenderRef: 用来指定该日志输出到哪个Appender。

Logger 标签有以下属性：
● name：指定Logger的名称，名称可以是类名、包名或自定义的名称。例如，如果设置为com.example.MyLogger，则日志内容将包含该名称。
● level：指定Logger的日志级别，如果不指定则将继承Loggers标签中的默认级别。例如，如果设置为INFO，则只会记录INFO及以上级别的日志。
● additivity：指定Logger是否继承它的父Logger的Appender。如果不指定，则将继承Loggers标签中的默认值。
● includeLocation：指定是否包含日志输出的调用位置信息。如果设置为true，则输出的日志将包括文件名、方法名和行号等信息。
● suppressExceptions：指定是否屏蔽日志输出中的异常信息。如果设置为false，则将在日志输出中包含异常信息

Logger标签还包括AppenderRef子标签，用于指定Logger所要使用的Appender。可以在Logger标签中指定多个AppenderRef，这样就可以将同一个Logger的日志输出到多个Appender中。如果没有指定，就会默认继承自root。如果指定了，那么会在指定的这个appender和root的appender中都会输出，此时我们可以设置Logger的additivity="false"只在自定义的appender中进行输出。

同时additivity设置为true，
会将当前的Logger特性会传递给Root，
即上述的日志不仅会输出到test.log文件，
也会输出到Root指向的控制台，

3.4.1、Logger 等级实验

<logger name="org.springframework" level="INFO" additivity="true">
</logger>

<Root level="ERROR">
    <AppenderRef ref="Console"/>
    <AppenderRef ref="InfoLog"/>
    <AppenderRef ref="WarnLog"/>
    <AppenderRef ref="ErrorLog"/>
</Root>

ROOT 等级设为 ERROR 时，org.springframework Logger 等级设为 OFF 时，发现原来的 warn.log 和 info.log 文件中，都只有级别大于或等于 ERROR 的日志信息了；
ROOT 等级设为 ERROR 时，org.springframework Logger 等级设为 INFO 时，发现info.log 文件中，增加了 org.springframework 包的相关 INFO 级别的日志信息了；

总结

Logger 日志等级和 appender 日志等级的关系：logger 日志等级和 appender 日志等级，谁「高」听谁的；
普通 Logger 的优先级高

四、异步日志

log4j2日志框架有个比较牛的功能是异步日志记录性能。

我们先在上面的二、Log4j2整合步骤(即同步日志)框架下测试以下代码打印耗时。

package com.example.demo.controller;

import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController(value = "/user")
@Slf4j
public class UserController {
    private static final Logger logger = LoggerFactory.getLogger(UserController.class);


    @GetMapping("/testLog")
    public void testLog() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            log.info("这是第{}次日志", i);
        }
        long end = System.currentTimeMillis();
        log.info("当前打印日志耗时：{}", (end - start));
    }


}

在这里插入图片描述
由上面的结果可以看出日志打印的耗时很长，所以为了解决日志耗时过长的问题，我们引入一个“异步日志”的工具—disruptor，它可以大大缩短耗时，优化性能。

4.1、引入disruptor

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

4.2、修改启动类

package com.example.demo;


import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import springfox.documentation.swagger2.annotations.EnableSwagger2WebMvc;

@SpringBootApplication
@MapperScan("com.example.demo.mapper")
//开启swagger功能
@EnableSwagger2WebMvc
public class MainApplication {

    public static void main(String[] args) {
        // 异步日志
        System.setProperty("log4jContextSelector", "org.apache.logging.log4j.core.async.AsyncLoggerContextSelector");
        SpringApplication.run(MainApplication.class,args);
    }
}

4.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{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n" />
        <!-- 定义日志存储的路径 -->
        <property name="FILE_PATH" value="./logs" />
        <property name="FILE_NAME" value="demo" />
    </Properties>

    <appenders>

        <console name="Console" target="SYSTEM_OUT">
            <!--输出日志的格式及颜色-->
            <PatternLayout pattern="[%style{%d}{bright,yellow}][%style{%t}{bright,blue}][%highlight{%p}][%style{%C}{bright,green}]: %msg%n%style{%throwable}{red}"
                           disableAnsi="false" noConsoleNoAnsi="false"/>
        </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}/$${date:yyyy-MM-dd}/info-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="debug" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，此处单位是1 天
					单位是由于filePattern中的最小单位决定的，本示例中filePattern的格式是年月日，所以最小单位是天。若filePattern格式是时分秒，则TimeBasedTriggeringPolicy的单位是秒。
				-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="30MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy fileIndex="nomax">
                <!--删除${FILE_PATH}目录及子目录下 180天前的.log.gz后缀的文件 -->
                <Delete basePath="${FILE_PATH}" maxDepth="2">
                    <IfFileName glob="*/*.log.gz"/>
                    <IfLastModified age="180d"/>
                </Delete>
            </DefaultRolloverStrategy>
        </RollingFile>

        <!-- 这个会打印出所有的warn及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileWarn" fileName="${FILE_PATH}/warn.log" filePattern="${FILE_PATH}/$${date:yyyy-MM-dd}/warn-%d{yyyy-MM-dd}_%i.log.gz">
            <Filters>
                <!--过滤掉error及更高级别日志-->
                <ThresholdFilter level="error" onMatch="DENY" onMismatch="NEUTRAL"/>
            </Filters>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，此处单位是1 天-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="30MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy fileIndex="nomax">
                <!--删除${FILE_PATH}目录及子目录下 180天前的.log.gz后缀的文件 -->
                <Delete basePath="${FILE_PATH}" maxDepth="2">
                    <IfFileName glob="*/*.log.gz"/>
                    <IfLastModified age="180d"/>
                </Delete>
            </DefaultRolloverStrategy>
        </RollingFile>

        <!-- 这个会打印出所有的error及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileError" fileName="${FILE_PATH}/error.log" filePattern="${FILE_PATH}/$${date:yyyy-MM-dd}/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="30MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy fileIndex="nomax">
                <!--删除${FILE_PATH}目录及子目录下 180天前的.log.gz后缀的文件 -->
                <Delete basePath="${FILE_PATH}" maxDepth="2">
                    <IfFileName glob="*/*.log.gz"/>
                    <IfLastModified age="180d"/>
                </Delete>
            </DefaultRolloverStrategy>
        </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="true">
            <!--<AppenderRef ref="Console"/>-->
        </Logger>

        <!-- additivity:是否向上级logger传递打印信息。默认是true。-->
        <!-- name="com.example"修改为自己的项目目录 -->
        <!--[需修改] level: 若需要打印sql日志则需要修改为debug级别；否则为info级别。 -->
        <Logger name="com.example" level="debug" additivity="true">
        </Logger>

         <!-- 异步日志 -->
        <AsyncLogger name="asyncLog" level="info" additivity="false">
            <appender-ref ref="RollingFileInfo"/>
        </AsyncLogger>

        <AsyncRoot level="info">
            <AppenderRef ref="RollingFileInfo"/>
        </AsyncRoot>

        <!--<root level="info">
            <appender-ref ref="Console" />
            <appender-ref ref="Filelog"/>
            <appender-ref ref="RollingFileInfo"/>
            <appender-ref ref="RollingFileWarn" level="warn"/>
            <appender-ref ref="RollingFileError"/>
        </root>-->
    </loggers>


</configuration>

4.4、再次进行测试

可以发现，控制台没有输出相关日志，这时候我们需要去找到在日志文件中配置的日志存放地址，查看具体的日志
在这里插入图片描述
打开文件后可见耗时大大缩短！！！

五、可能遇到的问题

5.1、日志打印不生效？

日志打印不生效可能是由于以下几种原因：

依赖冲突 ：springboot默认集成logback日志，所以需要把spring-boot-starter-logging依赖排除掉。spring-boot-starter-logging一般存在于spring-boot-starter-web、actuator等依赖中。

5.2、日志重复打印问题

有时候我们发现控制台或日志文件中打印了两次日志。这是为什么呢？

如果 Root 中的日志包含了 Logger 中的日志信息，并且 AppenderRef 是一样的配置，则日志会打印两次。

这时候我们需要使用一个 Logger 的属性来解决，那就是 additivity，其默认值为 true，需要配置为false

<Loggers>
   <Logger name="com.demo" level="info" additivity="true">
        <AppenderRef ref="Console"/>
    </Logger>

    <Root level="all">
        <AppenderRef ref="Console"/>
    </Root>
</Loggers>

如上图：我们在<Logger>标签中设置在控制台打印，并且设置additivity="true" ，所以日志会传递到root标签中再打印一次，结果就是打印了两次。

解决方法

方法一：在<Logger>中设置additivity="true"但是不引入<AppenderRef标签
<Loggers>
   <Logger name="com.demo" level="info" additivity="true">
    </Logger>

    <Root level="all">
        <AppenderRef ref="Console"/>
    </Root>
</Loggers>

方法二：在<Logger>中设置additivity="false",日志只会在<Logger>标签下的<AppenderRef中打印，不会传递到root标签中
<Loggers>
   <Logger name="com.demo" level="info" additivity="false">
        <AppenderRef ref="Console"/>
    </Logger>

    <Root level="all">
        <AppenderRef ref="Console"/>
    </Root>
</Loggers>

六、总结

6.1、Policy & Strategy

Policy 是用来控制日志文件何时(When)进行 Rolling/滚动的；
Strategy是用来控制日志文件如何(How)进行 Rolling/滚动的。

通俗理解就是：

Policy控制日志文件的生成。如按大小生成（每2M生成一个文件）、按时间生成（每小时/每天生成文件）；
Strategy控制日志文件的重命名及删除策略。如：当前目录下只保留3个文件、删除180天前的文件等等。

6.2、源码文件

git地址：springboot-log4j2

参考或推荐文章：
log4j官网地址：https://logging.apache.org/log4j/2.x/index.html
Log4j2配置官网地址：https://logging.apache.org/log4j/2.x/manual/configuration.html#AutomaticConfiguration
https://www.jianshu.com/p/8b30d312a47b
https://blog.csdn.net/bluuusea/article/details/104763368
https://open.alipay.com/portal/forum/post/137701054
https://blog.51cto.com/u_16213711/11732219