日志处理 | Next-gen Tech Edu

Log4j2

Mon, 01 Jan 0001 00:00:00 +0000

Log4j2

Log4j 2 包含了基于 LMAX 分离库的下一代的异步日志系统，在多线程环境下，异步日志系统比 Log4j 1.x 和 Logback 提高了 10 倍性能提升(吞吐量和延迟率)，各种框架的对比可以看到如下所示：

Log4j 2 是 Log4j 的升级版本，该版本比起其前任来说有着显著的改进，包含很多在 Logback 中的改进以及 Logback 架构中存在的问题。这是 Log4j 2 的首次发行的版本，值得关注的改进包括：

API 分离 – Log4j 的 API 和其实现进行分类(注：我讨厌这样，本来一个 jar 包搞定的，要变成好几个，跟 slf4j 似的的)
为日志审计而设计，与 Log4j 1.x 和 Logback 不同的是 Log4j 2 将不会在重新配置期间丢失事件，支持消息可方便进行审计
性能方面的提升，在关键领域比 Log4j 1.x 的性能提升不少，大部分情况下性能跟 Logback 差不多
支持多 APIs，支持 SLF4J 和 Commons Logging API
自动配置重载，支持 XML 和 JSON 格式的配置
插件体系架构，所有可配置的组件都是通过 Log4j 插件进行定义，包括 Appender, Layout, Pattern Converter, 等等
配置属性支持

配置文件

如果需要使用 Log4j2，首先需要在他的依赖文件里引入如下依赖：

 <dependencies>
 <dependency>
 <groupId>org.apache.logging.log4j</groupId>
 <artifactId>log4j-api</artifactId>
 <version>2.4.1</version>
 </dependency>
 <dependency>
 <groupId>org.apache.logging.log4j</groupId>
 <artifactId>log4j-core</artifactId>
 <version>2.4.1</version>
 </dependency>
 </dependencies>
 <dependency>
 <groupId>org.apache.logging.log4j</groupId>
 <artifactId>log4j-slf4j-impl</artifactId>
 <version>2.0-beta9</version>
 </dependency>

而后在代码文件中，可以使用 Slf4j，也可以直接使用 Log4j2，如下：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

private static final Logger log = LoggerFactory.getLogger(Test.class);

如果是直接使用的 log4j2，则只要用 LogManager 的 getLogger 函数获取一个 logger，就可以使用 logger 记录日志，代码如下：

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

public class HelloLog4j {
 private static Logger logger = LogManager.getLogger("HelloLog4j");

 public static void main(String[] args) {
 MyApplication myApplication = new MyApplication();

 logger.entry();
 logger.info("Hello, World!");
 myApplication.doIt();
 logger.error("Hello, World!");
 logger.exit();
 }
}

需要注意的是，log4j 2.0 与以往的 1.x 有一个明显的不同，其配置文件只能采用.xml, .json 或者 .jsn。在默认情况下，系统选择 configuration 文件的优先级如下：

classpath 下名为 log4j-test.json 或者 log4j-test.jsn 文件
classpath 下名为 log4j2-test.xml
classpath 下名为 log4j.json 或者 log4j.jsn 文件
classpath 下名为 log4j2.xml

Logger 配置

