java logger

来源：互联网发布：淘宝商品陈列模块代码编辑：程序博客网时间：2024/06/02 19:18

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维护嵌入在程序代码中的日志记录语句。通过规范日志记录的处理过程，一些人认为应该鼓励更多的使用日志记录并且获得更高程度的效率。

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

添加文件 dist/lib/log4j-1.2.6.jar 到 CLASSPATH 环境变量中。

3.log4j的基本概念

使用log4j大概涉及3个主要概念:

公共类 Logger

Logger 负责处理日志记录的大部分操作。

公共接口 Appender

Appender 负责控制日志记录操作的输出。

公共抽象类Layout

Layout 负责格式化Appender的输出。

几个重要规则

1：级别的控制，就是只要大于等于指定的控制级别，就可以输出

2：如果有多个logger，都可以匹配输出，则每个logger都产生输出，其中根logger

匹配所有的输出；而级别控制来源于路径最详细的logger。

3.1.Logger

日志记录器(Logger)是日志处理的核心组件。log4j具有5种正常级别(Level)。日志记录器(Logger)的可用级别Level (不包括自定义级别 Level)，以下内容就是摘自log4j API(http://jakarta.apache.org/log4j/docs/api/index.html):

Log4j建议只使用四个级别，优先级从高到低分别是ERROR、WARN、INFO、DEBUG

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 APIhttp://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

输出源

Log4j允许日志请求被输出到多个输出源。用Log4j的话说，一个输出源被

称做一个Appender 。

一个logger可以设置超过一个的appender。

n 常见Appender

org.apache.log4j.ConsoleAppender（控制台）

org.apache.log4j.FileAppender（文件）

org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）

org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个

新的文件）

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

org.apache.log4j.jdbc.JDBCAppender（把日志用JDBC记录到数据库中）

Appender 控制日志怎样输出

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，这样它才能知道怎样格式化它的输出。

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

org.apache.log4j.PatternLayout（可以灵活地指定布局模式），

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

org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

最常用的PatternLayout

%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)

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.使用外部配置文件

经常与外部日志文件联合使用，这样很多可选项不必硬编码在软件中。使用外部配置文件的优点就是修改可选项不需要重新编译程序。唯一的缺点就是，由于用到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>

<root>

<appender-ref ref="ConsoleAppender"/>

</root>

</log4j:configuration>

文件以标准的XML声明作为开始，后面跟着指出DTD（文档类型定义）的DOCTYPE声明，它定义了XML文件的结构，例如，什么元素可以嵌入在其他元素中等等。上面文件在log4j发行版的src/java/org/apache/log4j/xml目录中。接着看看封装所有元素的 log4j:configuration 元素，它在DOCTYPE声明中被指定为根元素。嵌入在根元素中有两个结构：

</appender>

这里创建一个名叫"ConsoleAppender"的 Appender，注意，你可以选择任何名字，该示例之所以选择"ConsoleAppender"，完全是为了示例的设计。接着这个appender类以全名形式给出，经常用规范（fully qualified）类名。 Appender必须具有一个指定的 name和class。嵌入在 Appender之内的是 layout元素，这里它被指定为SimpleLayout。 Layout 必须具有一个 class属性。

<root>

<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/">

</layout>

</appender>

<root>

<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 BLAH

log4j.rootLogger=DEBUG, BLAH

# add a ConsoleAppender to the logger BLAH

log4j.appender.BLAH=org.apache.log4j.ConsoleAppender

# set set that layout to be SimpleLayout

log4j.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");

}

配置示例-1

Log4j有两种配置方式，一种是xml格式，一种是properties格式。都是放

置到classpath下面。默认名称分别是：log4j.xml和log4j.properties

properties配置示例如下：

log4j.rootLogger=error,javass.Console,javass.File

log4j.appender.javass.Console=org.apache.log4j.ConsoleAppender

log4j.appender.javass.Console.layout=org.apache.log4j.PatternLayout

log4j.appender.javass.Console.layout.ConversionPattern=%d{HH:mm:ss,SSS}

