Java日志框架学习--LogBack和Log4j2--下

转x33g5p2x  于2022-05-18 转载在 Java  
字(24.9k)|赞(0)|评价(0)|浏览(503)

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提供了3种配置文件

  • logback.groovy
  • logback-test.xml
  • logback.xml

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

日志输出格式

日志输出格式：

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

使用演示

  1. <dependency>
  2.             <groupId>org.slf4j</groupId>
  3.             <artifactId>slf4j-api</artifactId>
  4.             <version>1.7.36</version>
  5.         </dependency>
  7.         <dependency>
  8.             <groupId>ch.qos.logback</groupId>
  9.             <artifactId>logback-classic</artifactId>
  10.             <version>1.2.11</version>
  11.         </dependency>

配置文件

输出到控制台

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <configuration>
  3.    <!--
  4.     配置文件通用属性
  5.     可以在当前配置文件中通过${name}的形式,取得value值
  6.     我们在此指定通用的日志输出格式
  7.     日志输出格式：
  8.     %-10level  级别 案例为设置10个字符，左对齐
  9.     %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
  10.     %c  当前类全限定名
  11.     %M  当前执行日志的方法
  12.     %L  行号
  13.     %thread 线程名称
  14.     %m或者%msg    信息
  15.     %n  换行
  16.          -->
  18.    <property name="pattern" value="[%-5level]  %d{yyyy-MM-dd HH:mm:ss:SSS} %c %M %L %thread %m%n"></property>
  20.    <!--
  21.       配置控制台输出的appender
  22.       -->
  23.     <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
  24.     <!--
  25.         表示对于日志输出目标的配置
  26.         默认: system.out 表示以黑色字体输出日志
  27.               system.err 表示以红色字体输出日志
  28.             -->
  29.         <target>
  30.             System.err
  31.         </target>
  33.     <!--
  34.        配置日志输出格式
  35.            -->
  36.        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  37.           <!--  格式引用通用属性配置  -->
  38.            <pattern>${pattern}</pattern>
  39.        </encoder>
  40.     </appender>
  42.      <!--
  43.         日志记录器
  44.         配置Root Logger
  45.          level: 日志级别
  46.         -->
  47.      <root level="all">
  48.          <appender-ref ref="console"/>
  49.      </root>
  50. </configuration>

输出到控制台和文件

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <configuration>
  3.     <!--
  4.      配置文件通用属性
  5.      可以在当前配置文件中通过${name}的形式,取得value值
  6.      我们在此指定通用的日志输出格式
  7.      日志输出格式：
  8.      %-10level  级别 案例为设置10个字符，左对齐
  9.      %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
  10.      %c  当前类全限定名
  11.      %M  当前执行日志的方法
  12.      %L  行号
  13.      %thread 线程名称
  14.      %m或者%msg    信息
  15.      %n  换行
  16.           -->
  18.     <property name="pattern" value="[%-5level]  %d{yyyy-MM-dd HH:mm:ss:SSS} %c %M %L %thread %m%n"></property>
  20.     <!--  配置文件的输出路径   -->
  21.     <property name="dir" value="logback.log"></property>
  23.     <!-- 配置文件输出的appender   -->
  24.     <appender name="file" class="ch.qos.logback.core.FileAppender">
  25.         <!-- 引入文件位置   -->
  26.         <file>${dir}</file>
  28.         <!--
  29.           配置日志输出格式
  30.        -->
  31.         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  32.             <!--  格式引用通用属性配置  -->
  33.             <pattern>${pattern}</pattern>
  34.         </encoder>
  36.     </appender>
  38.     <!--
  39.        配置控制台输出的appender
  40.        -->
  41.     <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
  42.         <!--
  43.             表示对于日志输出目标的配置
  44.             默认: system.out 表示以黑色字体输出日志
  45.                   system.err 表示以红色字体输出日志
  46.                 -->
  47.         <target>
  48.             System.err
  49.         </target>
  51.         <!--
  52.            配置日志输出格式
  53.                -->
  54.         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  55.             <!--  格式引用通用属性配置  -->
  56.             <pattern>${pattern}</pattern>
  57.         </encoder>
  58.     </appender>
  60.     <!--
  61.        日志记录器
  62.        配置Root Logger
  63.         level: 日志级别
  64.        -->
  65.     <root level="all">
  66.         <appender-ref ref="file"/>
  67.         <appender-ref ref="console"/>
  68.     </root>
  69. </configuration>

