Log4j2日志技术总结

前言

现在流行是SLF4j和Log4j2组合的日志技术，但为了日志技术归类，故前因后果都将做一下介绍。

市场上流行的日志框架

• JUL java util logging
  
  Java开发团队开发，Jdk原生版本，日志实现框架;
• Log4j
  
  Apache的一个开源项目;
• Logback
  
  由Log4j之父离职后做的另一个开源项目
  
  业界中称作log4j后浪；
• Log4j2
  
  Log4j官方的第二个版本，各个方面都是与Logback及其相似
  
  具有插件式结构、配置文件优化等特征
  
  Spring Boot1.4版本以后就不再支持log4j，所以第二个版本营运而生
• JCL
  
  第一个日志门面技术框架，apache旗下开发的日志门面技术
• SLF4j
  
  在JCL之后，由Log4j之父和Logback一起开发。

JCL 日志门面框架

简介

全称为Jakarta Commons Logging，是Apache提供的一个通用日志API。

使用它的好处就是，代码依赖是common-logging而非log4j的API， 避免了和具体的日志API直接耦合，在有必要时，可以更改日志实现的第三方库。

组件介绍

• Log 日志记录器
  
  负责日志输出等操作
• LogFactory
  
  日志工厂，负责创建Log实例。

JCL组件Maven依赖

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

SLF4J 日志门面框架

简介

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

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

SLF4J桥接技术

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

SLF4J组件Maven依赖

<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.25</version>
</dependency>

JUL日志实现框架

简介

JUL全程 Java Util Logging，它是java原生的日志框架，使用时不需要另外引用第三方的类库，相对其他的框架使用方便，学习简单，主要是使用在小型应用中。

JUL组件介绍

• Logger：记录器
  
  应用程序通过获取Logger对象，抵用其API来发布日志信息。Logger通常被认为是访问日志系统的入口程序。
• Handler：处理器
  
  每个Logger都会关联一个或者是一组Handler，Logger会将日志交给关联的Handler去做处理，由Handler负责将日志做记录。Handler具体实现了日志的输出位置，比如可以输出到控制台或者是文件中等等。
• Filter：过滤器
  
  根据需要定制哪些信息会被记录，哪些信息会被略过。
• Formatter：格式化组件
  
  它负责对日志中的数据和信息进行转换和格式化，所以它决定了我们输出日志最终的形式。
• Level：日志的输出级别
  
  每条日志消息都有一个关联的级别。我们根据输出级别的设置，用来展现最终所呈现的日志信息。根据不同的需求，去设置不同的级别。

基本配置

java.home --> 找到jre文件夹 --> lib --> logging.properties;具体配置略。

Log4j 日志实现框架

简介

Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

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

我们使用log4j技术，主要使用的是其配置文件

Log4j 1.0 现已停止维护，故使用Log4j要么升级到Lokback，要么升级到Log4j 2.0

Log4j组件介绍

• Loggers

日志记录器，负责收集处理日志记录，实例的命名就是类的全限定名，如com.bjpowernode.log4j.XX， Logger的名字大小写敏感，其命名有继承机制：例如：name为com.bjpowernode.log4j的logger会继承 name为com.bjpowernode。 Log4J中有一个特殊的logger叫做“root”，他是所有logger的根，也就意味着其他所有的logger都会直接 或者间接地继承自root。root logger可以用Logger.getRootLogger()方法获取。自log4j 1.2版以来， Logger 类已经取代了 Category 类。对于熟悉早期版本的log4j的人来说， Logger 类可以被视为 Category 类的别名。

com.bjpowernode.log4j.XX 儿子

com.bjpowernode.log4j 父亲

com.bjpowernode 爷爷

..

..

Root logger

上辈所做的日志属性设置，会直接的影响到子辈

关于日志级别信息，例如DEBUG、INFO、WARN、ERROR…级别是分大小的，DEBUG < INFO < WARN < ERROR，分别用来指定这条日志信息的重要程度，Log4j输出日志的规则是：只输出级别不低于设定级别的日志信息，假设Loggers级别设定为INFO，则INFO、WARN、ERROR级别的日志信息都会输出，而级别比INFO低的DEBUG则不会输出。

• Appenders