%5p (%C{1}:%M) - %m%n

配置示例-2

log4j.appender.javass.File=org.apache.log4j.DailyRollingFileAppender

log4j.appender.javass.File.file=javass.log

log4j.appender.javass.File.DatePattern=.yyyy-MM-dd

log4j.appender.javass.File.layout=org.apache.log4j.PatternLayout

log4j.appender.javass.File.layout.ConversionPattern=%d{HH:mm:ss,SSS} %5p

(%C{1}:%M) - %m%n

log4j.logger.cn.javass=debug

n 每个Appender都要引用自己的Layout。

n 每个Logger都可以指定一个级别，同时引用多个Appender；而一个Appender也同

时可以被多个Logger引用。

配置示例-3

xml配置示例如下：

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j='http://jakarta.apache.org/log4j/'>

<param name="ConversionPattern"

value="[%d{dd HH:mm:ss,SSS\} %-5p] [%t] %c{2\} - %m%n" />

</layout>

</appender>

配置示例-4

<appender name="file"

class="org.apache.log4j.DailyRollingFileAppender">

<param name="ConversionPattern"

value="[%d{MMdd HH:mm:ss SSS\} %-5p] [%t] %c{3\} - %m%n" />

</layout>

</appender>

<appender-ref ref="file" />

</logger>

<root>

<appender-ref ref="test" />

<appender-ref ref="file" />

</root>

</log4j:configuration>

首先要注意，log4j.xml优先于log4j.properties，如果同时存在log4j.xml和

log4j.properites，以log4j.xml为准。

n 在log4j.properties里，控制级别的时候，只能打印出大于指定级别的所有信

息；但是在log4j.xml中可以通过filter来完成过滤：典型的引用是只打印出某

种级别的信息。

<appender name="log.file"

class="org.apache.log4j.DailyRollingFileAppender">

</filter>

</appender>

n 可以通过logger的additivity=“false”属性，来设置多个logger是否重复输出

同一条信息

<appender-ref ref="log.console" />

<appender-ref ref="log.file" />

</logger>

在java中使用log4j时，我们可以使用它的eclipse插件log4e。它的官方网址

是：http://log4e.jayefem.de/，分为商业版本和免费版本。我们只需要使用其

免费版本，就可以极大的帮我们提高开发效率。比如：在一个类中声明一个

logger；帮我们写麻烦的logger.isDebugEnabled()；在一个方法开始的时候打

印所有的参数；输出一个变量等等。

除了使用log4j进行日志输出之外，我们还可以使用jdk内置的日志系统。

它位于java.util.logging包下，因此不需要引用额外的jar包。其基本概念与

log4j大同小异，我们可以类比的学习。

其配置文件位于jdk安装目录下的/jre/lib/logging.properties。

请同学们观察配置文件，自己找到我们在log4j里找的Appender、Layout、

级别和Logger，以及它们的关系。

使用classpath下的logging.properties

如果想使用自定义的logging.properties，只需要保证这段代码运行在getLogger之

前即可：

ClassLoader classLoader =

Thread.currentThread().getContextClassLoader();

InputStream inputStream =

classLoader.getResourceAsStream("logging.properties");