<?xml version="1.0" encoding="UTF-8"?>
 <!-- status=debug 可以查看log4j的装配过程 -->
 <configuration status="off" monitorInterval="1800">
 <properties>
 <property name="LOG_HOME">/log/fish</property>
 <!-- 日志备份目录 -->
 <property name="BACKUP_HOME">{LOG_HOME}/backup</property>
 <property name="STAT_NAME">stat</property>
 <property name="SERVER_NAME">global</property>
 </properties>
 <appenders>
 <!-- 定义控制台输出 -->
 <Console name="Console" target="SYSTEM_OUT" follow="true">
 <PatternLayout pattern="%date{yyyy-MM-dd HH:mm:ss.SSS} %level [%thread][%file:%line] - %msg%n" />
 </Console>
 <!-- 程序员调试日志 -->
 <RollingRandomAccessFile name="DevLog" fileName="${LOG_HOME}/${SERVER_NAME}"
 filePattern="${LOG_HOME}/${SERVER_NAME}.%d{yyyy-MM-dd-HH}.log">
 <PatternLayout pattern="%date{yyyy-MM-dd HH:mm:ss.SSS} %level [%thread][%file:%line] - %msg%n" />
 <Policies>
 <TimeBasedTriggeringPolicy interval="1" modulate="true" />
 </Policies>
 </RollingRandomAccessFile>
 <!-- 游戏产品数据分析日志 -->
 <RollingRandomAccessFile name="ProductLog"
 fileName="${LOG_HOME}/${SERVER_NAME}_${STAT_NAME}"
 filePattern="${LOG_HOME}/${SERVER_NAME}_${STAT_NAME}.%d{yyyy-MM-dd-HH}.log">
 <PatternLayout
 pattern="%date{yyyy-MM-dd HH:mm:ss.SSS} %level [%thread][%file:%line] - %msg%n" />
 <Policies>
 <TimeBasedTriggeringPolicy interval="1"
 modulate="true" />
 </Policies>
 </RollingRandomAccessFile>
 </appenders>
 <loggers>
 <!-- 3rdparty Loggers -->
 <logger name="org.springframework.core" level="info">
 </logger>
 <logger name="org.springframework.beans" level="info">
 </logger>
 <logger name="org.springframework.context" level="info">
 </logger>
 <logger name="org.springframework.web" level="info">
 </logger>
 <logger name="org.jboss.netty" level="warn">
 </logger>
 <logger name="org.apache.http" level="warn">
 </logger>
 <logger name="com.mchange.v2" level="warn">
 </logger>
 <!-- Game Stat logger -->
 <logger name="com.u9.global.service.log" level="info"
 additivity="false">
 <appender-ref ref="ProductLog" />
 </logger>
 <!-- Root Logger -->
 <root level="DEBUG" includeLocation="true">
 <appender-ref ref="DevLog" />
 <appender-ref ref="Console" />
 </root>
 </loggers>
</configuration>

loggers 标签，用于定义 logger 的 lever 和所采用的 appender，其中 appender-ref 必须为先前定义的 appenders 的名称，例如，此处为 Console。那么 log 就会以 appender 所定义的输出格式来输出 log。root 标签为 log 的默认输出形式，如果一个类的 log 没有在 loggers 中明确指定其输出 lever 与格式，那么就会采用 root 中定义的格式。例如以下定义：

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="OFF">
 <appenders>
 <Console name="Console" target="SYSTEM_OUT">
 <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
 </Console>
 </appenders>
 <loggers>
 <logger name="com.relin.HelloLog4j" level="error" additivity="false">
 <appender-ref ref="Console"/>
 </logger>
 <root level="trace">
 <appender-ref ref="Console"/>
 </root>
 </loggers>
</configuration>

此时，HelloLog4j 则会在 error 级别上输出 log，而其他类则会在 trace 级别上输出 log。需要注意的是 additivity 选项，如果设置为 true(默认值)则 HelloLog4j 的 log 会被打印两次，第二次打印是由于 HelloLog4j 同时也满足 root 里面定义的 trace。在 log4j2 中可以配置不同的 Logger 输出到不同的文件中，如果有时候需要按照不同的级别输出到不同的文件中，则直接在 logger 的 AppenderRef 中定义不同的 level 指向。

<loggers>
 <logger name="com.mvc.login" level="info" additivity="false">
 <appenderRef ref="LoginController" level="error"/>
 <appenderRef ref="InfoController" level="info"/>
 </logger>
</loggers>

Logback

Mon, 01 Jan 0001 00:00:00 +0000

基于 Logback 的 Java 日志处理

Logback 是一个日志框架，它与 Log4j 可以说是同出一源，都出自 Ceki Gülcü 之手。Slf4j 的全称是 Simple Logging Facade for Java，即简单日志门面；实现了日志框架一些通用的接口，结合日志框架一起使用，最终日志的格式、记录级别、输出方式等都是通过绑定具体的日志框架实现的。

Logback 主要由 logback-core, logback-classic, logback-access 三个模块组成，logback-core 是其它模块的基础设施，提供了一些关键的通用机制。logback-classic 的地位和作用等同于 Log4J，它也被认为是 Log4J 的一个改进版，并且它实现了简单日志门面 Slf4j；而 logback-access 主要作为一个与 Servlet 容器交互的模块，比如说 tomcat 或者 jetty，提供一些与 HTTP 访问相关的功能。

基础配置

我们可以通过 logback-spring.xml 来配置 Logback，基础配置如下：

<configuration scan="true" scanPeriod="60 seconds" debug="false">
 <!-- 引入 Spring Boot 基础配置 -->
 <include resource="org/springframework/boot/logging/logback/defaults.xml"/>

 <!-- 定义变量 -->
 <property name="APP_NAME" value="test"/>
 <property name="LOG_PATH" value="${user.home}/${APP_NAME}/logs"/>
 <property name="LOG_FILE" value="${LOG_PATH}/application.log"/>

 <!-- 日志输出级别变量 @see application-xxx.properties-->
 <springProperty scope="context" name="logLevel" source="log.level"/>

 <appender>
 // xxxx
 </appender>

 <logger>
 // xxxx
 </logger>

 <root level="${logLevel}">
 // xxxx
 </root>
