探究SLF4J日志框架的原理和使用

作者: sunpy | 来源:发表于2018-10-05 17:15 被阅读163次

介绍

最近发现项目中使用log4j和SLF4J，打算研究下SLF4J。SLF4J用作各种日志框架的简单外观或抽象，例如java.util.logging，logback和log4j。SLF4J允许最终用户在部署时插入所需的日志记录框架。
简单来说就是slf4j本身只是提供日志的外观，而slf4j并不提供具体的日志实现。
slf4j用户手册：
https://www.slf4j.org/manual.html

SLF4J不提供具体实现

导入jar包： slf4j-api-1.7.7.jar

public class Slf4jTest {
    public static void main(String[] args) {
        Logger logger = LoggerFactory.getLogger(Slf4jTest.class);
        logger.info("HelloWorld");
    }
}

1.png

SLF本身不提供日志具体实现，本身也是无法打印具体日志的，需要配合其他具体的日志框架实现。通过上面代码可以看出如果我们不指定具体的日志框架实现，那么SLF4J就无法调用具体日志框架。

完整例子

导包： slf4j-log4j12-1.6.2.jar 、slf4j-api-1.7.7.jar 、log4j-1.2.17.jar
log4j.properties

############# 日志输出到控制台 #############
# 通过根元素指定日志输出的级别、目的地
# 日志输出的优先级：  debug < info < warn < error
log4j.rootLogger=INFO,Console,File
# 日志输出到控制台使用的api类
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.Target=System.out
# 指定日志输出的格式：灵活的格式
log4j.appender.Console.layout = org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d %p %c.%M()-%m%n

############# 日志输出到文件 #############
log4j.appender.dailyRollingFile = org.apache.log4j.DailyRollingFileAppender
# 当前日志信息追加到文件的末尾
log4j.appender.File = org.apache.log4j.RollingFileAppender
# 文件参数，指定日志文件的路径(此处是输出到E:/log/myLog.log)
log4j.appender.File.File = E:/log/myLog.log
# 文件参数，指定日志文件的最大大小
log4j.appender.File.MaxFileSize = 10MB
log4j.appender.File.Threshold = ALL
log4j.appender.File.layout = org.apache.log4j.PatternLayout
log4j.appender.File.layout.ConversionPattern =[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c]%m%n

public class LoggerTest {
    
    public static void main(String[] args) throws Exception {
        Logger logger = LoggerFactory.getLogger(Object.class);
        logger.info("sunpy");
    }
}

1.png

SLF4J源码分析

public static Logger getLogger(Class<?> clazz) {
    // 获取对应的Logger日志器
    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;
}

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

getILoggerFactory方法

public static ILoggerFactory getILoggerFactory() {
    // INITIALIZATION_STATE初始化值为UNINITIALIZED
    if (INITIALIZATION_STATE == UNINITIALIZED) {
        // 将LoggerFactory上锁
        synchronized (LoggerFactory.class) {
            if (INITIALIZATION_STATE == UNINITIALIZED) {
                // 将初始化状态设置为进行中初始化状态
                INITIALIZATION_STATE = ONGOING_INITIALIZATION;
                // 执行初始化
                performInitialization();
            }
        }
    }
    switch (INITIALIZATION_STATE) {
    case SUCCESSFUL_INITIALIZATION:
        return StaticLoggerBinder.getSingleton().getLoggerFactory();
    case NOP_FALLBACK_INITIALIZATION:
        return NOP_FALLBACK_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;
    }
    throw new IllegalStateException("Unreachable code");
}

说明：判断当前初始化状态是否为未初始化状态，如果未初始化就将状态修改为当前正在初始化中，执行初始化方法performInitialization()。

// 执行初始化操作
private final static void performInitialization() {
    // 绑定
    bind();
    // 如果初始化状态等于成功初始化状态
    if (INITIALIZATION_STATE == SUCCESSFUL_INITIALIZATION) {
        // 执行版本安全检查
        versionSanityCheck();
    }
}

versionSanityCheck方法

// 版本号检查，如果不满足1.6.x或者1.7.x的版本，将打印版本不匹配的错误流信息
private final static void versionSanityCheck() {
    try {
        // public static String REQUESTED_API_VERSION = "1.6.99";
        // requested请求版本默认为1.6.99
        String requested = StaticLoggerBinder.REQUESTED_API_VERSION;

        boolean match = false;
        
        // static private final String[] API_COMPATIBILITY_LIST = new String[] { "1.6", "1.7" };
        // 遍历API_COMPATIBILITY_LIST
        for (String aAPI_COMPATIBILITY_LIST : API_COMPATIBILITY_LIST) {
            // 如果requested请求版本为1.6.x或者1.7.x，那么就将是否匹配的标识设置为true
            if (requested.startsWith(aAPI_COMPATIBILITY_LIST)) {
                match = true;
            }
        }
        
        // 如果标识不匹配，那么就打印SLF4J错误：版本不匹配请满足1.6.x或者1.7.x的版本
        if (!match) {
            Util.report("The requested version " + requested + " by your slf4j binding is not compatible with "
                            + Arrays.asList(API_COMPATIBILITY_LIST).toString());
            Util.report("See " + VERSION_MISMATCH + " for further details.");
        }
    } catch (java.lang.NoSuchFieldError nsfe) {
        // given our large user base and SLF4J's commitment to backward
        // compatibility, we cannot cry here. Only for implementations
        // which willingly declare a REQUESTED_API_VERSION field do we
        // emit compatibility warnings.
    } catch (Throwable e) {
        // we should never reach here
        Util.report("Unexpected problem occured during version sanity check", e);
    }
}