if (inputStream != null) {

try {

LogManager.getLogManager().readConfiguration(inputStream);

} catch (SecurityException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

slf4j简介

简单日记门面(simple logging Facade for java)SLF4J是为各种loging

APIs提供一个简单统一的接口，从而使得最终用户能够在部署的时候配置自己希

望的loging APIs实现。

准确的说， slf4j并不是一种具体的日志系统，而是一个用户日志系统的

facade，允许用户在部署最终应用时方便的变更其日志系统。

在系统开发中，统一按照slf4j的API进行开发，在部署时，选择不同的日

志系统包，即可自动转换到不同的日志系统上。比如：选择JDK自带的日志系

统，则只需要将slf4j-api-1.5.10.jar和slf4j-jdk14-1.5.10.jar放置到

classpath中即可，如果中途无法忍受JDK自带的日志系统了，想换成log4j的日

志系统，仅需要用slf4j-log4j12-1.5.10.jar替换slf4j-jdk14-1.5.10.jar即可

（当然也需要log4j的jar及配置文件）

SLF4J具备以下优点

SLF4J 受类加载器的影响较小，不易产生内存溢出的问题，性能得到了改善，更

主要是顺应了潮流的发展--可方便部署到OSGI 环境中

在java中使用slf4j

获得logger对象：

private static final Logger logger = LoggerFactory.getLogger(Test.class);

输出日志信息：

logger.debug(“debug”);

n 看似奇怪的重复级别判断：我们在看一些成熟框架的源代码中，经常看到如下代

码：

if (logger.isDebugEnabled()){

logger.debug(“debug：“+name);

}

为什么不是直接logger.debug(“debug：“+name);呢？

在配置文件中虽然可以使用控制级别为比debug级别更高的级别，而不输出

debug信息；但是，这里的字符串连接操作仍然会影响运行效率；如果先判断当

前logger的级别，如果级别不合适的话，连这句字符串连接都可以不做了。

1. 在SRC目录下创建一个文件，名为log4j.properties ，内容如下：

#此属性指定日志等级等于或低于INFO的日志信息输出到名为stdout的目的地

log4j.rootCategory=DEBUG, stdout

#此属性执行stdout这个输出目的地类型为控制台

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

#此属性指定输出日志的布局类，这里采用LOG4J默认的布局类

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

具备以上三个属性，我们就能够将日志输出到控制台了

只需在log4j.properties文件里添加一行：

log4j.appender.stdout.layout.ConversionPattern= %d %p [%C.%M(%L)] -

<%m>%n

重新运行LogTest.java,

详细的信息便呈现出来了。

问题又来了，假设我们程序已经开发完了，需要部署到正式环境了，这个时候如

果我们日志输出级别还是保持在DEBUG级别的话，那么我们的日志信息量以及日

志文件个头将会变得很大很大，不便于我们查阅和维护，因此我们在部署到正式

环境的时候需要将日志级别调低一点。修改log4j.properties

log4j.rootCategory=INFO, stdout

这样我们的日志里就不显示DEBUG信息了

5. 到目前为止，我们都只是把日志输出到控制台，可是大多数情况我们需要把日志

输出到日志文件，这要怎么配置呢，很简单，修改log4j.properties

#在前面的基础上，修改log4j.rootCategory属性添加一个目的地，起个名儿叫logfile

log4j.rootCategory=INFO, stdout,logfile

og4j.appender.logfile=org.apache.log4j.FileAppender

log4j.appender.logfile.File=LogTest.log

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

log4j.appender.logfile.layout.ConversionPattern= %d %p [%C.%M(%L)] -

<%m>%n

这样一来日志就会自动输出到LogTest.log文件

6. 如果老是向同一个日志文件写日志，那么一段时间后这个日志文件会变得非常大，不

便于我们我们维护，因此我们希望按照日志文件大小，比如日志文件到达100M后

就自动生成一个新的日志文件。LOG4J也提供了简单的配置方式，修改

log4j.properties

log4j.appender.logfile= org.apache.log4j.RollingFileAppender

log4j.appender.logfile.File=LogTest.log

log4j.appender.logfile.Append=true

log4j.appender.logfile.MaxFileSize=100MB

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

log4j.appender.logfile.layout.ConversionPattern= %d %p [%C.%M(%L)] -

<%m>%n

有时候我们又希望按照日期，每天生成一个日志文件：

log4j.appender.logfile= org.apache.log4j.DailyRollingFileAppender

log4j.appender.logfile.File=LogTest.log

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

log4j.appender.logfile.layout.ConversionPattern= %d %p [%C.%M(%L)] -

<%m>%n

常用的配置我们介绍得差不多了，其他诸如输出到数据库、SOCKET等方式可参阅网上

相关文章，这里就不再赘述了。

0 0