log4j 快速指南

log4j - 概述

log4j 是一个可靠、快速且灵活的基于 Java 的日志框架（API），根据 Apache 软件许可证发布。

log4j 已移植到 C、C++、C#、Perl、Python、Ruby 和 Eiffel 等语言。

log4j 可以通过外部配置文件在运行时进行高度配置。它将日志记录过程视为优先级级别，并提供机制将日志信息定向到各种目的地，例如数据库、文件、控制台、UNIX Syslog 等。

log4j 有三个主要组件

记录器 (loggers)：负责捕获日志信息。
追加器 (appenders)：负责将日志信息发布到各种首选目的地。
布局 (layouts)：负责以不同的样式格式化日志信息。

log4j 的历史

始于 1996 年初，作为欧盟 SEMPER（欧洲安全电子市场）项目的跟踪 API。
经过无数次增强和多次迭代，最初的 API 已发展成为 log4j，一个流行的 Java 日志包。
该软件包根据 Apache 软件许可证发布，这是一个由开源计划认证的成熟开源许可证。
最新的 log4j 版本，包括其完整源代码、类文件和文档，可以在 https://logging.apache.org/log4j/ 找到。

log4j 特性

它是线程安全的。
它针对速度进行了优化。
它基于命名记录器层次结构。
它支持每个记录器使用多个输出追加器。
它支持国际化。
它不受限于预定义的设施集。
可以使用配置文件在运行时设置日志记录行为。
它从一开始就被设计用于处理 Java 异常。
它使用多个级别，即 ALL、TRACE、DEBUG、INFO、WARN、ERROR 和 FATAL。
可以通过扩展 Layout 类轻松更改日志输出的格式。
日志输出的目标以及写入策略可以通过 Appender 接口的实现来更改。
它是故障停止的。但是，尽管它当然努力确保交付，但 log4j 并不保证每个日志语句都会交付到其目的地。

日志记录的优缺点

日志记录是软件开发的重要组成部分。编写良好的日志代码可以提供快速调试、轻松维护以及应用程序运行时信息的结构化存储。

日志记录也存在缺点。它可能会减慢应用程序的速度。如果过于冗长，可能会导致滚动盲视。为了缓解这些问题，log4j 被设计为可靠、快速且可扩展的。

由于日志记录很少是应用程序的主要焦点，因此 log4j API 努力做到简单易懂和易于使用。

log4j - 安装

log4j API 软件包根据 Apache 软件许可证发布，这是一个由开源计划认证的成熟开源许可证。

最新的 log4j 版本，包括完整源代码、类文件和文档，可以在 https://logging.apache.org/log4j/ 找到。

要在您的系统上安装 log4j，请从指定的 URL 下载 apache-log4j-x.x.x.tar.gz 并按照以下步骤操作。

步骤 1

将下载的文件解压缩并解压到 /usr/local/ 目录中，如下所示

$ gunzip apache-log4j-1.2.15.tar.gz
$ tar -xvf apache-log4j-1.2.15.tar
apache-log4j-1.2.15/tests/input/
apache-log4j-1.2.15/tests/input/xml/
apache-log4j-1.2.15/tests/src/
apache-log4j-1.2.15/tests/src/java/
apache-log4j-1.2.15/tests/src/java/org/
.......................................

解压时，它将创建如下名为 apache-log4j-x.x.x 的目录层次结构

