动态配置log4j

1 配置外部配置文件来配置的基本步骤

1.1　一个运用配置文件的实例

Log4j之因此能成功的缘由之一是它的灵活性。但若是只是简单的调用BasicConfigurator.configure()来进行配置工做，那么全部的配置都是在函数中写死的，之后修改配置就要修改原代码，这就不能体现出log4j的灵活性了，因此基本上不会经过BasicConfigurator.configure()来进行配置工做的。

为了增长软件的灵活性，最经常使用的作法就是使用配置文件，如web.xml之于J2EE，struts-config.xml之于struts同样，log4j也提供了让咱们把配置信息从程序转移到配置文件中的方法。Log4j提供了两种方式的配置文件：XML文件和Java的property配置文件。经过把配置信息转移到外部文件中，当咱们要修改配置信息时，就能够直接修改配置文件而不用去修改代码了，下面，咱们就来完成一个经过配置文件来实现log4j的实例。

例2-a：

package TestLog4j;

import org.apache.log4j.Logger;

import org.apache.log4j.BasicConfigurator;

import org.apache.log4j.PropertyConfigurator;

import org.apache.log4j.Priority; public class TestLog4j

{

static Logger logger = Logger.getLogger(TestLog4j.class.getName());

public TestLog4j(){}

public static void main(String[] args)

{

//经过BasicConfigurator类来初始化

//BasicConfigurator.configure();

//（1）经过配置文件来初始化

PropertyConfigurator.configure("F:\\nepalon\\log4j.properties");

logger.debug("Start of the main() in TestLog4j");　//代码（2）

logger.info("Just testing a log message with priority set to INFO");

logger.warn("Just testing a log message with priority set to WARN");

logger.error("Just testing a log message with priority set to ERROR");

logger.fatal("Just testing a log message with priority set to FATAL");

logger.log(Priority.WARN, "Testing a log message use a alternate form");

logger.debug(TestLog4j.class.getName());　//代码（2）

}

在这个例子中，咱们用PropertyConfigurator.configure("F:\\nepalon\\log4j.properties")代替BasicConfigurator.configure()进行配置。PropertyConfigurator.configure()函数的参数能够是一个properties文件所在路径的String对象，能够是一个properties文件所在路径的URL对象，也能够是一个properties对象。经过PropertyConfigurator.configure()能够经过指定的properties文件来配置信息。若是要用XML文件进行信息配置，能够在代码中调用DOMConfigurator()函数来进行配置工做。在这里，咱们只以properties文件来完成例子。接着，咱们来看一下log4j.properties文件中都有些什么东西：

例2-b：

log4j.rootLogger = DEBUG, A1

log4j.appender.A1 = org.apache.log4j.ConsoleAppender

log4j.appender.A1.layout = org.apache.log4j.PatternLayout

log4j.appender.A1.layout.ConversionPattern = %-4r [%t] %-5p %c %x - %m%n

运行这个实例，运行结果为

0 [main] DEBUG TestLog4j.TestLog4j - Start of the main() in TestLog4j

20 [main] INFO TestLog4j.TestLog4j - Just testing a log message with priority set to INFO

20 [main] WARN TestLog4j.TestLog4j - Just testing a log message with priority set to WARN

20 [main] ERROR TestLog4j.TestLog4j - Just testing a log message with priority set to ERROR

20 [main] FATAL TestLog4j.TestLog4j - Just testing a log message with priority set to FATAL

180 [main] WARN TestLog4j.TestLog4j - Testing a log message use a alternate form

180 [main] DEBUG TestLog4j.TestLog4j - TestLog4j.TestLog4j

下面，咱们分析一下这个配置文件。

1) 因为每个Logger对旬都有一个级别，文件的第一行就是定义了一个Logger及其级别。在这里定义了一个根记录器（root logger），这涉及到记录器的层次问题，在些暂时不深刻讨论，在后面的章节再进行讨论。

2) 第二行定义了一个名为A1的输出流，这个流就是控制台，因此经过Logger对象打印的信息会在控制台输出。

