Bootstrap

Java的常用日志技术（三）Log4j2及Log4j2与slfj整合详解

1、Log4j2简介

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

2、Log4j2特征

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看作是日志的实现e
        SLF4j+Log4j2的组合，是市场上最强大的日志功能实现方式，绝对是未来的主流趋势。

 3、log4j2常用标签

  • 根节点Configuration有两个属性:status和monitorinterval,有两个子节点:Appenders和Loggers.
    status用来指定log4j本身的打印日志的级别.
    monitorinterval用于指定log4j自动重新加载配置的监测间隔时间，单位是s,最小是5s.
  • Appenders节点，常见的有三种子节点:Console、RollingFile、File.
    * Console节点用来定义输出到控制台的Appender.
    　　 name:指定Appender的名字.
    　　 target:SYSTEM_OUT 或 SYSTEM_ERR,一般只设置默认:SYSTEM_OUT.
    　　 PatternLayout:输出格式，不设置默认为:%m%n.
    * File节点用来定义输出到指定位置的文件的Appender.
    　　name:指定Appender的名字.
    　　fileName:指定输出日志的目的文件带全路径的文件名.
    　　PatternLayout:输出格式，不设置默认为:%m%n.
    * RollingFile节点用来定义超过指定大小自动删除旧的创建新的的Appender.
    　　name:指定Appender的名字.
    　　fileName:指定输出日志的目的文件带全路径的文件名.
    　　PatternLayout:输出格式，不设置默认为:%m%n.
    　　filePattern:指定新建日志文件的名称格式.
    　　Policies:指定滚动日志的策略，就是什么时候进行新建日志文件输出日志.
    　　TimeBasedTriggeringPolicy:Policies子节点，基于时间的滚动策略，interval属性用来指定多久滚动一次．
    　　SizeBasedTriggeringPolicy:Policies子节点，基于指定文件大小的滚动策略，size属性用来定义
    　　每个日志文件的大小.
    　　DefaultRolloverStrategy:用来指定同一个文件夹下最多有几个日志文件时开始删除最旧的，
    　　如果不做配置，默认是7
    　
  • Loggers节点，常见的有两种:Root和Logger.
    * Root节点用来指定项目的根日志，如果没有单独指定Logger，那么就会默认使用该Root日志输出
    　　AppenderRef：Root的子节点，用来指定该日志输出到哪个Appender.
    * Logger节点用来单独指定日志的形式，比如要为指定包下的class指定不同的日志级别等。
    　　name:用来指定该Logger所适用的类或者类所在的包全路径,继承自Root节点.

 4、实现案例

001、在pom文件中导入依赖

<dependencies>
  <dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.12.1</version>
  </dependency>
  <!--log4j-core中有log4j-api的依赖包 ,所以可以不添加og4j-api依赖-->
  <!--<dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-api</artifactId>
      <version>2.11.1</version>
  </dependency>-->

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

  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.17</version>
  </dependency>
</dependencies>

002、创建测试类

package com.hwadee.log;

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


public class Log4j2Test {
    @Test
    public void test() {
        Logger logger = LogManager.getLogger(Log4j2Test.class);
        logger.fatal("fatal 信息");
        logger.error("error 错误信息，不会影响系统运行");
        logger.warn("warn 警告信息,可能会发生问题");
        logger.info("info 运行信息，数据连接、网络连接、I0操作等等");
        logger.debug("debug 调试信息，一般在开发中使用，记录程序变量参数传递信息等等");
        logger.trace("trace 追踪信息，记录程序所有的流程信息");
        
    }
}

003、启动测试类，运行效果如下：

 ERROR StatusLogger No Log4j 2 configuration file found 说明没有配置文件。

5、输出到控制台

001、在resources下创建log4j2的配置文件：log4j2.xml，如下：

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="WARN" monitorInterval="30">
    <!--定义所有的appender -->
    <appenders>
    <!--这个输出控制台的配置 
        target="SYSTEM_OUT 默认黑色字体，
        target="SYSTEM_ERR 设置红色字体-->
    <console name="consoleAppender" target="SYSTEM_ERR ">
        <!--输出日志的格式 -->
        <PatternLayout
                    pattern="[%-5level] %d{yyyy-MM-dd HH:mm:ss.sss} %c %M %L %thread %m%n" />
    </console>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效 -->
    <loggers>
        <root level="trace">
            <appender-ref ref="consoleAppender" />
        </root>
    </loggers>
</configuration>

002、 运行启动类，运行结果如下；