-rw-r--r--  1 root root   3565 2007-08-25 00:09 BUILD-INFO.txt
-rw-r--r--  1 root root   2607 2007-08-25 00:09 build.properties.sample
-rw-r--r--  1 root root  32619 2007-08-25 00:09 build.xml
drwxr-xr-x 14 root root   4096 2010-02-04 14:09 contribs
drwxr-xr-x  5 root root   4096 2010-02-04 14:09 examples
-rw-r--r--  1 root root   2752 2007-08-25 00:09 INSTALL
-rw-r--r--  1 root root   4787 2007-08-25 00:09 KEYS
-rw-r--r--  1 root root  11366 2007-08-25 00:09 LICENSE
-rw-r--r--  1 root root 391834 2007-08-25 00:29 log4j-1.2.15.jar
-rw-r--r--  1 root root    160 2007-08-25 00:09 NOTICE
-rwxr-xr-x  1 root root  10240 2007-08-25 00:27 NTEventLogAppender.dll
-rw-r--r--  1 root root  17780 2007-08-25 00:09 pom.xml
drwxr-xr-x  7 root root   4096 2007-08-25 00:13 site
drwxr-xr-x  8 root root   4096 2010-02-04 14:08 src
drwxr-xr-x  6 root root   4096 2010-02-04 14:09 tests

步骤 2

此步骤是可选的，取决于您将要从 log4j 框架中使用哪些功能。如果您的机器上已安装以下软件包，则可以正常使用，否则您需要安装它们才能使 log4j 工作。

JavaMail API：log4j 中基于电子邮件的日志记录功能需要在您的机器上从 glassfish.dev 安装 Java Mail API (mail.jar)。
JavaBeans Activation Framework：Java Mail API 还需要在您的机器上从 http://java.sun.com/products/javabeans/jaf/index.jsp 安装 JavaBeans Activation Framework (activation.jar)。
Java 消息服务：log4j 的 JMS 兼容功能需要在您的机器上从 http://java.sun.com/products/jms 安装 JMS 和 Java 命名和目录接口 JNDI。
XML 解析器：您需要一个与 JAXP 兼容的 XML 解析器才能使用 log4j。确保您的机器上已安装 Xerces.jar，可以从 http://xerces.apache.org/xerces-j/install.html 获取。

步骤 3

现在您需要适当地设置 CLASSPATH 和 PATH 变量。在这里，我们将仅为 log4j.x.x.x.jar 文件设置它。

$ pwd
/usr/local/apache-log4j-1.2.15
$ export CLASSPATH= \
      $CLASSPATH:/usr/local/apache-log4j-1.2.15/log4j-1.2.15.jar
$ export PATH=$PATH:/usr/local/apache-log4j-1.2.15/

log4j - 架构

log4j API 遵循分层架构，其中每一层提供不同的对象来执行不同的任务。这种分层架构使设计灵活且易于将来扩展。

log4j 框架中有两种类型的对象可用。

核心对象：这些是框架的必备对象。它们是使用框架所必需的。
支持对象：这些是框架的可选对象。它们支持核心对象执行其他但重要的任务。

核心对象

核心对象包括以下类型的对象

记录器对象

顶层是记录器，它提供记录器对象。记录器对象负责捕获日志信息，并将它们存储在命名空间层次结构中。

布局对象

布局层提供用于以不同样式格式化日志信息的布局对象。它在发布日志信息之前为追加器对象提供支持。

布局对象在以人类可读且可重用的方式发布日志信息方面发挥着重要作用。

追加器对象

这是一个较低级别的层，它提供追加器对象。追加器对象负责将日志信息发布到各种首选目的地，例如数据库、文件、控制台、UNIX Syslog 等。

以下虚拟图显示了 log4J 框架的组件

支持对象

log4j 框架中还有其他重要的对象在日志框架中发挥着至关重要的作用

级别对象

级别对象定义任何日志信息的粒度和优先级。API 中定义了七个日志级别：OFF、DEBUG、INFO、ERROR、WARN、FATAL 和 ALL。

过滤器对象

过滤器对象用于分析日志信息并进一步决定是否应记录该信息。

追加器对象可以有多个过滤器对象与其关联。如果将日志信息传递到特定的追加器对象，则与该追加器关联的所有过滤器对象都需要批准该日志信息，然后才能将其发布到附加的目的地。

对象渲染器