3) 第三行定义了打印信息的布局。在这里咱们用PatternLayout做为此记录器的布局，PatternLayout容许你以灵活的格式来打印信息。

4) 第四行指定的打印信息的具体格式，从结果可知，这个实例的打印格式为：当前打印语句所使用的时间 [日志所在的线程] 打印的级别当前日志所在的类的全名日志信息。

如今咱们来修改一下这个记录器的级别，把第一行的DEBUG改成INFO，再运行程序，结果将变为：

0 [main] INFO TestLog4j.TestLog4j - Just testing a log message with priority set to INFO

10 [main] WARN TestLog4j.TestLog4j - Just testing a log message with priority set to WARN

10 [main] ERROR TestLog4j.TestLog4j - Just testing a log message with priority set to ERROR

10 [main] FATAL TestLog4j.TestLog4j - Just testing a log message with priority set to FATAL

10 [main] WARN TestLog4j.TestLog4j - Testing a log message use a alternate form

因为这个Logger的级别变为INFO，而代码（2）是调用debug()函数来输出日志信息时只能当记录器级别为DEBUG时才输出信息，因此代码（2）将不输出信息。

1.2　实例原理

1.2.1　初始化配置信息

若是要经过JAVA的properties文件来配置信息，那么在代码中就要经过PropertyConfigurator.configure()函数从properties文件中加载配置信息，这个函数有三种参数形式：一个properties文件所在路径的String对象，能够是一个properties文件所在路径的URL对象，也能够是一个properties对象。若是要用XML文件来配置信息，则可用类型的

DOMConfigurator()函数来从一个XML文件中加载配置信息。

1.2.2　输出端Appender

在上面的例子中，咱们都是简单的把日志信息输出到控制台中。其实在log4j中还能够把日志信息输出到其它的输出端，对于同一个日志信息，咱们还可让它同时输出到多个输出端中，如同时在控制台和文件中进行打印。一个输出端就是一个appender。要在配置文件中定义一个appender有三步：

1) 在定义一个记录器的同时定义出该记录器的输出端appender。在例2的配置文件的第一句log4j.rootLogger = DEBUG, A1中，咱们定义了一个根记录器，它的级别为DEBUG，它有一个appender名为A1。定义根记录器的格式为log4j.rootLogger = [ level ], appendName1, appendName2, …appendNameN。同一个记录器可有多个输出端。

2) 定义appender的输出目的地。定义一个appender的输出目的地的格式为log4j.appender.appenderName = fully.qualified.name.of.appender.class。log4j提供了如下几种经常使用的输出目的地：

? org.apache.log4j.ConsoleAppender，将日志信息输出到控制台

? org.apache.log4j.FileAppender，将日志信息输出到一个文件

? org.apache.log4j.DailyRollingFileAppender，将日志信息输出到一个，而且天天输出到一个新的日志文件

? org.apache.log4j.RollingFileAppender，将日志信息输出到一个文件，经过指定文件的的尺寸，当文件大小到达指定尺寸的时候会自动把文件更名，如名为example.log的文件会更名为example.log.1，同时产生一个新的example.log文件。若是新的文件再次达到指定尺寸，又会自动把文件更名为example.log.2，同时产生一个example.log文件。依此类推，直到example.log. MaxBackupIndex，MaxBackupIndex的值可在配置文件中定义。

? org.apache.log4j.WriterAppender，将日志信息以流格式发送到任意指定的地方。

? org.apache.log4j.jdbc.JDBCAppender，经过JDBC把日志信息输出到数据库中。

在例2中，log4j.appender.A1 = org.apache.log4j.ConsoleAppender定义了名为A1的appender的输出目的地为控制台，因此日志信息将输出到控制台。

3) 定义与所选的输出目的地相关的参数，定义格式为：

log4j.appender.appenderName.optionName1 = value1

……

log4j.appender.appenderName.optionNameN = valueN

其中一个最经常使用的参数layout将在下面介绍。

1.2.3　输出格式（布局）layout

经过appender能够控制输出的目的地，而若是要控制输出的格式，就可经过log4j的layout组件来实现。经过配置文件定义一个appender的输出格式，也一般须要两个步骤：

