【Log】（三）Java 中的日志框架 logback、log4j2

短命女 2023-10-01 08:31 100阅读 0赞

【Log】（一）Java 中的日志框架 JUL、Log4j
【Log】（二）Java 中的日志框架 JCL、SLF
【Log】（三）Java 中的日志框架 logback、log4j2

1. logback 学习

1.1 logback 介绍

logback 是由 log4j 创始人设计的另一个开源日志组件，性能比 log4j 好

logback 主要分为 3 个模块：

  • logback-core：其它两个模块的基础模块
  • logback-classic：它是 log4j 的一个改良版本，同时它完整实现了 slf4j API
  • logback-access：访问模块与 Servlet 容器集成提供通过 http 来访问日志的功能

1.2 快速入门

新建一个 Maven 工程，引入依赖，POM 文件：

  1. <!--slf日志门面-->
  2. <dependency>
  3.   <groupId>org.slf4j</groupId>
  4.   <artifactId>slf4j-api</artifactId>
  5.   <version>1.7.26</version>
  6. </dependency>
  7. <!--logback-->
  8. <dependency>
  9.   <groupId>ch.qos.logback</groupId>
  10.   <artifactId>logback-classic</artifactId>
  11.   <version>1.2.3</version>
  12. </dependency>

  1. 入门案例：

    public class LogbackTest {

  1.     public static final Logger LOGGER = LoggerFactory.getLogger(LogbackTest.class);
  3.     @Test
  4.     public void testQuick() {
  6.         LOGGER.error("error");
  7.         LOGGER.warn("warn");
  8.         LOGGER.info("info");
  9.         LOGGER.debug("debug");
  10.         LOGGER.trace("trace");
  11.     }
  13. }

运行结果如下：
在这里插入图片描述
表明：logback 的默认级别是 debug。

1.3 配置文件

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

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

如果均不存在，则采用默认配置

  1. logback 组件之间的关系

  2. Logger：日志记录器。把它关联到应用的对应的 context 上后，主要用于存放日志对象，也可以定义日志类型、级别

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

  4. Layout：负责把事件转换成字符串，格式化日志信息输出。在 logback 中，Layout 对象被封装成 encoder 中

  5. 控制台 Appender

控制台 Appender：将日志信息输出到控制台，并且可以设置一些日志信息。

在 resources 下新建一个 logback.xml 配置文件

  1. <?xml version="1.0" encoding="utf-8" ?>
  2. <configuration>
  3.     <!--配置集中管理属性-->
  4.     <property name="pattern" value="[%-5level] %d{yyyy-mm-dd HH:mm:ss.SSS} %c %M %L [%thread] %m%n"></property>
  6.     <!--控制台日志输出的 Appender-->
  7.     <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
  8.         <!--控制输出流对象，默认为 System.out，可修改为 System.err-->
  9.         <target>System.err</target>
  10.         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  11.             <pattern>${pattern}</pattern>
  12.         </encoder>
  13.     </appender>
  15.     <!--root logger 配置-->
  16.     <root level="ALL">
  17.         <appender-ref ref="console"></appender-ref>
  18.     </root>
  19. </configuration>

%-5level：日志级别。向左对齐
%d{yyyy-mm-dd HH:mm:ss.SSS}：日期（格式化）
%c：方法名称
%M：类名
%thread：线程名
%m：日志信息
%n：换行

配置了配置文件后，运行结果如下：
在这里插入图片描述

  1. 文件 Appender

文件 Appender：将日志信息存放到日志文件中

  1. <?xml version="1.0" encoding="utf-8" ?>
  2. <configuration>
  3.     <!--配置集中管理属性-->
  4.     <property name="pattern" value="[%-5level] %d{yyyy-mm-dd HH:mm:ss.SSS} %c %M %L [%thread] %m%n"></property>
  5.     <property name="log_dir" value="E:/temp/logs"></property>
  7.     <!--控制台日志输出的 Appender-->
  8.     <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
  9.         <!--控制输出流对象，默认为 System.out，可修改为 System.err-->
  10.         <target>System.err</target>
  11.         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  12.             <pattern>${pattern}</pattern>
  13.         </encoder>
  14.     </appender>
  16.     <!--文件日志输出的 Appender-->
  17.     <appender name="file" class="ch.qos.logback.core.FileAppender">
  18.         <!--日志保存路径-->
  19.         <file>${log_dir}/logback.log</file>
  20.         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  21.             <pattern>${pattern}</pattern>
  22.         </encoder>
  23.     </appender>
  25.     <!--root logger 配置-->
  26.     <root level="ALL">
  27.         <appender-ref ref="console"></appender-ref>
  28.         <appender-ref ref="file" />
  29.     </root>
  30. </configuration>