对象渲染器对象专门用于提供传递到日志框架的不同对象的字符串表示形式。布局对象使用此对象来准备最终的日志信息。

日志管理器

日志管理器对象管理日志框架。它负责从系统范围的配置文件或配置类中读取初始配置参数。

log4j - 配置

上一章解释了 log4j 的核心组件。本章说明如何使用配置文件配置核心组件。配置 log4j 包括在配置文件中分配级别、定义追加器和指定布局对象。

log4j.properties 文件是 log4j 配置文件，它以键值对的形式保存属性。默认情况下，LogManager 在 CLASSPATH 中查找名为 log4j.properties 的文件。

根记录器的级别定义为 DEBUG。DEBUG 将名为 X 的追加器附加到它。
将名为 X 的追加器设置为有效的追加器。
为追加器 X 设置布局。

log4j.properties 语法

以下是追加器 X 的 log4j.properties 文件的语法

# Define the root logger with appender X
log4j.rootLogger = DEBUG, X

# Set the appender named X to be a File appender
log4j.appender.X=org.apache.log4j.FileAppender

# Define the layout for X appender
log4j.appender.X.layout=org.apache.log4j.PatternLayout
log4j.appender.X.layout.conversionPattern=%m%n

log4j.properties 示例

使用上述语法，我们在 log4j.properties 文件中定义以下内容

根记录器的级别定义为 DEBUG，将名为 FILE 的追加器附加到它。
追加器 FILE 定义为 org.apache.log4j.FileAppender。它写入位于 log 目录中的名为“log.out”的文件。
定义的布局模式为 %m%n，这意味着打印的日志消息后面将跟一个换行符。

# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=${log}/log.out

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

需要注意的是，log4j 支持 UNIX 风格的变量替换，例如 ${variableName}。

调试级别

我们对两个追加器都使用了 DEBUG。所有可能的选项是

TRACE
DEBUG
INFO
WARN
ERROR
FATAL
ALL

这些级别将在 log4j 日志级别中解释。

追加器

Apache log4j 提供追加器对象，这些对象主要负责将日志消息打印到不同的目的地，例如控制台、文件、套接字、NT 事件日志等。

每个追加器对象都与其关联的不同属性，这些属性指示该对象的行为。

属性	描述
layout	追加器使用布局对象及其关联的转换模式来格式化日志信息。
target	目标可以是控制台、文件或其他项目，具体取决于追加器。
level	级别是控制日志消息过滤所必需的。
threshold	追加器可以具有与其关联的阈值级别，独立于记录器级别。追加器会忽略任何级别低于阈值级别的日志消息。
filter	过滤器对象可以分析超出级别匹配的日志信息，并决定特定追加器是否应处理日志请求或将其忽略。

我们可以通过在配置文件中包含以下设置，并使用以下方法将追加器对象添加到记录器

log4j.logger.[logger-name]=level, appender1,appender..n

您可以使用以下 XML 格式编写相同的配置

<logger name="com.apress.logging.log4j" additivity="false">
   <appender-ref ref="appender1"/>
   <appender-ref ref="appender2"/>
</logger>

如果您愿意在程序中添加追加器对象，则可以使用以下方法

public void addAppender(Appender appender);

addAppender() 方法用于向 Logger 对象添加一个 Appender。如示例配置所示，可以在逗号分隔的列表中向一个日志记录器添加多个 Appender 对象，每个对象将日志信息打印到不同的目标。

在上面的示例中，我们只使用了一个 appender，即 FileAppender。所有可能的 appender 选项如下：

AppenderSkeleton
AsyncAppender
ConsoleAppender
DailyRollingFileAppender
ExternallyRolledFileAppender
FileAppender
JDBCAppender
JMSAppender
LF5Appender
NTEventLogAppender
NullAppender
RollingFileAppender
SMTPAppender
SocketAppender
SocketHubAppender
SyslogAppender
TelnetAppender
WriterAppender