因为符合OGNL规范，因此配置文件中可以配置的属性，大多可以通过翻看对应的类源码，通过set方法或者属性名推测出来

输出到控制台,文件和html

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <configuration>
  3.     <!--
  4.      配置文件通用属性
  5.      可以在当前配置文件中通过${name}的形式,取得value值
  6.      我们在此指定通用的日志输出格式
  7.      日志输出格式：
  8.      %-10level  级别 案例为设置10个字符，左对齐
  9.      %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
  10.      %c  当前类全限定名
  11.      %M  当前执行日志的方法
  12.      %L  行号
  13.      %thread 线程名称
  14.      %m或者%msg    信息
  15.      %n  换行
  16.           -->
  18.     <property name="pattern" value="[%-5level]  %d{yyyy-MM-dd HH:mm:ss:SSS} %c %M %L %thread %m%n"></property>
  20.     <!--  配置文件的输出路径   -->
  21.     <property name="fileDir" value="logback.log"></property>
  23.     <!--  配置输出为html形式的appender   -->
  24.     <appender name="html" class="ch.qos.logback.core.FileAppender">
  25.          <!-- 输出的文件位置 -->
  26.         <file>logback.html</file>
  27.          <!--  设置layout为输出html形式的  -->
  28.          <layout class="ch.qos.logback.classic.html.HTMLLayout">
  29.              <pattern>
  30.                  ${pattern}
  31.              </pattern>
  32.          </layout>
  33.     </appender>
  35.     <!-- 配置文件输出的appender   -->
  36.     <appender name="file" class="ch.qos.logback.core.FileAppender">
  37.         <!-- 引入文件位置   -->
  38.         <file>${fileDir}</file>
  40.         <!--
  41.           配置日志输出格式
  42.        -->
  43.         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  44.             <!--  格式引用通用属性配置  -->
  45.             <pattern>${pattern}</pattern>
  46.         </encoder>
  48.     </appender>
  50.     <!--
  51.        配置控制台输出的appender
  52.        -->
  53.     <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
  54.         <!--
  55.             表示对于日志输出目标的配置
  56.             默认: system.out 表示以黑色字体输出日志
  57.                   system.err 表示以红色字体输出日志
  58.                 -->
  59.         <target>
  60.             System.err
  61.         </target>
  63.         <!--
  64.            配置日志输出格式
  65.                -->
  66.         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  67.             <!--  格式引用通用属性配置  -->
  68.             <pattern>${pattern}</pattern>
  69.         </encoder>
  70.     </appender>
  72.     <!--
  73.        日志记录器
  74.        配置Root Logger
  75.         level: 日志级别
  76.        -->
  77.     <root level="all">
  78.         <appender-ref ref="file"/>
  79.         <appender-ref ref="console"/>
  80.         <appender-ref ref="html"/>
  81.     </root>
  82. </configuration>

html展示效果如果:

日志拆分

日志拆分使用的是RollingFileAppender,它继承了FileAppender,因此父类中能配置的属性，这里都可以配置，我们只需要关注当前类新增的查日志拆分策略属性即可。

在当前RollingFileAppender中也为我们提供了两个设置日志拆分策略的set方法:

先看一波如何配置，再来分析源码:

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <configuration>
  3.     <!--
  4.      配置文件通用属性
  5.      可以在当前配置文件中通过${name}的形式,取得value值
  6.      我们在此指定通用的日志输出格式
  7.      日志输出格式：
  8.      %-10level  级别 案例为设置10个字符，左对齐
  9.      %d{yyyy-MM-dd HH:mm:ss.SSS} 日期
  10.      %c  当前类全限定名
  11.      %M  当前执行日志的方法
  12.      %L  行号
  13.      %thread 线程名称
  14.      %m或者%msg    信息
  15.      %n  换行
  16.           -->
  18.     <property name="pattern" value="[%-5level]  %d{yyyy-MM-dd HH:mm:ss:SSS} %c %M %L %thread %m%n"></property>
  20.     <!--  配置文件的输出路径   -->
  21.     <property name="fileDir" value="logback.log"></property>
  23.     <!--  配置输出为html形式的appender   -->
  24.     <appender name="html" class="ch.qos.logback.core.FileAppender">
  25.          <!-- 输出的文件位置 -->
  26.         <file>logback.html</file>
  27.          <!--  设置layout为输出html形式的  -->
  28.          <layout class="ch.qos.logback.classic.html.HTMLLayout">
  29.              <pattern>
  30.                  ${pattern}
  31.              </pattern>
  32.          </layout>
  33.     </appender>
  35.     <!-- 配置文件输出的appender   -->
  36.     <appender name="file" class="ch.qos.logback.core.FileAppender">
  37.         <!-- 引入文件位置   -->
  38.         <file>${fileDir}</file>
  40.         <!--
  41.           配置日志输出格式
  42.        -->
  43.         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  44.             <!--  格式引用通用属性配置  -->
  45.             <pattern>${pattern}</pattern>
  46.         </encoder>
  48.     </appender>
  50.     <!--
  51.        配置控制台输出的appender
  52.        -->
  53.     <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
  54.         <!--
  55.             表示对于日志输出目标的配置
  56.             默认: system.out 表示以黑色字体输出日志
  57.                   system.err 表示以红色字体输出日志
  58.                 -->
  59.         <target>
  60.             System.err
  61.         </target>
  63.         <!--
  64.            配置日志输出格式
  65.                -->
  66.         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  67.             <!--  格式引用通用属性配置  -->
  68.             <pattern>${pattern}</pattern>
  69.         </encoder>
  70.     </appender>
  72.     <!-- 配置文件的appender,可拆分可归档-归档是压缩的意思   -->
  73.     <appender name="roll" class="ch.qos.logback.core.rolling.RollingFileAppender">
  74.          <!--  设置输出格式    -->
  75.          <layout class="ch.qos.logback.classic.PatternLayout">
  76.              <pattern>${pattern}</pattern>
  77.          </layout>
  78.          <!--  设置未归档的日志文件输出位置   -->
  79.          <file>roll_logback.log</file>
  81.           <!--  指定拆分规则  -->
  82.           <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
  83.                <!--   按照时间和压缩格式声明文件名,压缩格式gz    -->
  84.               <fileNamePattern>roll.%d{yyyy-MM-dd}.log%i.gz</fileNamePattern>
  86.               <!--   按照文件大小来进行拆分 -->
  87.               <maxFileSize>1KB</maxFileSize>
  88.           </rollingPolicy>
  89.     </appender>
  91.     <!--
  92.        日志记录器
  93.        配置Root Logger
  94.         level: 日志级别
  95.        -->
  96.     <root level="all">
  97.         <appender-ref ref="roll"/>
  98.     </root>
  99. </configuration>

下面分析一波，这里源码流程从subAppend函数讲起，因为每一条日志的输出，都需要交给至少一个appender,完成日志的输出，而交给appender后，一定会来到appender的subAppend这里，各位可以自行debug源码流程

这里拿RollingFileAppender进行讲解:

  1. @Override
  2.     protected void subAppend(E event) {
  3.         //日志真正写入前，现需要判断是否应该触发当前日志文件的归档行为
  4.         //因为可能当前写入数据超过了日志文件大小的限制，那么当前日志就应该归档，再创建一个新的日志文件
  5.         // The roll-over check must precede actual writing. This is the
  6.         // only correct behavior for time driven triggers.
  7.       
  8.         // We need to synchronize on triggeringPolicy so that only one rollover
  9.         // occurs at a time
  10.         //加锁确保一次只有一个线程进行日志roll操作
  11.         synchronized (triggeringPolicy) {
  12.         //triggeringPolicy负责判断是否需要进行roll over
  13.             if (triggeringPolicy.isTriggeringEvent(currentlyActiveFile, event)) {
  14.                 rollover();
  15.             }
  16.         }
  17.         //调用父类方法真正执行写入操作 
  18.         super.subAppend(event);
  19.     }