</configuration>

property 用来定义变量值的标签，property 标签有两个属性，name 和 value；其中 name 的值是变量的名称，value 的值时变量定义的值。通过 property 定义的值会被插入到 logger 上下文中。定义变量后，可以使 ${name} 来使用变量。

<included>
 <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
 <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
 <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
 <property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>
 <property name="FILE_LOG_PATTERN" value="${FILE_LOG_PATTERN:-%d{yyyy-MM-dd HH:mm:ss.SSS} ${LOG_LEVEL_PATTERN:-%5p} ${PID:- } --- [%t] %-40.40logger{39} : %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>

 <appender name="DEBUG_LEVEL_REMAPPER" class="org.springframework.boot.logging.logback.LevelRemappingAppender">
 <destinationLogger>org.springframework.boot</destinationLogger>
 </appender>

 <logger name="org.apache.catalina.startup.DigesterFactory" level="ERROR"/>
 ...
 <logger name="org.springframework.boot.actuate.endpoint.jmx" additivity="false">
 <appender-ref ref="DEBUG_LEVEL_REMAPPER"/>
 </logger>
 <logger name="org.thymeleaf" additivity="false">
 <appender-ref ref="DEBUG_LEVEL_REMAPPER"/>
 </logger>
</included>

然后在 Java 代码中可以通过 Slf4j 来获取到日志记录器对象：

// 通过 Slf4j LoggerFactory 获取 logger 对象
private static final Logger logger = LoggerFactory.getLogger(DemoTest.class);

// 通过 Slf4j 注解注入
@Slf4j
logger.info("info")

Appender

Appender 是一个日志打印的组件，这里组件里面定义了打印过滤的条件、打印输出方式、滚动策略、编码方式、打印格式等等。但是它仅仅是一个打印组件，如果我们不使用一个 logger 或者 root 的 appender-ref 指定某个具体的 appender 时，它就没有什么意义。上文定义的 root 本质上是根 logger,只不过 root 中不能有 name 和 additivity 属性，是有一个 level。

Appender 主要包含以下三类：

ConsoleAppender：把日志添加到控制台
FileAppender：把日志添加到文件
RollingFileAppender：滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件。它是 FileAppender 的子类

ConsoleAppender

最常用的日志输出就是输出到 Console 中，我们可以定义 Console 专用的 Appender:

<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
 <encoder>
 <pattern>logback: %d {HH:mm:ss.SSS} %logger{36} - %M - %msg%n</pattern>
 <!--<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS}|%level|%class|%thread|%method|%line|%msg%n</pattern>-->
 <!-- 使用 Spring Boot 预定义的 Pattern -->
 <!--<pattern>${CONSOLE_LOG_PATTERN}</pattern>-->
 </encoder>
</appender>

<root level="${logLevel}">
 <appender-ref ref="console"/>
</root>

RollingFileAppender

<appender name="APPLICATION"
 class="ch.qos.logback.core.rolling.RollingFileAppender">
 <file>${LOG_FILE}</file>
 <encoder>
 <pattern>${FILE_LOG_PATTERN}</pattern>
 </encoder>
 <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
 <fileNamePattern>${LOG_FILE}.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
 <maxHistory>7</maxHistory>
 <maxFileSize>50MB</maxFileSize>
 <totalSizeCap>20GB</totalSizeCap>
 </rollingPolicy>
</appender>

其中 rollingPolicy 子标签用来描述滚动策略，仅在 RollingFileAppender 中才需要配置。而该标签中常用的滚动策略是 TimeBasedRollingPolicy，它根据时间来制定滚动策略，既负责滚动也负责触发滚动。其他还有，FixedWindowRollingPolicy 根据固定窗口算法重命名文件的滚动策略。

Filter

在真实场景下，我们可能会需要将不同级别的日志输出到不同的文件中，在不引入新的 Logger 的情况下，我们可以通过 Filter 来进行过滤：

filter 其实是 appender 里面的子元素。它作为过滤器存在，执行一个过滤器会有返回 DENY，NEUTRAL，ACCEPT 三个枚举值中的一个。

DENY：日志将立即被抛弃不再经过其他过滤器
NEUTRAL：有序列表里的下个过滤器过接着处理日志
ACCEPT：日志会被立即处理，不再经过剩余过滤器