我们将在文件中的日志记录中介绍 FileAppender，并在数据库中的日志记录中介绍 JDBC Appender。

布局（Layout）

我们在 appender 中使用了 PatternLayout。所有可能的选项如下：

DateLayout
HTMLLayout
PatternLayout
SimpleLayout
XMLLayout

使用 HTMLLayout 和 XMLLayout，您还可以生成 HTML 和 XML 格式的日志。

布局格式化

您将在以下章节中学习如何格式化日志消息：日志格式化。

log4j - 示例程序

我们已经了解了如何创建配置文件。本章将介绍如何生成调试消息并将其记录到一个简单的文本文件中。

以下是为我们的示例创建的简单配置文件。让我们再次回顾一下它。

根日志记录器的级别定义为 DEBUG，并将其附加到名为 FILE 的 appender。
Appender FILE 定义为 org.apache.log4j.FileAppender，并将日志写入位于 log 目录中的名为“log.out”的文件。
定义的布局模式为 %m%n，这意味着打印的日志消息后面将跟一个换行符。

log4j.properties 文件的内容如下：

# Define the root logger with appender file
log = /usr/home/log4j
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=${log}/log.out

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

在 Java 程序中使用 log4j

以下 Java 类是一个非常简单的示例，它初始化并使用 Log4J 日志记录库用于 Java 应用程序。

import org.apache.log4j.Logger;

import java.io.*;
import java.sql.SQLException;
import java.util.*;

public class log4jExample{
   /* Get actual class name to be printed on */
   static Logger log = Logger.getLogger(log4jExample.class.getName());
   
   public static void main(String[] args)throws IOException,SQLException{
      log.debug("Hello this is a debug message");
      log.info("Hello this is an info message");
   }
}

编译和执行

以下是编译和运行上述程序的步骤。在进行编译和执行之前，请确保已正确设置了 PATH 和 CLASSPATH。

所有库都应该在 CLASSPATH 中可用，并且您的 log4j.properties 文件应该在 PATH 中可用。请按照以下步骤操作：

创建如上所示的 log4j.properties 文件。
创建如上所示的 log4jExample.java 文件并编译它。
执行 log4jExample 二进制文件以运行程序。

您将在 /usr/home/log4j/log.out 文件中获得以下结果：

Hello this is a debug message
Hello this is an info message

log4j - 日志记录方法

Logger 类提供了各种方法来处理日志记录活动。Logger 类不允许我们实例化新的 Logger 实例，但它提供了两种静态方法来获取 Logger 对象：

public static Logger getRootLogger();
public static Logger getLogger(String name);

这两种方法中的第一种返回应用程序实例的根日志记录器，它没有名称。

任何其他命名的 Logger 对象实例都是通过第二种方法通过传递日志记录器的名称来获得的。日志记录器的名称可以是您传递的任何字符串，通常是类名或包名，就像我们在上一章中使用的那样，并在下面提到。

static Logger log = Logger.getLogger(log4jExample.class.getName());

日志记录方法

一旦我们获得了命名日志记录器的实例，我们就可以使用日志记录器的几种方法来记录消息。Logger 类具有以下方法用于打印日志信息。

序号	方法及描述
1	public void debug(Object message) 它使用 Level.DEBUG 级别打印消息。
2	public void error(Object message) 它使用 Level.ERROR 级别打印消息。
3	public void fatal(Object message); 它使用 Level.FATAL 级别打印消息。
4	public void info(Object message); 它使用 Level.INFO 级别打印消息。
5	public void warn(Object message); 它使用 Level.WARN 级别打印消息。
6	public void trace(Object message); 它使用 Level.TRACE 级别打印消息。

所有级别都在 org.apache.log4j.Level 类中定义，并且可以按如下方式调用上述任何方法：

import org.apache.log4j.Logger;

public class LogClass {
   private static org.apache.log4j.Logger log = Logger.getLogger(LogClass.class);
   
