1.简介
程序开发环境中的日志记录是由嵌入在程序中以输出一些对开发人员有用信息的语句所组成。例如，跟踪语句（trace），结构转储和常见的 System.out.println或printf调试语句。log4j提供分级方法在程序中嵌入日志记录语句。日志信息具有多种输出格式和多个输出级别。
使用一个专门的日志记录包，可以减轻对成千上万的System.out.println语句的维护成本，因为日志记录可以通过配置脚本在运行时得以控制。 log4j维护嵌入在程序代码中的日志记录语句。通过规范日志记录的处理过程，一些人认为应该鼓励更多的使用日志记录并且获得更高程度的效率。
2.安装
为了使用我们即将要安装的日志记录工具，还必须要设置操作环境，只有这样，工具才能知道从哪里找到它所需要的信息，并且操作系统知道从哪里找到这个工具。那么，怎样做呢？实际上，它要求更改操作环境。
从 http://jakarta.apache.org/log4j/docs/download.html下载log4j发行版。
解压存档文件到合适的目录中。
添加文件 dist/lib/log4j-1.2.6.jar 到 CLASSPATH 环境变量中。
3.log4j的基本概念
使用log4j大概涉及3个主要概念:
公共类 Logger
Logger 负责处理日志记录的大部分操作。
公共接口 Appender
Appender 负责控制日志记录操作的输出。
公共抽象类Layout
Layout 负责格式化Appender的输出。
Log4j的类图
3.1.Logger
日志记录器(Logger)是日志处理的核心组件。log4j具有5种正常级别(Level)。 日志记录器(Logger)的可用级别Level (不包括自定义级别 Level)， 以下内容就是摘自log4j API (http://jakarta.apache.org/log4j/docs/api/index.html):
static Level DEBUG
DEBUG Level指出细粒度信息事件对调试应用程序是非常有帮助的。
static Level INFO
INFO level表明 消息在粗粒度级别上突出强调应用程序的运行过程。
static Level WARN
WARN level表明会出现潜在错误的情形。
static Level ERROR
ERROR level指出虽然发生错误事件，但仍然不影响系统的继续运行。
static Level FATAL
FATAL level指出每个严重的错误事件将会导致应用程序的退出。
另外，还有两个可用的特别的日志记录级别: (以下描述来自log4j API http://jakarta.apache.org/log4j/docs/api/index.html):
static Level ALL
ALL Level是最低等级的，用于打开所有日志记录。
static Level OFF
OFF Level是最高等级的，用于关闭所有日志记录。
日志记录器（Logger）的行为是分等级的。
日志记录器（Logger）将只输出那些级别高于或等于它的级别的信息。如果没有设置日志记录器（Logger）的级别，那么它将会继承最近的祖先的级别。因此，如果在包com.foo.bar中创建一个日志记录器（Logger）并且没有设置级别，那它将会继承在包com.foo中创建的日志记录器（Logger）的级别。如果在com.foo中没有创建日志记录器（Logger）的话,那么在com.foo.bar中创建的日志记录器（Logger）将继承root 日志记录器（Logger）的级别，root日志记录器（Logger）经常被实例化而可用，它的级别为DEBUG。
有很多方法可以创建一个日志记录器（Logger），下面方法可以取回root日志记录器:
Logger logger = Logger.getRootLogger();
还可以这样创建一个新的日志记录器:
Logger logger = Logger.getLogger("MyLogger");
比较常用的用法，就是根据类名实例化一个静态的全局日志记录器:
static Logger logger = Logger.getLogger(test.class);
所有这些创建的叫"logger"的日志记录器都可以用下面方法设置级别:
logger.setLevel((Level)Level.WARN);
可以使用7个级别中的任何一个; Level.DEBUG, Level.INFO, Level.WARN, Level.ERROR, Level.FATAL, Level.ALL and Level.OFF.
3.2.Appender
Appender 控制日志怎样输出。下面列出一些可用的Appender(log4j API中所描述的http://jakarta.apache.org/log4j/docs/api/index.html):
ConsoleAppender:使用用户指定的布局(layout) 输出日志事件到System.out或者 System.err。默认的目标是System.out。
DailyRollingFileAppender 扩展FileAppender，因此多个日志文件可以以一个用户选定的频率进行循环日志记录。
FileAppender 把日志事件写入一个文件
RollingFileAppender 扩展FileAppender备份容量达到一定大小的日志文件。
WriterAppender根据用户的选择把日志事件写入到Writer或者OutputStream。
SMTPAppender 当特定的日志事件发生时，一般是指发生错误或者重大错误时，发送一封邮件。
SocketAppender 给远程日志服务器（通常是网络套接字节点）发送日志事件（LoggingEvent）对象。
SocketHubAppender 给远程日志服务器群组（通常是网络套接字节点）发送日志事件（LoggingEvent）对象。
SyslogAppender给远程异步日志记录的后台精灵程序(daemon)发送消息。
TelnetAppender 一个专用于向只读网络套接字发送消息的log4j appender。
还可以实现 Appender 接口，创建以自己的方式进行日志输出的Appender。
3.2.1.使用ConsoleAppender
ConsoleAppender可以用这种方式创建：
ConsoleAppender appender = new ConsoleAppender(new PatternLayout());
创建了一个控制台appender，具有一个默认的PatternLayout。它使用了默认的System.out 输出。
3.2.2.使用FileAppender
FileAppender可以用这种方式创建:
FileAppender appender = null;
try {
appender = new FileAppender(new PatternLayout(),"filename");
} catch(Exception e) {}
上面用到的构造函数:
FileAppender(Layout layout, String filename)
实例化一个FileAppender并且打开变量"filename"指定的文件。
另一个有用的构造函数是：
FileAppender(Layout layout, String filename, boolean append)
实例化一个FileAppender并且打开变量"filename"指定的文件。
这个构造函数还可以选择是否对指定的文件进行追加的方式输出。如果没有指定值，那么默认的方式就是追加。
3.2.3.使用WriterAppender
WriterAppender可以用这种方式创建:
WriterAppender appender = null;
try {
appender = new WriterAppender(new PatternLayout(),new FileOutputStream("filename"));
} catch(Exception e) {}
这个WriterAppender使用的构造函数带有PatternLayout和OutputStream参数，在这种情况下， FileOutputStream用于向一个文件输出。当然，它还具有其他可用的构造函数。
3.3.Layout
Appender必须使用一个与之相关联的 Layout，这样它才能知道怎样格式化它的输出。当前，log4j具有三种类型的Layout:
HTMLLayout 格式化日志输出为HTML表格。
PatternLayout 根据指定的 转换模式格式化日志输出，或者如果没有指定任何转换模式，就使用默认的转换模式。
SimpleLayout 以一种非常简单的方式格式化日志输出，它打印级别 Level，然后跟着一个破折号“-“ ，最后才是日志消息。
3.4.基本示例
3.4.1.SimpleLayout和 FileAppender
这里是一个非常简单的例子，程序实现了SimpleLayout和FileAppender:
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.SimpleLayout;
import org.apache.log4j.FileAppender;
public class simpandfile {
static Logger logger = Logger.getLogger(simpandfile.class);
public static void main(String args[]) {
SimpleLayout layout = new SimpleLayout();
FileAppender appender = null;
try {
appender = new FileAppender(layout,"output1.txt",false);
} catch(Exception e) {}
logger.addAppender(appender);
logger.setLevel((Level) Level.DEBUG);
logger.debug("Here is some DEBUG");
logger.info("Here is some INFO");
logger.warn("Here is some WARN");
logger.error("Here is some ERROR");
logger.fatal("Here is some FATAL");
}
}
你可以下载: simpandfile.java。 还可以查看它的输出： output1.txt.
3.4.2.HTMLLayout和 WriterAppender
这里是一个非常简单的例子，程序实现了 HTMLLayout和WriterAppender:
import java.io.*;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.HTMLLayout;
import org.apache.log4j.WriterAppender;
public class htmlandwrite {
static Logger logger = Logger.getLogger(htmlandwrite.class);
public static void main(String args[]) {
HTMLLayout layout = new HTMLLayout();
WriterAppender appender = null;
try {
FileOutputStream output = new FileOutputStream("output2.html");
appender = new WriterAppender(layout,output);
} catch(Exception e) {}
logger.addAppender(appender);
logger.setLevel((Level) Level.DEBUG);
logger.debug("Here is some DEBUG");
logger.info("Here is some INFO");
logger.warn("Here is some WARN");
logger.error("Here is some ERROR");
logger.fatal("Here is some FATAL");
}
}
你可以下载: simpandfile.java. 还可以查看它的输出：output1.txt.
3.4.3.PatternLayout和 ConsoleAppender
这里是一个非常简单的例子，程序实现了PatternLayout和ConsoleAppender:
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.PatternLayout;
import org.apache.log4j.ConsoleAppender;
public class consandpatt {
static Logger logger = Logger.getLogger(consandpatt.class);
public static void main(String args[]) {
// Note, %n is newline
String pattern = "Milliseconds since program start: %r %n";
pattern += "Classname of caller: %C %n";
pattern += "Date in ISO8601 format: %d{ISO8601} %n";
pattern += "Location of log event: %l %n";
pattern += "Message: %m %n %n";
PatternLayout layout = new PatternLayout(pattern);
ConsoleAppender appender = new ConsoleAppender(layout);
logger.addAppender(appender);
logger.setLevel((Level) Level.DEBUG);
logger.debug("Here is some DEBUG");
logger.info("Here is some INFO");
logger.warn("Here is some WARN");
logger.error("Here is some ERROR");
logger.fatal("Here is some FATAL");
}
}
你可以下载:simpandfile.java. 还可以查看它的输出： output2.txt.
4.使用外部配置文件
Log4j经常与外部日志文件联合使用，这样很多可选项不必硬编码在软件中。使用外部配置文件的优点就是修改可选项不需要重新编译程序。唯一的缺点就是，由于用到io 指令，速度稍微有些减慢。
有两个方法可以用来指定外部配置文件：文本文件或者XML文件。既然现在所有事情都写成XML文件，那么该教程就重点讲解XML文件方法，但是也包含相关文本文件的例子。首先，看看下面的XML配置文件示例：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="ConsoleAppender" class="org.apache.log4j.ConsoleAppender">
<layout class="org.apache.log4j.SimpleLayout"/>
</appender>
<root>
<priority value ="debug" />
<appender-ref ref="ConsoleAppender"/>
</root>
</log4j:configuration>
文件以标准的XML声明作为开始，后面跟着指出DTD（文档类型定义）的DOCTYPE声明，它定义了XML文件的结构，例如，什么元素可以嵌入在其他元素中等等。上面文件在log4j发行版的src/java/org/apache/log4j/xml目录中。 接着看看封装所有元素的log4j:configuration 元素，它在DOCTYPE声明中被指定为根元素。嵌入在根元素中有两个结构：
<appender name="ConsoleAppender" class="org.apache.log4j.ConsoleAppender">
<layout class="org.apache.log4j.SimpleLayout"/>
</appender>
这里创建一个名叫"ConsoleAppender"的 Appender，注意，你可以选择任何名字，该示例之所以选择"ConsoleAppender"，完全是为了示例的设计。接着这个appender类以全名形式给出，经常用规范（fully qualified）类名。 Appender必须具有一个指定的name和class。嵌入在 Appender之内的是 layout元素，这里它被指定为SimpleLayout。 Layout 必须具有一个 class属性。
<root>
<priority value ="debug" />
<appender-ref ref="ConsoleAppender"/>
</root>
root元素必须存在且不能被子类化。示例中的优先级被设置为"debug"，设置appender饱含一个appender-ref元素。还有更多的属性或元素可以指定。查看log4j发行版中的src/java/org/apache/log4j/xml/log4j.dtd以了解关于XML配置文件结构的更多信息。可以用下面这种方法把配置信息文件读入到Java程序中:
DOMConfigurator.configure("configurationfile.xml");
DOMConfigurator 用一棵DOM树来初始化log4j环境。这里是示例中的XML配置文件：plainlog4jconfig.xml。这里是执行该配置文件的程序: files/externalxmltest.java:
import org.apache.log4j.Logger;
import org.apache.log4j.xml.DOMConfigurator;
public class externalxmltest {
static Logger logger = Logger.getLogger(filetest.class);
public static void main(String args[]) {
DOMConfigurator.configure("xmllog4jconfig.xml");
logger.debug("Here is some DEBUG");
logger.info("Here is some INFO");
logger.warn("Here is some WARN");
logger.error("Here is some ERROR");
logger.fatal("Here is some FATAL");
}
}
这里是一个实现带有PatternLayout的FileAppender的日志记录器Logger的XML配置文件:
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="appender" class="org.apache.log4j.FileAppender">
<param name="File" value="Indentify-Log.txt"/>
<param name="Append" value="false"/>
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%d [%t] %p - %m%n"/>
</layout>
</appender>
<root>
<priority value ="debug"/>
<appender-ref ref="appender"/>
</root>
</log4j:configuration>
你可以从这里下载示例: xmllog4jconfig2.xml。 想要得到更多的使用XML文件配置log4j环境的例子，请查看log4j发行版的目录src/java/org/apache/log4j/xml/examples/ 。
这就是上面讨论的文本文件形式的配置文件:
# initialise root logger with level DEBUG and call it BLAHlog4j.rootLogger=DEBUG,
BLAH# add a ConsoleAppender to the logger BLAHlog4j.appender.BLAH=
org.apache.log4j.ConsoleAppender# set set that layout to be SimpleLayoutlog4j.appender.BLAH.layout=
org.apache.log4j.SimpleLayout
从这里可以下载: plainlog4jconfig.txt。这就是执行该配置文件的程序:
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
public class externalplaintest {
static Logger logger = Logger.getLogger(externalplaintest.class);
public static void main(String args[]) {
PropertyConfigurator.configure("plainlog4jconfig.xml");
logger.debug("Here is some DEBUG");
logger.info("Here is some INFO");
logger.warn("Here is some WARN");
logger.error("Here is some ERROR");
logger.fatal("Here is some FATAL");
}
}
你可以下载使用该配置文件的示例： externalplaintest.java。想要获得更多的使用文本文件配置log4j环境的例子，请查看log4j发行版中的目录examples。
使用外部配置文件的例子就简单的讨论到这里，现在应该可以肯定你已经有能力独立学习更多的log4j发行版和测试版中提供的例子。
5.参考资料 (以及一些有参考价值的链接)
http://jakarta.apache.org/log4j/docs/manual.html
log4j的简明介绍 - Ceki G- 2002年3月
http://www.vipan.com/htdocs/log4jhelp.html
不要用System.out.println！用Log4j - Vipan Singla
给你的Java应用程序添加日志记录 - Kevin Brown
- Logger - 日志写出器，供程序员输出日志信息
- Appender - 日志目的地，把格式化好的日志信息输出到指定的地方去
- ConsoleAppender - 目的地为控制台的Appender
- FileAppender - 目的地为文件的Appender
- RollingFileAppender - 目的地为大小受限的文件的Appender
- Layout - 日志格式化器，用来把程序员的logging request格式化成字符串
- PatternLayout - 用指定的pattern格式化logging request的Layout
Logger对象是用来取代System.out或者System.err的日志写出器，用来供程序员输出日志信息。
Logger类对象提供一系列方法供程序员输出日志信息：
- public void debug(Object msg);
- public void debug(Object msg, Throwable t);
- public void info(Object msg);
- public void info(Object msg, Throwable t);
- public void warn(Object msg);
- public void warn(Object msg, Throwable t);
- public void error(Object msg);
- public void error(Object msg, Throwable t);
- public void fatal(Object msg);
- public void fatal(Object msg, Throwable t);
Logger由一个String类的名字识别，logger的名字是大小写敏感的，且名字之间具有继承的关系，子名有父名作为前缀，用点号.分隔。如：x.y是x.y.z的父亲。
根logger (root logger)是所有logger的祖先，它具有如下属性：1) 它总是存在的；2) 它不可以通过名字获得。
通过调用public static Logger Logger.getRootLogger()获得root logger；通过调用public static Logger Logger.getLogger(String name)或者public static Logger Logger.getLogger(Class clazz)获得（或者创建）一个named logger。后者相当于调用Logger.getLogger(clazz.getName())。
在某对象中，用该对象所属的类为参数，调用Logger.getLogger(Class clazz)以获得logger被认为是目前所知的最理智的命名logger的方法。
每个logger都被分配了一个日志级别 (log level)，用来控制日志信息的输出。未被分配level的logger将继承它最近的父logger的level。
每条输出到logger的日志请求(logging request)也都有一个level，如果该request的level大于等于该logger的level，则该request将被处理（称为enabled）；否则该request将被忽略。故可得知：
- logger的level越低，表示该logger越详细
- logging request的level越高，表示该logging request越优先输出
Level类中预定义了五个level，它们的大小关系如下：
Level.ALL < Level.DEBUG < Level.INFO < Level.WARN < Level.ERROR < Level.FATAL < Level.OFF
以下代码将用自己所属的类为参数，创建一个logger，启用默认配置，设置其level并向其输出若干logging request。
import org.apache.log4j.Logger;
import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Level;
public class Log4jTest {
public static void main(String argv[]) {
// Create a logger by the name of class Log4jTest.
Logger logger = Logger.getLogger(Log4jTest.class);
// Use the default configuration.
BasicConfigurator.configure();
// Set the logger level to Level.INFO
logger.setLevel(Level.INFO);
// This request will be disabled since Level.DEBUG < Level.INFO.
logger.debug("This is debug.");
// These requests will be enabled.
logger.info("This is an info.");
logger.warn("This is a warning.");
logger.error("This is an error.");
logger.fatal("This is a fatal error.");
return;
}
}
- 用同名参数调用Logger.getLogger(String name)将返回同一个logger的引用。故可以在一个地方配置logger，在另外一个地方获得配置好的logger，而无须相互间传递logger的引用。
- logger的创建可以按照任意的顺序，即，父logger可以后于子logger被创建。log4j将自动维护logger的继承树。
每个logger都可以拥有一个或者多个appender，每个appender表示一个日志的输出目的地，比如console或者某个文件。可以使用Logger.addAppender(Appender app)为logger增加一个appender；可以使用Logger.removeAppender(Appender app)为logger移除一个appender。
默认情况下，logger的additive标志被设置为true，表示子logger将继承父logger的所有appenders。该选项可以被重新设置，表示子logger将不再继承父logger的appenders。
root logger拥有目标为system.out的consoleAppender，故默认情况下，所有的logger都将继承该appender。
// Log4j APIs : class Logger
// 为logger对象增加或者移除一个Appender对象
public void appAppender(Appender app);
public void removeAppender(Appender app);
// 获得和设置additive标志：是否继承父logger的appenders
// 注意：在设置additive标志为false时，必须保证已经为该logger设置了新的appender，
// 否则log4j将报错：log4j:WARN No appenders could be found for logger (x.y.z).
public boolean getAdditivity();
public void setAdditivity(boolean additive);
可以使用ConsoleAppender对象把日志输出到控制台。每个ConsoleAppender都有一个target，表示它的输出目的地。它可以是System.out，标准输出设备（缓冲显示屏）；或者是System.err，标准错误设备（不缓冲显示屏）。ConsoleAppender的使用方法参考如下API：
// Log4j APIs : class ConsoleAppender extends WriterAppender
// 构造方法，使用一个Layout对象构造一个ConsoleAppender对象
// 默认情况下，ConsoleAppender的target是System.out
public ConsoleAppender(Layout layout);
// 构造方法，使用一个Layout对象和一个target字符串构造ConsoleAppender对象
// target的可能取值为ConsoleAppender.SYSTEM_OUT和ConsoleAppender.SYSTEM_ERR
public ConsoleAppender(Layout layout, String target);
可以使用FileAppender对象把日志输出到一个指定的日志文件中去。使用方法可以参考如下的API：
// Log4j APIs : class FileAppender extends WriterAppender
// 构造方法，使用一个Layout对象和日志文件名构造一个FileAppender对象
public FileAppender(Layout layout, String filename)
throws IOException;
public FileAppender(Layout layout, String filename, boolean append)
throws IOException;
可以使用FileAppender的子类RollingFileAppender对象，把日志输出到一个指定的日志文件中。不同的是该日志文件的大小受到限制，当日志内容超出最大的尺寸时，该文件将向上滚动（最老的日志被擦除）。还可以在该类对象中指定为日志文件做多少个备份。具体使用方法参考如下API：
// Log4j APIs : class RollingFileAppender extends FileAppender
// 构造方法，使用一个Layout对象和日志文件名构造一个RollingFileAppender对象
public RollingFileAppender(Layout layout, String filename)
throws IOException;
public RollingFileAppender(Layout layout, String filename, boolean append)
throws IOException;
// 获得和设置日志备份文件的个数
public int getMaxBackupIndex();
public void setMaxBackupIndex(int index);
// 获得和设置滚动日志文件的最大尺寸
public long getMaximumFileSize();
public void setMaximumFileSize(long size);
每个appender都和一个layout相联系；layout的任务是格式化用户的logging request，appender的任务是把layout格式化好的输出内容送往指定的目的地。
PatternLayout是Layout的一个子类，用来使用类似C语言的printf函数中使用的格式控制字符串来控制日志的输出格式。使用方法参考如下API：
// Log4j APIs : class PatternLayout extends Layout
// 无参数构造方法，使用DEFAULT_CONVERSION_PATTERN构造一个PatternLayout
// 注意：DEFAULT_CONVERSION_PATTERN为"%m%n"，只打印消息信息
public PatternLayout();
// 构造方法，使用自定义的pattern构造一个PatternLayout
public PatternLayout(String pattern);
// 获得和设置PatternLayout对象的日志pattern
public String getConversionPattern();
public void setConversionPattern(String pattern);
Fixme (heavyz)
To be added...
对log4j环境的配置就是对root logger的配置，包括把root logger设置为哪个级别(level)；为它增加哪些appender，等等。这些可以通过设置系统属性的方法来隐式地完成，也可以在程序里调用XXXConfigurator.configure()方法来显式地完成。
Logger类的静态初始化块(static initialization block)中对log4j的环境做默认的初始化。注意：如果程序员已经通过设置系统属性的方法来配置了log4j环境，则不需要再显式地调用XXXConfigurator.configure()方法来配置log4j环境了。
Logger的静态初始化块在完成初始化过程时将检查一系列log4j定义的系统属性。它所做的事情如下：
- 检查系统属性log4j.defaultInitOverride，如果该属性被设置为false，则执行初始化；否则（只要不是false，无论是什么值，甚至没有值，都是否则），跳过初始化。
- 把系统属性log4j.configuration的值赋给变量resource。如果该系统变量没有被定义，则把resource赋值为"log4j.properties"。注意：在apache的log4j文档中建议使用定义log4j.configuration系统属性的方法来设置默认的初始化文件是一个好方法。
- 试图把resource变量转化成为一个URL对象url。如果一般的转化方法行不通，就调用org.apache.log4j.helpers.Loader.getResource(resource, Logger.class)方法来完成转化。
- 如果url以".xml"结尾，则调用方法DOMConfigurator.configure(url)来完成初始化；否则，则调用方法PropertyConfigurator.configure(url)来完成初始化。如果url指定的资源不能被获得，则跳出初始化过程。
BasicConfigurator.configure()方法使用最简的方法配置log4j环境。注：所谓配置log4j环境，就是指配置root logger，因为所有其它的logger都是root logger的后代，所以它们（默认情况下）都将继承root logger的性质。
BasicConfigurator.configure()完成的任务是：
- 用默认pattern创建PatternLayout对象p：
PatternLayout p = new PatternLayout("%-4r[%t]%-5p%c%x - %m%n"); - 用p创建ConsoleAppender对象a，目标是system.out，标准输出设备：
ConsoleAppender a = new ConsoleAppender(p,ConsoleAppender.SYSTEM_OUT); - 为root logger增加一个ConsoleAppender p：
rootLogger.addAppender(p); - 把root logger的log level设置为DEBUG级别：
rootLogger.setLevel(Level.DEBUG);
xml格式的log4j配置文件需要使用org.apache.log4j.xml.DOMConfigurator.configure()方法来读入。对xml文件的语法定义可以在log4j的发布包中找到：org/apache/log4j/xml/log4j.dtd。
log4j的xml配置文件的树状结构如下所示，注意下图只显示了常用的部分。
xml declaration and DTD
|
log4j:configuration
|
+-- appender (name, class)
| |
| +-- param (name, value)
| +-- layout (class)
| |
| +-- param (name, value)
+-- logger (name, additivity)
| |
| +-- level (class, value)
| | |
| | +-- param (name, value)
| +-- appender-ref (ref)
+-- root
|
+-- param (name, class)
+-- level
| |
| +-- param (name, value)
+-- appender-ref (ref)
xml配置文件的头部包括两个部分：xml声明和DTD声明。头部的格式如下：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
- xmlns:log4j [#FIXED attribute] : 定义log4j的名字空间，取定值"http://jakarta.apache.org/log4j/"
- appender [* child] : 一个appender子元素定义一个日志输出目的地
- logger [* child] : 一个logger子元素定义一个日志写出器
- root [? child] : root子元素定义了root logger
appender元素定义一个日志输出目的地。
- name [#REQUIRED attribute] : 定义appender的名字，以便被后文引用
- class [#REQUIRED attribute] : 定义appender对象所属的类的全名
- param [* child] : 创建appender对象时传递给类构造方法的参数
- layout [? child] : 该appender使用的layout对象
layout元素定义与某一个appender相联系的日志格式化器。
- class [#REQUIRED attribute] : 定义layout对象所属的类的全名
- param [* child] : 创建layout对象时传递给类构造方法的参数
logger元素定义一个日志输出器。
- name [#REQUIRED attribute] : 定义logger的名字，以便被后文引用
- additivity [#ENUM attribute] : 取值为"true"（默认）或者"false"，是否继承父logger的属性
- level [? child] : 定义该logger的日志级别
- appender-ref [* child] : 定义该logger的输出目的地
root元素定义根日志输出器root logger。
- param [* child] : 创建root logger对象时传递给类构造方法的参数
- level [? child] : 定义root logger的日志级别
- appender-ref [* child] : 定义root logger的输出目的地
level元素定义logger对象的日志级别。
- class [#IMPLIED attribute] : 定义level对象所属的类，默认情况下是"org.apache.log4j.Level类
- value [#REQUIRED attribute] : 为level对象赋值。可能的取值从小到大依次为"all"、"debug"、"info"、"warn"、"error"、"fatal"和"off"。当值为"off"时表示没有任何日志信息被输出
- param [* child] : 创建level对象时传递给类构造方法的参数
appender-ref元素引用一个appender元素的名字，为logger对象增加一个appender。
- ref [#REQUIRED attribute] : 一个appender元素的名字的引用
- appender-ref元素没有子元素
param元素在创建对象时为类的构造方法提供参数。它可以成为appender、layout、filter、errorHandler、level、categoryFactory和root等元素的子元素。
- name and value [#REQUIRED attributes] : 提供参数的一组名值对
- param元素没有子元素
创建不同的Appender对象或者不同的Layout对象要调用不同的构造方法。可以使用param子元素来设定不同的参数值。
ConsoleAppender的构造方法不接受其它的参数。
... ... ... ...
<appender name="console.log" class="org.apache.log4j.ConsoleAppender">
<layout ... >
... ...
</layout>
</appender>
... ... ... ...
可以为FileAppender类的构造方法传递两个参数：File表示日志文件名；Append表示如文件已存在，是否把日志追加到文件尾部，可能取值为"true"和"false"（默认）。
... ... ... ...
<appender name="file.log" class="org.apache.log4j.FileAppender">
<param name="File" value="/tmp/log.txt" />
<param name="Append" value="false" />
<layout ... >
... ...
</layout>
</appender>
... ... ... ...
除了File和Append以外，还可以为RollingFileAppender类的构造方法传递两个参数：MaxBackupIndex备份日志文件的个数（默认是1个）；MaxFileSize表示日志文件允许的最大字节数（默认是10M）。
... ... ... ...
<appender name="rollingFile.log" class="org.apache.log4j.RollingFileAppender">
<param name="File" value="/tmp/rollingLog.txt" />
<param name="Append" value="false" />
<param name="MaxBackupIndex" value="2" />
<param name="MaxFileSize" value="1024" />
<layout ... >
... ...
</layout>
</appender>
... ... ... ...
可以为PatternLayout类的构造方法传递参数ConversionPattern。
... ... ... ...
<layout class="org.apache.log4j.PatternLayout>
<param name="Conversion" value="%d [%t] %p - %m%n" />
</layout>
... ... ... ...
为WSOTA（Web Services Over The Air）项目开发java web start的胖客户端时，使用了如下的xml文件配置log4j环境（文件名为wsota-rc.log4j.xml）：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<!-- ================================================================= -->
<!-- a rolling file appender -->
<!-- ================================================================= -->
<appender name="wsota-rc.file.log" class="org.apache.log4j.RollingFileAppender">
<param name="File" value="/tmp/wsota-rc.log" />
<param name="Append" value="false" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%d [%t] %p - %m%n" />
</layout>
</appender>
<!-- ================================================================= -->
<!-- a console appender -->
<!-- debug can be turned off by setting level of root to "off" -->
<!-- ================================================================= -->
<appender name="wsota-rc.console.log" class="org.apache.log4j.ConsoleAppender">
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%d [%t] %p - %m%n" />
</layout>
</appender>
<!-- use this to turn on debug to a rolling file. -->
<root>
<level value="debug" />
<appender-ref ref="wsota-rc.file.log" />
</root>
<!-- use this to turn on debug to console. -->
<!--
<root>
<level value="off" />
<appender-ref ref="wsota-rc.console.log" />
</root>
-->
<!-- use this to turn off debug. -->
<!--
<root>
<level value="off" />
<appender-ref ref="wsota-rc.console.log" />
</root>
-->
</log4j:configuration>
在胖客户程序中使用了如下代码来使用外部xml文件配置log4j环境，注意该代码段位于程序的main class的静态初始化块中，含有以下代码的类和xml配置文件在同一个目录下：
import org.apache.log4j.xml.DOMConfigurator;
public class SapFrame extends JFrame {
static {
DOMConfigurator.configure(SapFrame.class.getResource("wsota-rc.log4j.xml"));
}
... ... ... ...
}
- 让每个类都拥有一个private static的Logger对象，用来输出该类中的全部日志信息
- 使用xml文件来完成对log4j环境的配置。在项目的main class中的静态初始化块里放log4j环境的配置代码。注意：在一个项目中，log4j环境只需要被配置一次，而不是在每个使用了logger的类里都需要调用一次
- 用MyClass.class作为参数创建该类的静态Logger对象
Fixme (heavyz)
To add more...
- Log4j主页上的相关文档：http://jakarta.apache.org/log4j/docs
- Ashley J.S Mills的log4j教程：http://supportweb.cs.bham.ac.uk/documentation/tutorials/docsystem/build/tutorials/log4j/log4j.html
最近在搞一个项目架设，希望从构建一个项目方方面面都彻底研究透，增长实战经验。
今天先研究一下日志的构建，这里选择了log4j--java方面比较流行的log框架，功能
很强大，使用起来也很方便了
废话少说，先看看一个史上最简单的log例子，看看我是如何用最简洁的设计实现将异常
等信息写入日志文件的。
项目文件结构
--------TestLog
|----src
| |-com/janeky/log/Log.java
| |-log4j.properties
|----bin
| |-com/janeky/log/Log
|----lib
| |-log4j-1.2.11.jar
Eclipse新建一个java project TestLog
新建一个com.janeky.log包
导入log4j的jar包
包里新建一个Log.java
view plaincopy to clipboardprint?
package com.janeky.log;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
/**
* @author janeky
* Log演示程序
*/
public class Log {
//Logger实例
private Logger loger;
//将Log类封装成单实例的模式，独立于其他类。以后要用到日志的地方只要获得Log的实例就可以方便使用
private static Log log;
//构造函数，用于初始化Logger配置需要的属性
private Log()
{
//获得当前目录路径
String filePath=this.getClass().getResource("/").getPath();
//找到log4j.properties配置文件所在的目录(已经创建好)
filePath=filePath.substring(1).replace("bin", "src");
//获得日志类loger的实例
loger=Logger.getLogger(this.getClass());
//loger所需的配置文件路径
PropertyConfigurator.configure(filePath+"log4j.properties");
}
static Log getLoger()
{
if(log!=null)
return log;
else
return new Log();
}
//测试函数
public static void main(String args[])
{
Log log=Log.getLoger();
try
{
//引发异常
int a=2/0;
}catch(Exception e)
{
//控制台打印异常信息
e.printStackTrace();
//写入到日子文件
log.loger.error("error", e);
}
}
}
package com.janeky.log;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
/**
* @author janeky
* Log演示程序
*/
public class Log {
//Logger实例
private Logger loger;
//将Log类封装成单实例的模式，独立于其他类。以后要用到日志的地方只要获得Log的实例就可以方便使用
private static Log log;
//构造函数，用于初始化Logger配置需要的属性
private Log()
{
//获得当前目录路径
String filePath=this.getClass().getResource("/").getPath();
//找到log4j.properties配置文件所在的目录(已经创建好)
filePath=filePath.substring(1).replace("bin", "src");
//获得日志类loger的实例
loger=Logger.getLogger(this.getClass());
//loger所需的配置文件路径
PropertyConfigurator.configure(filePath+"log4j.properties");
}
static Log getLoger()
{
if(log!=null)
return log;
else
return new Log();
}
//测试函数
public static void main(String args[])
{
Log log=Log.getLoger();
try
{
//引发异常
int a=2/0;
}catch(Exception e)
{
//控制台打印异常信息
e.printStackTrace();
//写入到日子文件
log.loger.error("error", e);
}
}
}
在src文件夹中新建一个文本文档 log4j.properties
view plaincopy to clipboardprint?
#定义DEBUG优先级，R为日志输出目的的
log4j.rootLogger=DEBUG, R
#设置日志输出类型,为文件类型
log4j.appender.R=org.apache.log4j.FileAppender
#设置日志文件名my.log
log4j.appender.R.file=my.log
#每次在文件尾写入新的日志信息
log4j.appender.R.Append=true
#日志输出信息格式类型
log4j.appender.R.layout=org.apache.log4j.PatternLayout
#日志输出信息格式为 换行、换行、日期、优先级、[类名]、日志信息、换行
log4j.appender.R.layout.ConversionPattern=%n%n%d%p[%c]-%m%n
#定义DEBUG优先级，R为日志输出目的的
log4j.rootLogger=DEBUG, R
#设置日志输出类型,为文件类型
log4j.appender.R=org.apache.log4j.FileAppender
#设置日志文件名my.log
log4j.appender.R.file=my.log
#每次在文件尾写入新的日志信息
log4j.appender.R.Append=true
#日志输出信息格式类型
log4j.appender.R.layout=org.apache.log4j.PatternLayout
#日志输出信息格式为 换行、换行、日期、优先级、[类名]、日志信息、换行
log4j.appender.R.layout.ConversionPattern=%n%n%d%p[%c]-%m%n
运行吧，出错了，恭喜你成功了，去TestLog目录下寻找my.log日志信息吧
以后再任何需要记录日志的地方只要使用下面语句就行了
Log log= Log.getLogger();
log.logger.error("something u like to record");
记录日志就是这么简单，不过你可以有其他的需要：
我要将日志发到邮箱
我要将日志写到数据库
我要每天的日志自动归档
……
这些都可以通过修改配置log4j.properties配置文件来实现
以下是配置文件的语法
1. log4j.rootLogger = [level],appenderName,appenderName...
其中，level是日志记录的优先级，从高到低分别为FATAL ERROR WARN INFO DEBUG 。当
你定义一个级别，只有等于或者高于这个基本的才进行处理。 可选的All打印所有日志，OFF
关闭所有日志输出。
appenderName用于指定日志信息输出目的地，可以指定多个
2.配置appender
类型有以下几种
org.apache.log4j.jdbc.JDBCAppender 存入数据库
org.apache.log4j.net.SMTPAppender 发送到指定邮箱
net.cybercorlin.util.logger.appender.IMAppender 自定义类型
org.apache.log4j.ConsoleAppender 控制台
org.apache.log4j.FileAppender 文件
org.apache.log4j.DailyRollingFileAppender 每天产生一个日志文件
org.apache.log4j.RollingFileAppender 文件达到指定大小的时候产生一个新的文件
org.apache.log4j.WriterAppender 将日志信息以流格式发送到任意指定的地方
*************可以参照文章后面从网上摘抄的例子************
3.配置日志信息格式Layout
有以下几种
org.apache.log4j.HTMLLayout HTML表格形式
org.apache.log4j.PatternLayout 自定义的布局（下面将见到这么自定义配置)
org.apache.log4j.SimpleLayout 只包含日志信息基本和信息的字符信息
org.apache.log4j.TTCCLayout 包括日志产生时间、线程、类别等信息
4.自定义的布局中用到的格式化日志信息
采用跟C语言中printf的方式，参数有
%m 输出代码中指定的信息 如 log.error("error")
%p 输出优先级 就是上面提到的DEBUG,INFO等
%c 输出所在类的全名
%r 输出自应用启用到输出该log信息耗费的时间（毫秒）
%t 输出产生该日子事件的线程名
%n 输出换行符号 Windows平台为 "rn",unix平台“n"
%d 输出日志时间点 默认格式是ISO8601 可以自定义格式，比如%d{yyy MM dd hh:mm:ss,sss}
转自：http://www.cnblogs.com/caihongwu/archive/2009/10/26/1589958.html
3588
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
