前言
在日志Logger漫谈中提到了slf4j仅仅是作为日志门面，给用户提供统一的API使用，而真正的日志系统的实现是由logback或者log4j这样的日志系统实现，那究竟slf4j是怎样集成logback或者log4j的呢？
集成logback
前文中提到，如果要使用slf4j+logback，需要引入slf4j-api及logback-classic、logback-core三个jar包。
- 我们一般这样使用
Logger logger = LoggerFactory.getLogger("logger1");
logger.info("This is a test msg from: {}", "LNAmp");
- LoggerFactory.getLogger的源代码如下：
public static Logger getLogger(String name) {
ILoggerFactory iLoggerFactory = getILoggerFactory();
return iLoggerFactory.getLogger(name);
}
需要注意的是，Logger、LoggerFactory、ILoggerFactory都是slf4j-api.jar中的类或接口。
从源码看来，获取Logger有两个过程，现获取对应的ILoggerFactory，再通过ILoggerFactory获取Logger
public static ILoggerFactory getILoggerFactory() {
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://bugzilla.slf4j.org/show_bug.cgi?id=106
return TEMP_FACTORY;
}
throw new IllegalStateException("Unreachable code");
}
private final static void performInitialization() {
bind();
if (INITIALIZATION_STATE == SUCCESSFUL_INITIALIZATION) {
versionSanityCheck();
}
}
private final static void bind() {
try {
Set staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
reportMultipleBindingAmbiguity(staticLoggerBinderPathSet);
// the next line does the binding
StaticLoggerBinder.getSingleton();
INITIALIZATION_STATE = SUCCESSFUL_INITIALIZATION;
reportActualBinding(staticLoggerBinderPathSet);
emitSubstituteLoggerWarning();
} 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);
}
}
获取ILoggerFactory的过程基本可以分为
- performInitialization() ： 完成StaticLoggerBinder的初始化
- getLoggerFactory() ：通过StaticLoggerBinder.getSingleton().getLoggerFactory()获取对应的ILoggerFactory
在整个获取Logger的过程，StaticLoggerBinder是个非常重要的类，其对象以单例的形式存在。在performInitialization过程中，slf4j会首先查找"org/slf4j/impl/StaticLoggerBinder.class"资源文件，目的是为了在存在多个org/slf4j/impl/StaticLoggerBinder.class时给开发者report警告信息，接着slf4j会使用StaticLoggerBinder.getSingleton()完成StaticLoggerBinder单例对象的初始化。
slf4j之所以能使用StaticLoggerBinder.getSingleton()是因为logback-classic和slf4j-log4j都按照slf4j的规定实现了各自的org/slf4j/impl/StaticLoggerBinder.class。那么如果系统中同时存在logback-classic和slf4j-log4j的话，slf4j选择哪一个呢，答案是随机挑选（这是由类加载器决定的，同包同名字节码文件的加载先后顺序不一定）。
StaticLoggerBinder初始化
logback的StaticLoggerBinder的初始化如下
void init() {
try {
try {
new ContextInitializer(defaultLoggerContext).autoConfig();
} catch (JoranException je) {
Util.report("Failed to auto configure default logger context", je);
}
StatusPrinter.printInCaseOfErrorsOrWarnings(defaultLoggerContext);
contextSelectorBinder.init(defaultLoggerContext, KEY);
initialized = true;
} catch (Throwable t) {
// we should never get here
Util.report("Failed to instantiate [" + LoggerContext.class.getName()
+ "]", t);
}
}
其中ContextInitializer会完成配置文件例如logback.xml的文件解析和加载，特别要注意的是defaultLoggerContext是LoggerContext的实例，LoggerContext是logback对于ILoggerFactory的实现。
获取Logger
public final Logger getLogger(final String name) {
if (name == null) {
throw new IllegalArgumentException("name argument cannot be null");
}
// if we are asking for the root logger, then let us return it without
// wasting time
if (Logger.ROOT_LOGGER_NAME.equalsIgnoreCase(name)) {
return root;
}
int i = 0;
Logger logger = root;
Logger childLogger = (Logger) loggerCache.get(name);
if (childLogger != null) {
return childLogger;
}
String childName;
while (true) {
int h = Logger.getSeparatorIndexOf(name, i);
if (h == -1) {
childName = name;
} else {
childName = name.substring(0, h);
}
i = h + 1;
synchronized (logger) {
childLogger = logger.getChildByName(childName);
if (childLogger == null) {
childLogger = logger.createChildByName(childName);
loggerCache.put(childName, childLogger);
incSize();
}
}
logger = childLogger;
if (h == -1) {
return childLogger;
}
}
在logback中，ILoggerFactory的实现是LoggerContext，调用LoggerContext.getLogger获取的Logger实例类型为ch.qos.logback.classic.Logger，是org.slf4j.Logger的实现类。获取Logger的过程可以分为
- 是否是root，如果是，返回root
- 从loggerCache缓存中获取，loggerCache中包含了配置文件中解析出来的logger信息和之前create过的logger
- 将logger name以"."分割，获取或者创建的logger，例如com.mujin.lnamp，会创建名为com、com.mujin、com.mujin.lnamp的logger，并将其放入loggerCache然后返回com.mujin.lnamp。logger是root logger的child即logger.parent=ROOT
至此获取Logger完成，logback的Logger实现类为ch.qos.logback.classic.Logger
集成log4j
slf4j集成log4j需要引入slf4j-api、slf4j-log4j12、log4j三个Jar包，slf4j-log4j12用来起桥接作用。
获取Logger的过程和logback的过程一样，唯一不同的是StaticLoggerBinder的实现方式不一样，StaticLoggerBinder的构造方法如下
private StaticLoggerBinder() {
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");
}
}
只是新建了Log4jLoggerFactory的实例，Log4jLoggerFactory是ILoggerFactory的实现类。
log4j版的StaticLoggerBinder获取logger过程如下
public Logger getLogger(String name) {
Logger slf4jLogger = loggerMap.get(name);
if (slf4jLogger != null) {
return slf4jLogger;
} else {
org.apache.log4j.Logger log4jLogger;
if(name.equalsIgnoreCase(Logger.ROOT_LOGGER_NAME))
log4jLogger = LogManager.getRootLogger();
else
log4jLogger = LogManager.getLogger(name);
Logger newInstance = new Log4jLoggerAdapter(log4jLogger);
Logger oldInstance = loggerMap.putIfAbsent(name, newInstance);
return oldInstance == null ? newInstance : oldInstance;
}
}
思路很清晰
- 从loggerMap中尝试取出
- 如果logger name名为root，返回root
- 使用LogManager.getLogger返回Log4j的Logger实现，其类型为 org.apache.log4j.Logger log4jLogger
- 使用Log4jLoggerAdapter包装 org.apache.log4j.Logger log4jLogger，使其适配org.slf4j.Logger接口
- 将Log4jLoggerAdapter尝试放入loggerMap缓存
那这样就有个疑问了，log4j的配置文件如何加载的呢？答案在LogManager的静态块中
static {
Hierarchy h = new Hierarchy(new RootLogger(Level.DEBUG));
repositorySelector = new DefaultRepositorySelector(h);
String override = OptionConverter.getSystemProperty("log4j.defaultInitOverride", (String)null);
if(override == null || "false".equalsIgnoreCase(override)) {
String configurationOptionStr = OptionConverter.getSystemProperty("log4j.configuration", (String)null);
String configuratorClassName = OptionConverter.getSystemProperty("log4j.configuratorClass", (String)null);
URL url = null;
if(configurationOptionStr == null) {
url = Loader.getResource("log4j.xml");
if(url == null) {
url = Loader.getResource("log4j.properties");
}
} else {
try {
url = new URL(configurationOptionStr);
} catch (MalformedURLException var5) {
url = Loader.getResource(configurationOptionStr);
}
}
if(url != null) {
LogLog.debug("Using URL [" + url + "] for automatic log4j configuration.");
OptionConverter.selectAndConfigure(url, configuratorClassName, getLoggerRepository());
} else {
LogLog.debug("Could not find resource: [" + configurationOptionStr + "].");
}
}
以上会去加载log4j.properties或log4j.xml等配置文件，然后进行初始化
总结
slf4j通过StaticLoggerBinder链接log4j/logback，log4j/logback都提供了对应的StaticLoggerBinder实现，而对于org.slf4j.Logger接口，log4j提供的默认实现是Log4jLoggerAdapter，logback提供的实现是ch.qos.logback.classic.Logger。通过以上分析，我们可以回答两个问题了
- 如何判断系统中使用了slf4j日志门面？
- 可以通过Class.forName("org.slf4j.impl.StaticLoggerBinder")，如果没有抛出ClassNotFoundException说明使用了slf4j
- 如何判断系统使用了slf4j+log4j还是slf4j+logback
- 可以通过LogFactory.getLogger的返回类型判断，log4j实现是Log4jLoggerAdapter，logback实现是ch.qos.logback.classic.Logger
基于以上手段，我们可以做出一套适配log4j或者logback的日志记录工具类了，后续将有相关博文给出