1) 定义appender的布局模式。定义一个appender的布局模式的格式为log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class。Log4j提供的布局模式有如下几种：

? org.apache.log4j.HTMLLayout，以HTML表格形式布局

? org.apache.log4j.PatternLayout，能够灵活地指定布局模式

? org.apache.log4j.SimpleLayout，包含日志信息的级别和信息字符串

在例2　中log4j.appender.A1.layout = org.apache.log4j.PatternLayout定义了名为A1的appender的布局模式为PatternLayout。

2) 定义与所选的布局模式相关的设置信息，定义格式为：

log4j.appender.appenderName.layout.optionName1 = value1

……

log4j.appender.appenderName.layout.optionNameN = valueN

选择了不一样的布局模式可能会有不一样的设置信息。实例2所选的布局模式PatternLayout的一个PatternLayout为ConversionPattern ，经过定义这个PatternLayout的值，咱们能够指定输出信息的输出格式。在例2的配置文件中的定义以下log4j.appender.A1.layout.ConversionPattern = %-4r [%t] %-5p %c %x - %m%n。在下面，咱们将介绍布局模式PatternLayout的参数ConversionPattern的各个值表明的含义。

1.2.4　ConversionPattern参数的格式含义

格式名含义

%c 输出日志信息所属的类的全名

%d 输出日志时间点的日期或时间，默认格式为ISO8601，也能够在其后指定格式，好比：%d{yyy-MM-dd HH:mm:ss }，输出相似：2002-10-18- 22：10：28

%f 输出日志信息所属的类的类名

%l 输出日志事件的发生位置，即输出日志信息的语句处于它所在的类的第几行

%m 输出代码中指定的信息，如log(message)中的message

%n 输出一个回车换行符，Windows平台为 “ \r\n ” ，Unix平台为 “ \n ”

%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL。若是是调用debug()输出的，则为DEBUG，依此类推

%r 输出自应用启动到输出该日志信息所耗费的毫秒数

%t 输出产生该日志事件的线程名

1.3　定义多个输出目的地的实例

从上面的实例原理中咱们已经知道，同一个日志信息能够同时输出到多个输出目的地，在这个例子中，咱们将实现一个把日志信息同时输出到控制器、一个文件中的实例和数据库中。这个实例的Java代码咱们沿用例2中的代码，咱们只需修改配置文件便可。这也体现了log4j的灵活性。

例3-a：

create table log4j(

logID int primary key identity,

message varchar(1024),

priority varchar(10),

milliseconds int,

category varchar(256),

thread varchar(100),

NDC varchar(256),

createDate datetime,

location varchar(256),

caller varchar(100),

method varchar(100),

filename varchar(100),

line int

)

例3-b：

#1 定义了两个输出端

log4j.rootLogger = INFO, A1, A2,A3

#2 定义A1输出到控制器

log4j.appender.A1 = org.apache.log4j.ConsoleAppender

#3 定义A1的布局模式为PatternLayout

log4j.appender.A1.layout = org.apache.log4j.PatternLayout

#4 定义A1的输出格式

log4j.appender.A1.layout.ConversionPattern = %-4r [%t] %-5p %c - %m%n

#5 定义A2输出到文件

log4j.appender.A2 = org.apache.log4j.RollingFileAppender

#6 定义A2要输出到哪个文件

log4j.appender.A2.File = F:\\nepalon\\classes\\example3.log

#7 定义A2的输出文件的最大长度

log4j.appender.A2.MaxFileSize = 1KB

#8 定义A2的备份文件数

log4j.appender.A2.MaxBackupIndex = 3

#9 定义A2的布局模式为PatternLayout

log4j.appender.A2.layout = org.apache.log4j.PatternLayout

#10 定义A2的输出格式

log4j.appender.A2.layout.ConversionPattern = %d{yyyy-MM-dd hh:mm:ss}:%p %t %c - %m%n

#11区定义A3输出到数据库

log4j.appender.A3 = org.apache.log4j.jdbc.JDBCAppender

log4j.appender.A3.BufferSize = 40