说明：主要就是版本号安全检查，如果版本号不满足1.6.x或者1.7.x版本，那么就打印版本不匹配错误流信息。

关键源码设计

bind方法：绑定日志工厂

// 绑定
private final static void bind() {
    try {
      // 查找多个可能出现的StaticLoggerBinder类。
      Set<URL> staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
      // 校验设置的多个StaticLoggerBinder类
      reportMultipleBindingAmbiguity(staticLoggerBinderPathSet);
      // 创建一个默认的Log4jLoggerFactory工厂
      StaticLoggerBinder.getSingleton();
      // 更新初始化状态为成功初始化状态
      INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION;
      // 报告实际上加入的多个StaticLoggerBinder的日志类型。
      reportActualBinding(staticLoggerBinderPathSet);
      // 使用SLF4j提供的SubstituteLoggerFactory工厂
      fixSubstitutedLoggers();
    } 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.indexOf("org.slf4j.impl.StaticLoggerBinder.getSingleton()") != -1) {
        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);
    }
  }

findPossibleStaticLoggerBinderPathSet方法：查找多个可能出现的StaticLoggerBinder类。

static Set<URL> findPossibleStaticLoggerBinderPathSet() {
    Set<URL> staticLoggerBinderPathSet = new LinkedHashSet<URL>();
    try {
        // 获取类加载器
        ClassLoader loggerFactoryClassLoader = LoggerFactory.class.getClassLoader();
        Enumeration<URL> paths;
        // 当前类加载器为启动类加载器
        if (loggerFactoryClassLoader == null) {
            // 查找路径"org/slf4j/impl/StaticLoggerBinder.class"上的资源URL
            paths = ClassLoader.getSystemResources(STATIC_LOGGER_BINDER_PATH);
        } else { // 当前类加载器为非启动类加载器
            // 查找路径"org/slf4j/impl/StaticLoggerBinder.class"上的资源URL
            paths = loggerFactoryClassLoader.getResources(STATIC_LOGGER_BINDER_PATH);
        }
        // 遍历枚举集合
        while (paths.hasMoreElements()) {
            // 获取对应的URL资源
            URL path = paths.nextElement();
            // 将URL放入集合LinkedHashSet中
            staticLoggerBinderPathSet.add(path);
        }
    } catch (IOException ioe) {
        Util.report("Error getting resources from path", ioe);
    }
    return staticLoggerBinderPathSet;
}

说明：使用ClassLoader类加载器获取类org.slf4j.impl.StaticLoggerBinder.class，将返回可能多个对应的URL类型的Set集合。

reportMultipleBindingAmbiguity方法：校验设置的多个StaticLoggerBinder类

private static void reportMultipleBindingAmbiguity(Set<URL> staticLoggerBinderPathSet) {
    // Set集合staticLoggerBinderPathSet中找到大于1个StaticLoggerBinder对应的URL类
    if (isAmbiguousStaticLoggerBinderPathSet(staticLoggerBinderPathSet)) {
      // 打印错误流信息：类路径中包含多个SLF4J框架绑定
      Util.report("Class path contains multiple SLF4J bindings.");
      Iterator<URL> iterator = staticLoggerBinderPathSet.iterator();
      // 遍历Set集合
      while (iterator.hasNext()) {
        // 获取遍历到的资源URL
        URL path = (URL) iterator.next();
        // 打印错误流信息：发现绑定路径有。。。
        Util.report("Found binding in [" + path + "]");
      }
      Util.report("See " + MULTIPLE_BINDINGS_URL + " for an explanation.");
    }
}

说明：校验Set集合中出现多个StaticLoggerBinder类对应的访问资源URL类时，打印错误信息流。

StaticLoggerBinder.getSingleton()：单例模式设计
针对上面的StaticLoggerBinder出现多个的情况，那么SLF4J中是不希望出现多个StaticLoggerBinder，使用单例设计模式来防止产生多个对象的问题。

public class StaticLoggerBinder implements LoggerFactoryBinder {

  // 创建唯一StaticLoggerBinder实例SINGLETON
  private static final StaticLoggerBinder SINGLETON = new StaticLoggerBinder();

  // 对外提供获取单个实例的静态方法
  public static final StaticLoggerBinder getSingleton() {
    return SINGLETON;
  }

  // 私有构造器，防止外部new创建StaticLoggerBinder实例
  private StaticLoggerBinder() {
    // 创建一个Log4jLoggerFactory工厂类
    loggerFactory = new Log4jLoggerFactory();
    try {
      Level level = Level.TRACE;
    } catch (NoSuchFieldError nsfe) {
      Util
          .report("This version of SLF4J requires log4j version 1.2.12 or later. See also http://www.slf4j.org/codes.html#log4j_version");
    }
  }
  
