log4j 基础知识

简单例子：
将log4j-VERSION.jar架包加入到classpath中。
我使用的是log4j-1.2.16.jar


package com.cgodo.log4j.test;

import org.apache.log4j.Logger;

/**
* log4j测试
*
* @author liyixing [e-mail]
* @version 1.0
* @since 2011-7-3 上午01:37:42
*/
public class Test {
private static final Logger LOGGER = Logger.getLogger("test");

/**
* @param args
*/
public static void main(String[] args) {
LOGGER.debug("hello");
}
}

这里的输出信息应该是
log4j:WARN No appenders could be found for logger (test).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.

这是在说，我们还没有配置logger。
这个时候我们添加一句初始化默认配置的方法。


package com.cgodo.log4j.test;

import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Logger;

/**
* log4j测试
*
* @author liyixing [e-mail]
* @version 1.0
* @since 2011-7-3 上午01:37:42
*/
public class Test {
private static final Logger LOGGER = Logger.getLogger("test");

/**
* @param args
*/
public static void main(String[] args) {
//使用默认配置。
BasicConfigurator.configure();
LOGGER.debug("hello");
}
}

得到的输出信息是

0 [main] DEBUG test  - hello

一般使用log4j的步骤
1.配置，一个简单的配置方式是使用默认配置
BasicConfigurator.configure()

2.检索类的Logger对象
一般会使用如下三种方式
Logger.getLogger("com.wombat.X"); // String variant
Logger.getLogger(X.class.getName()); // another String variant
Logger.getLogger(X.class); // convenient Class variant

3.调用Logger的记录消息的方法
debug(), info(), warn(), error(), fatal(), log()


log4j组成部分
log4j由三个部分组成
loggers, appenders and layouts

如果一个logger的名字后面跟着一个点号，它就是点号后面的那个logger的前辈（ancestor），是这个晚辈（descendant） 的前缀。如果在它自己和这个晚辈之间没有其它的前辈，它和这个晚辈之间就是父子关系。
例如，叫做"com.foo"的logger是叫做 "com.foo.Bar"的logger的父辈 。同样地，"java"是"java.util" 的父辈，是"java.util.Vector"的前辈。这和java中package的概念是一样的。

根（root）logger 位于logger阶层的最上层。它在三个方面很特别:
1.它总是存在的。
2.不能给它的level设置为null
3.不能通过name获取到它。

根logger是通过Logger.getRootLogger获取的。而非根logger是通过Logger.getLogger获取的。

logger拥有如下方法
package org.apache.log4j;

public class Logger {
// Logger creation & retrieval methods:
public static Logger getRootLogger();
public static Logger getLogger(String name);

// printing methods:
public void debug(Object message);
public void info(Object message);
public void warn(Object message);
public void error(Object message);
public void fatal(Object message);

// printing methods for exceptions:
public void debug(Object message, Throwable t);
public void info(Object message, Throwable t);
public void warn(Object message, Throwable t);
public void error(Object message, Throwable t);
public void fatal(Object message, Throwable t);
// generic printing method:
public void log(Level p, Object message);
}

logger的创建和检索
记录器创建时，会以如上说的结构创建。通过getLogger方法，我们可以得到一个logger。这个方法如果发现这个logger不存在，就回创建它。而getLogger方法传入的name相同，它们得到的引用是同一个。
如：
Logger x = Logger.getLogger("wombat");
Logger y = Logger.getLogger("wombat");
得到的是两个相同实例。
对于祖先logger，在创建后代logger的时候，如果祖先没有创建，那么祖先的logger会先被创建。

对于日志级别，这和UNIX的日志是一样的。而windows则叫做日志时间类型。

常用的级别

1.FATAL致命级别。这个级别表示应用出现了致命的错误。这样的错误难以恢复的。而对于java的Exception，则不应该属于这个级别。

2.ERROR错误级别。一般在发生了Exception使用

3.WARN警告级别。对系统的警告。如当发现数据不正确的时候。

4.INFO信息级别。比DEBUG级别略高。它一般用于记录系统信息，或者记录系统运行中的重要标志。

5.DEBUG调试级别。这个级别使用比较多。一般用来再开发阶段使用。来输出调试信息，方便调试。

级别包含
ALL, DEBUG, INFO, WARN, ERROR, FATAL and OFF等。
级别等级关系
ALL < DEBUG < INFO < WARN < ERROR < FATAL < OFF