log4j.appender.A3.Driver = com.microsoft.jdbc.sqlserver.SQLServerDriver

log4j.appender.A3.URL = jdbc:microsoft:sqlserver://127.0.0.1:1433;DatabaseName=nepalon

log4j.appender.A3.User = sa

log4j.appender.A3.Password =

log4j.appender.A3.layout = org.apache.log4j.PatternLayout

log4j.appender.A3.layout.ConversionPattern = INSERT INTO log4j (createDate, thread, priority, category, message) values(getdate(), '%t', '%-5p', '%c', '%m')

配置文件中的六、七、8行显示了输出端为RollingFileAppender的特有参数及其运用的方法。11区显示了输出端为JDBCAppender的特有参数及其运用方法。在这着重讲解一下六、七、8行的做用。6行指定日志信息输出到哪一个文件，7行指定日志文件的最大长度，最后要详细介绍8行。第8行的参数是设置备份文件的个数的参数，在这里咱们设置为3，表示最多有3个备份文件，具体做用为：

1) 当example3.log文件的大小超过K时，就把文件更名为example3.log.1，同时生成一个新的example3.log文件

2) 当example3.log文件的大小再次超过1K，又把文件更名为example3.log.1。但因为此时example3.log.1已存在，则先把example3.log.1改名为example3.log.2，再把example3.log文件更名为example3.log.1

3) 同理，当example3.log文件的大小再次超过1K，先把example3.log.2文件改名为example3.log.3，把example3.log.1文件改名为example3.log.2，再把example3.log文件更名为example3.log.1

4) 当example3.log文件的大小再次超过1K，先把example3.log.2文件改名为example3.log.3，旧的example3.log.3文件将被覆盖；把example3.log.1文件改名为example3.log.2，旧的example3.log.2文件被覆盖；最后把example3.log文件更名为example3.log.1并覆盖掉旧的example3.log.1文件。

运行结果将分为两部分

在控制器中：

0 [main] INFO TestLog4j.TestLog4j - Just testing a log message with priority set to INFO

11 [main] WARN TestLog4j.TestLog4j - Just testing a log message with priority set to WARN

21 [main] ERROR TestLog4j.TestLog4j - Just testing a log message with priority set to ERROR 21 [main] FATAL TestLog4j.TestLog4j - Just testing a log message with priority set to FATAL

21 [main] WARN TestLog4j.TestLog4j - Testing a log message use a alternate form

在文件example3.log中：

2003-12-18 04:23:02:INFO main TestLog4j.TestLog4j - Just testing a log message with priority set to INFO

2003-12-18 04:23:02:WARN main TestLog4j.TestLog4j - Just testing a log message with priority set to WARN

2003-12-18 04:23:02:ERROR main TestLog4j.TestLog4j - Just testing a log message with priority set to ERROR

2003-12-18 04:23:02:FATAL main TestLog4j.TestLog4j - Just testing a log message with priority set to FATAL

2003-12-18 04:23:02:WARN main TestLog4j.TestLog4j - Testing a log message use a alternate form

1.4　配置log4j的总结

这个教程到这里，关于配置log4j的配置文件的基本原理已经讲完了，并且经过例3咱们已经能够完成基本的日志工做了。如今，咱们就作一个总结。配置一个配置文件的基本步骤以下：

1) 定义一个Logger。在定义Logger时指定该Logger的级别级其输出目的地。定义Logger的格式为

log4j.rootLogger = [ level ], appendName1, appendName2, …appendNameN。

2) 定义appender的输出目的地。定义一个appender的输出目的地的格式为

log4j.appender.appenderName = fully.qualified.name.of.appender.class。

log4j提供的输出端有ConsoleAppender、FileAppender 、DailyRollingFileAppender、RollingFileAppender和WriterAppender。

3) 定义appender的除布局模式外的其它相关参数，如例3中第六、七、8定义了A2的相关参数。定义格式为

log4j.appender.appenderName.optionName1 = value1

……

log4j.appender.appenderName.optionNameN = valueN

若是除了布局模式外不须要定义别的参数，可跳过这一步（如例3中的A1）。

