Log4j 的使用之整体概念

Log4j是个日志纪录工具,可以取代system.out.println之类的信息,而且还可以定义信息级别,可以根据需要显示想要得信息,更重要的是合理的使用该工具是个很好的编程好习惯,这也是在最近的项目中得出的一点心得:

1)我们用的是笨重的wsad,如果用调试模式来开发,肯定很慢,养成看日志的习惯,可以加快开发的速度,当然我的意思不是说日志可以取代调试工具,这个要看日志写的详细程度,而且特别复杂的程序,还得靠调试(除非你肯花时间在写日志上,或者将程序设计的简单),但无论如何,在开发时还是应该将两者配合使用,我90%的时间看日志,10%的时间用调试模式

2)日志决不是仅仅用于调试,我们这次开发使用了别人的开发的基础类,全部都打包成jar,在开发过程中如果不看日志信息简直无法找错,你或许会说可以看原文件,但毕竟时间有限,这也给了我们一些提示信息,当我们开发api给别人用的时候,一定写好日志信息,为别人提供方便

说了这么多废话,开始进入正题

A) 安装

1. 从 http://jakarta.apache.org/log4j/docs/download.html下载log4j发行版。

2. 解压存档文件到合适的目录中。

3. 添加目录中的文件 dist/lib/log4j-1.2.9.jar 到 CLASSPATH 环境变量中。(在eclipse中将该jar复制的你的工程下的lib目录中,然后在项目的build path中引用即可)

B) log4j的3个核心概念

B1)Logger：日志写出器

Logger对象是用来取代System.out或者System.err的日志写出器，用来供程序员输出日志信息。

• Logger的输出方法

Logger类对象提供一系列方法供程序员输出日志信息。

              // Printing methods :
         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);                  // Generic printing method :                  public void log(Level l, Object msg); 

              // Printing methods :
         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);                  // Generic printing method :                  public void log(Level l, Object msg); 

              // Printing methods :
         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);                  // Generic printing method :                  public void log(Level l, Object msg); 

• Logger的命名规则

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的方法。

• Log level

每个logger都被分配了一个日志级别 (log level)，用来控制日志信息的输出。未被分配level的logger将继承它最近的父logger的level。

每条输出到logger的日志请求(logging request)也都有一个level，如果该request的level大于等于该logger的level，则该request将被处理（称为enabled）；否则该request将被忽略。故可得知：

1. logger的level越低，表示该logger越详细
2. logging request的level越高，表示该logging request越优先输出

3. 如果没有设置日志记录器（Logger）的级别，那么它将会继承最近的祖先的级别。因此，如果在包com.foo.bar中创建一个日志记录器（Logger）并且没有设置级别，那它将会继承在包com.foo中创建的日志记录器（Logger）的级别。如果在com.foo中没有创建日志记录器（Logger）的话,那么在com.foo.bar中创建的日志记录器（Logger）将继承root 日志记录器（Logger）的级别，root日志记录器（Logger）经常被实例化而可用，它的级别为DEBUG。

Level类中预定义了五个level，它们的大小关系如下：

Level.ALL < Level.DEBUG < Level.INFO < Level.WARN < Level.ERROR < Level.FATAL < Level.OFF

有很多方法可以创建一个日志记录器（Logger），

下面方法可以取回root日志记录器:Logger logger = Logger.getRootLogger();

还可以这样创建一个新的日志记录器:Logger logger = Logger.getLogger("MyLogger");

比较常用的用法，就是根据类名实例化一个静态的全局日志记录器:static Logger logger = Logger.getLogger(test.class);

所有这些创建的叫"logger"的日志记录器都可以用下面方法设置级别:logger.setLevel((Level)Level.WARN);

下代码将用自己所属的类为参数，创建一个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的两点说明

1)用同名参数调用Logger.getLogger(String name)将返回同一个logger的引用。故可以在一个地方配置logger，在另外一个地方获得配置好的logger，而无须相互间传递logger的引用。
2)logger的创建可以按照任意的顺序，即，父logger可以后于子logger被创建。log4j将自动维护logger的继承树。

B2)Appender：日志目的地

每个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。

1)ConsoleAppender:使用用户指定的布局(layout) 输出日志事件到System.out或者 System.err。默认的目标是System.out。

2)DailyRollingFileAppender 扩展FileAppender，因此多个日志文件可以以一个用户选定的频率进行循环日志记录。

3)FileAppender 把日志事件写入一个文件

4)RollingFileAppender 扩展FileAppender备份容量达到一定大小的日志文件。

5)WriterAppender根据用户的选择把日志事件写入到Writer或者OutputStream。

6)SMTPAppender 当特定的日志事件发生时，一般是指发生错误或者重大错误时，发送一封邮件。

7)SocketAppender 给远程日志服务器（通常是网络套接字节点）发送日志事件（LoggingEvent）对象。

8)SocketHubAppender 给远程日志服务器群组（通常是网络套接字节点）发送日志事件（LoggingEvent）对象。

9)SyslogAppender给远程异步日志记录的后台精灵程序(daemon)发送消息。

10)TelnetAppender 一个专用于向只读网络套接字发送消息的log4j appender。

还可以实现 Appender 接口，创建以自己的方式进行日志输出的Appender。

• ConsoleAppender

ConsoleAppender可以用这种方式创建：

ConsoleAppender appender = new ConsoleAppender(new PatternLayout());

创建了一个控制台appender，具有一个默认的PatternLayout。它使用了默认的System.out 输出。

• 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"指定的文件。

这个构造函数还可以选择是否对指定的文件进行追加的方式输出。如果没有指定值，那么默认的方式就是追加。

• WriterAppender

WriterAppender可以用这种方式创建:

WriterAppender appender = null;
try {
appender = new WriterAppender(new PatternLayout(),new FileOutputStream("filename"));
} catch(Exception e) {}

这个WriterAppender使用的构造函数带有PatternLayout和OutputStream参数，在这种情况下， FileOutputStream用于向一个文件输出。当然，它还具有其他可用的构造函数。

B3)Layout：日志格式化器

每个appender都和一个layout相联系；layout的任务是格式化用户的logging request，appender的任务是把layout格式化好的输出内容送往指定的目的地。

当前，log4j具有三种类型的Layout:

1)HTMLLayout 格式化日志输出为HTML表格。

2)PatternLayout 根据指定的 转换模式格式化日志输出，或者如果没有指定任何转换模式，就使用默认的转换模式。

3)SimpleLayout 以一种非常简单的方式格式化日志输出，它打印级别 Level，然后跟着一个破折号“-“ ，最后才是日志消息

• 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");
}
}

• 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");
}
}

• 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");
}
}

注意:

上面B2)和B3)中的代码以及B1)中所有有关配置的代码,在实际的开发中一般是不需要,可以通过配置文件搞定,这样也便于维护,上面的例子主要用于理解

未完,待续.....

关于配置文件见下一篇