转： log4j入门教程

1. 简介 
2. 安装 
3. log4j基本概念 
3.1. Logger 
3.2. Appender 
3.2.1. 使用ConsoleAppender 
3.2.2. 使用FileAppender 
3.2.3. 使用WriterAppender 
3.3. Layout 
3.4. 基本示例 
3.4.1. SimpleLayout和FileAppender 
3.4.2. HTMLLayout和WriterAppender 
3.4.3. PatternLayout和ConsoleAppender 
4. 使用外部配置文件 
5. 参考资料 (以及一些有参考价值的链接) 
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的输出。 

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 

http://www.opensymphony.com/guidelines/logging.jsp 

LOG4J / OpenSymphony日志记录入门 

http://builder.com.com/article.jhtml?id=u00820020124kev01.htm 

给你的Java应用程序添加日志记录 - Kevin Brown

补充：

1、Log4j 是什么？ 
　　Log4j可以帮助调试（有时候debug是发挥不了作 用的）和分析，要下载和了解更详细的内容，还 
是访问其官方网站吧： http://jakarta.apache.org/log4j . 
2、Log4j 的概念 
　　Log4j中有三个主要的组件，它们分别是 Logger、Appender和Layout，Log4j 允许开发人员定 
义多个Logger，每个Logger拥有自己的名字，Logger之间通过名字来表明隶属关系。有一个Logger 
称为Root，它永远 存在，且不能通过名字检索或引用，可以通过Logger.getRootLogger（）方法获 
得，其它Logger 通过 Logger.getLogger（String name）方法。 
　　Appender则是用来指明将所有的log信息存放到什么地方，Log4j中支持多种appender，如 
console、files、GUI components、NT Event Loggers等，一个Logger可以拥有多个 
Appender，也就是你既可以将Log信息输出到屏幕，同时存储到一个文件中。 
　　Layout的作用是控制Log信息的输出方式，也就是格式化输出的信息。 
　　Log4j中将要输出的Log信息定义了5种级别，依次为DEBUG、INFO、WARN、ERROR和FATAL， 
当输出时，只有级别高过配置中规定的 级别的信息才能真正的输出，这样就很方便的来配置不同情况下 
要输出的内容，而不需要更改代码，这点实在是方便啊。 
3、Log4j 的配置文件 
　　虽然可以不用配置文件，而在程序中实现配置，但这种方法在如今的系统开发中显然是不可取的， 
能采用配置文件的地方一定一定要用配置文件。Log4j 支持两 种格式的配置文件：XML格式和Java 的 
property格式，本人更喜欢后者，首先看一个简单的例子吧，如下： 
log4j.rootLogger=debug, stdout, R 
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 
log4j.appender.R=org.apache.log4j.RollingFileAppender 
log4j.appender.R.File=example.log 
log4j.appender.R.MaxFileSize= 100KB 
# Keep one backup file 
log4j.appender.R.MaxBackupIndex=1 
log4j.appender.R.layout=org.apache.log4j.PatternLayout 
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n 
　　首先，是设置root，格式为 log4j.rootLogger=[level]，appenderName， ……，其中 
level就是设置需要输出信息的级别，后面是appender的输出的目的地，appenderName就是指定日 
志信息输出到哪个地方。您 可以同时指定多个输出目的地。 配置日志信息输出目的地Appender，其语 
法为 
log4j.appender.appenderName = fully.qualified.name.of.appender.class 
log4j.appender.appenderName.option1 = value1 
... 
log4j.appender.appenderName.option = valueN 
　　Log4j提供的appender有以下几种： 
　　org.apache.log4j.ConsoleAppender（控制台） 
　　org.apache.log4j.FileAppender（文件） 
　　org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件） 
　　org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生新文件） 
　　org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方） 
　　配置日志信息的格式（布局），其语法为： 
log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class 
log4j.appender.appenderName.layout.option1 = value1 
.... 
log4j.appender.appenderName.layout.option = valueN 
　　Log4j提供的layout有以下几种： 
　　org.apache.log4j.HTMLLayout（以HTML表格形式布局）， 
　　org.apache.log4j.PatternLayout（可以灵活地指定布局模式）， 
　　org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串）， 
　　org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息） 
　　Log4J采用类似C语言中的printf函数的打印格式格式化日志信息，打印参数如下： %m 输出代 
码中指定的消息 
　　%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL 
　　%r 输出自应用启动到输出该log信息耗费的毫秒数 
　　%c 输出所属的类目，通常就是所在类的全名 
　　%t 输出产生该日志事件的线程名 
　　%n 输出一个回车换行符，Windows 平台为“\r\n”，Unix平台为“\n” 
　　%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy 
MMM dd HH：mm：ss，SSS}，输出类似： 2002年10月18 日 22：10：28，921 
　　%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例： 
Testlog4.main（TestLog4.java：10） 
4、Log4j 在程序中的使用 
　　要在自己的程序中使用Log4j，首先需要将commons- logging.jar和logginglog4j- 
1.2.9.jar导入到构建路径中。然后再将log4j.properties放到src根目录 下。这样就可 
以在程序中使用log4j了。在类中使用log4j，首先声明一个静态变量 
Logger logger=Logger.getLog（"classname"）；现在就可以使用了，用法如下： 
logger.debug（"debug message"）或者logger.info（"info message"），看下面一个小例子： 
import com.foo.Bar; 
import org.apache.log4j.Logger; 
import org.apache.log4j.PropertyConfigurator; 
public class MyApp { 
static Logger logger = Logger.getLogger(MyApp.class.getName()); 
public static void main(String[] args) { 
// BasicConfigurator replaced with PropertyConfigurator. 
PropertyConfigurator.configure(args[0]); 
logger.info("Entering application."); 
Bar bar = new Bar(); 
bar.doIt(); 
logger.info("Exiting application."); 
} 
} 
5、log4j.properties配置文件 
# Set root category priority to info and its only appender to #console. 
log4j.rootCategory=info,console,R 
#log4j.debug=true 