   public static void main(String[] args) {
      log.trace("Trace Message!");
      log.debug("Debug Message!");
      log.info("Info Message!");
      log.warn("Warn Message!");
      log.error("Error Message!");
      log.fatal("Fatal Message!");
   }
}

当您编译并运行 LogClass 程序时，它将生成以下结果：

Debug Message!
Info Message!
Warn Message!
Error Message!
Fatal Message!

当与级别结合使用时，所有调试消息都更有意义。我们将在下一章中介绍级别，然后您将很好地理解如何将这些方法与不同的调试级别结合使用。

log4j - 日志级别

org.apache.log4j.Level 类提供以下级别。您还可以通过对 Level 类进行子类化来定义自定义级别。

级别	描述
ALL	所有级别，包括自定义级别。
DEBUG	指定细粒度的信息事件，这些事件对于调试应用程序最有用。
INFO	指定突出显示应用程序在粗粒度级别上的进展情况的信息消息。
WARN	指定潜在的有害情况。
ERROR	指定可能仍然允许应用程序继续运行的错误事件。
FATAL	指定非常严重的错误事件，这些事件可能会导致应用程序中止。
OFF	最高可能的级别，旨在关闭日志记录。
TRACE	指定比 DEBUG 更细粒度的信息事件。

级别如何工作？

如果 p >= q，则日志记录器级别为 q 的级别为 p 的日志请求将被启用。此规则是 log4j 的核心。它假设级别是有序的。对于标准级别，我们有 ALL < DEBUG < INFO < WARN < ERROR < FATAL < OFF。

以下示例显示了我们如何过滤所有 DEBUG 和 INFO 消息。此程序使用 logger 方法 setLevel(Level.X) 来设置所需的日志记录级别。

此示例将打印除 Debug 和 Info 之外的所有消息。

import org.apache.log4j.*;

public class LogClass {
   private static org.apache.log4j.Logger log = Logger.getLogger(LogClass.class);
   
   public static void main(String[] args) {
      log.setLevel(Level.WARN);

      log.trace("Trace Message!");
      log.debug("Debug Message!");
      log.info("Info Message!");
      log.warn("Warn Message!");
      log.error("Error Message!");
      log.fatal("Fatal Message!");
   }
}

当您编译并运行 LogClass 程序时，它将生成以下结果：

Warn Message!
Error Message!
Fatal Message!

使用配置文件设置级别

log4j 提供了基于配置文件的级别设置，当您想要更改调试级别时，它使您无需更改源代码。

以下是一个示例配置文件，它将执行与我们在上述示例中使用 log.setLevel(Level.WARN) 方法相同的任务。

# Define the root logger with appender file
log = /usr/home/log4j
log4j.rootLogger = WARN, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender
log4j.appender.FILE.File=${log}/log.out

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

现在让我们使用以下程序：

import org.apache.log4j.*;

public class LogClass {
   private static org.apache.log4j.Logger log = Logger.getLogger(LogClass.class);
   public static void main(String[] args) {
      log.trace("Trace Message!");
      log.debug("Debug Message!");
      log.info("Info Message!");
      log.warn("Warn Message!");
      log.error("Error Message!");
      log.fatal("Fatal Message!");
   }
}

现在编译并运行上述程序，您将在 /usr/home/log4j/log.out 文件中获得以下结果：

Warn Message!
Error Message!
Fatal Message!

log4j - 日志格式

Apache log4j 提供了各种 Layout 对象，每个对象都可以根据各种布局格式化日志记录数据。还可以创建以应用程序特定方式格式化日志记录数据的 Layout 对象。

所有 Layout 对象都从 Appender 对象接收 LoggingEvent 对象。然后，Layout 对象从 LoggingEvent 中检索消息参数，并应用相应的 ObjectRenderer 以获取消息的字符串表示形式。

布局类型