具体回滚策略是如何执行的，这里不再进行分析

过滤器

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <configuration>
  3.     <property name="pattern" value="[%-5level]  %d{yyyy-MM-dd HH:mm:ss:SSS} %c %M %L %thread %m%n"></property>
  5.     <!--  配置文件的输出路径   -->
  6.     <property name="fileDir" value="logback.log"></property>
  8.     <!--
  9.        配置控制台输出的appender
  10.        -->
  11.     <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
  12.         <!--
  13.             表示对于日志输出目标的配置
  14.             默认: system.out 表示以黑色字体输出日志
  15.                   system.err 表示以红色字体输出日志
  16.                 -->
  17.         <target>
  18.             System.err
  19.         </target>
  21.         <!--
  22.            配置日志输出格式
  23.                -->
  24.         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  25.             <!--  格式引用通用属性配置  -->
  26.             <pattern>${pattern}</pattern>
  27.         </encoder>
  29.      <!-- 配置过滤器  -->
  30.         <filter class="ch.qos.logback.classic.filter.LevelFilter">
  31.                 <!--  设置日志的输出级别 -->
  32.                 <level>ERROR</level>
  33.                <!--     高于Level中设置的日志级别,则打印日志      -->
  34.                <onMatch>ACCEPT</onMatch>
  35.                <!--     低于Level中设置的日志级别,则跳过          -->
  36.               <onMismatch>DENY</onMismatch>
  37.         </filter>
  38.     </appender>
  40.     <!--
  41.        日志记录器
  42.        配置Root Logger
  43.         level: 日志级别
  44.        -->
  45.     <root level="all">
  46.         <appender-ref ref="console"/>
  47.     </root>
  48. </configuration>

通过过滤器，我们可以设置某个appender的日志过滤输出

过滤器链在何时会执行呢？

异步日志

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <configuration>
  3.     <property name="pattern" value="[%-5level]  %d{yyyy-MM-dd HH:mm:ss:SSS} %c %M %L %thread %m%n"></property>
  4.     
  5.     <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
  6.         <target>
  7.             System.err
  8.         </target>
  9.         
  10.         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  11.             <pattern>${pattern}</pattern>
  12.         </encoder>
  13.     </appender>
  14.     
  15.     <!-- 异步日志的配置   -->
  16.     <appender name="async" class="ch.qos.logback.classic.AsyncAppender">
  17.         <appender-ref ref="console"/>
  18.     </appender>
  19.     
  20.     <root level="all">
  21.         <appender-ref ref="async"/>
  22.     </root>
  23. </configuration>

异步日志测试:

异步日志实现源码来看看吧:
先说明一下,logback采用生产者消费者模型实现的日志异步输出

默认如果丢弃的话，会丢弃掉info以下的日志输出

自定义Logger

  1. <logger name="com.dhy" level="info" additivity="false">
  2.         <appender-ref ref="async"/>
  3.     </logger>

name是包路径,包路径的设置是具有父子关系的

level是日志等级

additivity表示是否继承父类logger的配置

additivity为true,表示会继承父类的appenders,为false表示不继承父类的appenders

Log4j

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

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

应用演示

引入依赖:

  1. <dependency>
  2.     <groupId>org.apache.logging.log4j</groupId>
  3.     <artifactId>log4j-core</artifactId>
  4.     <version>2.12.1</version>
  5. </dependency>

可以设置jdk编译版本:

  1. <build>
  2.     <plugins>
  3.         <!-- 设置编译版本为1.8 -->
  4.         <plugin>
  5.             <groupId>org.apache.maven.plugins</groupId>
  6.             <artifactId>maven-compiler-plugin</artifactId>
  7.             <version>3.1</version>
  8.             <configuration>
  9.                 <source>1.8</source>
  10.                 <target>1.8</target>
  11.                 <encoding>UTF-8</encoding>
  12.             </configuration>
  13.         </plugin>
  14.     </plugins>
  15. </build>