记录日志以及定义日志的级别仅仅是Log4j的基本功能，Log4j日志系统还提供许多强大的功能，比如允许把日志输出到不同的地方，如控制台（Console）、文件（Files）等，可以根据天数或者文件大小产生新的文件，可以以流的形式发送到其它地方等等。

常用Appenders：

ConsoleAppender: 将日志输出到控制台;

FileAppender:将日志输出到文件中;

DailyRollingFileAppender:将日志输出到一个日志文件，并且每天输出到一个新的文件;

RollingFileAppender:将日志信息输出到一个日志文件，并且指定文件的尺寸，当文件大小达到指定尺寸时，会自动把文件改名，同时产生一个新的文件;

JDBCAppender:把日志信息保存到数据库中.

• Layouts

有时用户希望根据自己的喜好格式化自己的日志输出，Log4j可以在Appenders的后面附加Layouts来完成这个功能。Layouts提供四种日志输出样式，如根据HTML样式、自由指定样式、包含日志级别与信息的样式和包含日志时间、线程、类别等信息的样式。

常用Layouts:

HTMLLayout:格式化日志输出为HTML表格形式;

SimpleLayout:简单的日志输出格式化，打印的日志格式如默认INFO级别的消息;

PatternLayout:最强大的格式化组件，可以根据自定义格式输出日志，如果没有指定转换格式， 就是用默认的转换格式.

日志输出格式说明

使用PatternLayout可以自定义格式输出，是我们最常用的方式

这种格式化输出采用类似于 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字符，就从左边交远销出的字符截掉

添加依赖

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

基本配置

#配置根节点logger
log4j.rootLogger=trace,console

#配置自定义logger
log4j.logger.com.bjpowernode.log4j.test=info,file

#配置apache的logger
#log4j.logger.org.apache=error

#配置appender输出方式 输出到控制台
log4j.appender.console=org.apache.log4j.ConsoleAppender
#配置输出到控制台的格式
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.conversionPattern=[%-10p]%r %c%t%d{yyyy-MM-dd HH:mm:ss:SSS} %m%n

#配置appender输出方式 输出到文件
log4j.appender.file=org.apache.log4j.FileAppender
#配置输出到文件中的格式
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.conversionPattern=[%-10p]%r %c%t%d{yyyy-MM-dd HH:mm:ss:SSS} %m%n
#第一个file是我们自己命名的appenderName，第二个file是用来指定文件位置的属性
log4j.appender.file.file=D://test//log4j.log
#配置输出字符编码
log4j.appender.file.encoding=UTF-8

#RollingFileAppender的配置，我们可以针对于实际含义起名
log4j.appender.rollingFile=org.apache.log4j.RollingFileAppender
log4j.appender.rollingFile.layout=org.apache.log4j.PatternLayout
log4j.appender.rollingFile.layout.conversionPattern=[%-10p]%r %c%t%d{yyyy-MM-dd HH:mm:ss:SSS} %m%n
log4j.appender.rollingFile.file=D://test//log4j.log
log4j.appender.rollingFile.encoding=UTF-8
#指定日志文件内容大小
log4j.appender.rollingFile.maxFileSize=1MB
#指定日志文件的数量
log4j.appender.rollingFile.maxBackupIndex=5

#DailyRollingFileAppender的配置，我们可以针对于实际含义起名
log4j.appender.dailyRollingFile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.dailyRollingFile.layout=org.apache.log4j.PatternLayout
log4j.appender.dailyRollingFile.layout.conversionPattern=[%-10p]%r %c%t%d{yyyy-MM-dd HH:mm:ss:SSS} %m%n
log4j.appender.dailyRollingFile.file=D://test//log4j.log
log4j.appender.dailyRollingFile.encoding=UTF-8
log4j.appender.dailyRollingFile.datePattern='.'yyyy-MM-dd HH-mm-ss

#配置appender输出方式 输出到数据库表
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=123456
log4j.appender.logDB.Sql=INSERT INTO tbl_log(name,createTime,level,category,fileName,message) values('project_log','%d{yyyy-MM-dd HH:mm:ss}','%p','%c','%F','%m')

Logback日志实现框架

简介

Logback是由log4j创始人设计的又一个开源日志组件。

Logback当前分成三个模块：logback-core,logback- classic和logback-access。