4) 定义appender的布局模式。定义一个appender的布局模式的格式为

log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class。

布局模式其实也是步骤3）中的一个部分，只是布局模式参数是每个appender必须定义的参数。Log4j提供的布局模式有HTMLLayout、PatternLayout和SimpleLayout。

5) 定义与所选的布局模式相关的设置信息，定义格式为

og4j.appender.appenderName.layout.optionName1 = value1

……

log4j.appender.appenderName.layout.optionNameN = valueN

2　记录器的层次Logger hierarchy

2.1　何为记录器的层次hierarchy

首先，咱们先看一下何为层次，以咱们最熟悉的继承为例，下面是一张类图

在这个继承体系中，类B是类C的父类，类A是类C的祖先类，类D是类C的子类。这些类之间就构成一种层次关系。在这些具备层次关系的类中，子类均可继承它的父类的特征，如类B的对象能调用类A中的非private实例变量和函数；而类C因为继承自类B，因此类B的对象能够同时调用类A和类B中的非private实例变量和函数。

在log4j中，处于不一样层次中的Logger也具备象类这样的继承关系。

2.2　记录器的层次

若是一个应用中包含了上千个类，那么也几乎须要上千个Logger实例。如何对这上千个Logger实例进行方便地配置，就是一个很重要的问题。Log4J采用了一种树状的继承层次巧妙地解决了这个问题。在Log4J中Logger是具备层次关系的。它有一个共同的根，位于最上层，其它Logger遵循相似包的层次。下面咱们将进行介绍。

2.2.1　根记录器root logger

就象一个Java中的Object类同样，log4j中的logger层次中有一个称之为根记录器的记录器，其它全部的记录器都继承自这个根记录器。根记录器有两个特征：

1) 根记录器老是存在。就像Java中的Object类同样，由于用log4j输出日志信息是经过记录器来实现的，因此只要你应用了log4j，根记录器就确定存在的。

2) 根记录器没有名称，因此不能经过名称来取得根记录器。但在Logger类中提供了getRootLogger()的方法来取得根记录器。

2.2.2　记录器的层次

Logger遵循相似包的层次。如

static Logger rootLog = Logger.getRootLogger();

static Logger log1 = Logger.getLogger("test4j");

static Logger log2 = Logger.getLogger("test4j.test4j2");

static Logger log3 = Logger.getLogger("test4j.test4j2.test4j2");

那么rootLog是log2的祖先子记录器，log1是log2的父子记录器，log3是log2的子记录器。记录器象Java中的类继承同样，子记录器能够继承父记录器的设置信息，也能够能够覆写相应的信息。

首先先看一下记录器层次中的继承有什么用处。假设程序中的每一个包都具备一些基本的日志信息，而包中的不一样包可能会有些额外的日志信息要输出，这种状况就能够象处理Java中的类同样，运用Logger中的层次关系来达到目的。假设有个名为A的包，我包下的全部类都要把日志信息输出到控制台中；A.B包除了输出到控制台外还要输出到文件中；A.C包除了输出到控制台中还要输出到HTML文档中。这样咱们就能够经过定义一个父记录器A，它负责把日志信息输出到控制台中；定义一个A的子记录器A.B，它负责把日志信息输出到文件中；定义一个A的子记录器A.C，它负责把日志信息输出到HTML文档中。

记录器遵循的是相似包的层次，这样作为咱们带来了大大的方便。Logger类中的getLogger()方法能够取得Logger对象，这个方法有三种参数形式String、Class和URL，其实不管是用哪种，最终都是经过记录器的名字来取得记录器对象的。若是要取得一个名为A.B的记录器对象，咱们能够Logger.getLogger( “ A.B ” )。但从上面的例子中，咱们都是经过Logger.getLogger(TestLog4j.class.getName())这种方法来取得记录器对象。这是为何呢？如今咱们假设A.B的包下有一个类BClass，那么咱们调用BClass.class.getName()获得的是这个类的全名A.B.BClass。因此当调用Logger.getLogger(BClass.class.getName())时，最理想的状况是返回名为A.B.BClass的记录器对象。可是若是不存在名为A.B.BClass的记录器时它会怎样呢？其实经过Logger类的getLogger方法取得记录器时存在下面两种状况：