使用演示:

  1. import org.apache.logging.log4j.LogManager;
  2. import org.apache.logging.log4j.Logger;
  3. import org.testng.annotations.Test;
  5. public class LogTest {
  6.     @Test
  7.     public void Test(){
  8.         Logger logger = LogManager.getLogger(LogTest.class.getName());
  9.             log(logger);
  10.     }
  12.     private void log(Logger logger) {
  13.         logger.error("error");
  14.         logger.warn("warn");
  15.         logger.info("info");
  16.         logger.debug("debug");
  17.         logger.trace("trace");
  18.     }
  19. }

没有提供配置文件，会提供一个日志的默认配置，但是会给出一个警告

配置文件

log4j2的配置文件类似logback，会默认去加载类路径下的log4j2.xml

因为log4j2参考了logback的设计思路，但是未来减少借鉴量，就将原本logback配置文件中小写的标签值,都转为了大写

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <configuration  status="debug" monitorInterval="5">
  3. <!--  配置appender  -->
  4.  <Appenders>
  5. <!--  默认是system.out,这里我们设置为system.err,这一点和logback一样    -->
  6.      <Console name="console" target="SYSTEM_ERR"></Console>
  7.  </Appenders>
  9. <!-- 配置logger   -->
  10.     <Loggers>
  11. <!--   配置rootLogger     -->
  12.     <Root level="trace">
  13.         <AppenderRef ref="console"/>
  14.     </Root>
  15.     </Loggers>
  16. </configuration>

默认输出格式为%m%n

slf4j加log4j2

我们只需要导入一个依赖就够了:

  1. <!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-slf4j-impl -->
  2.         <dependency>
  3.             <groupId>org.apache.logging.log4j</groupId>
  4.             <artifactId>log4j-slf4j-impl</artifactId>
  5.             <version>2.17.2</version>
  6.         </dependency>

这样一个适配器依赖模块以及将slf4j门面依赖,log4j门面和log4k2日志实现依赖全部导入了

使用还是正常使用slf4j的日志门面api即可

日志输出到文件

这里的使用和之前logback的配置类似

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <configuration monitorInterval="5">
  4. <!--  公共属性  -->
  5.  <properties>
  6.      <property name="logDir">log4j2.log</property>
  7.  </properties>
  9. <!--  配置appender  -->
  10.  <Appenders>
  11. <!--  默认是system.out,这里我们设置为system.err,这一点和logback一样    -->
  12.      <Console name="console" target="SYSTEM_ERR"></Console>
  13.      <File name="file" fileName="${logDir}">
  14. <!--       输出格式           -->
  15.          <PatternLayout pattern="[%-5level] %d{yyyy-MM-dd HH:mm:ss:SSS} %m%n"></PatternLayout>
  16.      </File>
  17.  </Appenders>
  19. <!-- 配置logger   -->
  20.     <Loggers>
  21. <!--   配置rootLogger     -->
  22.     <Root level="trace">
  23.         <AppenderRef ref="console"/>
  24.         <AppenderRef ref="file"/>
  25.     </Root>
  26.     </Loggers>
  27. </configuration>

文件默认也是追加写入