logback-core是其它两个模块的基础模块。

logback-classic是log4j的一个改良版本。此外logback-classic完整实现SLF4J API。使你可以很方便地更换成其它日志系统如log4j或JDK14 Logging。

logback-access访问模块与Servlet容器集成提供通过Http来访问日志的功能。

Logback组件介绍

• Logger

日志的记录器，主要用于存放日志对象，也可以定义日志类型、级别。

• Appender

用于指定日志输出的目的地，目的地可以是控制台、文件、数据库等等。

• Layout

负责把事件转换成字符串，格式化的日志信息的输出;在Logback中Layout对象被封装在encoder中;也就是说我们未来使用的encoder其实就是Layout。

Logback提供的配置文件

logback.groovy,logback-test.xml,logback.xml。

如果都不存在则采用默认的配置

Logback日志输出格式

%-10level  级别 案例为设置10个字符，左对齐
%d{yyyy-MM-dd HH:mm:ss.SSS} 日期
%c  当前类全限定名
%M  当前执行日志的方法
%L  行号
%thread 线程名称
%m或者%msg    信息
%n  换行

Logback依赖

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

Logback的XML配置

<?xml version="1.0" encoding="UTF-8"?>
<!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 -->
<!-- scan:当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true -->
<!-- scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
<!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
<configuration scan="true" scanPeriod="10seconds" debug="false">

    <!--

        配置文件通用属性
        <property name="" value=""></property>
        所谓配置文件中的通用属性是为了让接下来的配置更加方便引用
        通过以${name}的形式，方便的取得value值
        通过取得的value值可以做文件的其他配置而使用

    -->

    <!--

        我们在此可以先做日志输出格式相关的配置
        %-10level  级别 案例为设置10个字符，左对齐
        %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
        %c  当前类全限定名
        %M  当前执行日志的方法
        %L  行号
        %thread 线程名称
        %m或者%msg    信息
        %n  换行

        以property的形式将日志输出格式配置成为文件的通用的属性
        那么下面我们配置的输出方式中，就可以重复的引用该配置（以下的配置，对于输出格式就不用配置多次了）

    -->
    <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %L %thread %m%n"></property>
    <property name="pattern1" value="[%-5level]%d{yyyy-MM-dd HH:mm:ss.SSS}%c%M%L%thread%m%n"></property>

    <!-- 配置文件的输出路径 -->
    <property name="logDir" value="D://test"></property>

    <!-- 配置文件的appender 普通文件-->
    <appender name="fileAppender" class="ch.qos.logback.core.FileAppender">

        <!-- 引入文件位置 -->
        <file>${logDir}/logback.log</file>

        <!-- 设置输出格式 -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>

    </appender>

    <!-- 配置控制台appender -->
    <appender name="consoleAppender" 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 html文件 -->
    <appender name="htmlFileAppender" class="ch.qos.logback.core.FileAppender">

        <file>${logDir}/logback.html</file>
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">

            <layout class="ch.qos.logback.classic.html.HTMLLayout">

                <pattern>${pattern1}</pattern>

            </layout>

        </encoder>

    </appender>

    <!-- 配置文件的appender 可拆分归档的文件 -->
    <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">

        <!-- 输入格式 -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
            <charset>UTF-8</charset> <!-- 设置字符集 -->
        </encoder>
        <!-- 引入文件位置 -->
        <file>${logDir}/roll_logback.log</file>

        <!-- 指定拆分规则 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">

            <!-- 按照时间和压缩格式声明文件名 压缩格式gz -->
            <fileNamePattern>${logDir}/roll.%d{yyyy-MM-dd}.log%i.gz</fileNamePattern>

            <!-- 按照文件大小来进行拆分 -->
            <maxFileSize>1KB</maxFileSize>
              <!--日志文件保留天数-->
            <maxHistory>120</maxHistory>
        </rollingPolicy>
      <!-- 此日志文件只记录INFO级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>INFO</level>
            <onMatch>NEUTRAL</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 配置控制台的appender 使用过滤器 -->
    <appender name="consoleFilterAppender" class="ch.qos.logback.core.ConsoleAppender">

        <target>
            System.err
        </target>

        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>

        <!-- 配置过滤器 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">

            <!-- 设置日志的输出级别 -->
            <level>ERROR</level>

            <!-- 高于level中设置的级别，则打印日志 -->
            <onMatch>ACCEPT</onMatch>

            <!-- 低于level中设置的级别，则屏蔽日志 -->
            <onMismatch>DENY</onMismatch>

        </filter>

    </appender>

    <!-- 配置异步日志 -->
    <appender name="asyncAppender" class="ch.qos.logback.classic.AsyncAppender">
        <appender-ref ref="consoleAppender"/>
    </appender>

    <!--

        日志记录器
        配置root logger
        level：配置日志级别

        可以同时配置多个appender，做日志的多方向输出

    -->
    <root level="ALL">

        <!-- 引入appender -->
        <!--<appender-ref ref="roll"/>-->
        <!--<appender-ref ref="consoleFilterAppender"/>-->
        <!--<appender-ref ref="consoleAppender"/>-->
        <appender-ref ref="asyncAppender"/>
    </root>

    <!--

        additivity="false"
        表示不继承rootlogger

    -->
    <logger name="com.bjpowernode" level="info" additivity="false">

        <!-- 在自定义logger中配置appender -->
        <appender-ref ref="consoleAppender"/>

    </logger>