1) 若是存在与所要找的名字彻底相同的记录器，则返回相应的记录器对象。

当调用Logger.getLogger(BClass.class.getName())时，若是定义了名为A.B.BClass的记录器，它就返回该记录器的对象。

2) 但若是找不到，它会尝试返回在记录器层次中与所要找的记录器最接近的记录器对象。

当调用Logger.getLogger(BClass.class.getName())时，若是没有定义了名为A.B.BClass的记录器，那会尝试返回名为A.B的记录器的对象；若是又没有定义名为A.B的记录器，它会尝试返回名为A的记录器的对象；若是也没定义名为A的记录器，它就会返回根记录器的对象，而根记录器是必须存在的，因此你总能获得一个记录器对象。

好了，如今咱们回到前面的问题，咱们为何总要经过Logger.getLogger(BClass.class.getName())这种以类全名做为参数来取得记录器对象呢？其实这是为了管理方便。由于咱们在定义设计Logger时也遵循相似包的规则，使设计器的名称与程序中的类包对应。如上面的假设中咱们的程序中有A包，A包下有B包和C包，B包下又有类BClass，那么咱们就可以使设计器的名为A、A.B、A.C、A.B.BClass，以此类推。那么当咱们经过类命名来取得设计器对象时，总能取到与所要的设计器最接近的设计器对象。

2.3　如何应用记录器的层次

2.3.1　若是定义及获取不一样层次的记录器

任何一个记录器的使用都有两个步骤：

1) 在配置文件中定义相应的记录器。

在配置文件中定义记录器的格式有两种

? 定义根记录器的格式为

log4j.rootLogger = [ level ], appendName1, appendName2, …appendNameN

? 定义一个非根记录器的格式为

log4j.logger.loggerName1 = [ level ], appendName1,…appendNameN

……

log4j.logger.loggerNameM = [ level ], appendName1, …appendNameN

咱们能够定义任意个非根记录器。

2) 在代码中调用Logger类的取得记录器方法取得相应的记录器对象。

要取得根记录器对象可经过Logger.getRootLogger()函数，要取得非根记录器可经过Logger.getLogger()函数。

理论知道就讲到这里，纸上得来终觉浅，下面，咱们来小小演练一下。

例4-a：

package TestLog4j;

import org.apache.log4j.Logger;

import org.apache.log4j.PropertyConfigurator;

import org.apache.log4j.Priority;

import TestLog4j.TestLog4j2.TestLog4j2;

public class TestLog4j