日志拆分

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <configuration monitorInterval="5">
  4. <!--  公共属性  -->
  5.  <properties>
  6.      <property name="logDir">log4j2.log</property>
  7.  </properties>
  9. <!--  配置appender  -->
  10.  <Appenders>
  11. <!--  默认是system.out,这里我们设置为system.err,这一点和logback一样    -->
  12.      <Console name="console" target="SYSTEM_ERR"></Console>
  13.      <File name="file" fileName="${logDir}">
  14. <!--       输出格式           -->
  15.          <PatternLayout pattern="[%-5level] %d{yyyy-MM-dd HH:mm:ss:SSS} %m%n"></PatternLayout>
  16.      </File>
  18.      <RollingFile name="rollingFile" fileName="rollLog.log"
  19.       filePattern="${date:yyyy-MM-dd}/roll-%d{yyyy-MM-dd-HH-mm}-%i.log">
  20.          <PatternLayout pattern="[%-5level] %d{yyyy-MM-dd HH:mm:ss:SSS} %m%n"></PatternLayout>
  21.          <Policies>
  22.              <!--  在系统启动时,触发拆分规则,产生一个日志文件  -->
  23.              <OnStartupTriggeringPolicy/>
  24.             <!--    按照文件的大小进行拆分         -->
  25.              <SizeBasedTriggeringPolicy size="10KB"/>
  26.            <!--  按照时间节点进行拆分,拆分规则就是filePattern           -->
  27.              <TimeBasedTriggeringPolicy/>
  28.          </Policies>
  29.           <!--在同一目录下,文件的个数限制，如果超出了设置的数值，则根据时间进行覆盖，新的覆盖旧的规则         -->
  30.          <DefaultRolloverStrategy max="30"/>
  31.      </RollingFile>
  32.  </Appenders>
  34. <!-- 配置logger   -->
  35.     <Loggers>
  36. <!--   配置rootLogger     -->
  37.     <Root level="trace">
  38.         <AppenderRef ref="rollingFile"/>
  39.     </Root>
  40.     </Loggers>
  41. </configuration>

关于log4j2的配置文件解析源码，大家可以参考AbstractConfiguration

异步日志

异步日志是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标记配置。

AsyncAppender测试

  • 引入异步日志依赖
  1. <dependency>
  2.             <groupId>com.lmax</groupId>
  3.             <artifactId>disruptor</artifactId>
  4.             <version>3.3.7</version>
  5.         </dependency>
  • 修改配置
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <configuration monitorInterval="5">
  4. <!--  公共属性  -->
  5.  <properties>
  6.      <property name="logDir">log4j2.log</property>
  7.  </properties>
  9. <!--  配置appender  -->
  10.  <Appenders>
  11. <!--  默认是system.out,这里我们设置为system.err,这一点和logback一样    -->
  12.      <Console name="console" target="SYSTEM_ERR"></Console>
  13.      <File name="file" fileName="${logDir}">
  14. <!--       输出格式           -->
  15.          <PatternLayout pattern="[%-5level] %d{yyyy-MM-dd HH:mm:ss:SSS} %m%n"></PatternLayout>
  16.      </File>
  17.      
  18.      <Async name="async">
  19.          <AppenderRef ref="console"></AppenderRef>
  20.      </Async>
  21.  </Appenders>
  23. <!-- 配置logger   -->
  24.     <Loggers>
  25. <!--   配置rootLogger     -->
  26.     <Root level="trace">
  27.         <AppenderRef ref="async"/>
  28.     </Root>
  29.     </Loggers>
  30. </configuration>
  • 测试异步效果
  1. public class LogTest {
  2.     @Test
  3.     public void Test(){
  4.         Logger logger = LoggerFactory.getLogger(LogTest.class.getName());
  5.             log(logger);
  6.         System.out.println("1111");
  7.         System.out.println("3333");
  8.         System.out.println("2222");
  9.     }
  11.     private void log(Logger logger) {
  12.         logger.error("error");
  13.         logger.warn("warn");
  14.         logger.info("info");
  15.         logger.debug("debug");
  16.         logger.trace("trace");
  17.     }
  18. }

AsyncLogger测试

  1. Log4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector

配置文件去掉async的配置

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <configuration monitorInterval="5">
  4. <!--  配置appender  -->
  5.  <Appenders>
  6. <!--  默认是system.out,这里我们设置为system.err,这一点和logback一样    -->
  7.      <Console name="console" target="SYSTEM_ERR"></Console>
  8.      <File name="file" fileName="${logDir}">
  9. <!--       输出格式           -->
  10.          <PatternLayout pattern="[%-5level] %d{yyyy-MM-dd HH:mm:ss:SSS} %m%n"></PatternLayout>
  11.      </File>
  12.  </Appenders>
  14. <!-- 配置logger   -->
  15.     <Loggers>
  16. <!--   配置rootLogger     -->
  17.     <Root level="trace">
  18.         <AppenderRef ref="console"/>
  19.     </Root>
  20.     </Loggers>
  21. </configuration>