6、slf4j与log4j2组合

       虽然log4j2也是日志门面，但是现在市场的主流趋势仍然是slf4j，所以我们仍然需要使用slf4j作为日志门面，搭配log4j2强大的日志实现功能，进行日志的相关操作。
       接下来我们配置的就是当今市场上的最强大，最主流的日志使用搭配方式:slf4j+log4j2

  1.  导入slf4j的日志门面
  2.  导入log4j2的适配器
  3.  导入log4j2的日志门面
  4. 导入log4j2的日志实现执行原理:  slf4j门面调用的是log4j2的门面，再由log4j2的门面调用log4j2的实现。

001、在pom文件中添加slf4j、log4j2、slf4j与log4j2的连接器依赖，如下：

<dependencies>
  <!--slf4j与log4j2实现所需要的日志依赖   start-->
  <dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.12.1</version>
  </dependency>
  <!--log4j-core中有log4j-api的依赖包 ,所以可以不添加og4j-api依赖-->
  <!--<dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-api</artifactId>
      <version>2.11.1</version>
  </dependency>-->

  <!--log4j2和slf4j的连接包 需要绑定到log4j2 core核心包上-->
  <dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j-impl</artifactId>
    <version>2.12.1</version>
    <scope>test</scope>
  </dependency>
  <!--slf4j 日志门面-->
  <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.25</version>
  </dependency>
  <!--slf4j与log4j2实现所需要的日志依赖   start-->

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

  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.17</version>
  </dependency>
</dependencies>

002、创建启动类，此时使用slf4j门面日志功能

package com.hwadee.log;

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


public class Log4j2Test {
    @Test
    public void test() {
        // logback 日志的5种级别的输出方式
        // 从低到高依次是 trace < debug < info < warn < error
        Logger logger = LoggerFactory.getLogger(Log4j2Test.class);

        logger.error("error 错误信息，不会影响系统运行");
        logger.warn("warn 警告信息,可能会发生问题");
        logger.info("info 运行信息，数据连接、网络连接、I0操作等等");
        logger.debug("debug 调试信息，一般在开发中使用，记录程序变量参数传递信息等等");
        logger.trace("trace 追踪信息，记录程序所有的流程信息");

    }
}

003、配置log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="WARN" monitorInterval="30">
    <!--定义所有的appender -->
    <appenders>
    <!--这个输出控制台的配置 
        target="SYSTEM_OUT 默认黑色字体，
        target="SYSTEM_ERR 设置红色字体-->
    <console name="consoleAppender" target="SYSTEM_ERR ">
        <!--输出日志的格式 -->
        <PatternLayout
                    pattern="[%-5level] %d{yyyy-MM-dd HH:mm:ss.sss} %c %M %L %thread %m%n" />
    </console>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效 -->
    <loggers>
        <root level="trace">
            <appender-ref ref="consoleAppender" />
        </root>
    </loggers>
</configuration>

004、启动测试类，测试结果如下：

 通过测试结果可以看处slf4j日志门面调用了log4j2日志门面。

7、日志异步：

001、在pom文件中添加异步 disruptor 依赖，如下：

<dependencies>
    <!--slf4j与log4j2实现所需要的日志依赖   start-->
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.12.1</version>
    </dependency>
    <!--log4j-core中有log4j-api的依赖包 ,所以可以不添加og4j-api依赖-->
    <!--<dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-api</artifactId>
        <version>2.11.1</version>
    </dependency>-->

    <!--log4j和slf4j的连接包 需要绑定到log4j 2 core核心包上-->
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-slf4j-impl</artifactId>
        <version>2.12.1</version>
        <scope>test</scope>
    </dependency>
    <!--slf4j 日志门面-->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.25</version>
    </dependency>
    <!--slf4j与log4j2实现所需要的日志依赖   start-->
    
    <!-- 日志异步 -->
    <dependency>
        <groupId>com.lmax</groupId>
        <artifactId>disruptor</artifactId>
        <version>3.3.7</version>
    </dependency>

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

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.17</version>
    </dependency>
</dependencies>

002、创建测试类

public class Log4j2Test {
    @Test
    public void test() {
        // logback 日志的5种级别的输出方式
        // 从低到高依次是 trace < debug < info < warn < error
        Logger logger = LoggerFactory.getLogger(Log4j2Test.class);
        for (int i = 0; i < 100; i++) {
            logger.error("error 错误信息，不会影响系统运行");
            logger.warn("warn 警告信息,可能会发生问题");
            logger.info("info 运行信息，数据连接、网络连接、I0操作等等");
            logger.debug("debug 调试信息，一般在开发中使用，记录程序变量参数传递信息等等");
            logger.trace("trace 追踪信息，记录程序所有的流程信息");

        }

        System.out.println("1---------------------------------");
        System.out.println("2---------------------------------");
        System.out.println("3---------------------------------");
        System.out.println("4---------------------------------");
        System.out.println("5---------------------------------");
    }
}

003、在resources下面配置log4j2.xml配置文件

 <?xml version="1.0" encoding="UTF-8"?>