# console is set to be a ConsoleAppender using a PatternLayout. 
log4j.appender.console=org.apache.log4j.ConsoleAppender 
log4j.appender.console.Threshold=info 
log4j.appender.console.layout=org.apache.log4j.PatternLayout 
log4j.appender.console.layout.ConversionPattern=- %m%n 

# R is set to be a File appender using a PatternLayout. 
log4j.appender.R=org.apache.log4j.RollingFileAppender 
log4j.appender.R.Append=true 
log4j.appender.R.Threshold=info 
log4j.appender.R.MaxFileSize=1024KB 
log4j.appender.R.MaxBackupIndex=10 
log4j.appender.R.File=d\:/log/bookconsole.log 
log4j.appender.R.layout=org.apache.log4j.PatternLayout 
log4j.appender.R.layout.ConversionPattern=%-d{yyyy-MM-dd HH\:mm\:ss} [%c]-[%p] %m%n

补充2：

log4j是一个非常强大的log记录软件，下面我们就来看看在项目中如何使log4j。

 

首先当然是得到log4j的jar档，推荐使用1.2.X版，下载地址：

http://logging.apache.org/log4j/1.2/download.html

 

我们先看一个最简单的示例：

【示例1】

项目结构：

【注：由于这里的多个项目公用一个jar档，我们可以创建一个专门放置jar档的Java工程，然后将jar档放到lib目录下。在要使用的工程中按图所示进行引用 】

Java代码：

 package com.coderdream.log4j;

 import org.apache.log4j.Logger;

 public class HelloLog4j {

     private static Logger logger = Logger.getLogger(HelloLog4j.class);

     /**
      * @param args
      */
     public static void main(String[] args) {
         // System.out.println("This is println message.");

         // 记录debug级别的信息
         logger.debug("This is debug message.");
         // 记录info级别的信息
         logger.info("This is info message.");
         // 记录error级别的信息
         logger.error("This is error message.");
     }
 }

  配置文件log4j.properties:

 #可以设置级别：debug>info>error
 #debug：显示debug、info、error
 #info：显示info、error
 #error：只error
 log4j.rootLogger=debug,appender1
 #log4j.rootLogger=info,appender1
 #log4j.rootLogger=error,appender1

 #输出到控制台
 log4j.appender.appender1=org.apache.log4j.ConsoleAppender
 #样式为TTCCLayout
 log4j.appender.appender1.layout=org.apache.log4j.TTCCLayout

