SLF4J日志绑定原理分析

前言

最近做项目,实际上也知道日志冲突的事,不过涉及MDC NDC数据传递,当日志框架冲突后,MDC和NDC就失效了,这里就涉及slf4j-api的MDC的绑定的过程,顺便分析了日志冲突实际生效的原因,理解SLF4J的设计思想。官方网址:SLF4J

Simple Logging Facade for Java(SLF 4J)作为一个简单的facade或抽象,用于各种日志框架(例如logback、log4j2),从而允许最终用户在部署时插入所需的日志记录框架。 简称门面模式,就是接口外加绑定实现。

SLF4J日志绑定原理分析_第1张图片

 实际上slf4j-api原生支持的日志框架主要有2种logback和log4j2,其他JDK日志log4j1、commons-logging等都是桥接到slf4j-api的。

SLF4J日志绑定原理分析_第2张图片

 桥接都是slf4j自己实现的,对应上面的架构图,MIT协议,所以商业用途可以修改源代码。

slf4j-api 1.x

直接code吧,源码说明问题,先使用slf4j-api 1.7.36版本为例

public class Main {

    private static final Logger LOGGER = LoggerFactory.getLogger(Main.class);

    public static void main(String[] args) {
        System.out.println("hello log");
        LOGGER.info("first slf4j-api logger!");
    }
}

很简单的代码,执行后