层次结构中的顶级类是抽象类 org.apache.log4j.Layout。这是 log4j API 中所有其他 Layout 类的基类。

Layout 类在应用程序中被定义为抽象，我们永远不会直接使用此类；相反，我们使用它的子类，如下所示：

DateLayout
HTMLLayout
PatternLayout。
SimpleLayout
XMLLayout

布局方法

此类提供了所有其他 Layout 对象中所有常见操作的骨架实现，并声明了两个抽象方法。

序号	方法及描述
1	public abstract boolean ignoresThrowable() 它指示日志信息是否处理作为日志事件一部分传递给它的任何 java.lang.Throwable 对象。如果 Layout 对象处理 Throwable 对象，则 Layout 对象不会忽略它，并返回 false。
2	public abstract String format(LoggingEvent event) 各个布局子类实现此方法以进行特定于布局的格式化。

除了这些抽象方法之外，Layout 类还为以下列出的方法提供了具体实现：

序号	方法及描述
1	public String getContentType() 它返回 Layout 对象使用的内容类型。基类返回 text/plain 作为默认内容类型。
2	public String getFooter() 它指定日志消息的页脚信息。
3	public String getHeader() 它指定日志消息的页眉信息。

每个子类都可以通过覆盖这些方法的具体实现来返回特定于类的信息。

log4j - 文件日志记录

要将日志信息写入文件，您必须使用 org.apache.log4j.FileAppender。

FileAppender 配置

FileAppender 具有以下可配置参数：

属性	描述
immediateFlush	此标志默认设置为 true，这意味着输出流到文件在每次追加操作时都会被刷新。
encoding	可以使用任何字符编码。默认情况下，它是特定于平台的编码方案。
threshold	此 appender 的阈值级别。
Filename	日志文件的名称。
fileAppend	此标志默认设置为 true，这意味着日志信息将追加到同一文件的末尾。
bufferedIO	此标志指示是否需要启用缓冲写入。默认情况下，它设置为 false。
bufferSize	如果启用了缓冲 I/O，则指示缓冲区大小。默认情况下，它设置为 8kb。

以下是 FileAppender 的示例配置文件 log4j.properties。

# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender

# Set the name of the file
log4j.appender.FILE.File=${log}/log.out

# Set the immediate flush to true (default)
log4j.appender.FILE.ImmediateFlush=true

# Set the threshold to debug mode
log4j.appender.FILE.Threshold=debug

# Set the append to false, overwrite
log4j.appender.FILE.Append=false

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

如果您希望拥有等效于上述 log4j.properties 文件的 XML 配置文件，则以下是其内容：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration>

<appender name="FILE" class="org.apache.log4j.FileAppender">
   <param name="file" value="${log}/log.out"/>
   <param name="immediateFlush" value="true"/>
   <param name="threshold" value="debug"/>
   <param name="append" value="false"/>
   <layout class="org.apache.log4j.PatternLayout">
      <param name="conversionPattern" value="%m%n"/>
   </layout>
</appender>

<logger name="log4j.rootLogger" additivity="false">
   <level value="DEBUG"/>
   <appender-ref ref="FILE"/>
</logger>

</log4j:configuration>

您可以尝试使用上述配置使用 log4j - Sample Program。

在多个文件中记录日志

您可能希望出于某些原因将日志消息写入多个文件，例如，如果文件大小达到某个阈值。

要将日志信息写入多个文件，您必须使用 org.apache.log4j.RollingFileAppender 类，该类扩展了 FileAppender 类并继承了其所有属性。

除了上面为 FileAppender 提到的属性外，我们还有以下可配置参数：

属性	描述
maxFileSize	这是文件超过该大小将被滚动的临界大小。默认值为 10 MB。
maxBackupIndex	此属性表示要创建的备份文件数量。默认值为 1。

以下是 RollingFileAppender 的示例配置文件 log4j.properties。

# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.RollingFileAppender

# Set the name of the file
log4j.appender.FILE.File=${log}/log.out

# Set the immediate flush to true (default)
log4j.appender.FILE.ImmediateFlush=true

# Set the threshold to debug mode
log4j.appender.FILE.Threshold=debug

# Set the append to false, should not overwrite
log4j.appender.FILE.Append=true

# Set the maximum file size before rollover
log4j.appender.FILE.MaxFileSize=5MB

# Set the the backup index
log4j.appender.FILE.MaxBackupIndex=2

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

如果您希望拥有 XML 配置文件，则可以生成与初始部分中提到的相同的 XML 配置文件，并仅添加与 RollingFileAppender 相关的其他参数。

此示例配置演示了每个日志文件允许的最大大小为 5 MB。超过最大大小后，将创建一个新的日志文件。由于 maxBackupIndex 定义为 2，因此当第二个日志文件达到最大大小时，第一个日志文件将被擦除，此后，所有日志信息将回滚到第一个日志文件。

您可以尝试使用上述配置使用 log4j - Sample Program。

每日日志文件生成

可能需要每天生成日志文件以保留日志信息的干净记录。

要将日志信息每天写入文件，您必须使用 org.apache.log4j.DailyRollingFileAppender 类，该类扩展了 FileAppender 类并继承了其所有属性。

除了上面为 FileAppender 提到的属性外，还有一个重要的可配置参数：

属性	描述
DatePattern	这指示何时滚动文件以及要遵循的命名约定。默认情况下，每天午夜执行滚动。

DatePattern 使用以下模式之一控制滚动计划：

DatePattern	描述
'.' yyyy-MM	每个月结束和下一个月开始时滚动。
'.' yyyy-MM-dd	每天午夜滚动。这是默认值。
'.' yyyy-MM-dd-a	每天中午和午夜滚动。
'.' yyyy-MM-dd-HH	每小时开始时滚动。
'.' yyyy-MM-dd-HH-mm	每分钟滚动。
'.' yyyy-ww	根据区域设置，每周的第一天滚动。

以下是一个示例配置文件log4j.properties，用于生成每天中午和午夜滚动的日志文件。

# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILE

# Define the file appender
log4j.appender.FILE=org.apache.log4j.DailyRollingFileAppender

# Set the name of the file
log4j.appender.FILE.File=${log}/log.out

# Set the immediate flush to true (default)
log4j.appender.FILE.ImmediateFlush=true

# Set the threshold to debug mode
log4j.appender.FILE.Threshold=debug

# Set the append to false, should not overwrite
log4j.appender.FILE.Append=true

# Set the DatePattern
log4j.appender.FILE.DatePattern='.' yyyy-MM-dd-a

# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%n

如果您希望拥有一个XML配置文件，您可以生成与初始部分中提到的相同的内容，并且仅添加与DailyRollingFileAppender相关的其他参数。

您可以尝试使用上述配置使用 log4j - Sample Program。

log4j - 数据库日志记录

log4j API 提供了org.apache.log4j.jdbc.JDBCAppender对象，它可以将日志信息放入指定的数据库中。

JDBCAppender 配置

属性	描述
bufferSize	设置缓冲区大小。默认大小为1。
驱动程序	将驱动程序类设置为指定的字符串。如果未指定驱动程序类，则默认为sun.jdbc.odbc.JdbcOdbcDriver。
layout	设置要使用的布局。默认布局为org.apache.log4j.PatternLayout。
密码	设置数据库密码。
SQL	指定每次发生日志事件时要执行的SQL语句。这可能是INSERT、UPDATE或DELETE。
URL	设置JDBC URL。
用户	设置数据库用户名。

日志表配置

在开始使用基于JDBC的日志记录之前，您应该创建一个表来维护所有日志信息。以下是创建LOGS表的SQL语句