  。。。
}

说明：对于SLF4J日志门面对应多个日志实现类中的StaticLoggerBinder ，SLF4J采用单例设计模式来实现的，采用饿汉式实现的。 --> 我早期博客：
创建型模式之单例设计模式（java版）

reportActualBinding方法：报告实际上加入的多个StaticLoggerBinder的日志类型。

// 提示实际绑定的StaticLoggerBinder
private static void reportActualBinding(Set<URL> staticLoggerBinderPathSet) {
    // staticLoggerBinderPathSet集合中元素个数大于1
    if (isAmbiguousStaticLoggerBinderPathSet(staticLoggerBinderPathSet)) {
      // 打印错误信息流： 实际绑定日志类型为Log4j
      Util.report("Actual binding is of type ["+StaticLoggerBinder.getSingleton().getLoggerFactoryClassStr()+"]");
    }
}

SubstituteLoggerFactory工厂方法模式设计

public class SubstituteLoggerFactory implements ILoggerFactory {

  final ConcurrentMap<String, SubstituteLogger> loggers = new ConcurrentHashMap<String, SubstituteLogger>();

  public Logger getLogger(String name) {
    // 获取代理Logger
    SubstituteLogger logger = loggers.get(name);
    // 如果logger为null
    if (logger == null) {
      // 直接创建SubstituteLogger
      logger = new SubstituteLogger(name);
      // 如果集合loggers包含name键，那么直接获取对应的logger，返回对应的logger
      // 如果集合loggers不包含name键，那么设置到loggers中，返回oldLogger为null
      SubstituteLogger oldLogger = loggers.putIfAbsent(name, logger);
      // 如果返回oldLogger不为null
      if (oldLogger != null)
        logger = oldLogger;
    }
    return logger;
  }

  public List<String> getLoggerNames() {
    return new ArrayList<String>(loggers.keySet());
  }

  public List<SubstituteLogger> getLoggers() {
    return new ArrayList<SubstituteLogger>(loggers.values());
  }

  public void clear() {
    loggers.clear();
  }
}

说明：实际上SubstituteLoggerFactory工厂实现了日志抽象工厂ILoggerFactory，实现了getLogger方法来获取创建的SubstituteLogger。思考：如果我们想创建一个自定义的日志类XXXLogger，那么我们直接就可以创建一个XXXLoggerFactory工厂实现ILoggerFactory接口，加入我们需要的逻辑到实现的getLogger方法中。
getLogger方法：如果我们没有找到默认的Log4j，那么就使用SubstituteLogger来代替。

fixSubstitutedLoggers方法：使用SLF4J提供的日志SubstitutedLogger（代理Logger）实现

private final static void fixSubstitutedLoggers() {
    // 获取所有的SubstituteLogger
    List<SubstituteLogger> loggers = TEMP_FACTORY.getLoggers();
    // 如果ArrayList集合loggers为空，直接退出方法
    if(loggers.isEmpty()){
      return;
    }

    Util.report("The following set of substitute loggers may have been accessed");
    Util.report("during the initialization phase. Logging calls during this");
    Util.report("phase were not honored. However, subsequent logging calls to these");
    Util.report("loggers will work as normally expected.");
    Util.report("See also " + SUBSTITUTE_LOGGER_URL);
    // 遍历loggers集合
    for(SubstituteLogger subLogger : loggers){
      // 通过名称获取对应的logger，然后设置委托类
      subLogger.setDelegate(getLogger(subLogger.getName()));
      Util.report(subLogger.getName());
    }

    TEMP_FACTORY.clear();
  }

Log4jLoggerFactory工厂解析

前面大概说了下SLF4J中获取Logger的流程，但是其中的一些细节需要再深入思考下，譬如我们前面提到了loggerFactory首先是使用Log4j的工厂Log4jLoggerFactory来进行初始化的。下面主要讲下Log4j的工厂Log4jLoggerFactory。

总结

前面大概分析了下SLF4J中获取Logger的流程；
1. 如果SLF4J为未初始化将进行初始化，其初始化默认使用Log4j的工厂Log4jLoggerFactory。如果找不到将使用SLF4J的SubstituteLoggerFactory工厂。
2. SLF4J使用ClassLoader类加载器来加载指定路径资源。
3. 对于多个StaticLoggerBinder，其获取采用饿汉式-单例设计模式来设计的。
4. SubstituteLoggerFactory工厂类设计，采用工厂方法模式来设计的。

思考

我们前面提到了loggerFactory首先是使用Log4j的工厂Log4jLoggerFactory来进行初始化的。那么Log4j工厂是如何进行初始化使用的？下篇文章再说。。。Log4j的一些实现。

探究SLF4J日志框架的原理和使用

介绍

SLF4J不提供具体实现

完整例子

SLF4J源码分析

关键源码设计

Log4jLoggerFactory工厂解析

总结

思考

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读