Java - 日志体系_Apache Commons Logging（JCL）日志接口库_桥接Logback 及 源码分析

Pre

Java - 日志体系_Apache Commons Logging（JCL）日志接口库

Java - 日志体系_Apache Commons Logging（JCL）日志接口库_适配Log4j2 及 源码分析

Java - 日志体系_Apache Commons Logging（JCL）日志接口库_桥接Logback 及 源码分析

Java - 日志体系_Simple Logging Facade for Java (SLF4J)日志门面_SLF4J实现原理分析

Java - 日志体系_Simple Logging Facade for Java (SLF4J)日志门面_SLF4J集成JUL 及 原理分析

Java - 日志体系_Simple Logging Facade for Java (SLF4J)日志门面_SLF4J集成Log4j1.x 及 原理分析

Java - 日志体系_Simple Logging Facade for Java (SLF4J)日志门面_SLF4J集成Log4j2.x 及 原理分析

Java - 日志体系_Simple Logging Facade for Java (SLF4J)日志门面_SLF4J集成logback 及 原理分析

Apache Commons

官网：Apache Commons

Apache Commons Proper

Commons Proper 致力于一个主要目标： 创建和维护可重用的 Java 组件。这 Commons Proper 是一个协作和共享的地方，其中 来自整个 Apache 社区的开发人员都可以 一起讨论由 Apache 项目共享的项目，以及 Apache 用户。

共享资源开发人员将努力确保他们的 组件对其他库的依赖性最小，因此 这些组件可以轻松部署。此外，共享资源 组件将尽可能保持其接口稳定，因此 Apache 用户（包括其他 Apache 项目）可以实现 这些组件。

Logging （Apache Commons Logging ）

https://commons.apache.org/proper/commons-logging/

JCL 集成logback

POM依赖

• jcl-over-slf4j (替代了 commons-logging)
• slf4j-api
• logback-core
• logback-classic

通过 jcl-over-slf4j 替换 commons-logging，从而让 commons-logging 使用 SLF4J 作为底层日志实现。

  <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>jcl-over-slf4j</artifactId>
      <version>2.0.16</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>2.0.16</version>
    </dependency>

    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-core</artifactId>
      <version>1.5.15</version>
    </dependency>
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>1.5.15</version>
    </dependency>

• jcl-over-slf4j：这个依赖项将 commons-logging 的日志请求转发到 SLF4J 框架。
• slf4j-api：SLF4J 的接口库，负责提供日志记录的 API。
• logback-core 和 logback-classic：这是 Logback 的核心和实现，负责具体的日志输出。

配置文件 logback.xml

logback.xml 文件用于定义日志输出的格式和方式。

 <configuration>
    <!-- 控制台输出 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} |||  %msg%n</pattern>
        </encoder>
    </appender>

    <!-- 文件输出 -->
    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>application.log</file>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- 可选：配置日志文件滚动 -->
    <appender name="ROLLING_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>application.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 按天滚动日志文件 -->
            <fileNamePattern>application-%d{yyyy-MM-dd}.log</fileNamePattern>
            <!-- 最多保留 30 天的日志文件 -->
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <!-- 根日志记录器 -->
    <root level="debug">
        <appender-ref ref="STDOUT" />
        <appender-ref ref="ROLLING_FILE" />
    </root>

    <!-- 可选：配置特定包的日志级别 -->
    <logger name="com.artisan" level="info" />
</configuration>

使用

在代码中，通过 commons-logging 的 API 来记录日志，并且通过 SLF4J 和 Logback 完成实际的日志输出。

package com.artisan;


import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 *  commons-logging 与 logback 集成
 *
 */
public class JclBridgeLogbackExample {
    // commons logging 的 Log 和  LogFactory
    private static final Log logger= LogFactory.getLog(JclBridgeLogbackExample.class);


    public static void main( String[] args ) {
        logger.trace("JclBridgeLogbackExample This is a trace message");
        logger.debug("JclBridgeLogbackExample This is a debug message");
        logger.info("JclBridgeLogbackExample This is an info message");
        logger.warn("JclBridgeLogbackExample This is a warning message");
        logger.error("JclBridgeLogbackExample This is an error message");
        logger.fatal("JclBridgeLogbackExample This is a fatal message");
    }
}

源码分析

jcl-over-slf4j 的工作原理

jcl-over-slf4j 的作用是将 commons-logging 的日志接口（例如 Log 和 LogFactory）转换为 SLF4J 的实现。具体地，它将 commons-logging 的日志请求转发给 SLF4J，而 SLF4J 则可以根据配置选择底层的日志框架（如 logback）。