CREATE TABLE LOGS
   (USER_ID VARCHAR(20) NOT NULL,
    DATED   DATE NOT NULL,
    LOGGER  VARCHAR(50) NOT NULL,
    LEVEL   VARCHAR(10) NOT NULL,
    MESSAGE VARCHAR(1000) NOT NULL
   );

示例配置文件

以下是一个示例配置文件log4j.properties，用于JDBCAppender，它将用于将消息记录到LOGS表中。

# Define the root logger with appender file
log4j.rootLogger = DEBUG, DB

# Define the DB appender
log4j.appender.DB=org.apache.log4j.jdbc.JDBCAppender

# Set JDBC URL
log4j.appender.DB.URL=jdbc:mysql:///DBNAME

# Set Database Driver
log4j.appender.DB.driver=com.mysql.jdbc.Driver

# Set database user name and password
log4j.appender.DB.user=user_name
log4j.appender.DB.password=password

# Set the SQL statement to be executed.
log4j.appender.DB.sql=INSERT INTO LOGS VALUES('%x','%d','%C','%p','%m')

# Define the layout for file appender
log4j.appender.DB.layout=org.apache.log4j.PatternLayout

对于MySQL数据库，您必须使用实际的DBNAME、用户ID和密码，您在其中创建了LOGS表。SQL语句是执行一个带有表名LOGS的INSERT语句，以及要输入表中的值。

JDBCAppender不需要显式定义布局。相反，传递给它的SQL语句使用PatternLayout。

如果您希望拥有等效于上述 log4j.properties 文件的 XML 配置文件，则以下是其内容：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration>

<appender name="DB" class="org.apache.log4j.jdbc.JDBCAppender">
   <param name="url" value="jdbc:mysql:///DBNAME"/>
   <param name="driver" value="com.mysql.jdbc.Driver"/>
   <param name="user" value="user_id"/>
   <param name="password" value="password"/>
   <param name="sql" value="INSERT INTO LOGS VALUES('%x','%d','%C','%p','%m')"/>
   <layout class="org.apache.log4j.PatternLayout">
   </layout>
</appender>

<logger name="log4j.rootLogger" additivity="false">
   <level value="DEBUG"/>
   <appender-ref ref="DB"/>
</logger>

</log4j:configuration>

示例程序

以下Java类是一个非常简单的示例，它初始化然后使用Log4J日志记录库用于Java应用程序。

import org.apache.log4j.Logger;
import java.sql.*;
import java.io.*;
import java.util.*;

public class log4jExample{
   /* Get actual class name to be printed on */
   static Logger log = Logger.getLogger(log4jExample.class.getName());
   
   public static void main(String[] args)throws IOException,SQLException{
      log.debug("Debug");
      log.info("Info");
   }
}

编译和执行

以下是编译和运行上述程序的步骤。确保在继续进行编译和执行之前已正确设置了PATH和CLASSPATH。

所有库都应该在CLASSPATH中可用，并且您的log4j.properties文件应该在PATH中可用。按照给定的步骤操作

创建如上所示的 log4j.properties 文件。
创建如上所示的 log4jExample.java 文件并编译它。
执行 log4jExample 二进制文件以运行程序。

现在检查DBNAME数据库内的LOGS表，您会发现以下条目

mysql >  select * from LOGS;
+---------+------------+--------------+-------+---------+
| USER_ID | DATED      | LOGGER       | LEVEL | MESSAGE |
+---------+------------+--------------+-------+---------+
|         | 2010-05-13 | log4jExample | DEBUG | Debug   |
|         | 2010-05-13 | log4jExample | INFO  | Info    |
+---------+------------+--------------+-------+---------+
2 rows in set (0.00 sec)

注意：这里x用于输出与生成日志事件的线程关联的嵌套诊断上下文(NDC)。我们使用NDC来区分处理多个客户端的服务器端组件中的客户端。有关此方面的更多信息，请查看Log4J手册。

打印页面