java日志原理

作者: slowwalkerlcr | 来源:发表于2019-07-15 23:02 被阅读0次

Java日志框架JUL
java日志原理
阿里Java开发手册思考（四）
java学习笔记-日志篇
FileBeat原理与实践指南
Java好文收集
2018-01-14 Java应用日志
Java 日志框架
Java基础 - 日志
Log

前言

映像中接触或使用到的java日志系统特别多，只是停留在配置即开箱使用的阶段，心里其实一直在疑惑，这么多日志框架到底它们之间有什么区别？总共又有多少中日志框架？那么对日志框架又是怎么知道确定使用哪一种的？所以下定决定要揭秘java日志框架

日志框架：是一种日志接口，不负责具体的日志输出形式（有点类似于JDBC），可以灵活的切换日志输出形式。常见的日志框架有slf4j、jcl，只提供Logger、LoggerFactory等接口

1、jcl 之前叫Jakarta Commons Logging，简称JCL，是Apache提供的一个通用日志API，可以让应用程序不再依赖于具体的日志实现工具。Apache commons-logging是JCL的标准实现。
commons-logging包中对其它一些日志工具，包括Log4J、Avalon LogKit、JUL等，进行了简单的包装，可以让应用程序在运行时，直接将JCL API打点的日志适配到对应的日志实现工具中。
2、SLF4J 全称 Simple Logging Facade for Java(简单日志门面)。与JCL类似，本身不替供日志具体实现，只对外提供接口或门面。因此它不是具体的日志解决方案，而是通过Facade Pattern门面模式对外提供一些Java Logging API。这些对外提供的核心API其实就是一些接口以及一个LoggerFactory的工厂类。

日志系统：是应用实际使用的日志工具，主要有log4j,jul(java.util.logging),logback等。一般在程序中应该避免直接使用，可以保证程序具有一定的灵活性。

image.png

Logger：日志输出实例，包含Appender和Layout
Appender：日志输出目标，如控制台，文件，数据库等。多个Appender可以被关联到任何Logger上，所以可以到多个输出文件上记录相同的信息。
Layout：定义日志输出格式：时间戳、线程名称、日志级别、日志内容、对应输出该日志的类、对应输出该日志的方法、行号及MDC信息

常用的日志组件.png

slf4j 作用及其实现原理

我们必须清楚地知道一点：slf4j只是一个日志标准，并不是日志系统的具体实现。理解这句话非常重要，slf4j只做两件事情：

提供日志接口
提供获取具体日志对象的方法
slf4j-simple、logback都是slf4j的具体实现，log4j并不直接实现slf4j，但是有专门的一层桥接slf4j-log4j12来实现slf4j。

为了更理解slf4j，我们先看例子，再读源码，相信读者朋友会对slf4j有更深刻的认识。

slf4j应用举例

pom.xml引入jar包

  <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>
     <dependency>
     <groupId>org.slf4j</groupId>
     <artifactId>slf4j-simple</artifactId>
     <version>1.7.25</version>
   </dependency>
   <dependency>
     <groupId>log4j</groupId>
     <artifactId>log4j</artifactId>
     <version>1.2.17</version>
   </dependency>
   <dependency>
     <groupId>org.slf4j</groupId>
     <artifactId>slf4j-log4j12</artifactId>
     <version>1.7.21</version>
   </dependency>

简单的java使用代码

 @Test
    public void testLog()
    {
        Logger logger = LoggerFactory.getLogger(AppTest.class);
        logger.info("log。。。");
    }

3.接着我们首先把上面pom.xml的日志框架实现的jar引用注释掉，只留下slf4j-api包，即不引入任何slf4j的实现类，运行testLog方法，我们看一下控制台的输出为：

没有任何日志实现类.png

看到没有任何日志的输出，这验证了我们的观点：slf4j不提供日志的具体实现，只有slf4j是无法打印日志的。

接着打开logback-classic的注释，运行testLog方法，我们看一下控制台的输出为

打开logback-classic的注释.png

看到我们只要引入了一个slf4j的具体实现类，即可使用该日志框架输出日志。

最后做一个测验，我们把所有日志打开，引入logback-classic、slf4j-simple、log4j，运行Test方法，控制台输出为：

image.png

