http://www.cnblogs.com/bird-li/p/4696662.html

*************************************************

日志对于一个系统来说非常重要,查找异常信息、分析系统运行情况等都需要用到日志。所以无论是JDK还是第三方都提供了关于日志的相关工具,本文分别介绍以下几种工具,以及各种工具间的整合、原理。

  • JDK的java.util.logging包
  • 第三方日志工具(commons-logging/slf4j,log4j/logback)

JDK的java.util.logging包

JDK1.4引入了java.util.logging包,包中主要的类包括:Logger、LogManager、Handler、Formatter。首先看一段比较简单的示例代码:

package me.likeyao.jdk.logger;

import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger; public class JDKLoggerTest {
public static void main(String[] args) {
Logger logger = Logger.getLogger("logger");
logger.info("hello world"); Handler handler = new Handler() {
@Override
public void publish(LogRecord record) {
}
@Override
public void flush() {
}
@Override
public void close() throws SecurityException {
}
}; handler.setFormatter(new Formatter() {
@Override
public String format(LogRecord record) {
return null;
}
}); logger.setLevel(Level.INFO);
logger.log(Level.FINEST, "hello world");
}
}

通过Logger.getLogger(name)方法可以获取logger对象,logger对象有三个比较重要的概念:level、handler、formatter。level称为日志级别,在java.util.logging包中定义了java.util.logging.Level类,里面包含SEVERE/WARNING/INFO/CONFIG/FINE/FINER/FINEST(从高到低)7种日志级别。设置日志级别会过滤掉一部分日志,例如当日志级别设置为INFO级别时,CONFIG/FINE/FINER/FINEST级别的日志就会被忽略。handler解决的问题是日志输出到哪里,是到控制台(java.util.logging.ConsoleHandler),还是到文件(java.util.logging.FileHandler),或者是写到Socket中(java.util.logging.SocketHandler)。formatter定义了日志输出的格式,可以是XML(java.util.logging.XMLFormatter),也可以自己实现JSON格式的Fomatter。

logger对象是如何生成的

生成logger对象涉及到java.util.logging.LogManager类,LogManager中用到了单例模式,在static块中初始化了LoggerManager实例对象。生成logger对象的过程:

从图中可以看到,logger对象是在LoggerManager中创建的。LoggerManager中有一个叫userContext的LoggerContext对象,userContext缓存了所有的logger对象(缓存在namedLoggers中),并维护了一套logger对象的父子结构。namedLoggers的定义:

private final Hashtable<String,LoggerWeakRef> namedLoggers = new Hashtable<>();

LoggerWeakRef继承自java.lang.ref.WeakReference,namedLoggers并不直接持有logger对象,当持有logger的对象被垃圾回收之后,只有一个weekreference指向logger,方便垃圾回收logger对象。

JDK logger其他一些有意思的东西

  • 有一个Logger.getLogger方法是两参数的,public static Logger getLogger(String name, String resourceBundleName),第二个参数最终会变成java.util.ResourceBundle对象,可以用来做国际化。
  • java.util.logging.Handler可以设置java.util.logging.Filter更灵活的过滤日志。

第三方日志工具(commons-logging/slf4j,log4j/logback)

首先把四个工具分成了两组,commons-logging/slf4j和log4j/logback。log4j/logback功能与java.util.logging包类似,提供实际的日志功能。commons-logging/slf4j是门面,作用是统一日志操作,屏蔽底层不同日志组件的差异。

commons-logging

commons-logging是apache的项目,使用commons-logging的代码:

package me.likeyao.java.logger;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; public class JCLTest {
private static Log logger = LogFactory.getLog(JCLTest.class);
public static void main(String[] args) throws Exception {
logger.info("hello world");
}
}

代码中用到了commons-logging日志对象(org.apache.commons.logging.Log),日志对象工厂(org.apache.commons.logging.LogFactory)。前面有说过commons-logging是一个统一操作的门面,不涉及具体的日志功能,那日志对象是怎么产生的?查看Log对象的继承关系:

commons-logging分别为支持的日志工具提供了一个Log类的实现类,在列表中看到了Log4JLogger和Jdk14Logger等,意味着commons-logging可以log4j、java.util.logging组合使用。因为没有对应的logback实现,所以也就无法一起使用。下图解释commons-logging如何决定具体生成哪种Logger对象:

LogFactory在static块中初始化了HashTable对象factories,以ClassLoader为key,LogFactory为value缓存了所有LogFactory对象。主要看一下LogFactoryImpl的discoverLogImplementation方法是如何发现底层使用的日志工具(省略了方法一部分内容):