<appender name="fileInfoLog" class="ch.qos.logback.core.rolling.RollingFileAppender">
 <filter class="ch.qos.logback.classic.filter.LevelFilter">
 <!--要拦截的日志级别-->
 <level>ERROR</level>
 <!--如果匹配，则禁止-->
 <onMatch>DENY</onMatch>
 <!--如果不匹配，则允许记录-->
 <onMismatch>ACCEPT</onMismatch>
 </filter>
 <encoder>
 <pattern>%d -- %msg%n</pattern>
 </encoder>
 <!--滚动策略-->
 <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
 <!--路径-->
 <fileNamePattern>${LOG_FILE}.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
 </rollingPolicy>
</appender>

<appender name="fileErrorLog" class="ch.qos.logback.core.rolling.RollingFileAppender">
 <!--添加 范围 过滤-->
 <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
 <level>ERROR</level>
 </filter>
 <encoder>
 <pattern>%d -- %msg%n</pattern>
 </encoder>
 <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
 <fileNamePattern>${LOG_FILE}.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
 </rollingPolicy>
</appender>

<root level="info">
 <appender-ref ref="fileInfoLog"/>
 <appender-ref ref="fileErrorLog"/>
</root>

其他的常用的 Filter 还有 ThresholdFilter 与 LevelFilter：

ThresholdFilter: 临界值过滤器，过滤掉低于指定临界值的日志。当日志级别等于或高于临界值时，过滤器返回 NEUTRAL；当日志级别低于临界值时，日志会被拒绝。
LevelFilter: 级别过滤器，根据日志级别进行过滤。如果日志级别等于配置级别，过滤器会根据 onMath(用于配置符合过滤条件的操作) 和 onMismatch(用于配置不符合过滤条件的操作)接收或拒绝日志。

Logger

我们可以通过自定义 Logger，来关联不同的包或者 Appender:

<logger name="wx.spring.boot.controller"
 level="${logging.level}" additivity="false">
 <appender-ref ref="console" />
</logger>

上面的这个配置文件描述的是：wx.spring.boot.controller 这个包下的 ${logging.level} 级别的日志将会使用 console 来打印；logger 有三个属性和一个子标签：

name: 用来指定受此 logger 约束的某一个包或者具体的某一个类。
level: 用来设置打印级别（TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF），还有一个值 INHERITED 或者同义词 NULL，代表强制执行上级的级别。如果没有设置此属性，那么当前 logger 将会继承上级的级别。
addtivity: 用来描述是否向上级 logger 传递打印信息。默认是 true。

<!-- fileControllerLog-->
<appender name="fileControllerLog" class="ch.qos.logback.core.rolling.RollingFileAppender">
 <file>${APP_LOG_FILE}</file>
 <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
 <level>${logging.level}</level>
 </filter>
 <encoder>
 <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ${LOG_LEVEL_PATTERN:-%5p} %t %logger{0} %m%n</pattern>
 <charset>utf8</charset>
 </encoder>
 <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
 <fileNamePattern>${APP_LOG_FILE}.log.%d{yyyy-MM-dd}</fileNamePattern>
 <maxHistory>10</maxHistory>
 </rollingPolicy>
</appender>

<!--此logger约束将.controller 包下的日志输出到 fileControllerLog-->
<logger name="wx.spring.boot.controller" level="${logging.level}" additivity="false">
 <appender-ref ref="fileControllerLog" />
 <appender-ref ref="fileErrorLog" />
</logger>

<!--此logger约束将.service 包下的日志输出到 fileServiceLog-->
<logger name="wx.spring.boot.service" level="${logging.level}" additivity="false">
 <appender-ref ref="fileServiceLog" />
 <appender-ref ref="fileErrorLog" />
</logger>

我们也可以将日志维度固定到某个具体的类：

<!--这里指定到了具体的某一个类-->
<logger name="wx.spring.boot.task.TestLogTask" level="${logging.level}" additivity="true">
 <appender-ref ref="SCHEDULERTASKLOCK-APPENDER" />
 <appender-ref ref="fileErrorLog" />
 </logger>

或者自定义 logger 名称：

<logger name="dependency" level="info" additivity="false">
 <appender-ref ref="dependencyAppender" />
</logger>

然后在代码中显式获取：

private static Logger logger = LoggerFactory.getLogger("dependency");

如果我们希望打印出 MyBatis 的 SQL 语句，则在 logback-spring.xml 中添加如下配置：

 <!-- 将sql语句输出到具体的日志文件中 -->