测试

混合异步输出日志

  1. <!--    配置异步Logger    -->
  2.     <AsyncLogger name="com" level="info"
  3.       includeLocation="false" additivity="false">
  4.         <AppenderRef ref="console"/>
  5.     </AsyncLogger>

异步性能比较

SpringBoot整合日志框架

springboot提供对日志的整合模块主要是spring-boot-starter-logging模块

首先引入了logback-classic，可以看出springboot默认使用的日志框架为logback

下面还有两个:一个是log4j-to-slf4j:2.14.1，这个是桥接器模块，因为该模块里面只有log4j2的门面api,这里还是通过api重定向，将log4j2的api使用，重定向到slf4j，然后slf4j底层再使用logback作为底层日志框架实现

jul-to-slf4j类似原理

下面来验证两点，一点是springboot默认使用的是logback作为日志选型,另一点是我们使用log4j2和jul的日志api，最终底层调用的还是logback

  1. package helper.com.logTest;
  4. import org.apache.logging.log4j.LogManager;
  5. import org.junit.jupiter.api.Test;
  6. import org.slf4j.Logger;
  7. import org.slf4j.LoggerFactory;
  8. import org.slf4j.bridge.SLF4JBridgeHandler;
  10. /**
  11.  * @author 大忽悠
  12.  * @create 2022/5/14 10:28
  13.  */
  14. public class Log4jTest {
  15.     @Test
  16.     public void testLogBack() {
  17.         System.err.println("------------testLogBack---------------");
  18.         Logger logger = LoggerFactory.getLogger(Log4jTest.class);
  19.         logger.error("error");
  20.         logger.warn("warn");
  21.         logger.info("info");
  22.         logger.debug("debug");
  23.         logger.trace("trace");
  24.         System.err.println("-----------testLog4j2Bridge----------------");
  25.         org.apache.logging.log4j.Logger log = LogManager.getLogger(Log4jTest.class);
  26.         log.error("error");
  27.         log.warn("warn");
  28.         log.info("info");
  29.         log.debug("debug");
  30.         log.trace("trace");
  31.         System.err.println("-----------testJULBridge----------------");
  32.         java.util.logging.Logger julLog= java.util.logging.Logger.getLogger(Log4jTest.class.getName());
  33.         julLog.addHandler(new SLF4JBridgeHandler());
  34.         julLog.severe("severe");
  35.         julLog.warning("warning");
  36.         julLog.info("info");
  37.         julLog.fine("fine");
  38.         julLog.finer("finer");
  39.         julLog.finest("finest");
  41.     }
  43. }

JUL的桥接需要手动添加handler完成,该handler的publish方法源码如下:

  1. public void publish(LogRecord record) {
  2.         if (record != null) {
  3.             org.slf4j.Logger slf4jLogger = this.getSLF4JLogger(record);
  4.             String message = record.getMessage();
  5.             if (message == null) {
  6.                 message = "";
  7.             }
  9.             if (slf4jLogger instanceof LocationAwareLogger) {
  10.                 this.callLocationAwareLogger((LocationAwareLogger)slf4jLogger, record);
  11.             } else {
  12.                 this.callPlainSLF4JLogger(slf4jLogger, record);
  13.             }
  15.         }
  16.     }

spring配置文件配置日志

  1. logging:
  2.    level:
  3.      helper:
  4.          com: trace
  5.   pattern:
  6.     console: "%d{yyyy年-MM月-dd日} [%-5level] %m%n"

spring配置文件配置日志输出到文件

  1. logging:
  2.   level:
  3.      helper:
  4.          com: trace
  5.   pattern:
  6.     console: "%d{yyyy年-MM月-dd日} [%-5level] %m%n"
  7.   file:
  8.     path: test