private static final String[] classesToDiscover = {
LOGGING_IMPL_LOG4J_LOGGER, //org.apache.commons.logging.impl.Log4JLogger
"org.apache.commons.logging.impl.Jdk14Logger",
"org.apache.commons.logging.impl.Jdk13LumberjackLogger",
"org.apache.commons.logging.impl.SimpleLog"
}; private Log discoverLogImplementation(String logCategory)
...
Log result = null;
//查看commons-logging.properties和System.getProperty是否配置了org.apache.commons.logging.log
String specifiedLogClassName = findUserSpecifiedLogClassName();
if (specifiedLogClassName != null) {
...
//如果有配置,直接使用配置的类创建Log
result = createLogFromClass(specifiedLogClassName,
logCategory,
true);
...
return result;
}
...
//如果没有,遍历classesToDiscover数组,如果使用指定的ClassLoader Class.forName能加载到类,就创建Log对象
for(int i=0; i<classesToDiscover.length && result == null; ++i) {
result = createLogFromClass(classesToDiscover[i], logCategory, true);
}
if (result == null) {
throw new LogConfigurationException
("No suitable Log implementation");
}
return result;
}

整个初始化Log对象的流程:

commons-logging中的classloader

网上搜commons-logging,可以看到不少文章都是在讲关于classloader的问题,贴出比较详细的一篇的链接:《Taxonomy of class loader problems encountered when using Jakarta Commons Logging》。文章中用的commons-logging本版较老,这里用commons-logging-1.2+log4k-1.2.17模拟一种场景,看看新commons-logging有什么改变。代码:

package me.likeyao.java.logger;

import java.io.File;
import java.net.URL;
import java.net.URLClassLoader; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; public class JCLTest3 { public static void main(String[] args) throws Exception {
//自定义classloader,模仿web容器classloader,自己加载优先
ChildClassLoader childClassLoader = new ChildClassLoader(
new URL[] { new File("c:/tmpclass/commons-logging-1.2.jar").toURL(),
new File("C:/respository3/log4j/log4j/1.2.17/log4j-1.2.17.jar").toURL()});
Thread.currentThread().setContextClassLoader(childClassLoader);
Log log = LogFactory.getLog(JCLTest3.class);
log.error("hello world");
} } class ChildClassLoader extends URLClassLoader { public ChildClassLoader(URL[] urls) {
super(urls, ClassLoader.getSystemClassLoader());
} @Override
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
Class c = findLoadedClass(name);
try{
c = findClass(name);
if (resolve) {
resolveClass(c);
}
}catch(Exception e){ }
if (c == null) {
c = super.loadClass(name, resolve);
}
return c;
}
}
}

命令行执行:java -cp .;commons-logging-1.2.jar me.likeyao.java.logger.JCLTest3。输出结果:执行没有抛异常,日志是通过JDK java.util.logging打出来了,而不是log4j。

可以从代码中分析出为什么会产生这样的结果。这里用到了两种类加载器:系统类加载器(AppClassLoader)和自定义的ChildClassLoader,系统类加载器能加载到当前编译目录的class文件和commons-logging.jar,ChildClassLoader加载了commons-logging.jar和log4j.jar,线程上下文加载器被设置为ChildClassLoader。当运行java命令时,随着程序运行会使用系统类加载器加载Log类、LogFactory类,查看上面discoverLogImplementation方法源码,由于没有配置org.apache.commons.logging.log属性,具体使用哪个Log的实现类会通过遍历classesToDiscover数组决定。下面看一下classesToDiscover[0]时的情况:

private Log createLogFromClass(String logAdapterClassName, //org.apache.commons.logging.impl.Log4JLogger
String logCategory,
boolean affectState)
throws LogConfigurationException {
...
//通过logAdapterClassName所制定的类创建的对象,方法返回的结果
Log logAdapter = null;
...
//获取classloader,这里会返回ChildClassLoader,即main方法中设置的线程上下文加载器
ClassLoader currentCL = getBaseClassLoader();
for(;;) {
try {
...
Class c;
try {
//因为ChildClassLoader加载器可以获取到org.apache.commons.logging.impl.Log4JLogger类,正常得到c
c = Class.forName(logAdapterClassName, true, currentCL);
} catch (ClassNotFoundException originalClassNotFoundException) {
...
}
//创建org.apache.commons.logging.impl.Log4JLogger对象,这里o的classloader是ChildClassLoader
constructor = c.getConstructor(logConstructorSignature);
Object o = constructor.newInstance(params); // 注意下面的注释,因为Log和o的类加载器不一致,所以不进入if分支
// Note that we do this test after trying to create an instance
// [rather than testing Log.class.isAssignableFrom(c)] so that
// we don't complain about Log hierarchy problems when the
// adapter couldn't be instantiated anyway.
if (o instanceof Log) {
logAdapterClass = c;
logAdapter = (Log) o;
break;
} // Oops, we have a potential problem here. An adapter class
// has been found and its underlying lib is present too, but
// there are multiple Log interface classes available making it
// impossible to cast to the type the caller wanted. We
// certainly can't use this logger, but we need to know whether
// to keep on discovering or terminate now.
//
// The handleFlawedHierarchy method will throw
// LogConfigurationException if it regards this problem as
// fatal, and just return if not.
// 根据allowFlawedHierarchy参数判断是否抛出LogConfigurationException,如果不抛异常,只是简单return,进入下一个循环
handleFlawedHierarchy(currentCL, c);
} catch (NoClassDefFoundError e) {
...
break;
} catch (ExceptionInInitializerError e) {
...
break;
} catch (LogConfigurationException e) {
// call to handleFlawedHierarchy above must have thrown
// a LogConfigurationException, so just throw it on
throw e;
} catch (Throwable t) {
...
} if (currentCL == null) {
break;
} // try the parent classloader
// currentCL = currentCL.getParent();
currentCL = getParentClassLoader(currentCL);
}
...
return logAdapter;
}

classesToDiscover[0]的调用中,logAdapter并没有指向org.apache.commons.logging.impl.Log4JLogger对象,而是返回了null。所以进入下一次循环classesToDiscover[1](org.apache.commons.logging.impl.Jdk14Logger),这一次因为Log类和org.apache.commons.logging.impl.Jdk14Logger类都是由系统类加载器加载,所以最终执行的结果日志由java.util.logging打出。commons-logging使用classloader来加载Resource和发现底层具体日志工具,在web容器或者OSGI这些需要用类加载器做隔离的情况下的确会出现一些问题。

SLF4J/LOG4J

另一种日志门面SLF4J,它采用“静态绑定”的方式避免了commons-logging中有关类加载的一些问题。下面的把SLF4J和LOG4J放到一起,首先还是比较简单的使用代码:

package me.likeyao.slf4j.logger;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory; public class SLF4JTest {
public static void main(String[] args) {
Logger logger = LoggerFactory.getLogger(SLF4JTest.class);
logger.error("hello world");
}
}

使用方式上看与commons-logging类似,除了类名上有一些区别。下图的是SLF4J整合LOG4J时Logger初始化时序图:

这里对几个类用了不同的颜色,蓝色代表类在slf4j-api包中,黄色代表类在slf4j-log4j12包中,红色代表类在log4j包中。相比commons-logging运行时通过classloader来发现底层日志工具,SLF4J是通过在不同的“桥梁包”里放置同名类org.slf4j.impl.StaticLoggerBinder来实现日志工具的绑定。例如,如果需要将SLF4J与java.util.logging整合,需要加入slf4j-jdk14-1.7.12,包中的StaticLoggerBinder类返回的loggerfactory是org.slf4j.impl.JDK14LoggerFactory;如果是SLF4J与log4j整合,需要加入slf4j-log4j12-1.7.12,包中的StaticLoggerBinder类返回的loggerfactory是org.slf4j.impl.Log4jLoggerFactory。这就是SLF4J的静态绑定。

LOG4J是常用的日志工具,与java.util.logging(jul)非常像,一些概念也是共通的。例如logger都是父子结构的、jul的handler对应log4j的appender、formater对应layout、也都存在filter。为了理清log4j中各个类的关系,整理一份类图:

整个类图的核心是org.apache.log4j.Category,但从1.2版本后log4j不会直接产生Category对象,而是Logger对象。Logger类继承自Category,扩展了一个日志级别:trace。当调用Logger对象的info/warn等方法时会生成一个LoggerEvent对象,AppenderAttachableImpl会遍历所有的appender调用doAppend方法。如果event没有被Filter过滤掉,那最终会经过Layout格式化,输出到appender指定的地方。LOG4J提供了很多appender供使用,这一点比JDK的hander强大很多。