输出结果：

 [main] DEBUG com.coderdream.log4j.HelloLog4j - This is debug message.
 [main] INFO com.coderdream.log4j.HelloLog4j - This is info message.
 [main] ERROR com.coderdream.log4j.HelloLog4j - This is error message.

  通过配置文件可知，我们需要配置3个方面的内容：

1、根目录（级别和目的地）；

2、目的地（控制台、文件等等）；

3、输出样式。

下面我们来看看Log4J的类图：

 

Logger - 日志写出器，供程序员输出日志信息 
Appender - 日志目的地，把格式化好的日志信息输出到指定的地方去 
ConsoleAppender - 目的地为控制台的Appender 
FileAppender - 目的地为文件的Appender 
RollingFileAppender - 目的地为大小受限的文件的Appender 
Layout - 日志格式化器，用来把程序员的logging request格式化成字符串 
PatternLayout - 用指定的pattern格式化logging request的Layout

Log4j基本使用方法 

　　Log4j由三个重要的组件构成：日志信息的优先级，日志信息的输出目的地，日志信息的输出格式。日志信息的优先级从高到低有ERROR、WARN、 INFO、DEBUG，分别用来指定这条日志信息的重要程度；日志信息的输出目的地指定了日志将打印到控制台还是文件中；而输出格式则控制了日志信息的显 示内容。

　　一、定义配置文件 

　　其实您也可以完全不使用配置文件，而是在代码中配置Log4j环境。但是，使用配置文件将使您的应用程序更加灵活。Log4j支持两种配置文件格式，一种是XML格式的文件，一种是Java特性文件（键=值）。下面我们介绍使用Java特性文件做为配置文件的方法：

　　1.配置根Logger，其语法为： 

　　log4j.rootLogger = [ level ] , appenderName, appenderName, …

　　其中，level 是日志记录的优先级，分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者您定义的级别。Log4j建议只使用四个级别，优 先级从高到低分别是ERROR、WARN、INFO、DEBUG。通过在这里定义的级别，您可以控制到应用程序中相应级别的日志信息的开关。比如在这里定 义了INFO级别，则应用程序中所有DEBUG级别的日志信息将不被打印出来。 appenderName就是指B日志信息输出到哪个地方。您可以同时指定多个输出目的地。

　　2.配置日志信息输出目的地Appender，其语法为： 

　　log4j.appender.appenderName = fully.qualified.name.of.appender.class
　　log4j.appender.appenderName.option1 = value1
　　…
　　log4j.appender.appenderName.option = valueN

　　其中，Log4j提供的appender有以下几种：
　　org.apache.log4j.ConsoleAppender（控制台），
　　org.apache.log4j.FileAppender（文件），
　　org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件），
　　org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件），
　　org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）

　　3.配置日志信息的格式（布局），其语法为： 

　　log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class
　　log4j.appender.appenderName.layout.option1 = value1
　　…
　　log4j.appender.appenderName.layout.option = valueN

　　其中，Log4j提供的layout有以e几种：
　　org.apache.log4j.HTMLLayout（以HTML表格形式布局），
　　org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
　　org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
　　org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

　　Log4J采用类似C语言中的printf函数的打印格式格式化日志信息，打印参数如下： %m 输出代码中指定的消息

　　%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
　　%r 输出自应用启动到输出该log信息耗费的毫秒数
　　%c 输出所属的类目，通常就是所在类的全名
　　%t 输出产生该日志事件的线程名
　　%n 输出一个回车换行符，Windows平台为“rn”，Unix平台为“n”
　　%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921
　　%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java:10)

　　二、在代码中使用Log4j 

　　1.得到记录器 

　　使用Log4j，第一步就是获取日志记录器，这个记录器将负责控制日志信息。其语法为：

　　public static Logger getLogger( String name)

　　通过指定的名字获得记录器，如果必要的话，则为这个名字创建一个新的记录器。Name一般取本类的名字，比如：

　　static Logger logger = Logger.getLogger ( ServerWithLog4j.class.getName () )

　　2.读取配置文件 

　　当获得了日志记录器之后，第二步将配置Log4j环境，其语法为：

