slf4j 如何启动logback,log4j源码分析

历史

• 知道java 日志框架的，应该知道log4j，logback，slf4j竟然是一个作者写的，我的天。为啥要写三个。。这个可以去看看相关的文章，今天讨论的门面slf4j是如何驱动logback和log4j的。
• 入口

    //一般日志的开启都是在这里开始的。
    private static final Logger logger = LoggerFactory.getLogger(EquipmentController.class);
 
    public static Logger getLogger(Class<?> clazz) {
    //从getLogger 方法中获取
        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 http://www.slf4j.org/codes.html#loggerNameMismatch for an explanation");
            }
        }
    
        return logger;
    }
 


//一直跟下去，会进行初始化LoggerFactory,这个loggerFactory是不一样的
// 这个地方是 重点了 因为在初始化LoggerFacotry 的时候是需要时间的，在初始化的期间，还有源源不断的log 在打印
//slf4j 是怎么做的呢
 public static ILoggerFactory getILoggerFactory() {
        //开始的状态是0  然后在将其锁住 只有一个能够进入初始化
        if (INITIALIZATION_STATE == 0) {
            Class var0 = LoggerFactory.class;
            synchronized(LoggerFactory.class) {
            //双重判断 进行预防
                if (INITIALIZATION_STATE == 0) {
                    INITIALIZATION_STATE = 1;
                    performInitialization();
                }
            }
        }
        switch(INITIALIZATION_STATE) {
        case 1:
            // 在初始化的时候 返回一个临时的factory 进行缓存
            return SUBST_FACTORY;
        case 2:
            throw new IllegalStateException("org.slf4j.LoggerFactory in failed state. Original exception was thrown EARLIER. See also http://www.slf4j.org/codes.html#unsuccessfulInit");
        case 3:
            return StaticLoggerBinder.getSingleton().getLoggerFactory();
        case 4:
            return NOP_FALLBACK_FACTORY;
        default:
            throw new IllegalStateException("Unreachable code");
        }
    }
 
 

• 初始化的时候 使用状态这个方式，然后只有一个进入初始化的过程，其他就进入到一个临时的缓存中，等初始化完成之后，再将其输出到正常Factory中。

//再往里面跟 就有一个方法
 private static final void bind() {
        String msg;
        try {
            Set<URL> staticLoggerBinderPathSet = null;
            if (!isAndroid()) {
                staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
                reportMultipleBindingAmbiguity(staticLoggerBinderPathSet);
            }
			//重点  初始化
            StaticLoggerBinder.getSingleton();
            INITIALIZATION_STATE = 3;
            reportActualBinding(staticLoggerBinderPathSet);
            // 将缓存里面的东西进行输出
            fixSubstituteLoggers();
            replayEvents();
            SUBST_FACTORY.clear();
        } catch (NoClassDefFoundError var2) {
            msg = var2.getMessage();
            if (!messageContainsOrgSlf4jImplStaticLoggerBinder(msg)) {
                failedBinding(var2);
                throw var2;
            }

            INITIALIZATION_STATE = 4;
            Util.report("Failed to load class \"org.slf4j.impl.StaticLoggerBinder\".");
            Util.report("Defaulting to no-operation (NOP) logger implementation");
            Util.report("See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.");
        } catch (NoSuchMethodError var3) {
            msg = var3.getMessage();
            if (msg != null && msg.contains("org.slf4j.impl.StaticLoggerBinder.getSingleton()")) {
                INITIALIZATION_STATE = 2;
                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 var3;
        } catch (Exception var4) {
            failedBinding(var4);
            throw new IllegalStateException("Unexpected initialization failure", var4);
        }

    }

• 重点出来了 StaticLoggerBinder.getSingleton(); 这个就是logback 和 log4j 共同实现的类，在通过再加载的方式，各自初始化，然后将缓存的东西输出清空