</configuration>

Log4j2

Log4j2简介

Apache Log4j 2是对Log4j的升级，它比其前身Log4j 1.x提供了重大改进，并提供了Logback中可用的许多改进，同时修复了Logback架构中的一些问题。被誉为是目前最优秀的Java日志框架。

Log4j2特征

性能提升

Log4j2包含基于LMAX Disruptor库的下一代异步记录器。在多线程场景中，异步记录器的吞吐量比Log4j 1.x和Logback高18倍，延迟低。

自动重新加载配置

与Logback一样，Log4j2可以在修改时自动重新加载其配置。与Logback不同，它会在重新配置发生时不会丢失日志事件。

高级过滤

与Logback一样，Log4j2支持基于Log事件中的上下文数据，标记，正则表达式和其他组件进行过滤。

此外，过滤器还可以与记录器关联。与Logback不同，Log4j2可以在任何这些情况下使用通用的Filter类。

插件架构

Log4j使用插件模式配置组件。因此，您无需编写代码来创建和配置Appender，Layout，Pattern Converter等。在配置了的情况下，Log4j自动识别插件并使用它们。

无垃圾机制

在稳态日志记录期间，Log4j2 在独立应用程序中是无垃圾的，在Web应用程序中是低垃圾。这减少了垃圾收集器的压力，并且可以提供更好的响应性能。

SLF4j + Log4j2 的组合，是市场上最强大的日志功能实现方式，绝对是未来的主流趋势。

Log4j2异步日志

异步日志是log4j2最大的特色，其性能的提升主要也是从异步日志中受益。

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

AsyncAppender方式

是通过引用别的Appender来实现的，当有日志事件到达时，会开启另外一个线程来处理它们。需要注意的是，如果在Appender的时候出现异常，对应用来说是无法感知的。 AsyncAppender应该在它引用的Appender之后配置，默认使用 java.util.concurrent.ArrayBlockingQueue实现而不需要其它外部的类库。 当使用此Appender的时候，在多线程的环境下需要注意，阻塞队列容易受到锁争用的影响，这可能会对性能产生影响。这时候，我们应该考虑使用无锁的异步记录器（AsyncLogger）。

AsyncLogger方式

AsyncLogger才是log4j2实现异步最重要的功能体现，也是官方推荐的异步方式。

它可以使得调用Logger.log返回的更快。你可以有两种选择：全局异步和混合异步。

全局异步：所有的日志都异步的记录，在配置文件上不用做任何改动，只需要在jvm启动的时候增加一个参数即可实现。

混合异步：你可以在应用中同时使用同步日志和异步日志，这使得日志的配置方式更加灵活。虽然Log4j2提供以一套异常处理机制，可以覆盖大部分的状态，但是还是会有一小部分的特殊情况是无法完全处理的，比如我们如果是记录审计日志（特殊情况之一），那么官方就推荐使用同步日志的方式，而对于其他的一些仅仅是记录一个程序日志的地方，使用异步日志将大幅提升性能，减少对应用本身的影响。

混合异步的方式需要通过修改配置文件来实现，使用AsyncLogger标记配置。