　　BasicConfigurator.configure ()： 自动快速地使用缺省Log4j环境。
　　PropertyConfigurator.configure ( String configFilename) ：读取使用Java的特性文件编写的配置文件。
　　DOMConfigurator.configure ( String filename ) ：读取XML形式的配置文件。

　　3.插入记录信息（格式化日志信息） 

　　当上两个必要步骤执行完毕，您就可以轻松地使用不同优先级别的日志记录语句插入到您想记录日志的任何地方，其语法如下：

　　Logger.debug ( Object message ) ;
　　Logger.info ( Object message ) ;
　　Logger.warn ( Object message ) ;
　　Logger.error ( Object message ) ;

 

示例2～示例8

 

【示例2】 输出为文本文件或HTML文件

 #设置级别：
 log4j.rootLogger=debug,appender1

 #输出到文件(这里默认为追加方式)
 log4j.appender.appender1=org.apache.log4j.FileAppender
 #设置文件输出路径
 #【1】文本文件
 #log4j.appender.appender1.File=c:/Log4JDemo02.log
 #【2】HTML文件
 log4j.appender.appender1.File=c:/Log4JDemo02.html
 #设置文件输出样式
 #log4j.appender.appender1.layout=org.apache.log4j.TTCCLayout
 log4j.appender.appender1.layout=org.apache.log4j.HTMLLayout

 

【 示例3】 输出为文本文件或HTML文件

 #设置级别和多个目的地
 log4j.rootLogger=debug,appender1,appender2

 #输出到控制台
 log4j.appender.appender1=org.apache.log4j.ConsoleAppender
 #设置输出样式
 log4j.appender.appender1.layout=org.apache.log4j.TTCCLayout

 #输出到文件(这里默认为追加方式)
 log4j.appender.appender2=org.apache.log4j.FileAppender
 #设置文件输出路径
 #【1】文本文件
 #log4j.appender.appender2.File=c:/Log4JDemo02.log
 #【2】HTML文件
 log4j.appender.appender2.File=c:/Log4JDemo02.html
 #设置文件输出样式
 #log4j.appender.appender2.layout=org.apache.log4j.TTCCLayout
 log4j.appender.appender2.layout=org.apache.log4j.HTMLLayout

 

【示例4】 SimpleLayout样式

 #设置级别和目的地
 log4j.rootLogger=debug,appender1

 #输出到控制台
 log4j.appender.appender1=org.apache.log4j.ConsoleAppender
 #设置输出样式
 log4j.appender.appender1.layout=org.apache.log4j.SimpleLayout

  输出结果：

 DEBUG - This is debug message.
 INFO - This is info message.
 ERROR - This is error message.

 

【示例5】 自定义样式

 #设置级别和目的地
 log4j.rootLogger=debug,appender1

 #输出到控制台
 log4j.appender.appender1=org.apache.log4j.ConsoleAppender
 #设置输出样式
 log4j.appender.appender1.layout=org.apache.log4j.PatternLayout
 #自定义样式
 # %r 时间 0
 # %t 方法名 main
 # %p 优先级 DEBUG/INFO/ERROR
 # %c 所属类的全名(包括包名)
 # %l 发生的位置，在某个类的某行
 # %m 输出代码中指定的讯息，如log(message)中的message
 # %n 输出一个换行

 log4j.appender.appender1.layout.ConversionPattern=%r [%t] [%p] - %c -%l -%m%n

输出结果：

 0 [main] [DEBUG] - com.coderdream.log4j.HelloLog4j
 -com.coderdream.log4j.HelloLog4j.main(HelloLog4j.java:16) -This is debug message.
 31 [main] [INFO] - com.coderdream.log4j.HelloLog4j
 -com.coderdream.log4j.HelloLog4j.main(HelloLog4j.java:18) -This is info message.
 31 [main] [ERROR] - com.coderdream.log4j.HelloLog4j
 -com.coderdream.log4j.HelloLog4j.main(HelloLog4j.java:20) -This is error message.

 