<logger name="wx.dao" level="${logging.sql.level}" additivity="false">
 <appender-ref ref="sqlAppender"/>
</logger>

MDC

Mon, 01 Jan 0001 00:00:00 +0000

MDC

MDC（Mapped Diagnostic Context，映射调试上下文）是 log4j 和 logback 提供的一种方便在多线程条件下记录日志的功能。某些应用程序采用多线程的方式来处理多个用户的请求。在一个用户的使用过程中，可能有多个不同的线程来进行处理。典型的例子是 Web 应用服务器。当用户访问某个页面时，应用服务器可能会创建一个新的线程来处理该请求，也可能从线程池中复用已有的线程。在一个用户的会话存续期间，可能有多个线程处理过该用户的请求。这使得比较难以区分不同用户所对应的日志。当需要追踪某个用户在系统中的相关日志记录时，就会变得很麻烦。

一种解决的办法是采用自定义的日志格式，把用户的信息采用某种方式编码在日志记录中。这种方式的问题在于要求在每个使用日志记录器的类中，都可以访问到用户相关的信息。这样才可能在记录日志时使用。这样的条件通常是比较难以满足的。MDC 的作用是解决这个问题。MDC 可以看成是一个与当前线程绑定的哈希表，可以往其中添加键值对。MDC 中包含的内容可以被同一线程中执行的代码所访问。当前线程的子线程会继承其父线程中的 MDC 的内容。当需要记录日志时，只需要从 MDC 中获取所需的信息即可。MDC 的内容则由程序在适当的时候保存进去。对于一个 Web 应用来说，通常是在请求被处理的最开始保存这些数据。

使用案例

让我们从一个例子开始。假设我们要写一个转账的软件。我们设置了一个 Transfer 类来表示一些基本信息：一个独特的转账 ID 和发送者的名字。

public class Transfer {
 private String transactionId;
 private String sender;
 private Long amount;

 public Transfer(String transactionId, String sender, long amount) {
 this.transactionId = transactionId;
 this.sender = sender;
 this.amount = amount;
 }
}

为了执行转移，我们需要使用一个由简单 API 支持的服务。

public abstract class TransferService {

 public boolean transfer(long amount) {
 // connects to the remote service to actually transfer money
 }

 abstract protected void beforeTransfer(long amount);

 abstract protected void afterTransfer(long amount, boolean outcome);
}

beforeTransfer() 和 afterTransfer() 方法可以被重写，以便在传输完成之前和之后运行自定义代码。我们将利用 beforeTransfer() 和 afterTransfer() 来记录一些关于传输的信息。

import org.apache.log4j.Logger;
import com.baeldung.mdc.TransferService;

public class Log4JTransferService extends TransferService {
 private Logger logger = Logger.getLogger(Log4JTransferService.class);

 @Override
 protected void beforeTransfer(long amount) {
 logger.info("Preparing to transfer " + amount + "$.");
 }

 @Override
 protected void afterTransfer(long amount, boolean outcome) {
 logger.info(
 "Has transfer of " + amount + "$ completed successfully ? " + outcome + ".");
 }
}

这里需要注意的主要问题是，当创建日志信息时，不可能访问 Transfer 对象；只有金额可以访问，因此不可能记录交易 ID 或发件人。让我们设置通常的 log4j.properties 文件，以便在控制台记录。

log4j.appender.consoleAppender=org.apache.log4j.ConsoleAppender
log4j.appender.consoleAppender.layout=org.apache.log4j.PatternLayout
log4j.appender.consoleAppender.layout.ConversionPattern=%-4r [%t] %5p %c %x - %m%n
log4j.rootLogger = TRACE, consoleAppender

最后让我们设置一个小程序，它能够通过 ExecutorService 同时运行多个传输。

public class TransferDemo {

 public static void main(String[] args) {
 ExecutorService executor = Executors.newFixedThreadPool(3);
 TransactionFactory transactionFactory = new TransactionFactory();
 for (int i = 0; i < 10; i++) {
 Transfer tx = transactionFactory.newInstance();
 Runnable task = new Log4JRunnable(tx);
 executor.submit(task);
 }
 executor.shutdown();
 }
}

我们注意到，为了使用 ExecutorService，我们需要将 Log4JTransferService 的执行包装在一个适配器中，因为 executor.submit()期望有一个 Runnable。

public class Log4JRunnable implements Runnable {
 private Transfer tx;

 public Log4JRunnable(Transfer tx) {
 this.tx = tx;
 }

 public void run() {
 log4jBusinessService.transfer(tx.getAmount());
 }
}