这是两种不同的实现方式，在设计和源码上都是不同的体现。

Log4j2依赖

    <!-- log4j2日志实现 -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.12.1</version>
        </dependency>

        <!-- 异步日志依赖 -->
        <dependency>
            <groupId>com.lmax</groupId>
            <artifactId>disruptor</artifactId>
            <version>3.3.7</version>
        </dependency>
		 <!-- slf4j日志门面 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
        <!-- log4j适配器 -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.12.1</version>
        </dependency>

Log4j2的配置文件->log4j2.xml

<?xml version='1.0' encoding='UTF-8' ?>
<!--status用来指定log4j本身的打印日志的级别-->
<!--monitorinterval用于指定log4j自动重新配置的监测间隔时间，单位是s,最小是5s.-->

<!--　日志共有8个级别，按照从低到高为：All < Trace < Debug < Info < Warn < Error < Fatal < OFF.

        　　　　　　All:最低等级的，用于打开所有日志记录.

        　　　　　　Trace:是追踪，就是程序推进以下，你就可以写个trace输出，所以trace应该会特别多，不过没关系，我们可以设置最低日志级别不让他输出.

        　　　　　　Debug:指出细粒度信息事件对调试应用程序是非常有帮助的.

        　　　　　　Info:消息在粗粒度级别上突出强调应用程序的运行过程.

        　　　　　　Warn:输出警告及warn以下级别的日志.

        　　　　　　Error:输出错误信息日志.

        　　　　　　Fatal:输出每个严重的错误事件将会导致应用程序的退出的日志.

        　　　　　　OFF:最高等级的，用于关闭所有日志记录.-->
