面试官突然的关心-日志篇 SLF4J

当面试官问到，你们用的什么日志框架，log4j 和logback吗？和slf4j什么区别？吓尿了，日志系统也关心，学起来！

前言

日志重要吗？程序猿排查问题，数据统计分析、故障定位都依赖日志，甚至有的公司直接用日志的输出，经过统计做业务系统的输入。所以日志实在太重要了，大家几乎每天都在用日志，那都知道用的是什么日志框架，以及实现的原理吗？

开胃菜

说Log4j 和 Logback 之前，不得不提SLF4J。

简单说，SLF4J相当于定义了接口，Log4j 和 Logback是具体实现。

SLF4J就是典型的门面模式，什么是门面模式，简单说系统访问入口SLF4J只提供一个门面，具体实现对调用方不可见，SLF4J门面模式画了个简图，如下：

阿里Java开发手册关于日志的第一条

【强制】应用中不可直接使用日志系统（Log4j、Logback）中的API，而应依赖使用日志框架 SLF4J中的API，使用门面模式的日志框架，有利于维护和各个类的日志处理方式统一。

前菜-泡菜豆腐汤（工程实践）

要打印日志，就会引入上面提到的日志框架，就拿我们平时工程中常用的maven来讲，会同时引入Log4j、sfl4j-jdk / Logback等作为日志记录系统，那SLF4J门面是怎么绑定具体的日志系统的呢？下面重点都做了加粗。

第一步
我们先写一个简单例子：新建一个maven工程，在pom中只加入SLF4J的依赖包，

<!--只引入slf4j-->
<dependencies>
     <dependency>
     <groupId>org.slf4j</groupId>
     <artifactId>slf4j-api</artifactId>
     <version>1.7.24</version>
     </dependency>
</dependencies>

写段打印日志的测试代码, 如下：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Slf4jTest {
     static final Logger logger = LoggerFactory.getLogger(Slf4jTest.class);
     public static void main(String[] args) {
         logger.info("验证slf4j");
     }
}

运行结果如下：

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.

因为我们现在只引入了门面SLF4J, 没有具体实现, 所有会报找不到StaticLoggerBinder的异常日志。

这个是运行期的报错，编译没问题，因为这个门面的具体实现是运行期绑定的。

第二步
我们在pom文件中添加logback的依赖，如下所示

    <dependencies>
        <!--引入slf4j门面-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.24</version>
        </dependency>
        <!--logback-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.1.11</version>
        </dependency>
    </dependencies>

运行结果如下：

我们说过SLF4J 是运行期决定绑定哪个具体实现的。

现在我们来做个实现，添加多个SLF4J的日志实现，看实现：

    <dependencies>
    <!--引入slf4j门面-->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.24</version>
        </dependency>
    <!--log4j-->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
        </dependency>
    <!--logback-->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.1.11</version>
        </dependency>
    <!--slf4j-simple-->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-simple</artifactId>
        <version>1.7.25</version>
        </dependency>
    <!--slf4j-log4j12-->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.21</version>
        </dependency>
    </dependencies>

运行结果：

SLF4J会提示Classpath 包含多个SLF4J的实现，已经最终从这些中选择的是logback实现。

那问题来了：LoggerFactory如何绑定具体的日志系统的呢？

正餐-韩式烤肉(源码分析)

先说结论

所有实现SLF4J标准的日志系统都需要提供StaticLoggerBinder类，如下图所示：

我们在Class 文件头写下面这段代码时，SLF4J是如何绑定具体日志系统的呢？

private Logger logger = LoggerFactory.getLogger(***.class);

看下LoggerFactory 的代码, 我们可以用IDEA 提供的快捷键Ctrl（Mac是Command）+ Shift +鼠标点击getLogger方法，进实现看。

    public static Logger getLogger(Class<?> clazz) {
        Logger logger = getLogger(clazz.getName());
        //其他代码
        return logger;
    }

    public static Logger getLogger(String name) {
        //获取系统LoggerFactory
        ILoggerFactory iLoggerFactory = getILoggerFactory();
        return iLoggerFactory.getLogger(name);
    }

LoggerFactory的getILoggerFactory实现如下图：

这段逻辑就是判断日志系统是否初始化，如果还没初始化，先进行初始化，performInitialization() 只会执行一次。

初始化过程中，INITIALIZATION_STATE是 初始化过程中状态。下面是定义的状态和变量

    static final int UNINITIALIZED = 0;
    static final int ONGOING_INITIALIZATION = 1;
    static final int FAILED_INITIALIZATION = 2;
    static final int SUCCESSFUL_INITIALIZATION = 3;
    static final int NOP_FALLBACK_INITIALIZATION = 4;
    //日志系统初始化状态
    static volatile int INITIALIZATION_STATE = UNINITIALIZED;

可以看到INITIALIZATION_STATE是volatile 修饰的，保证多线程初始化日志框架的时候状态的可见性，不会出现多次初始化。

我们再看下 performInitialization() 函数，重点就在bind函数, 这里实际上就是绑定具体的日志框架，如下：

    private final static void performInitialization() {
        bind();//就在这个函数实现具体日志系统绑定
        if (INITIALIZATION_STATE == SUCCESSFUL_INITIALIZATION) {
            versionSanityCheck();
        }
    }

    private final static void bind() {
        try {
            Set<URL> staticLoggerBinderPathSet = null;
            // skip check under android, see also
            // http://jira.qos.ch/browse/SLF4J-328
            //第一步: 如果是Android 则跳过, 否则查找类路径下所有的StaticLoggerBinder实现类
            if (!isAndroid()) {
                //划重点，看后面这个函数
                staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
                reportMultipleBindingAmbiguity(staticLoggerBinderPathSet);
            }
            // the next line does the binding
            //第二步: 可能会有多个StaticLoggerBinder实现类，随机绑定其中一个
            StaticLoggerBinder.getSingleton();
            INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION;
            //打印实际绑定的
            reportActualBinding(staticLoggerBinderPathSet);

            fixSubstituteLoggers();
            replayEvents();
            // release all resources in SUBST_FACTORY
            SUBST_FACTORY.clear();
        } catch (NoClassDefFoundError ncde) {
            // ...
        } catch (java.lang.NoSuchMethodError nsme) {
            // ...
        } catch (Exception e) {
            // ...
        }
    }

重点函数 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;
            // 路径：STATIC_LOGGER_BINDER_PATH = org/slf4j/impl/StaticLoggerBinder.class
            //就是查找classpath下所有 StaticLoggerBinder，限制一定是org.slf4j.impl这个包路径
            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;
    }

如果系统中有多个SLF4J实现时，ClassLoader.getResources() 方法会从ClassPath查找到多个StaticLoggerBinder的实现类，通过类加载器加载所有StaticLoggerBinder类（指定包路径，这个也是个知识点，包路径+类名唯一标识一个类, 类加载机制之后文章会讲），

org/slf4j/impl/StaticLoggerBinder.class

如下图所示：

我们看下是不是每个日志框架都有自己的 org/slf4j/impl/StaticLoggerBinder.class

甜点-延伸

如果我们自己要实现一套日志框架，只需要在我们工程中创建一个StaticLoggerBinder类，当然包名一定要是 org/slf4j/impl/。

原文链接：https://blog.youkuaiyun.com/zhengwangzw/article/details/116036625