{

static Logger logger = Logger.getLogger(TestLog4j.class.getName());　//（2）

public TestLog4j(){}

public static void main(String[] args)

{

//同时输出到控制台和一个文件的实例并实现了Logger的继承

PropertyConfigurator.configure("F:\\nepalon\\log4j2.properties");

logger.debug("Start of the main() in TestLog4j");

logger.info("Just testing a log message with priority set to INFO");

logger.warn("Just testing a log message with priority set to WARN");

logger.error("Just testing a log message with priority set to ERROR");

logger.fatal("Just testing a log message with priority set to FATAL");

logger.log(Priority.WARN, "Testing a log message use a alternate form");

logger.debug(TestLog4j.class.getName());

TestLog4j2 testLog4j2 = new TestLog4j2();　//（1）

testLog4j2.testLog();

}

在类TestLog4j中咱们调用了另外一个类TestLog4j2，下面看一下类TestLog4j2的代码。

例4-b：

package TestLog4j.TestLog4j2;

import org.apache.log4j.Logger;

import org.apache.log4j.PropertyConfigurator;

import org.apache.log4j.Priority;

public class TestLog4j2

{

static Logger logger = Logger.getLogger(TestLog4j2.class.getName());　//（1）

public TestLog4j2(){}

public void testLog()

{

//同时输出到控制台和一个文件的实例

PropertyConfigurator.configure("F:\\nepalon\\log4j2.properties");

logger.debug("2Start of the main()");

logger.info("2Just testing a log message with priority set to INFO");

logger.warn("2Just testing a log message with priority set to WARN");

logger.error("2Just testing a log message with priority set to ERROR");

logger.fatal("2Just testing a log message with priority set to FATAL");

logger.log(Priority.DEBUG, "Testing a log message use a alternate form");

logger.debug("2End of the main()");

}

最后咱们来看一下配置文件。

例4-c：

log4j2.properties文件内容

＃1区

#### Use two appenders, one to log to console, another to log to a file

log4j.rootLogger = debug, stdout

#2区

#Print only messages of priority WARN or higher for your category

log4j.logger.TestLog4j= , R

log4j.logger.TestLog4j.TestLog4j2=WARN

#3区

#### First appender writes to console

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

# Pattern to output the caller's file name and line number.

log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n

#4区

#### Second appender writes to a file

log4j.appender.R=org.apache.log4j.RollingFileAppender

log4j.appender.R.File=F:\\nepalon\\classes\\TestLog4j\\example.log

# Control the maximum log file size

log4j.appender.R.MaxFileSize=100KB

# Archive log files (one backup file here)

log4j.appender.R.MaxBackupIndex=1

log4j.appender.R.layout=org.apache.log4j.PatternLayout

log4j.appender.R.layout.ConversionPattern=%d{yyyy-MM-dd hh:mm:ss}:%p %t %c - %m%n

先看一下运行结果。

在控制台中的结果为：

DEBUG [main] (?:?) - Start of the main() in TestLog4j

INFO [main] (?:?) - Just testing a log message with priority set to INFO

WARN [main] (?:?) - Just testing a log message with priority set to WARN

ERROR [main] (?:?) - Just testing a log message with priority set to ERROR

FATAL [main] (?:?) - Just testing a log message with priority set to FATAL

WARN [main] (?:?) - Testing a log message use a alternate form

DEBUG [main] (?:?) - TestLog4j.TestLog4j

WARN [main] (?:?) - 2Just testing a log message with priority set to WARN

ERROR [main] (?:?) - 2Just testing a log message with priority set to ERROR

FATAL [main] (?:?) - 2Just testing a log message with priority set to FATAL

输出文件的结果为：

2003-12-19 04:19:44:DEBUG main TestLog4j.TestLog4j - Start of the main() in TestLog4j

2003-12-19 04:19:44:INFO main TestLog4j.TestLog4j - Just testing a log message with priority set to INFO

2003-12-19 04:19:44:WARN main TestLog4j.TestLog4j - Just testing a log message with priority set to WARN

2003-12-19 04:19:44:ERROR main TestLog4j.TestLog4j - Just testing a log message with priority set to ERROR

2003-12-19 04:19:44:FATAL main TestLog4j.TestLog4j - Just testing a log message with priority set to FATAL

2003-12-19 04:19:44:WARN main TestLog4j.TestLog4j - Testing a log message use a alternate form

2003-12-19 04:19:44:DEBUG main TestLog4j.TestLog4j - TestLog4j.TestLog4j

2003-12-19 04:19:44:WARN main TestLog4j.TestLog4j2.TestLog4j2 - 2Just testing a log message with priority set to WARN

2003-12-19 04:19:44:ERROR main TestLog4j.TestLog4j2.TestLog4j2 - 2Just testing a log message with priority set to ERROR

2003-12-19 04:19:44:FATAL main TestLog4j.TestLog4j2.TestLog4j2 - 2Just testing a log message with priority set to FATAL

首先，先来看一下配置文件都有些什么东西。

1) 在1区中定义了一个根记录器。这个根记录器具备DEBUG级别并有一个名称为stdout的输出端appender。

2) 2区中的内容是这一节的重点，也是应用到记录器层次的地方，但其实也只有两句，充分体现了log4j的简单性。在这里，咱们定义了两个名称分别为TestLog4j和TestLog4j.TestLog4j2设计器。