和上面的差别是，可以输出日志，但是会输出一些告警日志，提示我们同时引入了多个slf4j的实现，然后选择其中的一个作为我们使用的日志系统。

从例子我们可以得出一个重要的结论，即slf4j的作用：只要所有代码都使用门面对象slf4j，我们就不需要关心其具体实现，最终所有地方使用一种具体实现即可，更换、维护都非常方便。

slf4j实现原理

上面看了slf4j的示例，下面研究一下slf4j的实现，我们只关注重点代码。

slf4j的用法就是常年不变的一句Logger logger = LoggerFactory.getLogger(AppTest.class);"，可见这里就是通过LoggerFactory去拿slf4j提供的一个Logger接口的具体实现而已，LoggerFactory的getLogger的方法实现为：

public static Logger getLogger(Class<?> clazz) {
        Logger logger = getLogger(clazz.getName());
        if (DETECT_LOGGER_NAME_MISMATCH) {
            Class<?> autoComputedCallingClass = Util.getCallingClass();
            if (autoComputedCallingClass != null && nonMatchingClasses(clazz, autoComputedCallingClass)) {
                Util.report(String.format("Detected logger name mismatch. Given name: \"%s\"; computed name: \"%s\".", logger.getName(),
                                autoComputedCallingClass.getName()));
                Util.report("See " + LOGGER_NAME_MISMATCH_URL + " for an explanation");
            }
        }
        return logger;
    }

从第2行开始跟代码，一直跟到LoggerFactory的bind()方法：
org.slf4j.LoggerFactory#getILoggerFactory ==> org.slf4j.LoggerFactory#performInitialization ==> org.slf4j.LoggerFactory#bind

  private final static void bind() {
        try {
            Set<URL> staticLoggerBinderPathSet = null;
            // skip check under android, see also
            // http://jira.qos.ch/browse/SLF4J-328
            if (!isAndroid()) {
                staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
                reportMultipleBindingAmbiguity(staticLoggerBinderPathSet);
            }
            // the next line does the binding
            StaticLoggerBinder.getSingleton();
            INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION;
            reportActualBinding(staticLoggerBinderPathSet);
            fixSubstituteLoggers();
            replayEvents();
            // release all resources in SUBST_FACTORY
            SUBST_FACTORY.clear();
        } catch (NoClassDefFoundError ncde) {
            String msg = ncde.getMessage();
            if (messageContainsOrgSlf4jImplStaticLoggerBinder(msg)) {
                INITIALIZATION_STATE = NOP_FALLBACK_INITIALIZATION;
                Util.report("Failed to load class \"org.slf4j.impl.StaticLoggerBinder\".");
                Util.report("Defaulting to no-operation (NOP) logger implementation");
                Util.report("See " + NO_STATICLOGGERBINDER_URL + " for further details.");
            } else {
                failedBinding(ncde);
                throw ncde;
            }
        } catch (java.lang.NoSuchMethodError nsme) {
            String msg = nsme.getMessage();
            if (msg != null && msg.contains("org.slf4j.impl.StaticLoggerBinder.getSingleton()")) {
                INITIALIZATION_STATE = FAILED_INITIALIZATION;
                Util.report("slf4j-api 1.6.x (or later) is incompatible with this binding.");
                Util.report("Your binding is version 1.5.5 or earlier.");
                Util.report("Upgrade your binding to version 1.6.x.");
            }
            throw nsme;
        } catch (Exception e) {
            failedBinding(e);
            throw new IllegalStateException("Unexpected initialization failure", e);
        }
    }

现在代码还在org.slf4j.LoggerFactory`类里`,重点关注org.slf4j.LoggerFactory#findPossibleStaticLoggerBinderPathSet``

static Set<URL> findPossibleStaticLoggerBinderPathSet() {
        // use Set instead of list in order to deal with bug #138
        // LinkedHashSet appropriate here because it preserves insertion order
        // during iteration
        Set<URL> staticLoggerBinderPathSet = new LinkedHashSet<URL>();
        try {
            ClassLoader loggerFactoryClassLoader = LoggerFactory.class.getClassLoader();
            Enumeration<URL> paths;
            if (loggerFactoryClassLoader == null) {
                paths = ClassLoader.getSystemResources(STATIC_LOGGER_BINDER_PATH);
            } else {
                paths = loggerFactoryClassLoader.getResources(STATIC_LOGGER_BINDER_PATH);
            }
            while (paths.hasMoreElements()) {
                URL path = paths.nextElement();
                staticLoggerBinderPathSet.add(path);
            }
        } catch (IOException ioe) {
            Util.report("Error getting resources from path", ioe);
        }
        return staticLoggerBinderPathSet;
    }