当我们运行同时管理多笔转账的演示程序时，我们很快发现，日志并不像我们希望的那样有用。跟踪每笔转账的执行情况是很复杂的，因为被记录的唯一有用的信息是转账的金额和执行该特定转账的线程的名称。更重要的是，我们不可能区分由同一个线程执行的相同金额的两个不同交易，因为相关的日志行看起来基本相同。

Log4j

Log4j 中的 MDC 允许我们在一个类似于地图的结构中填入一些信息，这些信息在实际写入日志消息时可以被 appender 访问。MDC 结构在内部被附加到执行线程上，与 ThreadLocal 变量的方式相同。

import org.apache.log4j.MDC;

public class Log4JRunnable implements Runnable {
 private Transfer tx;
 private static Log4JTransferService log4jBusinessService = new Log4JTransferService();

 public Log4JRunnable(Transfer tx) {
 this.tx = tx;
 }

 public void run() {
 MDC.put("transaction.id", tx.getTransactionId());
 MDC.put("transaction.owner", tx.getSender());
 log4jBusinessService.transfer(tx.getAmount());
 MDC.clear();
 }
}

不出所料，MDC.put() 被用来在 MDC 中添加一个键和一个相应的值，而 MDC.clear() 则清空 MDC。现在让我们修改 log4j.properties 来打印我们刚刚存储在 MDC 中的信息。只需改变转换模式，用 %X{} 占位符来表示我们希望被记录的 MDC 中的每个条目。

log4j.appender.consoleAppender.layout.ConversionPattern=
%-4r [%t] %5p %c{1} %x - %m - tx.id=%X{transaction.id} tx.owner=%X{transaction.owner}%n

现在，如果我们运行这个应用程序，我们会注意到每一行都带有正在处理的事务的信息，使我们更容易跟踪应用程序的执行。

638 [pool-1-thread-2] INFO Log4JBusinessService
- Has transfer of 1104$ completed successfully ? true. - tx.id=2 tx.owner=Marc
638 [pool-1-thread-2] INFO Log4JBusinessService
- Preparing to transfer 1685$. - tx.id=4 tx.owner=John
666 [pool-1-thread-1] INFO Log4JBusinessService
- Has transfer of 1985$ completed successfully ? true. - tx.id=1 tx.owner=Marc
666 [pool-1-thread-1] INFO Log4JBusinessService
- Preparing to transfer 958$. - tx.id=5 tx.owner=Susan
739 [pool-1-thread-3] INFO Log4JBusinessService
- Has transfer of 783$ completed successfully ? true. - tx.id=3 tx.owner=Samantha
739 [pool-1-thread-3] INFO Log4JBusinessService
- Preparing to transfer 1024$. - tx.id=6 tx.owner=John
1259 [pool-1-thread-2] INFO Log4JBusinessService
- Has transfer of 1685$ completed successfully ? false. - tx.id=4 tx.owner=John
1260 [pool-1-thread-2] INFO Log4JBusinessService
- Preparing to transfer 1667$. - tx.id=7 tx.owner=Marc

Log4j2

Log4j2 中也有同样的功能，让我们看看如何使用它。首先让我们建立一个 TransferService 子类，使用 Log4j2 进行记录。

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

public class Log4J2TransferService extends TransferService {
 private static final Logger logger = LogManager.getLogger();

 @Override
 protected void beforeTransfer(long amount) {
 logger.info("Preparing to transfer {}$.", amount);
 }

 @Override
 protected void afterTransfer(long amount, boolean outcome) {
 logger.info("Has transfer of {}$ completed successfully ? {}.", amount, outcome);
 }
}

然后让我们改变使用 MDC 的代码，它在 Log4j2 中实际上叫做 ThreadContext。

import org.apache.log4j.MDC;

public class Log4J2Runnable implements Runnable {
 private final Transaction tx;
 private Log4J2BusinessService log4j2BusinessService = new Log4J2BusinessService();

 public Log4J2Runnable(Transaction tx) {
 this.tx = tx;
 }

 public void run() {
 ThreadContext.put("transaction.id", tx.getTransactionId());
 ThreadContext.put("transaction.owner", tx.getOwner());
 log4j2BusinessService.transfer(tx.getAmount());
 ThreadContext.clearAll();
 }
}

同样，ThreadContext.put() 在 MDC 中添加了一个条目，而 ThreadContext.clearAll() 则删除了所有现有条目。我们仍然想念 log4j2.xml 文件来配置日志记录。我们可以注意到，指定哪些 MDC 条目应该被记录的语法与 Log4j 中使用的语法相同。