指定的是存放日志文件夹的名字，日志会生成在该文件夹下面，名字为spring.log

spring引入logback的配置文件

放在类路径下,名字就叫logback.xml就可以了

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <configuration>
  3.     <property name="pattern" value="大忽悠日志: [%-5level]  %d{yyyy-MM-dd HH:mm:ss:SSS} %c %M %L %thread %m%n"></property>
  5.     <!--  配置文件的输出路径   -->
  6.     <property name="fileDir" value="logback.log"></property>
  7.     
  8.     <!--
  9.        配置控制台输出的appender
  10.        -->
  11.     <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
  12.         <!--
  13.             表示对于日志输出目标的配置
  14.             默认: system.out 表示以黑色字体输出日志
  15.                   system.err 表示以红色字体输出日志
  16.                 -->
  17.         <target>
  18.             System.err
  19.         </target>
  21.         <!--
  22.            配置日志输出格式
  23.                -->
  24.         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  25.             <!--  格式引用通用属性配置  -->
  26.             <pattern>${pattern}</pattern>
  27.         </encoder>
  28.     </appender>
  30.     <!-- 配置文件的appender,可拆分可归档-归档是压缩的意思   -->
  31.     <appender name="roll" class="ch.qos.logback.core.rolling.RollingFileAppender">
  32.          <!--  设置输出格式    -->
  33.          <layout class="ch.qos.logback.classic.PatternLayout">
  34.              <pattern>${pattern}</pattern>
  35.          </layout>
  36.          <!--  设置未归档的日志文件输出位置   -->
  37.          <file>roll_logback.log</file>
  39.           <!--  指定拆分规则  -->
  40.           <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
  41.                <!--   按照时间和压缩格式声明文件名,压缩格式gz    -->
  42.               <fileNamePattern>roll.%d{yyyy-MM-dd}.log%i.gz</fileNamePattern>
  44.               <!--   按照文件大小来进行拆分 -->
  45.               <maxFileSize>1KB</maxFileSize>
  46.           </rollingPolicy>
  47.     </appender>
  49.     <!--
  50.        日志记录器
  51.        配置Root Logger
  52.         level: 日志级别
  53.        -->
  54.     <root level="info">
  55.         <appender-ref ref="roll"/>
  56.         <appender-ref ref="console"/>
  57.     </root>
  58. </configuration>

Spring整合log4j2

  • 移除spring-boot-starter-logging模块依赖
  • 添加之前我们使用的log4j2的依赖即可
  1. <!--        spring web-->
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-web</artifactId>
  5.             <exclusions>
  6.                 <exclusion>
  7.                     <groupId>org.springframework.boot</groupId>
  8.                     <artifactId>spring-boot-starter-logging</artifactId>
  9.                 </exclusion>
  10.             </exclusions>
  11.         </dependency>
  13.         <dependency>
  14.             <groupId>org.springframework.boot</groupId>
  15.             <artifactId>spring-boot-starter-log4j2</artifactId>
  16.         </dependency>

下面引入log4j2的配置文件进行测试即可:

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <configuration  status="debug" monitorInterval="5">
  3.     <!--  配置appender  -->
  4.     <Appenders>
  5.         <!--  默认是system.out,这里我们设置为system.err,这一点和logback一样    -->
  6.         <Console name="console" target="SYSTEM_ERR"></Console>
  7.     </Appenders>
  9.     <!-- 配置logger   -->
  10.     <Loggers>
  11.         <!--   配置rootLogger     -->
  12.         <Root level="info">
  13.             <AppenderRef ref="console"/>
  14.         </Root>
  15.     </Loggers>
  16. </configuration>

输出彩色日志

记得开启Jansi（一个支持输出ANSI颜色的类库）

  1. -Dlog4j.skipJansi=false

记-Log4j 设置控制台打印彩色日志

log4j2日志配置颜色

log4j2底层配置文件动态刷新原理

log4j和log4j2怎么动态加载配置文件

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://cjdhy.blog.csdn.net/article/details/124793071

内容来源于网络，如有侵权，请联系作者删除！

Java日志开发语言学习

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com