<configuration status="WARN" monitorInterval="30">
    <!--定义所有的appender -->
    <appenders>
    <!--这个输出控制台的配置 
        target="SYSTEM_OUT 默认黑色字体，
        target="SYSTEM_ERR 设置红色字体-->
        <console name="consoleAppender" target="SYSTEM_ERR ">
           <!--输出日志的格式 -->
           <PatternLayout
                    pattern="[%-5level] %d{yyyy-MM-dd HH:mm:ss.sss} %c %M %L %thread %m%n" />
        </console>

       <!-- 日志异步标签  -->
        <async name="asyncAppender">
            <appenderRef ref="consoleAppender"/>
        </async>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效 -->
    <loggers>
        <root level="trace">
            <appender-ref ref="asyncAppender" />
        </root>
    </loggers>
</configuration>

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="WARN" monitorInterval="30">
    <!--定义所有的appender -->
    <appenders>
    <!--这个输出控制台的配置 
        target="SYSTEM_OUT 默认黑色字体，
        target="SYSTEM_ERR 设置红色字体-->
        <console name="consoleAppender" target="SYSTEM_ERR ">
           <!--输出日志的格式 -->
           <PatternLayout
                    pattern="[%-5level] %d{yyyy-MM-dd HH:mm:ss.sss} %c %M %L %thread %m%n" />
        </console>
        <async name="asyncAppender">
            <appenderRef ref="consoleAppender"/>
        </async>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效 -->
    <loggers>
        <root level="trace">
            <appender-ref ref="asyncAppender" />
        </root>
    </loggers>
</configuration>

004、启动测试类，测试结果如下:

9、全局异步日志：

        全局异步：所有的日志都是异步的日志记录，在配置文件上不用做任何的改动，只需要在类路径resources下添加一个properties属性文件，做一步配置即可，文件名要求是:log4j2.component.properties。

001、在resources下面配置log4j2.xml配置文件

使用全局的，就不需要 <async> 标签，

        <async name="asyncAppender">
            <appenderRef ref="consoleAppender"/>
        </async>

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="WARN" monitorInterval="30">
    <!--定义所有的appender -->
    <appenders>
    <!--这个输出控制台的配置 
        target="SYSTEM_OUT 默认黑色字体，
        target="SYSTEM_ERR 设置红色字体-->
        <console name="consoleAppender" target="SYSTEM_ERR ">
           <!--输出日志的格式 -->
           <PatternLayout
                    pattern="[%-5level] %d{yyyy-MM-dd HH:mm:ss.sss} %c %M %L %thread %m%n" />
        </console>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效 -->
    <loggers>
        <root level="trace">
            <appender-ref ref="consoleAppender" />
        </root>
    </loggers>
</configuration>

002、在类路径resources下log4j2.component.properties，如下：

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

003、启动测试类（使用8日志异步中的测试类），测试结果如下:

       通过测试结果和配置文件可以知，全局异步日志实现。注意，在使用全局异步时候，og4j2.xml配置文件中的 <async>标签无需使用。

10、混合异步日志：

       混合异步:可以在应用中同时使用同步日志和异步日志，这使得日志的配置及输出会更加的灵活。

     需求:
     假设我们现在有自定义的 logger -- com.hwadee，让自定义的logger是异步的，rootlogger是同步的。
     注意：
     在做测试前，一定要将全局的异步配置注释掉。

001、在resources目录下的log4j2.component.properties配置文件中全局异步注释掉

#Log4jContextselector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector

002、在resources下面配置log4j2.xml配置文件

​
<?xml version="1.0" encoding="UTF-8"?>
<configuration status="WARN" monitorInterval="30">
    <!--定义所有的appender -->
    <appenders>
    <!--这个输出控制台的配置 
        target="SYSTEM_OUT 默认黑色字体，
        target="SYSTEM_ERR 设置红色字体-->
        <console name="consoleAppender" target="SYSTEM_ERR ">
           <!--输出日志的格式 -->
           <PatternLayout
                    pattern="[%-5level] %d{yyyy-MM-dd HH:mm:ss.sss} %c %M %L %thread %m%n" />
        </console>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效 -->
    <loggers>
        <!--  自定义日志 logger 让自定义的logger是异步的
              includeLocation="false"
              表示去除日志记录中的行号信息，这个行号信息非常的影响日志记录的效率（生产中都不加这个行号)
              严重的时候可能记录的比同步的日志效率还有低
              -->
        <Asynclogger name="com.hwadee" level="trace" includeLocation="false" additivity="false">
            <!--  将控制台设置为异步 -->
            <appenderRef ref="consoleAppender"/>
        </Asynclogger>

        <root level="trace">
            <appender-ref ref="consoleAppender" />
        </root>
    </loggers>