当然，如果更想直观地看日志，可将日志文件设置成 html 格式：

  1. <!--html 文件格式-->
  2. <appender name="htmlFile" class="ch.qos.logback.core.FileAppender">
  3.     <!--日志保存路径-->
  4.     <file>${log_dir}/logback.html</file>
  5.     <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
  6.         <layout class="ch.qos.logback.classic.html.HTMLLayout">
  7.             <pattern>%level%d{yyyy-mm-dd HH:mm:ss.SSS}%c%M%L%thread%m</pattern>
  8.         </layout>
  9.     </encoder>
  10. </appender>
  1. 日志拆分和归档压缩的 Appender

当日志文件较大时，我们不能让日志信息都存储在同一个日志文件里面，所以，我们要将日志信息进行拆分。

  1. <!--日志拆分和归档压缩的 Appender-->
  2. <appender name="rollFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
  3.     <!--日志保存路径-->
  4.     <file>${log_dir}/roll_logback.log</file>
  5.     <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  6.         <pattern>${pattern}</pattern>
  7.     </encoder>
  8.     <!--指定拆分规则-->
  9.     <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
  10.         <!--按照时间和压缩格式声明拆分的文件名-->
  11.         <fileNamePattern>${log_dir}/rolling.%d{yyyy-MM-dd-HH-mm-ss}.log%i.gz</fileNamePattern>
  12.         <!--按照文件大小拆分-->
  13.         <maxFileSize>1MB</maxFileSize>
  14.     </rollingPolicy>
  15. </appender>

测试代码：运行一万次

  1. @Test
  2. public void testQuick() {
  4.     for (int i = 0; i < 10000; i++) {
  6.         LOGGER.error("error");
  7.         LOGGER.warn("warn");
  8.         LOGGER.info("info");
  9.         LOGGER.debug("debug");
  10.         LOGGER.trace("trace");
  11.     }
  12. }

运行结果如下：
在这里插入图片描述
日志文件拆分规则：日志压缩文件按照秒拆分（精确到秒），当日志文件超过 1 MB 时，日志文件会再次进行拆分，且日志文件名中的 .log%i.gz 中的 i 就会自加。

  1. 日志级别过滤器



    ${log_dir}/roll_logback.log

    ${pattern}




    ${log_dir}/rolling.%d{yyyy-MM-dd-HH-mm-ss}.log%i.gz

    1MB



    ERROR
    ACCEPT
    DENY

其中，

  1. <filter class="ch.qos.logback.classic.filter.LevelFilter">
  2.     <level>ERROR</level>
  3.     <onMatch>ACCEPT</onMatch>
  4.     <onMismatch>DENY</onMismatch>
  5. </filter>

表示：只记录 ERROR 级别的日志信息

  1. 异步日志

默认情况下，程序运行时，程序和日志记录是同步的。使用异步日志的话，就可以使程序和日志记录不是同步。

  1. <!--异步日志-->
  2. <appender name="asyc" class="ch.qos.logback.classic.AsyncAppender">
  3.     <!--指定某个具体的 appender-->
  4.     <appender-ref ref="rollFile"></appender-ref>
  5. </appender>
  7. <!--root logger 配置-->
  8. <root level="ALL">
  9.     <appender-ref ref="console"></appender-ref>
  10.     <appender-ref ref="asyc" />
  11. </root>

  1. 自定义 logger

上述标签含义：自定义 Logger 对象没有继承 rootLogger 对象，但它用到了 console appender，并且只输出 info 级别以上的日志信息。