SLF4J日志绑定原理分析_第3张图片 

 出现红字,那么就来分析红字的来源,从getLogger开始,因为info这些方法,实际上是接口方法,关键还是创建的slf4j-api的Logger的实现

  // Support for detecting mismatched logger names.
    static final String DETECT_LOGGER_NAME_MISMATCH_PROPERTY = "slf4j.detectLoggerNameMismatch";
    static final String JAVA_VENDOR_PROPERTY = "java.vendor.url";

    //通过系统变量读取slf4j.detectLoggerNameMismatch
    static boolean DETECT_LOGGER_NAME_MISMATCH = Util.safeGetBooleanSystemProperty(DETECT_LOGGER_NAME_MISMATCH_PROPERTY);
    
    static final String CODES_PREFIX = "http://www.slf4j.org/codes.html";
    static final String LOGGER_NAME_MISMATCH_URL = CODES_PREFIX + "#loggerNameMismatch";

    public static Logger getLogger(Class clazz) {
        Logger logger = getLogger(clazz.getName()); //关键代码,获取Logger对象,class默认是类全面,也可以自定义字符串,那就是另外的API
        if (DETECT_LOGGER_NAME_MISMATCH) {
            //通过调用关系取class,securityManager.getClassContext();
            //定义slf4j.detectLoggerNameMismatch为true才会生效,默认布尔为false
            Class autoComputedCallingClass = Util.getCallingClass();
            if (autoComputedCallingClass != null && nonMatchingClasses(clazz, autoComputedCallingClass)) {
                //这里report就是system.err就是控制台红字
                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;
    }

然后继续看getLogger

    public static Logger getLogger(String name) {
        ILoggerFactory iLoggerFactory = getILoggerFactory();
        return iLoggerFactory.getLogger(name);
    }

没什么讲的,过度代码,获取factory接口实现,然后获取logger实现,ILoggerFactory实际上也是需要logback或者log4j2自己需要实现的,实现的来源于StaticLoggerBinder

    public static ILoggerFactory getILoggerFactory() {
        //状态机制
        if (INITIALIZATION_STATE == UNINITIALIZED) {
            //未初始化,同步初始化
            synchronized (LoggerFactory.class) {
                if (INITIALIZATION_STATE == UNINITIALIZED) {
                    INITIALIZATION_STATE = ONGOING_INITIALIZATION; //更新状态
                    performInitialization(); //关键逻辑,初始化factory实现
                }
            }
        }
        switch (INITIALIZATION_STATE) {
        case SUCCESSFUL_INITIALIZATION: //成功
            //注意这个StaticLoggerBinder在slf4j-api是没有定义的,绑定器单例获取factory,这里很可能NoClassDefFound抛异常
            return StaticLoggerBinder.getSingleton().getLoggerFactory(); 
        case NOP_FALLBACK_INITIALIZATION:
            return NOP_FALLBACK_FACTORY; //失败,但有默认factory
        case FAILED_INITIALIZATION:
            throw new IllegalStateException(UNSUCCESSFUL_INIT_MSG); //失败
        case ONGOING_INITIALIZATION:
            // support re-entrant behavior.
            // See also http://jira.qos.ch/browse/SLF4J-97
            return SUBST_FACTORY; //重入行为,再次创建factory
        }
        throw new IllegalStateException("Unreachable code");
    }

源码可以看到这个类飘红了,jar包里面是没有这个类的,但是类不存在编译不过,猜测是slf4j-api有依赖类,打包剔除的,等源码分析后看github看看

SLF4J日志绑定原理分析_第4张图片

关键还是performInitialization

    private final static void performInitialization() {
        bind();
        if (INITIALIZATION_STATE == SUCCESSFUL_INITIALIZATION) {
            versionSanityCheck();//成功初始化检查版本号
        }
    }

看看检查版本号,推测slf4j-api的1.6和1.7是兼容的,但是不兼容slf4j-api 2.x

SLF4J日志绑定原理分析_第5张图片 

关键还是bind方法

    private final static void bind() {
        try {
            Set staticLoggerBinderPathSet = null;
            // skip check under android, see also
            // http://jira.qos.ch/browse/SLF4J-328
            if (!isAndroid()) {//判断系统变量java.vendor.url是否包含android字符串
                //查找可能的StaticLoggerBinder
                staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet(); 
                //如果找到多个就打印在控制台
                reportMultipleBindingAmbiguity(staticLoggerBinderPathSet);
            }
            // the next line does the binding
            // 见上面,StaticLoggerBinder没有实现发现就会报错NoClassDefFound
            StaticLoggerBinder.getSingleton();
            INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION; //状态更新
            reportActualBinding(staticLoggerBinderPathSet); //打印实际绑定的binder
        } catch (NoClassDefFoundError ncde) { //就是处理刚刚说的异常
            String msg = ncde.getMessage();// 下面的信息就是demo在控制台打印的NOP
            if (messageContainsOrgSlf4jImplStaticLoggerBinder(msg)) {
                // no-operation (NOP) logger implementation
                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(); 
            //很明显就是1.6和1.7不兼容1.5的情况,方法变了
            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);
        } finally {
            postBindCleanUp();//替代日志factory,报告事件,实际上就是控制台打印
        }
    }

查找逻辑也很简单,关键在于类定义和查找,实际上Spring也经常有这种逻辑处理,类只有类名,只定义标准

SLF4J日志绑定原理分析_第6张图片 

如果有多个就打印出来

    private static boolean isAmbiguousStaticLoggerBinderPathSet(Set binderPathSet) {
        return binderPathSet.size() > 1;
    }

    /**
     * Prints a warning message on the console if multiple bindings were found
     * on the class path. No reporting is done otherwise.
     * 
     */
    private static void reportMultipleBindingAmbiguity(Set 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.");
        }
    }

实际使用那个Binder

 

MDC同理

SLF4J日志绑定原理分析_第7张图片 

 同时石锤slf4j-api开发过程中有实现Binder

SLF4J日志绑定原理分析_第8张图片

打包去掉类,或许我们也可以这样,在特定时刻,方便框架开发,业务实现一般不会这样用。

SLF4J日志绑定原理分析_第9张图片

 

slf4j-api 2.x

为什么会单独介绍2.x版本,架构变了,笔者在查看github,发现slf4j-api的master即2.x的最新代码,真的使用SPI了,同时意味着刚刚的Binder实现类在源码移除了

截止现在slf4j-api最新版是2.0.7,查看源码

   public static ILoggerFactory getILoggerFactory() {
        return getProvider().getLoggerFactory();
    }

    static SLF4JServiceProvider getProvider() {
        if (INITIALIZATION_STATE == 0) {
            Class var0 = LoggerFactory.class;
            synchronized(LoggerFactory.class) {
                if (INITIALIZATION_STATE == 0) {
                    INITIALIZATION_STATE = 1;
                    performInitialization();
                }
            }
        }

        switch (INITIALIZATION_STATE) {
            case 1:
                return SUBST_PROVIDER;
            case 2:
                throw new IllegalStateException("org.slf4j.LoggerFactory in failed state. Original exception was thrown EARLIER. See also https://www.slf4j.org/codes.html#unsuccessfulInit");
            case 3:
                return PROVIDER;
            case 4:
                return NOP_FALLBACK_SERVICE_PROVIDER;
            default:
                throw new IllegalStateException("Unreachable code");
        }
    }

实际上根1.x是一样的,方法名称变了,具体是否使用SPI,还要看performInitialization

    private final static void bind() {
        try {
            // 找到SLF4JServiceProvider
            List providersList = findServiceProviders();
            reportMultipleBindingAmbiguity(providersList); // 多个打印
            if (providersList != null && !providersList.isEmpty()) { 
                // 多个实现,使用SPI的第一个
                PROVIDER = providersList.get(0);
                // SLF4JServiceProvider.initialize() is intended to be called here and nowhere else.
                PROVIDER.initialize(); //初始化,因为判空的缘故,所以正常情况不会出现类未定义的异常
                INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION;
                reportActualBinding(providersList); //实际绑定
            } else {
                // 没有的时候,就是1.x控制台不引入任何日志jar的内容,提示有变化
                INITIALIZATION_STATE = NOP_FALLBACK_INITIALIZATION;
                Util.report("No SLF4J providers were found.");
                Util.report("Defaulting to no-operation (NOP) logger implementation");
                Util.report("See " + NO_PROVIDERS_URL + " for further details.");

                //老式查找,因为SPI了,所以忽略加载了
                Set staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
                reportIgnoredStaticLoggerBinders(staticLoggerBinderPathSet);
            }
            postBindCleanUp();//替代factory,reportEvent
        } catch (Exception e) {
            failedBinding(e);
            throw new IllegalStateException("Unexpected initialization failure", e);
        }
    }

Java SPI加载逻辑,加载后取第一个生效

SLF4J日志绑定原理分析_第10张图片 

MDC同理,实际上看1.x的源码,还有一个Marker的接口也是同样的道理

SLF4J日志绑定原理分析_第11张图片 

没有任何日志jar的打印

 SLF4J日志绑定原理分析_第12张图片

NOP模式 

 logback实现

因为logback和log4j2实现都差不多,所以以logback为例,因为Springboot内置

以slf4j-api 2.0.7和logback 1.4.8为例

先看logback classic的SPI配置

SLF4J日志绑定原理分析_第13张图片

 文件内容就是实现类

ch.qos.logback.classic.spi.LogbackServiceProvider

先看initialize方法,在slf4j-api的bind方法中会被调用

    public void initialize() {
        defaultLoggerContext = new LoggerContext();
        defaultLoggerContext.setName(CoreConstants.DEFAULT_CONTEXT_NAME);
        initializeLoggerContext();
        defaultLoggerContext.start();
        markerFactory = new BasicMarkerFactory();
        mdcAdapter = new LogbackMDCAdapter();
        // set the MDCAdapter for the defaultLoggerContext immediately
        defaultLoggerContext.setMDCAdapter(mdcAdapter);
    }

初始化日志套件,关键是LoggerContext,有Marker和MDC的工厂或者适配器的创建,这2个也是日志的SPI机制附加的

public static ILoggerFactory getILoggerFactory() {
    return getProvider().getLoggerFactory();
}

logback的工厂就是initialize的defaultLoggerContext

SLF4J日志绑定原理分析_第14张图片

然后创建logger,这个实际上就是层级创建,因为这个设计,所以logger天然适合MDC传输数据,比如线程id

SLF4J日志绑定原理分析_第15张图片 

log4j2实际上也差不多,据测试log4j2的性能比logback强一些,笔者没测试过,实际应用也不会特别考虑这个原因,因为Boot集成了,而且logback性能也不差。另外logback和log4j2实际上不同配置也会造成性能差异,比如是否阻塞和是否丢日志的抉择等,可以查询官方,适配详细参数。

 

日志冲突分析

日志冲突跟slf4j-api加载多个实现或者桥接器有关,表现为加载多个Binder或者SPI实现,但是实际加载的不是我们想要的,如果加载log4j1这样的,很可能slf4j-api的System.err都不会打印,只能删掉除了slf4j-api的其他所有日志jar,一个一个排查,如果fatjar压入了日志jar的源码,那么只能class扫描才行。

日志冲突跟slf4j-api加载的过程有关:

  1. 1.6、1.7的版本是类实际加载的时间有关,那么这个就跟Maven依赖顺序,打Spring Boot包是否排序有关
  2. 2.x的版本跟Java SPI的配置文件加载时间有关,也是跟jar的加载顺序有关

最长见的是外置Tomcat,非embed tomcat,tomcat7会对lib目录排序,tomcat8的lib目录就是解压后的操作系统决定顺序,导致不同机器运行后日志冲突不一致,解决办法也简单,外置tomcat也支持不解压运行,可以看tomcat源码,或者使用Spring boot这样内嵌tomcat,打包就把顺序固定。

笔者故意冲突

SLF4J日志绑定原理分析_第16张图片

实际就会打印

SLF4J日志绑定原理分析_第17张图片 

如果我调换依赖顺序

SLF4J日志绑定原理分析_第18张图片 

因为我没有log4j的实现,所以日志是打印不出来的。 

总结

实际上这些原理一般不需要了解也可以正常打印日志,现在开发都考虑到各种问题了,所以有了Spring Boot这种一体jar,包打好了就固定了,不过出问题需要会查问题即可。另外吐槽golang的日志框架,真的五花八门,一般用的Uber-go的zap包,但是K8S docker又是另外的,实际上有接口注入还好,可以自定义,如果没提供接口注入就彻底不能动了,只能在框架重新实现,就是没有slf4j-api的缘故,门面模式实际上在框架和中间件等开发还是有很关键的作用

你可能感兴趣的:(架构设计,Java,java,slf4j)