开发中，日志记录是不可或缺的一部分，应用日志的记录主要用于：记录操作轨迹数据、监控系统运行情况、系统故障定位问题，日志的重要性不言而喻，想要快速定位问题，日志分析是个重要的手段，Java也提供了多种日志框架来进行有效的日志管理。本文将探讨Java常用的日志框架以及使用案例。
一、发展历史
- 1996: Log4j 1.x 由瑞士程序员CeKi Gülcü 发布
- 2002: JDK 1.4 发布，包含 JUL（java.util.logging，位于java.logging模块下），是 JDK 官方自带的日志框架。JUL 性能很差，使用比较少。
- 2002: Apache推出了Jakarta Commons Logging（简称JCL）日志接口
- 2010: Slf4j 发布
- 2009: Logback 发布
- 2014: Log4j2 发布
二、日志框架
现有的一些日志框架：
- 日志实现：JUL（java.util.logging）、logback、log4j、log4j2
- 日志门面：JCL（Jakarta Commons Logging）、Slf4j(Simple Logging Facade for Java）
1.Log4j
官方网站： http://logging.apache.org/log4j/1.2
Log4j 是 Apache 的一个开源项目，创始人 Ceki Gulcu。是 Java 领域资格最老，应用最广的日志工具。Log4j 中有三个主要组件：
- loggers（记录器） - 负责接收并记录日志信息。
- appenders（输出器） - 负责发布日志信息，定义了日志信息的目的地（如控制台、文件、数据库等）。
- layouts（布局） -负责定义日志输出的格式。
这种解耦的设计使得Log4j非常灵活，可以很容易地根据项目的需求进行定制。
1.1 log4j使用：
1).添加maven依赖
<!-- log4j -->
<dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version>
</dependency>
2).resources目录下创建log4j.properties文件（log4j支持两种配置文件格式：一种是XML格式的文件，一种是properties属性文件）
log4j.rootLogger=INFO,M,C,E
log4j.additivity.monitorLogger=false
# INFO级别文件输出配置
log4j.appender.M=org.apache.log4j.DailyRollingFileAppender
log4j.appender.M.File=/logs/info.log
log4j.appender.M.ImmediateFlush=false
log4j.appender.M.BufferedIO=true
log4j.appender.M.BufferSize=16384
log4j.appender.M.Append=true
log4j.appender.M.Threshold=INFO
log4j.appender.M.DatePattern='.'yyyy-MM-dd
log4j.appender.M.layout=org.apache.log4j.PatternLayout
log4j.appender.M.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} %p %l %m %n
# ERROR级别文件输出配置
log4j.appender.E=org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File=/logs/error.log
log4j.appender.E.ImmediateFlush=true
log4j.appender.E.Append=true
log4j.appender.E.Threshold=ERROR
log4j.appender.E.DatePattern='.'yyyy-MM-dd
log4j.appender.E.layout=org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} %p %l %m %n
# 控制台输出配置
log4j.appender.C=org.apache.log4j.ConsoleAppender
log4j.appender.C.Threshold=INFO
log4j.appender.C.layout=org.apache.log4j.PatternLayout
log4j.appender.C.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%t] %-5p %l %m %n
appender配置常使用的类如下:
org.apache.log4j.ConsoleAppender（控制台）
org.apache.log4j.FileAppender（文件）
org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）
org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件）
org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
layouts常用配置类：
org.apache.log4j.HTMLLayout（以HTML表格形式布局）
org.apache.log4j.PatternLayout（可以灵活地指定布局模式）
org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串）
org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等信息）
layout格式化打印参数：
* log4j 采用类似 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字符，就从左边交远销出的字符截掉xml文件格式如下：
<?xml version="1.0" encoding="UTF-8"?><Configuration><Appenders><Appender><Filters><LevelRangeFilter minLevel="..." maxLevel="..." onMatch="..." onMismatch="..."/></Filters><PatternLayout pattern="..." charset="..."/><Policies><CronTriggeringPolicy schedule="..."/><SizeBasedTriggeringPolicy size="..."/><TimeBasedTriggeringPolicy /></Policies></Appender><Appender>...</Appender></Appenders><Loggers><Logger><AppenderRef ref="..."></Logger><Root><AppenderRef ref="..."></Root></Loggers></Configuration>
3) log4j日志打印测试
import org.apache.log4j.Logger;
public class Log4jTest {@Testpublic void testLog4j(){// 1.创建日志记录器对象，使用静态方法创建Logger logger = Logger.getLogger("com.example.logtest.Log4jTest");// 记录debug级别的信息logger.debug("This is debug message.");// 记录info级别的信息logger.info("This is info message.");// 记录error级别的信息logger.error("This is error message.");}
}
2.JUL
JUL全称Java util Logging是Java原生的日志框架，使用时不需要另外引用第三方类库，JUL主要用于小型应用程序中，其设计原理基于几个核心组件：
- Logger：记录器，是应用程序访问日志系统的入口点。应用程序通过获取Logger对象，并调用其API来发布日志信息。Logger对象通常与特定的类或代码块相关联，以便能够精确地跟踪和记录日志。
- Handler：也被称为Appenders，每个Logger都会关联一个或多个Handler。Handler负责处理Logger传递过来的日志信息，并将其发送到指定的目的地，如控制台、文件、网络上的其他日志服务或操作系统日志等。Handler的具体实现决定了日志记录的位置和方式。
- Filter：过滤器，用于根据特定条件筛选日志信息。开发者可以根据需要定制哪些信息会被记录，哪些信息会被忽略，从而实现对日志信息的精细控制。
- Level：日志的输出级别。每条日志消息都有一个关联的级别，如DEBUG、INFO、WARN、ERROR等。这些级别粗略地指导了日志消息的重要性和紧迫性。
JUL的配置相对简单，配置文件通常使用.properties或XML格式，虽然是JDK自带的日志库，JUL使用的并不广泛，原因是因为JUL早期存在性能问题，到JDK1.5上才有了不错的进步，但现在和Logback/Log4j2相比还是有所不如
2.1 测试案例
import java.util.logging.Level;
import java.util.logging.Logger;
public class JULTest {@Testpublic void testQuick(){// 1.创建日志记录器对象，使用静态方法创建Logger logger = Logger.getLogger("com.example.logtest.JULTest");// 2.日志记录输出logger.info("hello JUL");// 通用方法输出logger.log(Level.INFO, "info msg");// 通过占位符输出logger.log(Level.INFO, "name: {0},age: {1}", new Object[]{"zhangsan",20});}
}
2.2 日志级别
java.util.logging.Level中定义了7个日志的级别
// 关闭日志记录
public static final Level OFF = new Level("OFF",Integer.MAX_VALUE, defaultBundle);
// 错误--最高的日志级别
public static final Level SEVERE = new Level("SEVERE",1000, defaultBundle);
// 警告
public static final Level WARNING = new Level("WARNING", 900, defaultBundle);
// 消息（默认级别）
public static final Level INFO = new Level("INFO", 800, defaultBundle);
// 配置
public static final Level CONFIG = new Level("CONFIG", 700, defaultBundle);
// 详细信息（少）
public static final Level FINE = new Level("FINE", 500, defaultBundle);
// 详细信息（中）
public static final Level FINER = new Level("FINER", 400, defaultBundle);
// 详细信息（多）-- 最低级的日志级别
public static final Level FINEST = new Level("FINEST", 300, defaultBundle);
// 启用所有消息日志
public static final Level ALL = new Level("ALL", Integer.MIN_VALUE, defaultBundle);
2.3 日志配置
如果我们没有添加配置，JUL默认的配置文件：JAVA_HOME/jre/lib/logging.properties
############################################################
# Default Logging Configuration File
#
# You can use a different file by specifying a filename
# with the java.util.logging.config.file system property.
# For example java -Djava.util.logging.config.file=myfile
########################################################################################################################
# Global properties
############################################################# "handlers" specifies a comma separated list of log Handler
# classes. These handlers will be installed during VM startup.
# Note that these classes must be on the system classpath.
# By default we only configure a ConsoleHandler, which will only
# show messages at the INFO and above levels.
## RootLogger使用的处理器
handlers= java.util.logging.ConsoleHandler# To also add the FileHandler, use the following line instead.
#handlers= java.util.logging.FileHandler, java.util.logging.ConsoleHandler# Default global logging level.
# This specifies which kinds of events are logged across
# all loggers. For any given facility this global level
# can be overriden by a facility specific level
# Note that the ConsoleHandler also has a separate level
# setting to limit messages printed to the console.
# RootLogger日志等级
.level= INFO############################################################
# Handler specific properties.
# Describes specific configuration info for Handlers.
############################################################
## 文件处理器
# default file output is in user's home directory.
java.util.logging.FileHandler.pattern = %h/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter
## 控制台处理器
# Limit the message that are printed on the console to INFO and above.
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter# Example to customize the SimpleFormatter output format
# to print one-line log message like this:
# <level>: <log message> [<date/time>]
#
# java.util.logging.SimpleFormatter.format=%4$s: %5$s [%1$tc]%n############################################################
# Facility specific properties.
# Provides extra control for each logger.
############################################################# For example, set the com.xyz.foo logger to only log SEVERE
# messages:
com.xyz.foo.level = SEVERE
自定义日志级别及配置
@Test
public void test2() throws IOException {
// 1.获取日志记录器对象
Logger logger = Logger.getLogger("com.example.logtest.JULTest");// 关闭系统默认配置
logger.setUseParentHandlers(false);
// 一、自定义配置日志级别// 创建ConsoleHandler 控制台输出
ConsoleHandler consoleHandler = new ConsoleHandler();
// 创建简单格式转换对象
SimpleFormatter simpleFormatter = new SimpleFormatter();
// 进行关联
consoleHandler.setFormatter(simpleFormatter);
logger.addHandler(consoleHandler);
// 配置日志具体级别
logger.setLevel(Level.ALL);
consoleHandler.setLevel(Level.ALL);// 二、输出到日志文件
FileHandler fileHandler = new FileHandler("d:/jul.log");
// 进行关联
fileHandler.setFormatter(simpleFormatter);
logger.addHandler(fileHandler);// 日志记录输出
logger.severe("severe");
logger.warning("warning");
logger.info("info"); // 默认日志输出级别
logger.config("config");
logger.fine("fine");
logger.finer("finer");
logger.finest("finest");
}
2.4 日志对象Logger的父子关系
JUL中Logger对象存在父子关系，也就是父亲Logger的设置，同时能够作用于儿子，这种父子关系是通过树状结构包路径进行存储，如下：logger1的日志设置，对logger2也能生效。
@Testpublic void test3() throws Exception {// 日志记录器对象父子关系Logger logger1 = Logger.getLogger("com.fang");Logger logger2 = Logger.getLogger("com.fang.log");System.out.println(logger2.getParent() == logger1);// 所有日志记录器对象的顶级父元素 class为java.util.logging.LogManagerSystem.out.println("logger2 parent:" + logger2.getParent() + "，name：" + logger2.getParent().getName());// 一、自定义日志级别// a.关闭系统默认配置logger1.setUseParentHandlers(false);// b.创建handler对象ConsoleHandler consoleHandler = new ConsoleHandler();// c.创建formatter对象SimpleFormatter simpleFormatter = new SimpleFormatter();// d.进行关联consoleHandler.setFormatter(simpleFormatter);logger1.addHandler(consoleHandler);// e.设置日志级别logger1.setLevel(Level.ALL);consoleHandler.setLevel(Level.ALL);// 测试日志记录器对象父子关系logger2.severe("severe");logger2.warning("warning");logger2.info("info");logger2.config("config");logger2.fine("fine");logger2.finer("finer");logger2.finest("finest");}
测试结果：
true
logger2 parent:java.util.logging.Logger@6ec8211c，name：com.fang
五月 10, 2024 12:09:45 上午 com.example.logtest.JULTest testLogParent
严重: severe
五月 10, 2024 12:09:45 上午 com.example.logtest.JULTest testLogParent
警告: warning
五月 10, 2024 12:09:45 上午 com.example.logtest.JULTest testLogParent
信息: info
五月 10, 2024 12:09:45 上午 com.example.logtest.JULTest testLogParent
配置: config
五月 10, 2024 12:09:45 上午 com.example.logtest.JULTest testLogParent
详细: fine
五月 10, 2024 12:09:45 上午 com.example.logtest.JULTest testLogParent
较详细: finer
五月 10, 2024 12:09:45 上午 com.example.logtest.JULTest testLogParent
非常详细: finest
3.Slf4j
Slf4J（Simple Logging Facade for Java）是一个用于Java的简单日志门面（Facade）主要是为了给Java日志访问提供一套标准、规范的API框架，它本身并不提供具体的日志实现，具体的实现可以交由其他日志框架，例如 log4j 、 logback、java.util.logging等。当然 Slf4J 自己也提供了功能较为简单的实现 slf4j-simple，但是一般很少用到。SLF4J 的作者就是 log4j 的作者 Ceki Gülcü，他宣称 SLF4J 比 log4j 更有效率，而且比 Apache Commons Logging (JCL) 简单、稳定。
官网：https://www.slf4j.org
3.1 Slf4j的官网架构图
上面架构图中可以看到，第一层是应用层，第二层即为slf4j提供的抽象接口：slf4j-api.jar，第三层的话蓝色的（2列5列6列）是日志的实现，而且是直接实现slf4j-api.jar相关接口，湖蓝色（3列4列）是适配层，与上面的slf4j-api接口以及第4层具体日志框架（log4j、jul）的适配。从上图也可以看到logback是直接实现了slf4j的接口的，而log4j在被slf4j调用的时候需要一个适配层。
reload4j：reload4j是Apache log4j版本1.x的一个分支，由于log4j存在一些安全漏洞，Apache社区和其他开发者开始寻求解决方案，reload4j就是其中之一。通过使用slf4j-reload4j，开发者可以在不修改太多代码的情况下，将他们的应用程序从log4j 1.x迁移到reload4j，从而提高应用程序的安全性和稳定性。
slf4j的主要搭配如下：
- Slf4j+logback slf4j-api.jar+logback-classic.jar+logback-core.jar
- Slf4j+log4j slf4j-api.jar+slf4j-log4j12.jar+log4j.jar
- Slf4j+jul slf4j-api.jar+slf4j-jdk14.jar
- Slf4j无日志实现 slf4j-api.jar+slf4j-nop.jar
官网第二张图（桥接策略）
可以看到，上面含义是如果我们已经使用了其他日志框架的api，想转到另一种日志框架api，该如何使用桥接的jar包，如从logback到log4j，JUL到log4j等，本质是通过将一种框架日志交给slf4j，slf4j再通过桥接包到转给另一种框架日志输出，总的来说为以下情况：
- 在使用JCL，则可以通过：jcl-over-slf4j.jar
- 在使用log4j，则可以通过：log4j-over-slf4j.jar
- 在使用JUL，则可通过jul-to-slf4j.jar
注意： 虽然使用 log4j-over-slf4j 可以实现 Log4j 桥接到 SLF4J，也可以使用 slf4j-log4j12 实现 SLF4J 适配到 Log4j，但是它不能同时使用它们，否则就会产生死循环。jcl 和 jul 也是同样的道理，jcl-over-slf4j.jar和slf4j-jcl.jar不能同时出现，jul-over-slf4j.jar和slf4j-log4j12.jar不能同时出现。
4.Logback
官网：https://logback.qos.ch/
Logback是由Ceki Gülcü（同时也是SLF4J的作者）创建的新一代日志框架，旨在解决Log4J的部分性能瓶颈和设计局限。Logback不仅实现了SLF4J API，还具有高度优化的性能、丰富的配置选项和强大的扩展能力。SpringBoot底层也是使用slf4j+logback的方式进行日志记录。
Logback主要分为三个模块:
- logback-core ：其它两个模块的基础模块
- logback-classic ：它是log4j的一个改良版本，同时它完整实现了slf4j API
- logback-access ：访问模块与Servlet容器集成提供通过Http来访问日志的功能
4.1 Logback 使用示例
1）添加依赖
<dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId><version>1.7.25</version>
</dependency>
<dependency><groupId>ch.qos.logback</groupId><artifactId>logback-classic</artifactId><version>1.2.3</version>
</dependency>
实际开发中我们可以直接引入spring-boot-starter-web依赖，因为spring-boot-starter-web包含了spring-boot-starter 而spring-boot-starter包含了spring-boot-starter-logging
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId>
</dependency>
2）配置文件
logback会依次读取以下类型配置文件：
- logback.groovy
- logback-test.xml
- logback.xml
如果均不存在会采用默认配置
logback-spring.yml
<?xml version="1.0" encoding="utf-8"?>
<!--配置文件说明：
共有一个父标签、两种属性、三个节点:
1.一个父标签：configuration
2. 两种属性：contextName和property
3. 三个节点：appender、root、logger主要就是appender追加到哪里：控制台/文件，然后采用哪种pattern（在property定义了pattern格式）
然后就是logger和root配置，指定日志输出级别，以及引用哪种appender
-->
<configuration><!--根节点<configuration>包含的属性：scan:当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。--><contextName>logback-spring-demo-dev</contextName><property name="pattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg %n"/><property name="pattern-color"value="%yellow(%d{yyyy-MM-dd HH:mm:ss.SSS}) [%thread] %highlight(%-5level) %green(%logger{50}) - %highlight(%msg) %n"/><!--文件路径输出说明，会自动生成文件夹及log文件，但是由于我这个是多模块，默认生成在父目录下的logs文件夹下面，所以要在子模块下生成要再加一个路径--><property name="LOG_HOME" value="./springboot_log/logs"/><!-- 控制台输出 --><appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender"><!--ThresholdFilter为系统定义的拦截器，例如我们用ThresholdFilter来过滤掉ERROR级别以下的日志不输出到文件中。如果不用记得注释掉，不然你控制台会发现没日志~--><!--<filter class="ch.qos.logback.classic.filter.ThresholdFilter">--><!--<level>ERROR</level>--><!--</filter>--><encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder"><pattern>${pattern}</pattern></encoder></appender><!-- 控制台输出-带颜色 --><appender name="CONSOLE-WITH-COLOR" class="ch.qos.logback.core.ConsoleAppender"><encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder"><pattern>${pattern-color}</pattern></encoder></appender><!-- 文件输出 --><appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender"><rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"><fileNamePattern>${LOG_HOME}/%d.%i.log</fileNamePattern><timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP"><maxFileSize>10MB</maxFileSize></timeBasedFileNamingAndTriggeringPolicy><maxHistory>30</maxHistory></rollingPolicy><encoder><pattern>${pattern}</pattern></encoder></appender><!--相当于全局的配置--><root level="INFO"><appender-ref ref="CONSOLE-WITH-COLOR"/><appender-ref ref="FILE"/></root><!--1. root和logger是父子的关系。Logger的appender根据参数additivity决定是否要叠加root的appender，logger的级别是其自身定义的级别，和root的级别没什么关系。2. logger对单个包或类添加配置，相当于局部配置，root相当于全局配置如果logger里面配置了additivity="false"，就会覆盖root的，只打印一遍；但是additivity="true"，就会向上层再次传递，不会覆盖，而是打印两遍！--><!--相当于局部配置：配置特定类/包使用不同的日志输出器appender：TestControoler2的会输出两遍，additivity="true"--><logger name="com.apple.controller.TestController2" level="INFO" additivity="true"><appender-ref ref="CONSOLE"/></logger></configuration>
3）测试
@Slf4j
@RestController
public class TestController {@RequestMapping("/index")public String index(){log.info("==========hello logback=============");return "hello logback";}
}
5.JCL(Jakarta Commons Logging)
官网：https://commons.apache.org/proper/commons-logging/
JCL是Apache基金会所属的项目，是一套Java日志接口，之前叫Jakarta Commons Logging，后更名为Commons Logging， 它本身并不提供日志的具体实现，（当然，commons-logging内部有一个SimpleLog但是功能非常常弱 ，所以一般不会单独使用它），而是在运行时绑定具体的日志组件来工作（如Log4j、JUL ）。
JCL两个基本抽象类：
- Log：日志记录器
- LogFactory：日志工厂（负责创建Log实例）
5.1 JCL例子
maven依赖：
<dependency> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId><version>1.2</version>
</dependency>
测试
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;public class JCLTest {@Testpublic void testJCL(){// 创建日志对象Log log = LogFactory.getLog(JCLTest.class);// 记录debug级别的信息log.debug("This is debug message.");// 记录info级别的信息log.info("This is info message.");// 记录error级别的信息log.error("This is error message.");}
}
6.log4j2
官网：https://logging.apache.org/log4j/2.x/
Apache Log4J曾一度是Java世界中最流行的日志框架之一，以其灵活性和模块化设计著称。然而，随着时间推移，原版Log4J暴露出了一些性能和功能上的短板。于是，Apache基金会推出了Log4J2，这是一个经过彻底重构并优化的新版本，引入了许多新特性，主要有：
- 异常处理，在 logback中，Appender中的异常不会被应用感知到，但是在log4j2中，提供了一些异 常处理机制。
- 性能提升， log4j2相较于log4j 和logback都具有很明显的性能提升，后面会有官方测试的数据。
- 自动重载配置，参考了 logback的设计，当然会提供自动刷新参数配置，最实用的就是我们在生产 上可以动态的修改日志的级别而不需要重启应用。
- 无垃圾机制， log4j2在大部分情况下，都可以使用其设计的一套无垃圾机制，避免频繁的日志收集导致的jvm gc
6.1案例实现：
1）引入依赖：
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-log4j2</artifactId><version>2.6.13</version>
</dependency>
2) log4j2.xml
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" monitorInterval="5"><properties><property name="LOG_HOME">D:/logs</property></properties><Appenders><Console name="Console" target="SYSTEM_OUT"><PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] [%-5level] %c{36}:%L --- %m%n" /></Console><File name="file" fileName="${LOG_HOME}/myfile.log"><PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l%c{36} - %m%n" /></File><RandomAccessFile name="accessFile" fileName="${LOG_HOME}/myAcclog.log"><PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l%c{36} - %m%n" /></RandomAccessFile><RollingFile name="rollingFile" fileName="${LOG_HOME}/myrollog.log"filePattern="D:/logs/$${date:yyyy-MM-dd}/myrollog-%d{yyyyMM-dd-HH-mm}-%i.log"><ThresholdFilter level="debug" onMatch="ACCEPT" onMismatch="DENY" /><PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l%c{36} - %msg%n" /><Policies><OnStartupTriggeringPolicy /><SizeBasedTriggeringPolicy size="10 MB" /><TimeBasedTriggeringPolicy /></Policies><DefaultRolloverStrategy max="30" /></RollingFile></Appenders><Loggers><Root level="trace"><AppenderRef ref="Console" /></Root></Loggers>
</Configuration>
3）JAVA代码测试
import org.slf4j.LoggerFactory;public class LogTest {static org.slf4j.Logger logger = LoggerFactory.getLogger(LogTest.class);public static void main(String[] args) {logger.trace("trace level");logger.debug("debug level");logger.info("info level");logger.warn("warn level");logger.error("error level");}
}
参考：
- http://t.csdnimg.cn/lW60J
- https://time.geekbang.org/column/article/220307
- https://www.cnblogs.com/cxyyh/p/10633581.html