logger 标签的属性说明：

  • name：测试类 LogbackTest 所在的类名
  • level：控制日志级别
  • additivity：自定义 logger 对象是否继承 rootLogger 对象的功能。为 false，表示不继承 root logger 的功能

2. log4j2 学习

2.1 log4j2 介绍

log4j2 是 log4j 的升级版，参考了 logback 的优秀的设计，修复了一些问题，因此，带来了一些重大的提升

2.2 快速入门

目前市面上主流的日志门面是 slf4j。虽然 log4j2 也是日志门面，但它的实现功能非常强大，性能优越。所以，大家一般还是将 log4j2 看做是日志的实现。slf4j + log4j2 是未来趋势。

新建一个 Maven 工程，引入依赖，POM 文件：

  1. <!--log4j2的日志门面-->
  2. <dependency>
  3.   <groupId>org.apache.logging.log4j</groupId>
  4.   <artifactId>log4j-api</artifactId>
  5.   <version>2.11.1</version>
  6. </dependency>
  7. <!--log4j2的日志实现-->
  8. <dependency>
  9.   <groupId>org.apache.logging.log4j</groupId>
  10.   <artifactId>log4j-core</artifactId>
  11.   <version>2.10.0</version>
  12. </dependency>

入门案例：

  1. public class Log4j2Test {
  4.     public static final Logger LOGGER = LogManager.getLogger(Log4j2Test.class);
  6.     @Test
  7.     public void testQuick() {
  9.         LOGGER.fatal("fatal");
  10.         LOGGER.error("error");
  11.         LOGGER.warn("warn");
  12.         LOGGER.info("info");
  13.         LOGGER.debug("debug");
  14.         LOGGER.trace("trace");
  15.     }
  17. }

运行结果后：
在这里插入图片描述
表明：log4j2 的日志默认级别为 error。

slf4j + log4j2：

  1. <!--slf日志门面-->
  2. <dependency>
  3.   <groupId>org.slf4j</groupId>
  4.   <artifactId>slf4j-api</artifactId>
  5.   <version>1.7.26</version>
  6. </dependency>
  7. <!--使用log4j2的适配器进行绑定-->
  8. <dependency>
  9.   <groupId>org.apache.logging.log4j</groupId>
  10.   <artifactId>log4j-slf4j-impl</artifactId>
  11.   <version>2.10.0</version>
  12. </dependency>
  14. <!--log4j2的日志门面-->
  15. <dependency>
  16.   <groupId>org.apache.logging.log4j</groupId>
  17.   <artifactId>log4j-api</artifactId>
  18.   <version>2.11.1</version>
  19. </dependency>
  20. <!--log4j2的日志实现-->
  21. <dependency>
  22.   <groupId>org.apache.logging.log4j</groupId>
  23.   <artifactId>log4j-core</artifactId>
  24.   <version>2.10.0</version>
  25. </dependency>

测试代码：

  1. public class SlfTest {
  4.     public static final Logger LOGGER = LoggerFactory.getLogger(SlfTest.class);
  6.     @Test
  7.     public void testQuick() {
  9.         LOGGER.error("error");
  10.         LOGGER.warn("warn");
  11.         LOGGER.info("info");
  12.         LOGGER.debug("debug");
  13.         LOGGER.trace("trace");
  14.     }
  16. }

2.3 配置文件