Appender的初始化在LogManager的static块中进行,最终解析发生在org.apache.log4j.xml.DOMConfigurator类中,logger、root、appender都在这里解析。

    if (tagName.equals(CATEGORY) || tagName.equals(LOGGER)) {
parseCategory(currentElement);
} else if (tagName.equals(ROOT_TAG)) {
parseRoot(currentElement);
} else if(tagName.equals(RENDERER_TAG)) {
parseRenderer(currentElement);
} else if(tagName.equals(THROWABLE_RENDERER_TAG)) {
if (repository instanceof ThrowableRendererSupport) {
ThrowableRenderer tr = parseThrowableRenderer(currentElement);
if (tr != null) {
((ThrowableRendererSupport) repository).setThrowableRenderer(tr);
}
}
} else if (!(tagName.equals(APPENDER_TAG)
|| tagName.equals(CATEGORY_FACTORY_TAG)
|| tagName.equals(LOGGER_FACTORY_TAG))) {
quietParseUnrecognizedElement(repository, currentElement, props);
}

LOGBACK

logback是log4j的一个替代品,初始化和打日志代码流程相似。为什么要从log4j切换到logback,logback网站上已经给出了(Reasons to prefer logback over log4j)。要使用SLF4J+logback需要引入三个包:slf4j-api、logback-core、logback-classic。这里和log4j对比,介绍一下两种日志工具的父子结构。无论是java.util.logging还是log4j/logback都为logger对象提供了父子结构,这样做有什么好处?我觉得主要是这样logger对象会有一个树形的层次结构,底层的logger可以复用父logger中的一些配置,比如日志级别,appender等。从log4j和logback的配置文件中,也可以看出这一点,通过为某个包名的logger指定appender和日志级别,可以作用所有这个包下的logger。例如:

<logger name="me.likeyao" additivity="false">
<level value="WARN" />
<appender-ref ref="CONSOLE" />
</logger>

log4j和logback在处理父子结构时有一些差别,先看log4j的代码:

synchronized(ht) {
Object o = ht.get(key);
if(o == null) {
logger = factory.makeNewLoggerInstance(name);
logger.setHierarchy(this);
ht.put(key, logger);
updateParents(logger);
return logger;
} else if(o instanceof Logger) {
return (Logger) o;
} else if (o instanceof ProvisionNode) {
//System.out.println("("+name+") ht.get(this) returned ProvisionNode");
logger = factory.makeNewLoggerInstance(name);
logger.setHierarchy(this);
ht.put(key, logger);
updateChildren((ProvisionNode) o, logger);
updateParents(logger);
return logger;
}
else {
// It should be impossible to arrive here
return null; // but let's keep the compiler happy.
}
}

log4j在创建logger时,如果父节点是一个logger,那只维护一个子logger对父logger的引用。如果父节点不存在,就创建一些ProvisionNode对象(这是一个Vector的子类),保存所有下面子的logger。举个例子:当获取名称为x.y.z的logger时,首先会创建logger(x.y.z);然后查找父logger x.y,如果x.y不存在,就创建一个ProvisionNode对象,把logger(x.y.z)放到ProvisionNode对象中;然后继续向上搜索名称为x的logger,就将logger(x.y.z)的parent设置为logger(x)。当调用logger(x.y.z)对象的info/warn等方法时,如果logger(x.y.z)没有设置日志级别和appender,就是沿着parent向上搜索,直到rootLogger为止。

logback的结构稍微有一些区别,所有的节点都是Logger对象,对象中有指向parent和children的引用,并且创建节点时,会把parent的日志级别直接复制到自己对象中。

    // if the desired logger does not exist, them create all the loggers
// in between as well (if they don't already exist)
String childName;
while (true) {
int h = LoggerNameUtil.getSeparatorIndexOf(name, i);
if (h == -1) {
childName = name;
} else {
childName = name.substring(0, h);
}
// move i left of the last point
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;
}
}

总结

SL4J/COMMONS-LOGGING、LOG4J、LOGBACK、JUL都是常用的Java日志工具,基本思想都是通过Factory生成logger对象,然后由LogManager管理/缓存logger对象,同时维护一个父子结构方便复用配置。logger对象包含三要素:日志级别、输出到哪里、格式化。