<configuration status="info"  monitorInterval="10">

    <!--配置全局通用属性-->
    <properties>
        <property name="PRO_NAME">logs</property>
        <property name="PRO_NAMEPAYMENT">logspayment</property>
        <property name="PATTERN_LAYOUT">%date{dd HH:mm:ss.SSS} %highlight{%-5level}|%style{%X{requestId}}|%l:%m%n
        </property>
        <property name="PATTERN_ERROR">%date{dd HH:mm:ss.SSS} %highlight{%-5level|%X{requestId}| %l:%m%n}
        </property>
    </properties>

    <Appenders>
        <!--name:指定Appender的名字-->
        <!--target:SYSTEM_OUT 或 SYSTEM_ERR,一般只设置默认:SYSTEM_OUT-->
        <!--PatternLayout:输出格式，不设置默认为:%m%n.-->
        <Console name="ConsoleInfo" target="SYSTEM_OUT" >
            <Filters>
                <!--如果是error级别拒绝-->
                <ThresholdFilter level="error" onMatch="DENY" onMismatch="NEUTRAL"/>
                <!--如果是debug\info\warn输出-->
                <ThresholdFilter level="debug" onMatch="ACCEPT" onMismatch="DENY"/>
            </Filters>
            <PatternLayout pattern="${PATTERN_LAYOUT}" charset="UTF-8" disableAnsi="false" noConsoleNoAnsi="false"/>
        </Console>

        <Console name="ConsoleError" target="SYSTEM_OUT">
            <PatternLayout pattern="${PATTERN_ERROR}" charset="UTF-8" disableAnsi="false" noConsoleNoAnsi="false"/>
            <Filters>
                <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
            </Filters>
        </Console>

        <!--
            按照指定规则来拆分日志文件

            fileName:日志文件的名字
            filePattern：日志文件拆分后文件的命名规则
                        %d{yyyy-MM-dd HH时mm分}：根据分钟，创建一个压缩文件
          注意:log.gz代表自动压缩 log代表文件夹
          rollog-%d{yyyy-MM-dd-HH-mm}-%i.log
                        为文件命名的规则：%i表示序号，从0开始，目的是为了让每一份文件名字不会重复
        -->
        <RollingFile name="FileInfo" fileName="${PRO_NAME}/info.log"
                     filePattern="${PRO_NAME}/info/info-%d{yyyy-MM-dd HH时mm分}-%i.log.gz">
            <PatternLayout pattern="${PATTERN_LAYOUT}"/>
            <!-- 指定滚动日志的策略，就是什么时候进行新建日志文件输出日志.-->
            <Policies>
                <!-- 间隔时间 10分钟分割一次  -->
                <TimeBasedTriggeringPolicy interval="10" modulate="true"/>
                <!-- 单个文件超过200M 分割一次-->
                <SizeBasedTriggeringPolicy size="200MB"/>
            </Policies>
            <!--保存日志文件个数-->
            <!-- 在同一目录下，文件的个数限制，如果超出了设置的数值，则根据时间进行覆盖，新的覆盖旧的规则-->
            <DefaultRolloverStrategy max="120"/>
        </RollingFile>

        <!--单独节点日志配置-->
        <!--
            按照指定规则来拆分日志文件

            fileName:日志文件的名字
            filePattern：日志文件拆分后文件的命名规则
                        $${date:yyyy-MM-dd}：根据日期当天，创建一个文件夹
                                    例如：2021-01-01这个文件夹中，记录当天的所有日志信息（拆分出来的日志放在这个文件夹中）
                                          2021-01-02这个文件夹中，记录当天的所有日志信息（拆分出来的日志放在这个文件夹中）
          rollog-%d{yyyy-MM-dd-HH-mm}-%i.log
                        为文件命名的规则：%i表示序号，从0开始，目的是为了让每一份文件名字不会重复
        -->
        <RollingFile name="FileInfopayment" fileName="${PRO_NAMEPAYMENT}/info.log"
                     filePattern="${PRO_NAMEPAYMENT}/info/info-%d{yyyy-MM-dd}-%i.log" modulate="true">
            <PatternLayout pattern="${PATTERN_LAYOUT}"/>
            <Policies>
                <!-- 间隔时间 1天分割一次  -->
                <TimeBasedTriggeringPolicy interval="1" modulate="true"/>
                <!-- 单个文件超过200M 分割一次-->
                <SizeBasedTriggeringPolicy size="200MB"/>
                <!-- 在系统启动时，触发拆分规则，产生一个日志文件 -->
                <OnStartupTriggeringPolicy/>
            </Policies>
            <!--保存日志文件个数-->
            <!-- 在同一目录下，文件的个数限制，如果超出了设置的数值，则根据时间进行覆盖，新的覆盖旧的规则-->
            <DefaultRolloverStrategy max="120"/>
        </RollingFile>

        <!-- 配置异步日志 -->
        <Async name="myAsync">

            <!-- 将控制台输出做异步的操作-->
            <AppenderRef ref="ConsoleInfo"/>
            <AppenderRef ref="ConsoleError"/>
        </Async>
    </Appenders>

    <Loggers>

        <!-- 配置rootlogger -->
        <Root level="trace">

            <!-- 将控制台异步输出-->
            <AppenderRef ref="myAsync"/>
            <AppenderRef ref="FileInfo"/>
        </Root>

        <!-- 自定义logger，让自定义的logger为异步logger -->
        <!--
            level 代表日志打印级别
            includeLocation="false"
            表示去除日志记录中的行号信息，这个行号信息非常的影响日志记录的效率（生产中都不加这个行号）
            严重的时候可能记录的比同步的日志效率还有低

            additivity="false"
            表示不继承rootlogger

        -->
        <AsyncLogger name="com.yxkj.netplus.modular.payment" level="trace"
                     includeLocation="false" additivity="false">

            <!-- 将控制台异步输出-->
            <AppenderRef ref="myAsync"/>
            <AppenderRef ref="FileInfopayment"/>
        </AsyncLogger>
    </Loggers>
</configuration>

SpringBoot集成日志

SpringBoot集成LogBack

SpringBoot默认集成了LogBack，若要使用LogBack日志打印，则只需要在resources文件夹下配置logback.xml即可

SpringBoot集成Log4J2

• 第一步:依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions><!-- 排除LogBack依赖 -->
                <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>
<!-- 异步日志依赖 -->
        <dependency>
            <groupId>com.lmax</groupId>
            <artifactId>disruptor</artifactId>
            <version>3.3.7</version>
        </dependency>

• 第二步:添加配置文件

在respurces文件夹下添加Log4j2.xml配置文件

参考

视屏参考:https://www.bilibili.com/video/BV1Mb4y1Z74W?p=85

Log4j2配置文件参考:https://www.cnblogs.com/keeya/p/10101547.html