log4j2 默认加载 classpath 下的 log4j2.xml 文件中的配置

  1. <?xml version="1.0" encoding="utf-8" ?>
  2. <!--
  3.     status=warn：日志框架本身的输出日志级别
  4.     monitorInterval="5"：自动加载配置文件的间隔时间，不低于5秒
  5. -->
  6. <Configuration status="warn" monitorInterval="5">
  7.     <!--配置集中管理属性-->
  8.     <properties>
  9.         <property name="LOG_HOME" value="E:/temp/logs"></property>
  10.     </properties>
  12.     <Appenders>
  13.         <Console name="console" target="SYSTEM_OUT">
  14.             <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] [%-5level] %c{36}:%L --- %m%n"></PatternLayout>
  15.         </Console>
  17.         <File name="file" fileName="${LOG_HOME}/myfile.log">
  18.             <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] [%-5level] %c{36}:%L --- %m%n"></PatternLayout>
  19.         </File>
  20.         <!--使用随机读写流-->
  21.         <RandomAccessFile name="accessFile" fileName="${LOG_HOME}/myAcclog.log">
  22.             <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] [%-5level] %c{36}:%L --- %m%n"></PatternLayout>
  23.         </RandomAccessFile>
  24.         <!--按照一定规则拆分-->
  25.         <RollingFile name="rollingFile" fileName="${LOG_HOME}/myRolllog.log"
  26.                      filePattern="${LOG_HOME}/$${date:yyyy-MM-dd}/myRolllog-%d{yyyy-MM-dd-HH-mm}-%i.log">
  27.             <ThresholdFilter level="debug" onMatch="ACCEPT" onMismatch="DENY" />
  28.             <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] [%-5level] %c{36}:%L --- %m%n"></PatternLayout>
  29.             <!--拆分规则-->
  30.             <Policies>
  31.                 <!--系统启动时，触发并启动拆分规则，生成新的日志文件-->
  32.                 <OnStartupTriggeringPolicy />
  33.                 <!--按照文件大小拆分-->
  34.                 <SizeBasedTriggeringPolicy size="10 MB" />
  35.                 <!--按照时间节点拆分，规则由filePattern定义-->
  36.                 <TimeBasedTriggeringPolicy />
  37.             </Policies>
  38.             <!--在同一个目录下，文件的个数限定30个，超过后覆盖旧的日志信息-->
  39.             <DefaultRolloverStrategy max="30" />
  40.         </RollingFile>
  41.     </Appenders>
  43.     <Loggers>
  44.         <Root level="info">
  45.             <AppenderRef ref="console" />
  46.         </Root>
  47.     </Loggers>
  49. </Configuration>

2.4 异步日志

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

log4j2 提供了两种异步方式：AsyncAppender、AsyncLogger（常用）

【注意】：配置异步日志，需要引入依赖：

  1. <dependency>
  2.   <groupId>com.lmax</groupId>
  3.   <artifactId>disruptor</artifactId>
  4.   <version>3.3.4</version>
  5. </dependency>

  1. AsyncAppender


    …

    ss.SSS} [%t] [%-5level] %c{36}:%L --- %m%n">

运行代码后，结果如下：
在这里插入图片描述

  1. AsyncAppender
    AsyncAppender 才是 log4j2 的重头戏，也是官方推荐的方式。有两种方式：全局异步、混合异步。

全局异步

全局异步：所有的日志都是异步地记录，在配置文件上不做任何修改。只需要添加一个 log4j2.component.properties 配置文件。

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

混合异步

混合异步：可以在应用中同时使用同步日志和异步日志，这使得日志的配置更加灵活

修改 log4j2.xml：

  1. <Configuration>
  2.     ...
  3.     <Loggers>
  4.         <!--自定义Logger对象 includeLocation="false" 关闭行号信息-->
  5.         <AsyncLogger name="com.zzc.log.log4j2" level="info" includeLocation="false" additivity="false">
  6.             <AppenderRef ref="console" />
  7.         </AsyncLogger>
  9.         <Root level="info">
  10.             <AppenderRef ref="console" />
  11.             <AppenderRef ref="Async" />
  12.         </Root>
  13.     </Loggers>
  14. </Configuration>

运行代码，结果如下：
在这里插入图片描述
表明：没有显示行号。

3. SpringBoot 中的日志

SpringBoot 日志也是开发中常用的日志系统。SpringBoot 默认就是使用 SLF4J 作为日志门面，logback 作为日志实现来记录日志。

3.1 SpringBoot 中的日志设计

SpringBoot 中的日志：

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-logging</artifactId>
  4. </dependency>

依赖结构图：
在这里插入图片描述
总结：

  1. SpringBoot 底层使用 logback 作为日志实现
  2. 使用了 SLF4J 作为日志门面
  3. 将 JUL 也转换为了 SLF4J
  4. 也可以使用 Log4j2 作为日志门面，但是最终也是通过 SLF4J 调用 logback