实现org.apache.log4j.Level接口，我们还可以定义自己的级别。

一个logger的有效级别如果没有指定（level 为null），那么它将从它的父类继承，直到root logger，找到一个level不为null的祖先为止。

logger name	指定级别	有效级别
root（根级别）	DEBUG	DEBUG
x	none	DEBUG
x.y	none	DEBUG
x.y.z	none	DEBUG

如表格，只有root logger被指派了级别。这个级别的值，DEBUG，被其它的loggers X, X.Y 和 X.Y.Z继承了。

logger name	指定级别	有效级别
root（根级别）	DEBUG	DEBUG
x	ERROR	ERROR
x.y	INFO	INFO
x.y.z	DEBUG	DEBUG

如表格，所有的logger都指定了级别，无需继承。

logger name	指定级别	有效级别
root（根级别）	INFO	INFO
x	DEBUG	DEBUG
x.y	none	DEBUG
x.y.z	WARN	WARN

如表只有x.y没设置级别，它将从它的上级logger(x)继承级别DEBUG

logger name	指定级别	有效级别
root（根级别）	DEBUG	DEBUG
x	ERROR	ERROR
x.y	none	ERROR
x.y.z	none	ERROR

如表root和x指定了级别。x.y和x.y.z未设置级别，他们将从x继承而来。

日志过滤器。
日志是通过调用对应级别的方法来完成的。如果当前的logger开启的级别高于调用的方法级别，那么过滤器就会不允许打印。


例子
package com.cgodo.log4j.test;

import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;

/**
* log4j测试
*
* @author liyixing [e-mail]
* @version 1.0
* @since 2011-7-3 上午01:37:42
*/
public class Test {
private static final Logger LOGGER = Logger.getLogger("test");

/**
* @param args
*/
public static void main(String[] args) {
BasicConfigurator.configure();
Logger logger = Logger.getLogger("com.foo");
// 设置等级为info
logger.setLevel(Level.INFO);
// 它未设置级别，从com.foo继承
Logger barLogger = Logger.getLogger("com.foo.Bar");
// because WARN >= INFO.
logger.warn("warn.");
// This request is disabled, because DEBUG < INFO.
logger.debug("debug.");
// INFO >= INFO.
barLogger.info("Located nearest gas station.");
// This request is disabled, because DEBUG < INFO.
barLogger.debug("debug2");
}
}
结果只有两句级别是输出的
0 [main] WARN com.foo  - warn.
0 [main] INFO com.foo.Bar  - Located nearest gas station.

层次性的级别过滤 Threshold
它设置的是全局的过滤级别。而logger的级别只是针对当前logger的

package com.cgodo.log4j.test;

import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.spi.LoggerRepository;

/**
* log4j测试
*
* @author liyixing [e-mail]
* @version 1.0
* @since 2011-7-3 上午01:37:42
*/
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
BasicConfigurator.configure();
Logger x = Logger.getLogger("foo.bar");
x.setLevel(Level.INFO);
LoggerRepository repository = x.getLoggerRepository();
//设置了全局的为WARN
repository.setThreshold(Level.WARN);
//info < warn
x.info("Dropped message.");
//设置全局的为off
repository.setThreshold(Level.OFF);
//fatal < off
x.fatal("This is a serious message but it will also be dropped.");
repository.setThreshold(Level.ALL);
x.info("Hello world.");
//debug >= all
x.debug("Remember: DEBUG < INFO.");
}
}

输出内容为
0 [main] INFO foo.bar  - Hello world.

打印异常
package com.cgodo.log4j.test;

import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;

/**
* log4j测试
*
* @author liyixing [e-mail]
* @version 1.0
* @since 2011-7-3 上午01:37:42
*/
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
BasicConfigurator.configure();
Logger x = Logger.getLogger("foo.bar");

x.setLevel(Level.ALL);
x.error("exception测试", new RuntimeException("测试"));
}
}

输出内容
0 [main] ERROR foo.bar  - exception测试
java.lang.RuntimeException: 测试
at com.cgodo.log4j.test.Test.main(Test.java:24)

Appenders
log4j允许将输出信息输出到不同设备中。
调用logger的addAppender方法将添加一个设备。
logger的每一个允许的级别日志记录调用都将传递到这个设备。