</configuration>

​

 003、启动测试类（使用8日志异步中的测试类），测试结果如下:

注意:

注意：​如果使用异步日志，AsyncAppender、AsyncLogger不要同时出现，没有这个需求，效果也不会叠加如果同时出现,那么效率会以AsyncAppender为主。

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="WARN" monitorInterval="30">
    <!--定义所有的appender -->
    <appenders>
    <!--这个输出控制台的配置 
        target="SYSTEM_OUT 默认黑色字体，
        target="SYSTEM_ERR 设置红色字体-->
        <console name="consoleAppender" target="SYSTEM_ERR ">
           <!--输出日志的格式 -->
           <PatternLayout
                    pattern="[%-5level] %d{yyyy-MM-dd HH:mm:ss.sss} %c %M %L %thread %m%n" />
        </console>

        <async name="asyncAppender">
            <appenderRef ref="consoleAppender"/>
        </async>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效 -->
    <loggers>
        <!--  自定义日志 logger 让自定义的logger是异步的  -->
        <Asynclogger name="com.hwadee" level="trace" includeLocation="false" additivity="false">
            <!--  将控制台设置为异步 -->
            <appenderRef ref="consoleAppender"/>
        </Asynclogger>

        <root level="trace">
            <appender-ref ref="consoleAppender" />
        </root>
    </loggers>
</configuration>

日志异步性能强软，最高的的代表最强。

11、自定义logger及其他配置输出如下：

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="WARN" monitorInterval="30">
    <!--定义所有的appender -->
    <appenders>
        <!--这个输出控制台的配置  target="SYSTEM_OUT 默认黑色字体，target="SYSTEM_ERR 设置红色字体-->
        <console name="consoleAppender" target="SYSTEM_ERR">
            <!--输出日志的格式 -->
            <PatternLayout
                    pattern="[%-5level] %d{yyyy-MM-dd HH:mm:ss.sss} %c %M %L %thread %m%n"/>
        </console>
        <!-- 这个会打印出所有的info及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档 -->
        <RollingFile name="RollingFileInfo"
                     fileName="./logs/log4j2.log"
                     filePattern="./logs/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch） -->
            <ThresholdFilter level="info" onMatch="ACCEPT"
                             onMismatch="DENY"/>
            <PatternLayout
                    pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
        </RollingFile>
        <RollingFile name="RollingFileWarn"
                     fileName="./logs/warn.log"
                     filePattern="./logs/$${date:yyyy-MM}/warn-%d{yyyy-MM-dd}-%i.log">
            <ThresholdFilter level="warn" onMatch="ACCEPT"
                             onMismatch="DENY"/>
            <PatternLayout
                    pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件，这里设置了10 -->
            <DefaultRolloverStrategy max="10"/>
        </RollingFile>
        <RollingFile name="RollingFileError"
                     fileName="./logs/error.log"
                     filePattern="./logs/$${date:yyyy-MM}/error-%d{yyyy-MM-dd}-%i.log">
            <ThresholdFilter level="error" onMatch="ACCEPT"
                             onMismatch="DENY"/>
            <PatternLayout
                    pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>

            <!-- Policies:指定滚动日志的策略，就是什么时候进行新建日志文件输出日志 -->
            <Policies>
                <!-- DefaultRolloverStrategy:用来指定同一个文件夹下最多有几个日志文件时开始删除最旧的，如果不做配置，默认是7 -->
                <!-- 子节点，基于时间的滚动策略，interval属性用来指定多久滚动一次 -->
                <TimeBasedTriggeringPolicy/>
                <!-- 子节点，基于指定文件大小的滚动策略，size属性用来定义每个日志文件的大小. -->
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
        </RollingFile>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效 -->
    <loggers>
        <!--  自定义日志 logger 过滤掉spring和mybatis的一些无用的DEBUG信息 -->
        <logger name="org.springframework" level="INFO"></logger>
        <logger name="org.mybatis" level="INFO"></logger>
        <root level="trace">
            <appender-ref ref="consoleAppender"/>
            <appender-ref ref="RollingFileInfo"/>
            <appender-ref ref="RollingFileWarn"/>
            <appender-ref ref="RollingFileError"/>
        </root>
    </loggers>
</configuration>

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
anaconda创建环境、下载包出现：DEBUG:urllib3.connectionpool:Starting new HTTPS connection (1)
Cisco DHCP配置实验
Vue | 03Vue之组件化开发
chatgpt搭建大模型技术知识解读与总结
小乌龟git如何同步远程分支_git同步远程分支 原创
solr 6.1.0 的配置及简单使用
Java正则表达式实例详解
IntelliJ IDEA 文档无法编辑，变成了只读模式
leetcode极速复习版-第二章链表
老鸟的Python入门教程
;