3.2 SpringBoot 中使用日志

1.入门案例：

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class ApplicationTests {
  6.     private static final Logger LOGGER = LoggerFactory.getLogger(ApplicationTests.class);
  8.     @Test
  9.     public void contextLoads() {
  11.         LOGGER.error("error");
  12.         LOGGER.warn("warn");
  13.         LOGGER.info("info");
  14.         LOGGER.debug("debug");
  15.         LOGGER.trace("trace");
  16.     }
  18. }

运行结果：
在这里插入图片描述
SpringBoot 中的默认日志级别：info

2.配置文件：

application.properties：

  1. # 指定自定义 Logger 对象日志级别
  2. logging.level.com.zzc.sbexp=debug
  3. # 指定控制台输出信息格式
  4. logging.pattern.console=[%-5level] %d{yyyy-MM-dd HH:mm:ss} %c [%thread] === %m%n
  5. # 指定日志文件存放的目录，文件名默认为 spring.log
  6. logging.file=E://temp/springboot.log
  7. # 指定日志文件消息格式
  8. logging.pattern.file=[%-5level] %d{yyyy-MM-dd HH:mm:ss} %c [%thread] === %m%n

运行结果如下：
在这里插入图片描述
3.指定日志配置文件：

给类路径下放上每个日志框架自己的配置文件；SpringBoot 就不使用默认配置的了。






















日志框架 配置文件
logback logback.xml、logback-spring.xml
log4j2 log4j2.xml、log4j2-spring.xml
jul logging.properties

logback.xml 直接就被 SpringBoot 识别了。

logback.xml：

  1. <?xml version="1.0" encoding="utf-8" ?>
  2. <configuration>
  3.     <!--配置集中管理属性-->
  4.     <property name="pattern" value="[%-5level] %d{yyyy-mm-dd HH:mm:ss.SSS} %c %M %L [%thread] --- %m%n"></property>
  5.     <property name="log_dir" value="E:/temp/logs"></property>
  7.     <!--控制台日志输出的 Appender-->
  8.     <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
  9.         <!--控制输出流对象，默认为 System.out，可修改为 System.err-->
  10.         <target>System.err</target>
  11.         <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
  12.             <pattern>${pattern}</pattern>
  13.         </encoder>
  14.     </appender>
  16.     <!--自定义Logger对象-->
  17.     <logger name="com.zzc.sbexp" level="info" additivity="false">
  18.         <appender-ref ref="console" />
  19.     </logger>
  20. </configuration>

运行代码后：
在这里插入图片描述
4.切换日志配置文件：

将日志框架切换为 log4j2

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-web</artifactId>
  4.     <exclusions>
  5.         <!--排除logback-->
  6.         <exclusion>
  7.             <groupId>org.springframework.boot</groupId>
  8.             <artifactId>spring-boot-starter-logging</artifactId>
  9.         </exclusion>
  10.     </exclusions>
  11. </dependency>
  12. <dependency>
  13.     <groupId>org.springframework.boot</groupId>
  14.     <artifactId>spring-boot-starter-log4j2</artifactId>
  15. </dependency>

log4j2.xml：

  1. <?xml version="1.0" encoding="utf-8" ?>
  3. <Configuration status="warn" monitorInterval="5">
  4.     <!--配置集中管理属性-->
  5.     <properties>
  6.         <property name="LOG_HOME" value="E:/temp/logs"></property>
  7.     </properties>
  9.     <Appenders>
  10.         <Console name="console" target="SYSTEM_OUT">
  11.             <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] [%-5level] %c{36}:%L --- %m%n"></PatternLayout>
  12.         </Console>
  13.     </Appenders>
  15.     <Loggers>
  16.         <Root level="info">
  17.             <AppenderRef ref="console" />
  18.         </Root>
  19.     </Loggers>
  21. </Configuration>

发表评论

表情：
评论列表 （有 0 条评论，100人围观）

还没有评论，来说两句吧...

相关阅读