Java日志 (zhuan)的更多相关文章

  1. [翻译]Java日志终极指南

    本文由 ImportNew - Wing 翻译自 loggly.欢迎加入翻译小组.转载请见文末要求. Java日志基础 Java使用了一种自定义的.可扩展的方法来输出日志.虽然Java通过java.u ...

  2. Java日志框架:SLF4J,Common-Logging,Log4J,Logback说明

    Log4j  Apache的一个开放源代码项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台.文件.GUI组件.甚至是套接口服务 器.NT的事件记录器.UNIX Syslog守护进程等 ...

  3. Java日志规范

    前言 一个在生产环境里运行的程序如果没有日志是很让维护者提心吊胆的,有太多杂乱又无意义的日志也是令人伤神.程序出现问题时候,从日志里如果发现不了问题可能的原因是很令人受挫的.本文想讨论的是如何在Jav ...

  4. Java日志系统及框架分析

    最近在考虑将容器(Tomcat)内的应用日志统一成slf4j + logback,主要目的有: 快速定位应用日志输出路径,方便日志的采集: 能动态调整日志的级别,方便线上问题定位: 方便在容器层面做扩 ...

  5. Java日志系统框架的设计与实现

    推荐一篇好的文章介绍java日志系统框架的设计的文章:http://soft.chinabyte.com/database/438/11321938.shtml 文章内容总结: 日志系统对跟踪调试.程 ...

  6. Java学习笔记(十九)——Java 日志记录 AND log4j

    [前面的话] 学习的进度应该稍微在快一点. Java日志到了必须学习怎么使用的时候了,因为在项目中要进行使用.基础性文章,选择性阅读. [结构] java日志对调试,记录运行,问题定位都起到了很重要的 ...

  7. Java程序员最常用的8个Java日志框架

    转自:http://www.codeceo.com/article/8-java-log-framework.html 作为一名Java程序员,我们开发了很多Java应用程序,包括桌面应用.WEB应用 ...

  8. Java 日志管理最佳实践

    转:http://blog.jobbole.com/51155/ 日志记录是应用程序运行中必不可少的一部分.具有良好格式和完备信息的日志记录可以在程序出现问题时帮助开发人员迅速地定位错误的根源.对于开 ...

  9. Java日志管理方法(转载)

    原文地址:http://www.cnblogs.com/leocook/p/log_java.html java开发中常见的几种日志管理方案有以下4种: 1. Commons-logging + lo ...

随机推荐

  1. word2vec模型cbow与skip-gram的比较

    cbow和skip-gram都是在word2vec中用于将文本进行向量表示的实现方法,具体的算法实现细节可以去看word2vec的原理介绍文章.我们这里大体讲下两者的区别,尤其注意在使用当中的不同特点 ...

  2. 设计模式之适配器模式(Adapter Pattern)C++实现

    适配器模式(Adapter Pattern)是作为两个不兼容的接口之间的桥梁.这样的类型的设计模式属于结构型模式.它结合了两个独立接口的功能. 意图:将一个类的接口转换成客户希望的另外一个接口.适配器 ...

  3. 前端框架(二)DIV多选复选框框的封装和MySql数据库存取

    图能够包括的寓意和含义是文字不能比拟的,先有一个效果图你也就知道这篇文章的主要内容是关于什么问题的.省去了一大堆文字的累述.看以下这张图: watermark/2/text/aHR0cDovL2Jsb ...

  4. Unix 网络编程 读书笔记3

    第四章 基本tcp 套接口编程 注意区分AF_XXX 和PF_XXX,AF代表address family, PF代表protocol family. 1 socket 函数 2 connect 函数 ...

  5. js-知识集锦

      CreateTime--2016年9月22日14:37:51Author:Marydonjs小知识点集锦1. JSON.stringify(Obj);//将Object对象转换成json格式的st ...

  6. 〖Linux〗build ssh for Arm

    1. 交叉编译环境: export ARCH=arm export SUBARCH=arm export PATH=/opt/FriendlyARM/toolschain//bin:$PATH exp ...

  7. 关联更新SQL语句

    update F_A_Info  set level=b.level from  F_A_Info a,F_A_Info_QUAN b where a.id=b.id

  8. 九度OJ 1183 守形数 (模拟)

    题目1183:守形数 时间限制:1 秒 内存限制:32 兆 特殊判题:否 提交:2663 解决:1424 题目描写叙述: 守形数是这样一种整数.它的平方的低位部分等于它本身. 比方25的平方是625. ...

  9. 更改 pandas dataframe 中两列的位置

    更改 pandas dataframe 中两列的位置: 把其中的某列移到第一列的位置. 原来的 df 是: df = pd.read_csv('I:/Papers/consumer/codeandpa ...

  10. Java虚拟机学习 - 查看JVM参数及值的命令行工具(6)

    查看JVM各个参数值方式 1. HotSpot vm中的各个globals.hpp文件  查看jvm初始的默认值及参数 globals.hpp globals_extension.hpp c1_glo ...