Appender Additivity
Logger x.y.z的log输出信息将被输出到x.y.z的所有appenders和它的前辈的 appenders。这就是"appender additivity"的意思。
但是，如果logger x.y.z的前辈，比如说x.y，x.y的additivity flag被设置为 false，那么，x.y.z的输出信息将被输出到x.y.z的所有appenders中去，以及它的前辈的——截止在x.y那里，包括x.y在内的，appenders中去，但是不会输出到x.y的前辈的 appenders中去。
默认情况下，Loggers的additivity flag设置为true。


package com.cgodo.log4j.test;

import java.io.IOException;

import org.apache.log4j.FileAppender;
import org.apache.log4j.Logger;
import org.apache.log4j.SimpleLayout;

/**
* log4j测试
*
* @author liyixing [e-mail]
* @version 1.0
* @since 2011-7-3 上午01:37:42
*/
public class Test {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
FileAppender a0 = new FileAppender(new SimpleLayout(), "a0.log");
FileAppender a1 = new FileAppender(new SimpleLayout(), "a1.log");
Logger root = Logger.getRootLogger();
Logger x = Logger.getLogger("x");
Logger xyz = Logger.getLogger("x.y.z");

root.addAppender(a0);
x.addAppender(a1);
// Note that we have not added any appenders to the xyz logger.
xyz.debug("Some message.");
xyz.info("Another message.");
}
}


如上代码
1.由于我们没有加载默认配置，所以不会往控制台输出信息
2.a1.log文件的内容
DEBUG - Some message.
INFO - Another message.
3.a0.log 的内容
DEBUG - Some message.
INFO - Another message.
可以发现，调用了记录日志的方法后，x.y,x.y.zlogger的日志同时打印在了root的日志appenders中。


package com.cgodo.log4j.test;

import java.io.IOException;

import org.apache.log4j.FileAppender;
import org.apache.log4j.Logger;
import org.apache.log4j.SimpleLayout;

/**
* log4j测试
*
* @author liyixing [e-mail]
* @version 1.0
* @since 2011-7-3 上午01:37:42
*/
public class Test {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
FileAppender a0 = new FileAppender(new SimpleLayout(), "a0.log");
FileAppender a1 = new FileAppender(new SimpleLayout(), "a1.log");
FileAppender secureAppender = new FileAppender(new SimpleLayout(),
"secret.log");
Logger root = Logger.getRootLogger();
root.addAppender(a0);
Logger x = Logger.getLogger("x");
x.addAppender(a1);
Logger xyz = Logger.getLogger("x.y.z");
Logger secureLogger = Logger.getLogger("secure");
secureLogger.addAppender(secureAppender);
secureLogger.setAdditivity(false);
// The accessLogger is a child of the secureLogger.
Logger accessLogger = Logger.getLogger("secure.access");
// Output goes to a0.log and a1.log.
xyz.debug("Regular message.");
// Ouput goes only to secret.log.
accessLogger.warn("Detected snooping attempt by Eve.");
}
}

如上代码，a0.log,a1.log都有相同内容输出。而secret.log只有
WARN - Detected snooping attempt by Eve.
一句话。因为secureLogger.setAdditivity(false);设置为false。到secureLogger的appenders输出完毕后不会再往上面传递了。

Layouts
除了对输出设备的要求外，还会对输出格式布局有要求。一个常见的布局是PatternLayout布局。它的输出格式和C语句的格式化输出很类似

Object Rendering 对象渲染
这是log4j的强大功能。将对象以自定的布局格式方式输出。


package com.cgodo.log4j.test;

import java.io.IOException;

import org.apache.log4j.FileAppender;
import org.apache.log4j.Logger;
import org.apache.log4j.SimpleLayout;

import com.cgodo.log4j.model.User;

/**
* log4j测试
*
* @author liyixing [e-mail]
* @version 1.0
* @since 2011-7-3 上午01:37:42
*/
public class Test {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
FileAppender a0 = new FileAppender(new SimpleLayout(), "a0.log");
Logger root = Logger.getRootLogger();
root.addAppender(a0);
Logger log = Logger.getLogger("test");
User user = new User(1, "aaa");

log.debug("debug user");
log.debug(user);
}
}

如上，未定义格式的情况下，输出内容是
DEBUG - debug user
DEBUG - com.cgodo.log4j.model.User@1bcc0bc

对象渲染器需要实现org.apache.log4j.or.ObjectRenderer接口
如我们可以使用AttributesRenderer来访问org.xml.sax.Attributes objects.