1. 步骤一：将 commons-logging 转向 SLF4J

   • jcl-over-slf4j 提供了一个 LogFactory 类，该类实现了 commons-logging 的 LogFactory 接口，负责创建 Log 实例。
   • 该类内部，LogFactory 被静态化为 SLF4JLogFactory，即它总是创建 SLF4JLogFactory 的实例，而不再使用 commons-logging 自带的实现。

2. 步骤二：使用 SLF4J 作为底层日志实现

   • SLF4JLogFactory 内部调用 LoggerFactory.getLogger(name) 来获取 SLF4J 的 Logger 实例。LoggerFactory 是 SLF4J 提供的工厂类，负责返回一个底层日志记录器实例。
   • 一旦获取到 SLF4J 的 Logger 实例，jcl-over-slf4j 将其封装成 commons-logging 定义的 Log 接口的实现，即 SLF4JLog 或 SLF4JLocationAwareLog。
   • SLF4JLog 或 SLF4JLocationAwareLog 通过委托的方式将实际的日志调用转发给 SLF4J 的 Logger，而 Logger 决定了最终使用哪个底层日志框架（如 logback）。

1. LogFactory 的实现

在 jcl-over-slf4j 中，LogFactory 被静态化为 SLF4JLogFactory：

public abstract class LogFactory {
    static LogFactory logFactory = new SLF4JLogFactory();
    // 其他代码...
}

• SLF4JLogFactory 是 LogFactory 的实现，它负责创建 Log 实例。
• LogFactory.getLog() 方法调用 SLF4JLogFactory 中的 newInstance() 方法来创建 Log 实例。

2. SLF4JLogFactory 和 Log 的实例化过程

SLF4JLogFactory 实现了 LogFactory 接口，并重写了 newInstance() 方法来创建 Log 对象：

public class SLF4JLogFactory extends LogFactory {
    public Log newInstance(String name) {
        Logger slf4jLogger = LoggerFactory.getLogger(name);
        Log newInstance;
        if (slf4jLogger instanceof LocationAwareLogger) {
            newInstance = new SLF4JLocationAwareLog((LocationAwareLogger) slf4jLogger);
        } else {
            newInstance = new SLF4JLog(slf4jLogger);
        }
        return newInstance;
    }
}

• LoggerFactory.getLogger(name) 创建了一个 SLF4J 的 Logger 实例（这背后通常是 logback）。
• 如果 Logger 实现了 LocationAwareLogger，则会使用 SLF4JLocationAwareLog，它提供了更加详细的日志信息（如日志位置等）。
• 否则，使用普通的 SLF4JLog 实现。

3. SLF4JLog 和 SLF4JLocationAwareLog

SLF4JLog 和 SLF4JLocationAwareLog 是 Log 接口的实现，它们负责将 commons-logging 的日志方法（如 debug(), info() 等）委托给 SLF4J 的 Logger。这两个类的源码大致如下：

public class SLF4JLog implements Log {
    private final Logger slf4jLogger;

    public SLF4JLog(Logger slf4jLogger) {
        this.slf4jLogger = slf4jLogger;
    }

    @Override
    public void trace(Object message) {
        slf4jLogger.trace(String.valueOf(message));
    }

    @Override
    public void debug(Object message) {
        slf4jLogger.debug(String.valueOf(message));
    }

    @Override
    public void info(Object message) {
        slf4jLogger.info(String.valueOf(message));
    }

    // 其他日志级别方法...
}

SLF4JLocationAwareLog 类似，只不过它会获取日志的调用位置（如类名、行号等）以提供更详细的日志信息。

4. 日志输出的流程

1. 通过 commons-logging API 写日志：

   • 使用 commons-logging 提供的 Log 接口进行日志编写（例如 LogFactory.getLog() 获取日志实例）。
   • 调用 trace(), debug(), info() 等方法。

2. 日志请求转发给 SLF4J：

   • jcl-over-slf4j 将这些日志请求转发到 SLF4J 的 Logger 实例。

3. 最终日志输出：

   • SLF4J 根据底层的配置选择具体的日志框架（如 logback），并将日志输出到目标（控制台、文件等）。

小结

• jcl-over-slf4j 使 commons-logging 可以使用 SLF4J 作为底层日志实现，进而可以通过 SLF4J 配置选择 logback 作为实际的日志框架。
• LogFactory 和 Log 被重定向到 SLF4JLogFactory 和 SLF4JLog，这些类将日志请求转发给 SLF4J，而 SLF4J 决定底层日志框架（如 logback）的使用。
• 这种方式允许我们继续使用 commons-logging API 进行日志记录，而底层的日志实现却是 logback，结合了两者的优势。