<Configuration status="INFO">
 <Appenders>
 <Console name="stdout" target="SYSTEM_OUT">
 <PatternLayout
 pattern="%-4r [%t] %5p %c{1} - %m - tx.id=%X{transaction.id} tx.owner=%X{transaction.owner}%n" />
 </Console>
 </Appenders>
 <Loggers>
 <Logger name="com.baeldung.log4j2" level="TRACE" />
 <AsyncRoot level="DEBUG">
 <AppenderRef ref="stdout" />
 </AsyncRoot>
 </Loggers>
</Configuration>

再次，让我们执行应用程序，我们将看到 MDC 信息被打印在日志中。

1119 [pool-1-thread-3] INFO Log4J2BusinessService
- Has transfer of 1198$ completed successfully ? true. - tx.id=3 tx.owner=Samantha
1120 [pool-1-thread-3] INFO Log4J2BusinessService
- Preparing to transfer 1723$. - tx.id=5 tx.owner=Samantha
1170 [pool-1-thread-2] INFO Log4J2BusinessService
- Has transfer of 701$ completed successfully ? true. - tx.id=2 tx.owner=Susan
1171 [pool-1-thread-2] INFO Log4J2BusinessService
- Preparing to transfer 1108$. - tx.id=6 tx.owner=Susan
1794 [pool-1-thread-1] INFO Log4J2BusinessService
- Has transfer of 645$ completed successfully ? true. - tx.id=4 tx.owner=Susan

Slf4j/Logback

在 Slf4j 中，MDC 也是可用的，条件是底层日志库支持它。正如我们刚才看到的，Logback 和 Log4j 都支持 MDC，所以我们不需要什么特别的东西就可以在标准的设置下使用它。让我们准备一下通常的 TransferService 子类，这次使用 Java 的 Simple Logging Facade。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

final class Slf4TransferService extends TransferService {
 private static final Logger logger = LoggerFactory.getLogger(Slf4TransferService.class);

 @Override
 protected void beforeTransfer(long amount) {
 logger.info("Preparing to transfer {}$.", amount);
 }

 @Override
 protected void afterTransfer(long amount, boolean outcome) {
 logger.info("Has transfer of {}$ completed successfully ? {}.", amount, outcome);
 }
}

现在让我们使用 SLF4J 的 MDC 味道。在这种情况下，其语法和语义与 log4j 中的相同。

import org.slf4j.MDC;

public class Slf4jRunnable implements Runnable {
 private final Transaction tx;

 public Slf4jRunnable(Transaction tx) {
 this.tx = tx;
 }

 public void run() {
 MDC.put("transaction.id", tx.getTransactionId());
 MDC.put("transaction.owner", tx.getOwner());
 new Slf4TransferService().transfer(tx.getAmount());
 MDC.clear();
 }
}

我们必须提供 Logback 的配置文件：logback.xml。

<configuration>
 <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
 <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
 <pattern>%-4r [%t] %5p %c{1} - %m - tx.id=%X{transaction.id} tx.owner=%X{transaction.owner}%n</pattern>
 </encoder>
 </appender>
 <root level="TRACE">
 <appender-ref ref="stdout" />
 </root>
</configuration>

同样，我们将看到 MDC 中的信息被正确地添加到了日志信息中，尽管这些信息并没有在 log.info() 方法中明确提供。

1020 [pool-1-thread-3] INFO c.b.m.s.Slf4jBusinessService
- Has transfer of 1869$ completed successfully ? true. - tx.id=3 tx.owner=John
1021 [pool-1-thread-3] INFO c.b.m.s.Slf4jBusinessService
- Preparing to transfer 1303$. - tx.id=6 tx.owner=Samantha
1221 [pool-1-thread-1] INFO c.b.m.s.Slf4jBusinessService
- Has transfer of 1498$ completed successfully ? true. - tx.id=4 tx.owner=Marc
1221 [pool-1-thread-1] INFO c.b.m.s.Slf4jBusinessService
- Preparing to transfer 1528$. - tx.id=7 tx.owner=Samantha
1492 [pool-1-thread-2] INFO c.b.m.s.Slf4jBusinessService
- Has transfer of 1110$ completed successfully ? true. - tx.id=5 tx.owner=Samantha
1493 [pool-1-thread-2] INFO c.b.m.s.Slf4jBusinessService
- Preparing to transfer 644$. - tx.id=8 tx.owner=John

MDC and Thread Pools

MDC implementations are usually using *ThreadLocal*s to store the contextual information. That’s an easy and reasonable way to achieve thread-safety. However, we should be careful using MDC with thread pools.