? 在定义TestLog4j记录器时没有指定级别，因此它的级别继承自它的父记录器，即要记录器，因此它的级别也为DEBUG。在定义TestLog4j记录器时又定义了一个名称为R的输出端，因此它的输出端有两个，一个从根记录器继承而来的名为stdout的输出端，另外一个为在此定义的名为R的输出端。在此须要注意的是，在定义记录器时必须先定义记录器的级别，而后才是记录器的输出端。若是只想定义输出端而不定义级别，则虽然级别能够为空，但逗号分隔符不能省略。如定义TestLog4j记录器的作法。

? 在定义TestLog4j.TestLog4j2记录器时又指定了它的级别，因为一个记录器的级别只能有一个，因此新指定的级别将覆写掉它的父记录器的级别（这就象Java中的多态）。咱们没有定义TestLog4j.TestLog4j2记录器的输出端，因此它的输出端将从它的父记录器中继承而来。它的父记录器为estLog4j记录器，因此它和estLog4j记录器同样具备两个名称分别为stdout和R的输出端。

3) 剩下的3区和4区分别设置了两个输出端的参数值。

接下来，回到咱们的代码，看一下是如何取得记录器，在取记录器时又发生了什么。

1) 例4-a中的代码（2）中，语句Logger.getLogger()中的参数TestLog4j.class.getName()的值为TestLog4j. TestLog4j，因此此语句的结果是取得一个名为TestLog4j. TestLog4j的记录器的对象。但在配置文件中并无定义这样的记录器，因此最终将返回与所需的名称TestLog4j. TestLog4j最接近的记录器对象，即名为TestLog4j的记录器的对象。

2) 例4-b中的代码（1）的原理与例4-a中的代码（2）类似，指望取得的是名为TestLog4j.TestLog4j2. TestLog4j2的记录器对象，但最终返回的是TestLog4j.TestLog4j2记录器的对象。

三　log4j与J2EE的结合

到目前为止，这篇文章讲的都是如何在application中应用log4j，而Java如今的应用主流是J2EE和J2ME。如今，咱们来看一下要如何在J2EE开发中应用log4j。其实在Web application中应用log4j也很简单，与在application中应用log4j不一样之处就是要在全部应用log4j的代码以前对log4j进行初始化。因此，咱们在web application中就要把log4j的初始化工做独立出来，把它放在Servlet中。下面，咱们看一个例子。

例5-a：

进行初始化的Servlet：

import org.apache.log4j.PropertyConfigurator;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

/**

* log4j.jar的初始化类，参考web.xml

*/

public class Log4jInit extends HttpServlet

{

public void init()

{

//经过web.xml来动态取得配置文件

String prefix = getServletContext().getRealPath("/");

String file = getInitParameter("log4j-init-file");

// 若是没有给出相应的配置文件，则不进行初始化

if(file != null)

{

PropertyConfigurator.configure(prefix+file);　//（1）

}

public void doGet(HttpServletRequest req, HttpServletResponse res)

{}

}

下面来看一下这个Servlet在web.xml中的定义。

例5-b：

<servlet-name>log4j-init</servlet-name>

<servlet-class>TestLog4j.Log4jInit</servlet-class>

<init-param>

<param-name>log4j-init-file</param-name>

<param-value>sort.properties</param-value>

</init-param>

<load-on-startup>1</load-on-startup>

</servlet>

由于log4j的初始化要在全部的log4j调用以前完成，因此在web.xml文件中，咱们必定要把对应的Servlet定义的load-on-startup应设为1，以便在Web容器启动时即装入该Servlet。

完成了这两个步骤这后，咱们就能够象在application开发中同样在web application任何地方应用log4j了。下面是在javabean中的应用的一个例子。

例5-c：

import org.apache.log4j.Logger;

public class InfoForm

{

static Logger logger = Logger.getLogger(InfoForm.class);

protected String title;

protected String content;

public InfoForm() {}

public void setTitle(Object value)

{

logger.debug("nepalon:title = " + title);

title = value;

}

public String getTitle()

{

logger.debug("nepalon:title = " + title);

return title;

}

public void setContent(String value)

{

content = value;

logger.debug("nepalon: content() = " + content);

}

public String getContent()

{

logger.debug("nepalon: content = \n" + content);

return content;

}