【示例6】 多目的地、自定义样式

 #设置级别和目的地
 log4j.rootLogger=debug,appender1,appender2

 #输出到控制台
 log4j.appender.appender1=org.apache.log4j.ConsoleAppender
 #设置输出样式
 log4j.appender.appender1.layout=org.apache.log4j.PatternLayout
 #自定义样式
 # %r 时间 0
 # %t 方法名 main
 # %p 优先级 DEBUG/INFO/ERROR
 # %c 所属类的全名(包括包名)
 # %l 发生的位置，在某个类的某行
 # %m 输出代码中指定的讯息，如log(message)中的message
 # %n 输出一个换行符号
 log4j.appender.appender1.layout.ConversionPattern=[%d{yy/MM/dd HH:mm:ss:SSS}][%C-%M] %m%n

 #输出到文件(这里默认为追加方式)
 log4j.appender.appender2=org.apache.log4j.FileAppender
 #设置文件输出路径
 #【1】文本文件
 log4j.appender.appender2.File=c:/Log4JDemo06.log
 #设置文件输出样式
 log4j.appender.appender2.layout=org.apache.log4j.PatternLayout
 log4j.appender.appender2.layout.ConversionPattern=[%d{HH:mm:ss:SSS}][%C-%M] -%m%n

 

【示例7】 【企业应用】设置 特定包的级别和目的地

先增加一个包，新建一个类：

 package com.coderdream.log4jDao;

 import org.apache.log4j.Logger;

 public class HelloDao {
     private static Logger logger = Logger.getLogger(HelloDao.class);

     /**
      * @param args
      */
     public static void main(String[] args) {
         // 记录debug级别的信息
         logger.debug("This is debug message from Dao.");
         // 记录info级别的信息
         logger.info("This is info message from Dao.");
         // 记录error级别的信息
         logger.error("This is error message from Dao.");
     }
 }

      如果这个类作为基类，如J2EE中的BaseDao、BaseAction、BaseService等等，则我们可以将各层的日志信息分类输出到各个文件。

 

 #省略根，只设置特定包的级别和目的地
 log4j.logger.com.coderdream.log4j=debug,appender1
 log4j.logger.com.coderdream.log4jDao=info,appender1,appender2

 #输出到控制台
 log4j.appender.appender1=org.apache.log4j.ConsoleAppender
 #设置输出样式
 log4j.appender.appender1.layout=org.apache.log4j.PatternLayout
 #自定义样式
 # %r 时间 0
 # %t 方法名 main
 # %p 优先级 DEBUG/INFO/ERROR
 # %c 所属类的全名(包括包名)
 # %l 发生的位置，在某个类的某行
 # %m 输出代码中指定的讯息，如log(message)中的message
 # %n 输出一个换行符号
 log4j.appender.appender1.layout.ConversionPattern=[%d{yy/MM/dd HH:mm:ss:SSS}][%C-%M] %m%n

 #输出到文件(这里默认为追加方式)
 log4j.appender.appender2=org.apache.log4j.FileAppender
 #设置文件输出路径
 #【1】文本文件
 log4j.appender.appender2.File=c:/Log4JDemo07_Dao.log
 #设置文件输出样式
 log4j.appender.appender2.layout=org.apache.log4j.PatternLayout
 log4j.appender.appender2.layout.ConversionPattern=[%d{HH:mm:ss:SSS}][%C-%M] -%m%n

 

【示例8】 log4j.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="appender1"
         class="org.apache.log4j.RollingFileAppender">
         <param name="File" value="logfile08.html" />
         <param name="MaxFileSize" value="1MB" />
         <param name="MaxBackupIndex" value="5" />
         <layout class="org.apache.log4j.HTMLLayout">
         </layout>
     </appender>

     <root>
         <level value="debug" />
         <appender-ref ref="appender1" />
     </root>
 </log4j:configuration>

 

为了提高效率，我们可以在写日志前增加判断：

 // 记录debug级别的信息
 if (logger.isDebugEnabled()) {
     logger.debug("This is debug message from Dao.");
 }

 // 记录info级别的信息
 if (logger.isInfoEnabled()) {
     logger.info("This is info message from Dao.");
 }

 // 记录error级别的信息
 logger.error("This is error message from Dao.");

参考资料：

1、log4j 详 解( 一)

2、log4j 详解(二)

3、Log4j基本使用方法

4、Log4j 用法(一)

5、log4j.properties 使用说明

6、Apache Log4j详解

7、log4j.xml配置详解

8、log4j.xml配置详解