Let’s see how the combination of ThreadLocal-based MDCs and thread pools can be dangerous:

We get a thread from the thread pool.
Then we store some contextual information in MDC using MDC.put() or ThreadContext.put().
We use this information in some logs and somehow we forgot to clear the MDC context.
The borrowed thread comes back to the thread pool.
After a while, the application gets the same thread from the pool.
Since we didn’t clean up the MDC last time, this thread still owns some data from the previous execution.

This may cause some unexpected inconsistencies between executions. One way to prevent this is to always remember to clean up the MDC context at the end of each execution. This approach usually needs rigorous human supervision and, therefore, is error-prone.

Another approach is to use *ThreadPoolExecutor* hooks and perform necessary cleanups after each execution. To do that, we can extend the ThreadPoolExecutor class and override the afterExecute() hook:

public class MdcAwareThreadPoolExecutor extends ThreadPoolExecutor {

 public MdcAwareThreadPoolExecutor(int corePoolSize,
 int maximumPoolSize,
 long keepAliveTime,
 TimeUnit unit,
 BlockingQueue<Runnable> workQueue,
 ThreadFactory threadFactory,
 RejectedExecutionHandler handler) {
 super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
 }

 @Override
 protected void afterExecute(Runnable r, Throwable t) {
 System.out.println("Cleaning the MDC context");
 MDC.clear();
 org.apache.log4j.MDC.clear();
 ThreadContext.clearAll();
 }
}

This way, the MDC cleanup would happen after each normal or exceptional execution automatically. So, there is no need to do it manually:

@Override
public void run() {
 MDC.put("transaction.id", tx.getTransactionId());
 MDC.put("transaction.owner", tx.getSender());

 new Slf4TransferService().transfer(tx.getAmount());
}

Now we can re-write the same demo with our new executor implementation:

ExecutorService executor = new MdcAwareThreadPoolExecutor(3, 3, 0, MINUTES,
 new LinkedBlockingQueue<>(), Thread::new, new AbortPolicy());

TransactionFactory transactionFactory = new TransactionFactory();

for (int i = 0; i < 10; i++) {
 Transfer tx = transactionFactory.newInstance();
 Runnable task = new Slf4jRunnable(tx);

 executor.submit(task);
}

executor.shutdown();

Slf4j

Mon, 01 Jan 0001 00:00:00 +0000

Slf4j

SLF4J，即简单日志门面（Simple Logging Facade for Java），不是具体的日志解决方案，它只服务于各种各样的日志系统。按照官方的说法，SLF4J 是一个用于日志系统的简单 Facade，允许最终用户在部署其应用时使用其所希望的日志系统。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloWorld {

 public static void main(String[] args) {
 Logger logger = LoggerFactory.getLogger(HelloWorld.class);
 logger.info("Hello World");
 }
}

Spring Boot 对 slf4j 支持的很好，内部已经集成了 slf4j，一般我们在使用的时候，会对 slf4j 做一下配置。application.yml 文件是 Spring Boot 中唯一一个需要配置的文件，一开始创建工程的时候是 application.properties 文件，个人比较细化用 yml 文件，因为 yml 文件的层次感特别好，看起来更直观，但是 yml 文件对格式要求比较高，比如英文冒号后面必须要有个空格，否则项目估计无法启动，而且也不报错。用 properties 还是 yml 视个人习惯而定，都可以。本课程使用 yml。

我们看一下 application.yml 文件中对日志的配置：

logging:
config: logback.xml
level:
com.test.course03.dao: trace

logging.config 是用来指定项目启动的时候，读取哪个配置文件，这里指定的是日志配置文件是根路径下的 logback.xml 文件，关于日志的相关配置信息，都放在 logback.xml 文件中了。logging.level 是用来指定具体的 mapper 中日志的输出级别，上面的配置表示 com.test.course03.dao 包下的所有 mapper 日志输出级别为 trace，会将操作数据库的 sql 打印出来，开发时设置成 trace 方便定位问题，在生产环境上，将这个日志级别再设置成 error 级别即可。

常用的日志级别按照从高到低依次为：ERROR、WARN、INFO、DEBUG。

日志处理 | Next-gen Tech Edu

Log4j2

Log4j2

配置文件

Logger 配置

Logback

基于 Logback 的 Java 日志处理

基础配置

Appender

ConsoleAppender

RollingFileAppender

Filter

Logger

Links

MDC

MDC

使用案例

Log4j

Log4j2

Slf4j/Logback

MDC and Thread Pools

Slf4j

Slf4j