这个地方重点其实就是12行paths = loggerFactoryClassLoader.getResources(STATIC_LOGGER_BINDER_PATH);的代码，getLogger的时候会去classpath下找STATIC_LOGGER_BINDER_PATH，STATIC_LOGGER_BINDER_PATH值为"org/slf4j/impl/StaticLoggerBinder.class"，即所有slf4j的实现，在提供的jar包路径下，一定是有"org/slf4j/impl/StaticLoggerBinder.class"存在的，我们可以看一下：

logback-classic.png

slf4j-log4j.png

slf4j-simple.png
我们不能避免在系统中同时引入多个slf4j的实现，所以接收的地方是一个Set。大家应该注意到，上部分在演示同时引入logback、slf4j-simple、log4j的时候会有警告：

image.png
这就是因为有三个"org/slf4j/impl/StaticLoggerBinder.class"存在的原因，此时reportMultipleBindingAmbiguity方法控制台输出语句：

  private static void reportMultipleBindingAmbiguity(Set<URL> binderPathSet) {
        if (isAmbiguousStaticLoggerBinderPathSet(binderPathSet)) {
            Util.report("Class path contains multiple SLF4J bindings.");
            for (URL path : binderPathSet) {
                Util.report("Found binding in [" + path + "]");
            }
            Util.report("See " + MULTIPLE_BINDINGS_URL + " for an explanation.");
        }
    }

那网友朋友可能会问，同时存在三个"org/slf4j/impl/StaticLoggerBinder.class"怎么办？首先确定的是这不会导致启动报错，其次在这种情况下编译期间，编译器会选择其中一个StaticLoggerBinder.class进行绑定（StaticLoggerBinder.getSingleton();选择了对应的StaticLoggerBinder）,这个地方sfl4j也在reportActualBinding方法中报告了绑定的是哪个日志框架：

 private static void reportActualBinding(Set<URL> binderPathSet) {
        // binderPathSet can be null under Android
        if (binderPathSet != null && isAmbiguousStaticLoggerBinderPathSet(binderPathSet)) {
            Util.report("Actual binding is of type [" + StaticLoggerBinder.getSingleton().getLoggerFactoryClassStr() + "]");
        }
    }

对照上面的截图，看最后一行，确实是"Actual binding is of type..."这句。

最后StaticLoggerBinder就比较简单了，不同的StaticLoggerBinder其getLoggerFactory实现不同，拿到ILoggerFactory之后调用一下getLogger即拿到了具体的Logger，可以使用Logger进行日志输出。

参考链接

Java日志框架JUL
1 日志实现原理 Java 的日志框架有很多，比如：JUL（Java Util Logging）、Log4j、Lo...
java日志原理
前言映像中接触或使用到的java日志系统特别多，只是停留在配置即开箱使用的阶段，心里其实一直在疑惑，这么多日志框...
阿里Java开发手册思考（四）
上期我们分享了Java中日志的处理（上）：Java中日志的相关知识、Slf4j的原理及源码分析本期我们将分享Jav...
java学习笔记-日志篇
java学习笔记-日志篇-目录 java日志篇（1）-日志概述 java日志篇（2）-JUL(java.util....
FileBeat原理与实践指南
一、FileBeat原理日志采集器有很多，比如Logstash,功能虽然强大，但是它依赖java、在数据量大的时...
Java好文收集
Java日志 Java日志终极指南关于日志记录的一些感想 Spring测试 testing-improvement...
2018-01-14 Java应用日志
java日志体系 java日志体系很混乱。在日志实现框架在有log4j，log4j2，java.util.log，...
Java 日志框架
title: Java 日志框架date: 2021/02/05 12:28 一、Java 日志框架简介 1.1 ...
Java基础 - 日志
什么是java日志？将应用程序的日志输出到指定地址 java日志的核心 Logger ：Logger负责捕捉事件...
Log
混乱的 Java 日志体系正确的打日志姿势