当前位置：文档库 › log4j中文手册

log4j中文手册

Log4j手册

文档版本：1.1

编者：陈华

联系方式:clinker@https://www.wendangku.net/doc/7217072912.html,

发布日期：2006年4月5日

1. 简介 (1)

1. 简介 (3)

1.1 概述 (3)

1.2 主要组件 (3)

2. Logger (4)

2.1 层次结构 (4)

2.2 输出级别 (5)

3. Appenders (7)

3.1 概念说明 (7)

3.2 Appender的配置 (7)

3.3 Appender的添加性 (8)

4. Layouts (8)

4.1 概念说明 (8)

4.2 Layout的配置 (9)

5. 配置 (10)

6. 默认的初始化过程 (13)

7. 配置范例 (14)

7.1 Tomcat (14)

8. Nested Diagnostic Contexts (14)

9. 优化 (15)

9.1 日志为禁用时，日志的优化 (15)

9.2 当日志状态为启用时，日志的优化 (16)

9.3 日志信息的输出时，日志的优化 (16)

10. 总结 (16)

11. 附录 (17)

11.1 参考文档 (17)

11.2 比较全面的配置文件 (17)

11.3 日志乱码的解决 (19)

1. 简介

1.1 概述

程序开发环境中的日志记录是由嵌入在程序中以输出一些对开发人员有用信息的语句所组成。例如，跟踪语句（trace），结构转储和常见的System.out.println或printf调试语句。log4j提供分级方法在程序中嵌入日志记录语句。日志信息具有多种输出格式和多个输出级别。

使用一个专门的日志记录包，可以减轻对成千上万的System.out.println语句的维护成本，因为日志记录可以通过配置脚本在运行时得以控制。log4j维护嵌入在程序代码中的日志记录语句。通过规范日志记录的处理过程，一些人认为应该鼓励更多的使用日志记录并且获得更高程度的效率。

1.2 主要组件

Log4j有三个主要组件： loggers、appenders和layouts。这三个组件协同工作，使开发人员能够根据消息类型和级别来记录消息，并且在程序运行期控制消息的输出格式位置。 Logger：日志记录器

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

Appender：日志信息的输出目的地

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

Layout：日志格式化器

Layout 负责格式化Appender的输出。

图1-1 Log4j的类图

2. Logger

日志记录器(Logger)是日志处理的核心组件。

2.1 层次结构

Log4j首要的相对于简单的使用System.out.println()方法的优点是基于它的在禁止一些特定的信息输出的同时不妨碍其它信息的输出的能力。这个能力源自于日志命名空间，也就是说，所有日志声明的空间，它根据一些开发员选择的公式而分类。

Loggers 被指定为实体，Logger的名字是大小写敏感的，它们遵循以下的命名规则：

命名继承：如果类别的名称（后面加一个点）是其子类别名称的前缀，则它就是另一个类别的祖辈。

如果一个类别(Logger)和它的子类别之间没有其它的继承关系，我们就称之为parent与child的关系。

例如，类别"com.foo"是类别"com.foo.Bar"的parent。类似的，"java"是"java.util"的parent，是"java.util.Vector"的父辈。

根(root) 类别位于logger继承结构的最上层。它有两种例外：

(1)它一直存在

(2)它不能根据名称而获得。

调用类的静态方法Logger.getRootLogger可以得到它。其它所有的Logger可以通过静态方法Logger.getLogger而得到它们自己的实例。这个方法取希望的Logger名作为参数。Logger 的一些基本的方法示例如下：

package org.apache.Log4j;

public class Logger {

// Creation & retrieval methods:

public static Logger getRootLogger();

public static Logger getLogger(String name);

// printing methods:

public void debug(Object message);

public void info(Object message);

public void warn(Object message);

public void error(Object message);

// generic printing method:

public void log(Level l, Object message);

}

Loggers可以被分配的级别。所有级别的集合包括：DEBUG、INFO、WARN、ERROR、FATAL。它们被定义于org.apache.Log4j.Level 类。虽然我们不鼓励，但是你们可以通过继承Level 类来定义你们自己的级别。我们随后将介绍一个比较好的方法。

如果一个Logger没有被分配一个级别，那么它将从一个被分配了级别的最接近它的ancestor 哪里继承。正规的说：级别的继承：对于一个给定的Logger C，它的继承的级别等于从C 开始上溯到的第一个拥有非空级别的Logger的级别。

为了保证所有的Logger最终能够继承到一个级别，根Logger通常有一个已经定义了的级别。以下四个表中的数据演示了根据以上规则得到的结果。

例1：

类别名分配的级别继承的级别

root Proot Proot

X none Proot

X.Y none Proot

X.Y.Z none Proot

在例子1中，只有根Logger定义了一个级别，它的级别的值"Proot"被所有其它的Loggers X、X.Y和X.Y.Z所继承。

例2：

类别名分配的级别继承的级别

root Proot Proot

X Px Px

X.Y Pxy Pxy

X.Y.Z Pxyz Pxyz

在例子2中，所有的Logger都有一个被分配的级别值，所以它们不需要级别继承。

例3：

类别名分配的级别继承的级别

root Proot Proot

X Px Px

X.Y none Px

X.Y.Z Pxyz Pxyz

在例子3中，根Logger，以及X和X.Y.Z被分别分配了级别Proot，Px和Pxyz。Logger X.Y 从它的父类别X继承了级别值Px。

例4：

类别名分配的级别继承的级别

root Proot Proot

X Px Px

X.Y none Px

X.Y.Z none Px

在例子4中，根Logger和X被分别分配了级别"Proot"和"Px"，Logger X.Y 和X.Y.Z从被分配了级别的最接近它们的祖先X那里得到继承。

2.2 输出级别

我们需要通过调用Logger的输出的实例方法之一来实现日志请求。这些输出的方法是debug、info、warn、error、fatal和log。

通过定义输出方法来区分日志的请求的级别。例如，如果c是一个Logger的实例，那么声

明 https://www.wendangku.net/doc/7217072912.html,(“…”)就是一个INFO级别的日志请求。

如果一个日志的请求的级别高于或等于日志的级别那么它就能被启用。反之，将被禁用。一个没有被安排级别的Logger将从它的父辈中得到继承。这个规则总结如下：

基本的选择规则：假如在一个级别为q的Logger中发生一个级别为p的日志请求，如果p>=q，那么请求将被启用。

这是Log4j的核心原则。它假设级别是有序的。对于标准级别，我们定义DEBUG

以下是关于这条规则的一个例子。

// 取得名为com.foo的logger实例

Logger logger = Logger.getLogger("com.foo");

// 现在设置它的级别。

// 一般情况下你不需要编程式的设置logger的级别，通常都是通过配置文件来设置的。cat.setLevel(https://www.wendangku.net/doc/7217072912.html,);

Logger barlogger = Logger.getLogger("com.foo.Bar");

// 这个请求可用，因为WARN >= INFO

logger.warn("Low fuel level.");

// 这个请求不可用，因为DEBUG < INFO.

logger.debug("Starting search for nearest gas station.");

// 名为com.foo.Bar的logger继承了com.foo的级别，

//因此，下面的请求可用，因为INFO >= INFO

https://www.wendangku.net/doc/7217072912.html,("Located nearest gas station.");

//这个请求不可用，因为DEBUG < INFO

barlogger.debug("Exiting gas station search");

调用getLogger方法将返回一个同名的Logger对象的实例。例如，

Categoty x = Logger.getLogger("wombat");

Categoty y = Logger.getLogger("wombat");

x和y参照的是同一个Logger对象。

这样我们就可以先定义一个Logger，然后在代码的其它地方不需传参就可以重新得到我们已经定义了的Logger的实例。

同基本的生物学理论——父先于子相反，Log4j 的loggers可以以任何顺序创造和配置。特别是，一个后实例化的"parent"logger能够找到并且连接它的子logger。

配置Log4j的环境通常在一个应用程序被初始化的时候进行，最好的方法是通过读一个配置文件。这个方法我们将简短介绍。

Log4j使得通过软件组件命名logger很容易。我们可以通过Logger的静态的初始化方法在

每一个类里定义一个logger，令 logger的名字等于类名的全局名，而实现logger的命名。这是一个实效的简单的定义一个logger的方法。因为日志输出带有产生日志的类的名字，这个命名策略使得我们更容易定位到一个日志信息的来源。虽然普通，但却是命名logger 的常用策略之一。Log4j没有限制定义logger的可能。开发员可以自由的按照它们的意愿定义logger的名称。

然而，以类的所在位置来命名Logger好象是目前已知的最好方法。

3. Appenders

3.1 概念说明

有选择的启用或者禁用日志请求仅仅是Log4j的一部分功能。Log4j允许日志请求被输出到多个输出源。用Log4j的话说，一个输出源被称做一个Appender。Appender包括console（控制台）、files（文件）、GUI components（图形的组件）、remote socket servers（socket 服务）、JMS（java信息服务）、NT Event Loggers（NT的事件日志）和remote UNIX Syslog daemons （远程UNIX的后台日志服务）。它也可以做到异步记录。

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

用addAppender方法添加一个appender到一个给定的logger。对于一个给定的logger，它每个生效的日志请求都被转发到logger所有的appender上和该logger的父辈logger的appender上。换句话说，appende自动从它的父辈获得继承。举例来说，如果一个根logger 拥有一个console appender，那么所有生效的日志请求至少会被输出到console上。如果一个名为C的logger有一个file类型的appender，那么它就会对它自己以及所有它的子logger 生效。我们也可以通过设置appender的additivity flag为false，来重载appender的默认行为，以便继承的属性不在生效。

3.2 Appender的配置

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

log4j.appender.appenderName = https://www.wendangku.net/doc/7217072912.html,.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.3 Appender的添加性

调节输出源（appender）添加性的规则如下。

输出源的可添加性（Appender Additivity）：一个名为C的logger的日志定义的输出将延续到它自身以及它的ancestor logger的appenders。这就是术语"appender additivity"的含义。

然而，logger C的一个祖先logger P，它的附加标志被设为false，那么C的输出将被定位到所有C的appender，以及从它开始上溯到P的所有ancestor logger的appender。

Loggers的附加标记（additivity flag）默认为true。

下表是一个例子。

名称

添加的

Appenders

可添加性

标志

输出目标注释

root A1不可用A1根logger是匿名的，但可以用Logger.getRootLogger()方法来访问。根logger没有默认的appender。

x A-x1, A-x2true A1, A-x1, A-x2x和root的appenders x.y none true A1, A-x1, A-x2x和root的appenders

x.y.z A-xyz1true A1, A-x1, A-x2,

A-xyz1

x.y.z和x和root的

appenders

security A-sec false A-sec 由于可添加性为false，所以没有继承的appender。

security.access none true A-sec 只有security的appender，因为security 的可添加性标志为false

4. Layouts

4.1 概念说明

经常，用户希望不但自定义输出源，而且定义输出格式。这是通过在appender上附加一个layout来完成的。layout负责根据用户的希望来格式化日志请求。而appender是负责发送格式化的输出到它的目的地。

PatternLayout，作为Log4j标准版中的一部分，让用户以类似C语言的printf方法的格式来指定日志的输出格式。

例如，转化模式为"%r [%t] %-5p %c - %m%n" 的PatternLayout 将输出类似如下的信息：176 [main] INFO org.foo.Bar - Located nearest gas station.

第一个栏位是自从程序开始后消逝的毫秒数。

第二个栏位是做出日志的线程。

第三个栏位是log的级别。

第四个栏位是日志请求相关的logger的名字。而"-"后的文字是信息的表述。

Log4j将根据用户定义的公式来修饰日志信息的内容。例如，如果你经常需要记录Oranges，一个在你当前的项目被用到的对象类型，那么你可以注册一个OrangeRenderer，它将在一个orange需要被记录时被调用。

对象渲染类似类的结构继承。例如，假设oranges是fruits，如果你注册了一个FruitRenderer，所有的水果包括oranges将被FruitRenderer所渲染。除非你注册了一个orange。

对象渲染必须实现ObjectRenderer接口。

4.2 Layout的配置

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

https://www.wendangku.net/doc/7217072912.html,yout = https://www.wendangku.net/doc/7217072912.html,yout.class

https://www.wendangku.net/doc/7217072912.html,yout.option1 = value1

…

https://www.wendangku.net/doc/7217072912.html,yout.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)

5. 配置

Log4j在程序中有充分的可配置性。然而，用配置文件配置Log4j具有更大的弹性。目前，它的配置文件支持xml和java properties（key=value）文件两种格式。

让我们以一个例子来演示它是如何做的。假定有一个用了Log4j的程序MyApp。

import com.foo.Bar;

// Import Log4j classes.

import org.apache.Log4j.Logger;

import org.apache.Log4j.BasicConfigurator;

public class MyApp {

// Define a static logger variable so that it references the

// Logger instance named "MyApp".

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

public static void main(String[] args) {

// Set up a simple configuration that logs on the console.

BasicConfigurator.configure();

https://www.wendangku.net/doc/7217072912.html,("Entering application.");

Bar bar = new Bar();

bar.doIt();

https://www.wendangku.net/doc/7217072912.html,("Exiting application.");

}

｝

MyApp以引入Log4j的相关类开始，接着它定义了一个静态logger变量，并给予值为"MyApp"类的全路径名称。

MyApp用了定义在包com.foo中的类Bar。

package com.foo;

import org.apache.Log4j.Logger;

public class Bar {

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

public void doIt() {

logger.debug("Did it again!");

}

调用BasicConfigurator.configure()方法创建了一个相当简单的Log4j的设置。它加入一个ConsoleAppender到根logger。输出将被采用了"%-4r [%t] %-5p %c %x - %m%n"模式的PatternLayout所格式化。

注意，根logger默认被分配了Level.DEBUG的级别。

MyApp的输出为：

0 [main] INFO MyApp - Entering application.

36 [main] DEBUG com.foo.Bar - Did it again!

51 [main] INFO MyApp - Exiting application.

随后的图形描述了在调用BasicConfigurator.configure()方法后MyApp的对象图。

图5-1 MyApp对象图

需要提醒的是，Log4j的子logger只连接到已经存在的它们的父代。特别的是，名为com.foo.bar的logger是直接连接到根logger，而不是围绕着没用的com或com.foo logger。这显著的提高了程序性能并且减少的内存占用。

MyApp类配置Log4j是通过调用BasicConfigurator.configure 方法。其它的类仅仅需要引入org.apache.Log4j.Logger 类，找到它们希望用的logger，并且用它就行。

以前的例子通常输出同样的日志信息。幸运的是，修改MyApp是容易的，以便日志输出可以在运行时刻被控制。这里是一个小小修改的版本。

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]);

https://www.wendangku.net/doc/7217072912.html,("Entering application.");

Bar bar = new Bar();

bar.doIt();

https://www.wendangku.net/doc/7217072912.html,("Exiting application.");

}

修改后的 MyApp通知程序调用PropertyConfigurator()方法解析一个配置文件，并且根据这个配置文件来设置日志。

这里是一个配置文件的例子，它将产生同以前BasicConfigurator 基本例子一样的输出结果。

# Set root logger level to DEBUG and its only appender to A1.

Log4j.rootLogger=DEBUG, A1

# A1 is set to be a ConsoleAppender.

Log4j.appender.A1=org.apache.Log4j.ConsoleAppender

# A1 uses PatternLayout.

https://www.wendangku.net/doc/7217072912.html,yout=org.apache.Log4j.PatternLayout

https://www.wendangku.net/doc/7217072912.html,yout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

假设我们不在对com.foo包的任何类的输出感兴趣的话，随后的配置文件向我们展示了实现这个目的的方法之一。

Log4j.rootLogger=DEBUG, A1

Log4j.appender.A1=org.apache.Log4j.ConsoleAppender

https://www.wendangku.net/doc/7217072912.html,yout=org.apache.Log4j.PatternLayout

# Print the date in ISO 8601 format

https://www.wendangku.net/doc/7217072912.html,yout.ConversionPattern=%d [%t] %-5p %c - %m%n

# Print only messages of level WARN or above in the package com.foo.

https://www.wendangku.net/doc/7217072912.html,.foo=WARN

以这个配置文件配置好的MyApp将输出如下：

2000-09-07 14:07:41,508 [main] INFO MyApp - Entering application.

2000-09-07 14:07:41,529 [main] INFO MyApp - Exiting application.

当logger com.foo.bar没有被分配一个级别，它将从com.foo继承，在配置文件中它被设置了WARN的级别。在Bar.doIt方法中定义的log为DEBUG级别，低于WARN，因此doIt() 方法的日志请求被禁用。

这里是另外一个配置文件，它使用了多个appenders.

Log4j.rootLogger=debug, stdout, R

Log4j.appender.stdout=org.apache.Log4j.ConsoleAppender

https://www.wendangku.net/doc/7217072912.html,yout=org.apache.Log4j.PatternLayout

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

https://www.wendangku.net/doc/7217072912.html,yout.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

https://www.wendangku.net/doc/7217072912.html,yout=org.apache.Log4j.PatternLayout

https://www.wendangku.net/doc/7217072912.html,yout.ConversionPattern=%p %t %c - %m%n

以这个配置文件调用加强了的MyApp类将输出如下信息。

INFO [main] (MyApp2.java:12) - Entering application.

DEBUG [main] (Bar.java:8) - Doing it again!

INFO [main] (MyApp2.java:15) - Exiting application.

另外,因为根logger有被分配第二个appender,所以输出也将被定向到example.log文件。这个文件大小达到100kb时将自动备份。备份时老版本的example.log文件自动被移到文件example.log.1中。

注意我们不需要重新编译代码就可以获得这些不同的日志行为。我们一样可以容易的使日志输出到UNIX Syslog daemon，重定向所有的com.foo到NT Event logger，或者转发日志到一个远程的Log4j服务器,它根据本地server的策略来进行日志输出。例如转发日志事件到第二个Log4j服务器。

6. 默认的初始化过程

Log4j类库不对它的环境做任何假设。特别是没有默认的Log4j appender。在一些特别的有着良好定义的环境下，logger的静态inializer将尝试自动的配置Log4j。java语言的特性保证类的静态initializer当且仅当装载类到内存之时只会被调用一次。要记住的重要一点是，不同的类装载器可能装载同一个类的完全不同的拷贝。这些同样类的拷贝被虚拟机认为是完全不相干的。

默认的initialization是非常有用的，特别是在一些应用程序所依靠的运行环境被准确的定位的情况下。例如，同一样的应用程序可以被用做一个标准的应用程序，或一个applet，或一个在web-server控制下的servlet。

准确的默认的initialization原理被定义如下：

(1)设置系统属性Log4j.defaultInitOverride为"false"以外的其它值，那么Log4j将跳过默认

的initialization过程。

(2)设置资源变量字符串给系统属性Log4j.configuration。定义默认initialization文件的最好

的方法是通过系统属性Log4j.configuration。万一系统属性Log4j.configuration没有被定义，那么设置字符串变量resource 给它的默认值Log4j.properties。

(3)尝试转换resource 变量为一个URL。

(4)如果变量resource的值不能被转换为一个URL，例如由于MalformedURLException违

例，那么通过调用org.apache.Log4j.helpers.Loader.getResource(resource, Logger.class) 方法从classpath中搜索resource，它将返回一个URL，并通知"Log4j.properties"的值是一个错误的URL。看See Loader.getResource(https://www.wendangku.net/doc/7217072912.html,ng.String) 查看搜索位置的列表。(5)如果没有URL被发现，那么放弃默认的initialization。否则用URL配置Log4j。

PropertyConfigurator将用来解析URL，配置Log4j，除非URL以".xml"为结尾。在这种情况下的话DOMConfigurator将被调用。你可以有机会定义一个自定义的configurator。

系统属性Log4j.configuratorClass的值取自你的自定义的类名的全路径。自定义的configurator必须实现configurator接口。

7. 配置范例

7.1 Tomcat

Tomcat下的初始化默认的Log4j initialization典型的应用是在web-server 环境下。在tomcat 下，你应该将配置文件Log4j.properties放在你的web应用程序的WEB-INF/classes 目录下。Log4j将发现属性文件，并且以此初始化。这是使它工作的最容易的方法。

8. Nested Diagnostic Contexts

在现实世界中的系统经常不得不同时处理多个客户端请求。在这样的一个典型的多线程的系统中，不同的线程将处理不同的客户端。Logging特别能够适应这种复杂的分布式的应用程序的调试和跟踪。一个常见的区分每个客户端所输出的Logging的方法是为每个客户端实例化一个新的独立的Logger。这导致Logger的大量产生，管理的成本也超过了logging本身。

唯一标识每个log请求是一个轻量级的技术。Neil Harrison 在名为“Patterns for Logging Diagnostic Messages”的书中描述了这个方法in Pattern Languages of Program Design 3, edited by R. Martin, D. Riehle, and F. Buschmann (Addison-Wesley, 1997).

为了唯一标识每个请求，用户把上下文信息推入NDC(Nested Diagnostic Context)中。

NDC类示例如下：

public class NDC {

// Used when printing the diagnostic

public static String get();

// Remove the top of the context from the NDC.

public static String pop();

// Add diagnostic context for the current thread.

public static void push(String message);

// Remove the diagnostic context for this thread.

public static void remove(); s

}

NDC如同一个堆栈样管理每个线程。注意所有the org.apache.log4j.NDC 类的方法都是静态的。假设NDC输出被开启，每次一个log 请求被生成时，适当的log4j组件为将要输出log 的线程包含完整的NDC堆栈。这是在没有用户的干预的情况下做到的，用户只负责在NDC 中定位正确的信息，通过在代码中正确位置插入很少的push和pop方法就行了。相反的，在代码中per-client实现方法有着很大变化。

为了演示这点，让我们以一个发送内容到匿名客户端的servlet为例。这个servlet可以在开始执行每个其他代码前的初始化时建立NDC。上下文信息可以是客户主机的名字和其他的

请求中固有的信息。

典型的信息包括cookies。因此，即使servlet同时为多个客户同时提供服务，log 被同样的代码初始化，例如属于同一个logger，依然可以被区别，因为每个客户请求将有不同的NDC 堆栈。与之相比，Contrast this with the complexity of passing a freshly instantiated logger to all code exercised during the client's request。

不过，一些诡异的程序，例如虚拟主机的web server记录日志，不是一般的依靠虚拟主机的上下文，还要依靠软件的组件发出请求。近来log4j的发布版本支持多层的树形结构。这个增强允许每个虚拟主机可以处理在树型结构中属于它自己的logger。

9. 优化

一个经常引用的依靠于logging的参数是可以计算的花费。这是一个合理的概念，一个适度的应用程序可能产生成千上万个日志请求。许多努力花在测量和调试logging的优化上。Log4j要求快速和弹性：速度最重要，弹性是其次。

用户应该注意随后的优化建议。

9.1 日志为禁用时，日志的优化

当日志被彻底的关闭，一个日志请求的花费等于一个方法的调用加上整数的比较时间。

在233mhz的Pentium II 机器上这个花费通常在5-50纳秒之间。

然而，方法调用包括参数构建的隐藏花费。

例如，对于logger cat，

logger.debug("Entry number: " + i + " is " + String.valueOf(entry));

引起了构建信息参数的花费，例如，转化整数i和entry到一个string，并且连接中间字符串，不管信息是否被输出。这个参数的构建花费可能是很高，它主要决定于被调用的参数的大小。

避免参数构建的花费应如下，

if(logger.isDebugEnabled() {

logger.debug("Entry number: " + i + " is " + String.valueOf(entry[i]));

}

如果logger的debug被关闭这将不会招致参数构建的花费。另一方面，如果logger是debug 的话，它将产生两次判断 logger是否能用的花费。一次是在debugenabled，一次是debug。这是无关紧要的，因为判断日志是否可用只占日志实际花费时间的约1%。

在Log4j里，日志请求在Logger 类的实例里。Logger 是一个类，而不是一个接口。这大量的减少了在方法调用上的弹性化的花费。

当然用户采用预处理或编译时间技术去编译出所有的日志声明。这将导致完美的执行成效。

然而因为二进制应用程序不包括任何的日志声明的结果，日志不可能对那个二进制程序开启。以我的观点，以这种较大的代价来换取较小的性能优化是不值得的。

9.2 当日志状态为启用时，日志的优化

这是本质上的优化logger的层次。当日志状态为开，Log4j依然需要比较请求的级别与logger 的级别。然而，logger可能没有被安排一个级别；它们将从它们的father继承。这样，在继承之前，logger可能需要搜索它的祖先。

这里有一个认真的努力使层次的搜索尽可能的快。例如，子logger仅仅连接到它的存在的father logger。

在先前展示的BasicConfigurator 例子中，名为com.foo.bar 的logger是连接到根logger，因此绕过了不存在的logger com和com.foo。这将显著的改善执行的速度，特别是解析logger 的层结构时。

典型的层次结构的解析的花费是logger彻底关闭时的三倍。

9.3 日志信息的输出时，日志的优化

这是主要花费在日志输出的格式化和发送它到它的输出源上。这里我们再一次的付出努力以使格式化执行的尽可能快。同appender一样。实际上典型的花费大约是100-300毫秒。

详情看org.apache.log4.performance.Logging。

虽然Log4j有许多特点，但是它的第一个设计目标还是速度。一些Log4j的组件已经被重写过很多次以改善性能。不过，投稿者经常提出了新的优化。你应该满意的知道，以SimpleLayout的配置执行测试已经展示了Log4j的输出同System.out.println一样快。

10. 总结

Log4j是一个用java写成的流行的日志包。一个它与众不同的特点是在logger中的继承的概念。用logger的继承可以以任意的间隔控制日志的状态输出。这个减少了体积和最小化日志的代价。

易管理性是Log4j API的优点之一。只要日志定义被加入到代码中，它们就可以用配置文件来控制。它们可以有选择的被禁用，并且按照用户选择好的格式发送到不同的多个输出源上。Log4j的包经过良好的设计成，因此不需花费沉重的执行代价就可以将它们保留在产品中。

11. 附录

11.1 参考文档

Log4j short manual

Log4j 学习笔记 by heavyz

说明：本文主体为log4j short manual，翻译者不可考。其余内容取自互联网，作者不可考。

11.2 比较全面的配置文件

下面的Log4J配置文件实现了输出到控制台、文件、回滚文件、发送日志邮件、输出到数据库日志表、自定义标签等全套功能。

log4j.rootLogger=DEBUG,CONSOLE,A1,im

https://www.wendangku.net/doc/7217072912.html,.apache=true

# 应用于控制台

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender

log4j.appender.Threshold=DEBUG

log4j.appender.CONSOLE.Target=System.out

log4j.appender.CONSOLE.Encoding=GBK

https://www.wendangku.net/doc/7217072912.html,yout=org.apache.log4j.PatternLayout

https://www.wendangku.net/doc/7217072912.html,yout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

#https://www.wendangku.net/doc/7217072912.html,yout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORI TY]%n%x[NDC]%n%t[THREAD] n%c[CATEGORY]%n%m[MESSAGE]%n%n

#应用于文件

log4j.appender.FILE=org.apache.log4j.FileAppender

log4j.appender.FILE.File=file.log

log4j.appender.FILE.Append=false

log4j.appender.FILE.Encoding=GBK

https://www.wendangku.net/doc/7217072912.html,yout=org.apache.log4j.PatternLayout

https://www.wendangku.net/doc/7217072912.html,yout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

# Use this layout for LogFactor 5 analysis

# 应用于文件回滚

log4j.appender.ROLLING_FILE=org.apache.log4j.RollingFileAppender

log4j.appender.ROLLING_FILE.Threshold=ERROR

log4j.appender.ROLLING_FILE.File=rolling.log

log4j.appender.ROLLING_FILE.Append=true

log4j.appender.CONSOLE_FILE.Encoding=GBK

log4j.appender.ROLLING_FILE.MaxFileSize=10KB

log4j.appender.ROLLING_FILE.MaxBackupIndex=1

log4j.appender.ROLLING_https://www.wendangku.net/doc/7217072912.html,yout=org.apache.log4j.PatternLayout

log4j.appender.ROLLING_https://www.wendangku.net/doc/7217072912.html,yout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

#应用于socket

log4j.appender.SOCKET=org.apache.log4j.RollingFileAppender

log4j.appender.SOCKET.RemoteHost=localhost

log4j.appender.SOCKET.Port=5001

log4j.appender.SOCKET.LocationInfo=true

# Set up for Log Facter 5

https://www.wendangku.net/doc/7217072912.html,yout=org.apache.log4j.PatternLayout

https://www.wendangku.net/doc/7217072912.html,yout.ConversionPattern=[start]%d{DATE}[DATE]%n%p[PRIORITY]% n%x[NDC]%n%t[THREAD]%n%c[CATEGORY]%n%m[MESSAGE]%n%n

# Log Factor 5 Appender

log4j.appender.LF5_APPENDER=org.apache.log4j.lf5.LF5Appender

log4j.appender.LF5_APPENDER.MaxNumberOfRecords=2000

# 发送日志给邮件

log4j.appender.MAIL=https://www.wendangku.net/doc/7217072912.html,.SMTPAppender

log4j.appender.MAIL.Threshold=FATAL

log4j.appender.MAIL.BufferSize=10

log4j.appender.MAIL.From=web@https://www.wendangku.net/doc/7217072912.html,

log4j.appender.MAIL.SMTPHost=https://www.wendangku.net/doc/7217072912.html,

log4j.appender.MAIL.Subject=Log4J Message

log4j.appender.MAIL.To=web@https://www.wendangku.net/doc/7217072912.html,

https://www.wendangku.net/doc/7217072912.html,yout=org.apache.log4j.PatternLayout

https://www.wendangku.net/doc/7217072912.html,yout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

# 用于数据库

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

log4j.appender.DATABASE.URL=jdbc:mysql://localhost:3306/test

log4j.appender.DATABASE.driver=com.mysql.jdbc.Driver

https://www.wendangku.net/doc/7217072912.html,er=root

log4j.appender.DATABASE.password=

log4j.appender.DATABASE.sql=INSERT INTO LOG4J (Message) V ALUES ('[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n')

https://www.wendangku.net/doc/7217072912.html,yout=org.apache.log4j.PatternLayout

https://www.wendangku.net/doc/7217072912.html,yout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

# 每天新建日志

log4j.appender.A1=org.apache.log4j.DailyRollingFileAppender

log4j.appender.A1.File=log

log4j.appender.A1.Encoding=GBK

log4j.appender.A1.DatePattern='.'yyyy-MM-dd

https://www.wendangku.net/doc/7217072912.html,yout=org.apache.log4j.PatternLayout

https://www.wendangku.net/doc/7217072912.html,yout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L : %m%n

#自定义Appender

log4j.appender.im = net.cybercorlin.util.logger.appender.IMAppender

log4j.appender.im.host = https://www.wendangku.net/doc/7217072912.html,

https://www.wendangku.net/doc/7217072912.html,ername = username

log4j.appender.im.password = password

log4j.appender.im.recipient = corlin@https://www.wendangku.net/doc/7217072912.html,

https://www.wendangku.net/doc/7217072912.html,yout=org.apache.log4j.PatternLayout

https://www.wendangku.net/doc/7217072912.html,yout.ConversionPattern =[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

11.3 日志乱码的解决

缺省配置下，Log4j的输出内容使用系统默认编码。在中文Windows下，一般不会出现乱码问题。而在Linux/Unix，可能会由于没有设置匹配的系统环境而导致log4j在输出中文时产生乱码，解决方法为：

增加Encoding选项。

例如：

log4j.appender.CONSOLE.Encoding=GBK

appende为文件时，处理方法相同。

详细内容参见：org.apache.log4j.WriterAppender中对encoding的处理。

log4j学习

log4j 如同Hadoop一样，把需要的jar包（hadoop.jar )和配置文件，放到CLASSPATH中，配置Log4j也要如此，把log4j-1.2.8.jar，log4j.properties放到classpath中。配置文件配置的是Log输出到哪里，如何输出，何时输出，哪些类的log要输出（等级）（Where， How，When，Who）代码中用到的 private final Log log = LogFactory.getLog(getClass()); 得到类的全名，Log4j框架就会去找相应的package是否有设置输出log，以及它的等级。如果等级为DEBUG那么log.isDebugEnabled()为true。如下所示，如果等级为INFO，那么log.isInfoEnabled()、log.isWarnEnabled()、log.isErrorEnabled()这三个为true，其他的为false？（有待确认）等级可分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL，如果配置OFF则不打出任何信息，如果配置为INFO这样只显示INFO, WARN, ERROR的log信息，而 DEBUG信息不会被显示，具体讲解可参照第三部分定义配置文件中的logger。 if (log.isDebugEnabled()){ log.debug("111"); } if (log.isInfoEnabled()){ https://www.wendangku.net/doc/7217072912.html,("222"); } 完整的文章如下：在强调可重用组件开发的今天，除了自己从头到尾开发一个可重用的日志操作类外，Apache为我们提供了一个强有力的日志操作包-Log4j。 Log4j是Apache的一个开放源代码项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件、甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。此外，通过Log4j其他语言接口，您可以在C、C++、.Net、PL/SQL程序中使用Log4j，其语法和用法与在Java程序中一样，使得多语言分布式系统得到一个统一一致的日志组件模块。而且，通过使用各种第三方扩展，您可以很方便地将Log4j集成到J2EE、JINI甚至是SNMP应用中。说明：下面分为三部分，第一部分讲解如何配置log4j；第二部分为对log4j.properties配置文件中的各个属性的讲解；第三部分为对log4j的详细讲解。如果只想配置上log4j，那么只需要看前两个部分就可以，如果想对log4j深入了解，则还需看第三部分。一、Log4j配置

Eclipse从入门到精通(第二版)_ch37

第37章在Eclipse中使用Hibernate 本章将把Hibernate应用到myweb项目中，对数据库层的代码进行改造，同时还会介绍一些Hibernate工具的使用。 37.1 概述 37.1.1 持久化框架产生的背景和现状什么叫持久化？数据在内存中，关机后就会丢失。而如果把数据保存到后台的数据库中，就能达到“持久”保存数据的目的。而持久化框架的目的就是为了帮助用户更好地使用数据库。在Java数据库项目中，由于数据库是关系型而非面向对象的。很多时候，用面向对象方法完成了前期的设计和分析，到了数据库层编程时就会变得很别扭，其中最痛苦的就是写面向过程的SQL语句。 J2EE开发主要由JSP、Servlet、JavaBean和EJB 4部分组成。其中EJB是J2EE中一个比较重要的部分，它提供了企业级开发所需的分布式支持。但现实中的大部分项目都是单服务器的轻量级项目，一般都不会涉及分布式的开发环境，这时用EJB就像大炮打蚊子，蚊子没打到，房子却被打破个洞。EJB的笨重和复杂一直让开发者很不满，其中EJB中Entity Bean受到的批评最多，现实项目中鲜有使用Entity Bean的成功范例。开发者急切地需要一种符合Java编程习惯的、适合轻量级开发的、易于使用的数据库持久化解决方案。在这个背景下就产生了轻量级的数据库持久化技术，其中最主要的就是Hibernate、JDO。 Hibernate是一个民间开源项目，有点像一个草莽英雄，但Hibernate从实用出发的设计思路，使得它脱颖而出成为最流行的持久化技术。Hibernate的作者Gavin King也一举成名，现已成为EJB 3.0专家组的成员，并且在EJB 3.0的Entity Bean部分，将采用和Hibernate 类似的设计方案。因此，Hibernate是开发者学习和使用持久化技术的一个比较好的选择，即使以后EJB 3.0一统天下，所学的Hibernate知识也不会浪费。 JDO 2.0是经JCP（Java规范管理委员会，由SUN、IBM、Oracle等共同参与）承认的一个正式规范，所以也受到了开发者很大的关注。估计未来3年内，持久化技术将以EJB 3.0、Hibernate和JDO 2.0为主，成三足鼎立之势。

ElasticSearch5.1 基本概念和配置详解

二、几个基本概念接近实时（NRT） Elasticsearch 是一个接近实时的搜索平台。这意味着，从索引一个文档直到这个文档能够被搜索到有一个很小的延迟（通常是1 秒）。集群（cluster）代表一个集群，集群中有多个节点（node），其中有一个为主节点，这个主节点是可以通过选举产生的，主从节点是对于集群内部来说的。es的一个概念就是去中心化，字面上理解就是无中心节点，这是对于集群外部来说的，因为从外部来看es集群，在逻辑上是个整体，你与任何一个节点的通信和与整个es集群通信是等价的。索引（index）

ElasticSearch将它的数据存储在一个或多个索引（index）中。用SQL领域的术语来类比，索引就像数据库，可以向索引写入文档或者从索引中读取文档，并通过ElasticSearch内部使用Lucene将数据写入索引或从索引中检索数据。文档（document）文档（document）是ElasticSearch中的主要实体。对所有使用ElasticSearch 的案例来说，他们最终都可以归结为对文档的搜索。文档由字段构成。映射（mapping）所有文档写进索引之前都会先进行分析，如何将输入的文本分割为词条、哪些词条又会被过滤，这种行为叫做映射（mapping）。一般由用户自己定义规则。类型（type）每个文档都有与之对应的类型（type）定义。这允许用户在一个索引中存储多种文档类型，并为不同文档提供类型提供不同的映射。分片（shards）代表索引分片，es可以把一个完整的索引分成多个分片，这样的好处是可以把一个大的索引拆分成多个，分布到不同的节点上。构成分布式搜索。分片的数量只能在索引创建前指定，并且索引创建后不能更改。副本（replicas）代表索引副本，es可以设置多个索引的副本，副本的作用一是提高系统的容错性，当个某个节点某个分片损坏或丢失时可以从副本中恢复。二是提高es的查询效率，es会自动对搜索请求进行负载均衡。数据恢复（recovery）

log4j和slf4j日志框架入门

Java私塾《日志框架入门》 ——深入浅出系列精品教程

Log4j是什么、有什么 n介绍 Log4j是Apache的一个开放源代码项目，通过使用Log4j，可以控制日志信息输送的目的地是控制台、文件、GUI组件、甚至是套接口服务器、NT的事件记录器等；也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，能够更加细致地控制日志的生成过程。这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。 n是什么一个开源的、轻量级的、用于日志管理的框架 n有什么 Log4j由三个重要的组件构成：日志信息的输出格式，日志信息的优先级，日志信息的输出目的地。日志信息的优先级用来指定这条日志信息的重要程度；日志信息的输出目的地指定了日志将打印到控制台还是文件中；而输出格式则控制了日志信息的显示内容。真正高质量培训签订就业协议网址：https://www.wendangku.net/doc/7217072912.html,

Log4j能干什么 n能干什么主要用来进行日志记录的管理，包括对日志输出的目的地，输出的信息级别和输出的格式等。 n日志类别的层次结构(Loggers) Log4j首要的相对于简单的使用System.out.println()方法的优点是基于它的在禁止一些特定的信息输出的同时不妨碍其它信息的输出的能力。这个能力源自于日志命名空间，也就是说，所有日志声明的空间，它根据一些开发员选择的公式而分类。 Logger被指定为实体，Logger的名字是大小写敏感的，它们遵循以下的命名语法规则：用“.”来划分层次级别，如：cn.javass.test 真正高质量培训签订就业协议网址：https://www.wendangku.net/doc/7217072912.html,

log4j2中文手册

Log4j2使用手册一．Log4j2介绍 Log4j1.x被广泛应用于应用程序，但是近年发展明显放缓，因为要维持较老java版本的使用，使得log4j1.x的发展更困难。而作为其代替品，slf4j/logback做出了许多必要改进，为什么还需要log4j2? 主要有以下几个原因: (1)Log4j2被设计用作审计日志框架, log4j和logback在重载配置时，都会丢失日志时间，而log4j2不会。Logback 中appenders中的异常对于应用来说是不可见的，log4j2可以配置异常向应用渗透。 (2)Log4j2 包含基于LMAX Disruptor library的下一代无锁Asynchronous Loggers，在多线程环境下， Asynchronous Loggers相比slf4j/ logback提高了10倍以上的吞吐量，并且有着更低的延时。 (3)Log4j2的插件机制，使得在不需要修改框架的情况下，通过添加 Appenders, Filters, Layouts, Lookups轻松扩展框架。 (4)简单的插件配置，无需指定具体类名即可在configuration中配置插件。 (5)支持自定义日志级别，可以在代码或者configuration中自定义日志级别。 (6)支持lambda表达式，java8的应用可以在请求日志级别启用时使用lambda表达式懒构建一个日志消息，不需要显示的日志级别检查，使得代码更简洁。 (7)支持消息对象，消息允许支持有趣和复杂的结构，传递到日志记录系统，并且可以高效的操作。用户可以自由创建消息类型和编写Layouts, Filters and Lookups来操作这些消息。 (8)Log4j1在Appenders 上支持Filters 。logback增加了TurboFilters ，允许在日志事件在处理前进行过滤。Log4j2 可以配置Filters在Logger后者Appender前运行。 (9)许多Logback的Appenders不接受Layout，并且只能按照固定格式发送日志数据。大部分log4j2接收Layout 配置，允许日志数据按照任何所需格式传输。 (10)Log4j1与logback的Layouts是返回一个String类型，这可能导致一些编码问题。Log4j2使用了简单的方式：

log4j.properties配置文件配置项的说明

在程序中，可以以以下方式来使用 Log log = https://www.wendangku.net/doc/7217072912.html,mons.logging.LogFactory.LogFactory.getLog(yourClassName.class); log.debug("debug message -------------------"); https://www.wendangku.net/doc/7217072912.html,("inf o message ******************"); log.warn("w arn message +++++++++++++++"); log.error("error msg================="); 本文主要讲的是如何配置log4j，先让我们先看看一个典型的log4j配置： ==========log4j.properties================== log4j.appender.stdout=org.apache.log4j.ConsoleAppender https://www.wendangku.net/doc/7217072912.html,yout=org.apache.log4j.PatternLayout https://www.wendangku.net/doc/7217072912.html,yout.ConversionPattern=%d{MM-dd HH\:mm\:ss.SSS} %-5p [%F\:%L]%x %m%n log4j.appender.f ileout=org.apache.log4j.RollingFileAppender log4j.appender.f ileout.File=D:/w orkspace/log4jtest/log/application.log log4j.appender.f ileout.MaxFileSize=10000KB log4j.appender.f ileout.MaxBackupI ndex=10 log4j.appender.f https://www.wendangku.net/doc/7217072912.html,yout=org.apache.log4j.PatternLayout log4j.appender.f https://www.wendangku.net/doc/7217072912.html,yout.ConversionPattern=%d{MM-dd HH:mm:ss.SSS}[%24F:%-3L:%-5p]%x %m%n log4j.rootCategory=INF O, stdout, fileout https://www.wendangku.net/doc/7217072912.html,.wolf square.log2=DEB UG,stdout =================================== 这个文件可以划为三小块 ===========第一块定义了一个名为 stdout 的appender和layout (appender,layout的概念后面再解释，目前先记着有这样两个名词)：log4j.appender.stdout=org.apache.log4j.ConsoleAppender 定义stdout的实际输出实现类，从这个appender实现类名可以猜到，这个类是负责控制台输出的。 https://www.wendangku.net/doc/7217072912.html,yout=org.apache.log4j.PatternLayout 定义stdout的输出装饰器 https://www.wendangku.net/doc/7217072912.html,yout.ConversionPattern=%d{MM-dd HH\:mm\:ss.SSS} %-5p [%F\:%L]%x %m%n 装饰器参数配置 ============第二块定义了一个名为 fileout 的appender和layout: log4j.appender.f ileout=org.apache.log4j.RollingFileAppender 同理可猜这个实现类是输出到文件的 log4j.appender.f ileout.File=D:/w orkspace/log4jtest/log/application.log log4j.appender.f ileout.MaxFileSize=10000KB log4j.appender.f ileout.MaxBackupI ndex=10 log4j.appender.f https://www.wendangku.net/doc/7217072912.html,yout=org.apache.log4j.PatternLayout log4j.appender.f https://www.wendangku.net/doc/7217072912.html,yout.ConversionPattern=%d{MM-dd HH:mm:ss.SSS}[%24F:%-3L:%-5p]%x %m%n ============第三块定义了名字分别为rootCategory,https://www.wendangku.net/doc/7217072912.html,.wolf square.log2的两个logger log4j.rootCategory=INF O, stdout, fileout https://www.wendangku.net/doc/7217072912.html,.wolf square.log2=DEB UG,stdout rootCategory logger是缺省的logger，记录所有的包的信息输出。第二个logger是只输出指定包com.w olf square.log2下的日志信息。

SSH三大框架整合(详细版)

1：构建WEB项目 2：构建数据库 3：加入依赖包尽量不要依赖IDE，通过自己手动加包完成访问数据库需要的包：mysql的驱动包 Hibernate的包：hibernate3.jar 核心包依赖的必须包：antlr-2.7.6.jar 用于解析成HQL语句的包 commons-collections-3.1.jar apache提供的包，提供对集合框架的增强 dom4j-1.6.1.jar 解析XML文件的包 javassist-3.9.0.GA.jar 动态修改字节码需要用到的包 jta-1.1.jar 用于JTA事务的包 slf4j-api-1.5.8.jar 日志接口包---》依赖一定的实现包 slf4j-log4j12-1.5.0.jar log4j.jar 另外一种实现包：slf4j-simple-1.5.10.jar 可选的包：c3p0-0.9.1.jar 用于创建C3P0连接池的包 ehcache-1.2.3.jar ：用于缓存实现的包 cglib-2.2.jar 动态修改字节码的包 Spring的包：spring.jar 核心包 aopalliance.jar 使用Aop功能可以用到的包 aspectjrt.jar aspectjweaver.jar 使用ASPECTJ表达式需要用到的包如果是使用DBCP连接池的话，需要两个jar包 commons-dbcp.jar commons-pool.jar 如果需要用到commons增加包的话，可以加入以下包 commons-beanutils.jar commons-lang.jar commons-logging.jar Struts2的包：commons-fileupload-1.2.1.jar commons-io-1.3.2.jar freemarker-2.3.13.jar ：在Struts2 中默认使用的是FreeMarker模板引擎 ognl-2.6.11.jar ：Struts2中使用OGNL表达式 struts2-core-2.1.6.jar 核心包 xwork-2.1.2.jar 核心包 struts2-spring-plugin-2.1.6.jar Struts2跟Spring整合需要的插件包 4：构建项目分包结构 5：放置配置文件 6：创建POJO和相对应的hbm.xml 7：修改空白的Hibernate.cfg..xml并创建表结构 8：创建DAO,SERVICE,ACTION 9：修改配置文件

一份比较完整的log4j的xml配置

须og4项须og4项..xm须须og4项须ogger Logger.getRootLogger() 须ogger Logger.getLogger(String name) 须ogger Logger.getLogger(C须ass c须azz) Logger.getLogger(c须azz.getName()) (.setLeve须(int,Exception)) Leve须.ALL Leve须.DEB此G Leve须.INFO Leve须.WARN Leve须.ERROR Leve须.FA正AL Leve须.OFF Appender(.addAppender(Appender).setAdditivity(boo须ean additive) ) org.apache.须og4项.Conso须eAppender targer: Conso须eAppender.SYS正EM_O此正(Defau须t) Conso须eAppender.SYS正EM_ERR pub须ic Conso须eAppender(Layout) pub须ic Conso须eAppender(Layout,String targer) org.apache.须og4项.Fi须eAppender pub须ic Fi须eAppender(Layout,String fi须eName) pub须ic Fi须eAppender(Layout,String fi须eName,boo须ean append) org.apache.须og4项.Dai须yRo须须ingFi须eAppender , org.apache.须og4项.Ro须须ingFi须eAppender , pub须ic Ro须须ingFi须eAppender(Layout,String fi须eName) void setMaxBac顺upIndex(int index) void setMaximumFi须eSize(须ong size) org.apache.须og4项.WriterAppender org.apache.须og4项.JDBCAppender (Layout) %c %d %f %须

log4j教程

以前都是把所有日志都输出到一个文件下面，今天有个同事问想把某个包下的日志输出到指定的地方，于是就在网上查了一些资料，总结一下，以免以后用到。一、log4j是什么? Log4j是一个开源的日志记录组件，其产品已经相当的成熟，且使用非常的广泛。在工程中以易用，方便等代替了 System.out 等打印语句。 Log4j的目标是：它允许开发人员以任意的精细程度控制哪些日志说明被输出。通过使用外部的配置文件，可以在运行时配置它。 Log4j的具体在 https://www.wendangku.net/doc/7217072912.html,/log4j/找到它（有使用的文档说明）。另外，log4j已经被转换成 C, C++, C#, Perl, Python, Ruby, 和 Eiffel 语言。二、通常我们建立一个log4j.properties文件放在src下，编译之后就生成在../web- inf/class/当然也可以放到其它任何目录，只要该目录被包含到类路径中即可，中定位这个文件，并读入这个文件完成的配置。这个配置文件告诉Log4J以什么样的格式、把什么样的信息、输出到什么地方。 Log4j有三个主要的组件：Loggers(记录器)，Appenders(输出源)和Layouts(布局)，这里可简单理解为日志类别，日志要输出的地方和日志以何种形式输出。综合使用这三个组件可以轻松的记录信息的类型和级别，并可以在运行时控制日志输出的样式和位置。下面对三个组件分别进行说明： 1、 Loggers Loggers组件在此系统中被分为五个级别：DEBUG、INFO、WARN、ERROR和FATAL。这五个级别是有顺序的，DEBUG Log4j有一个规则：假设Loggers级别为P，如果在Loggers中发生了一个级别Q比P高，则可以启动，否则屏蔽掉。假设你定义的级别是info，那么error和warn的日志可以显示而比他低的debug信息就不显示了。其语法表示为： org.apache.log4j.ConsoleAppender（控制台） org.apache.log4j.FileAppender（文件） org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）

Log4j 日志内容详解

Log4j详细解 1.1. 背景在应用程序中添加日志记录总的来说基于三个目的：监视代码中变量的变化情况，周期性的记录到文件中供其他应用进行统计分析工作；跟踪代码运行时轨迹，作为日后审计的依据；担当集成开发环境中的调试器的作用，向文件或控制台打印代码的调试信息。最普通的做法就是在代码中嵌入许多的打印语句，这些打印语句可以输出到控制台或文件中，比较好的做法就是构造一个日志操作类来封装此类操作，而不是让一系列的打印语句充斥了代码的主体。 1.2. Log4j简介在强调可重用组件开发的今天，除了自己从头到尾开发一个可重用的日志操作类外，Apache为我们提供了一个强有力的日志操作包-Log4j。 Log4j是Apache的一个开放源代码项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件、甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。此外，通过Log4j其他语言接口，您可以在C、C+ +、.Net、PL/SQL程序中使用Log4j，其语法和用法与在Java程序中一样，使得多语言分布式系统得到一个统一一致的日志组件模块。而且，通过使用各种第三方扩展，您可以很方便地将Log4j集成到J2EE、JINI 甚至是SNMP应用中。 Log4j有三个主要的组件： Loggers(记录器)，Appenders (输出源)和Layouts(布局)，这里可简单理解为日志类别，日志要输出的地方和日志以何种形式输出。综合使用这三个组件可以轻松的记录信息的类型和级别，并可以在运行时控制日志输出的样式和位置。下面对三个组件分别进行说明：1、Loggers Loggers组件在此系统中被分为五个级别：DEBUG、INFO、W ARN、ERROR和FATAL。这五个级别是有顺序的，DEBUG < INFO < W ARN < ERROR < FATAL，分别用来指定这条日志信息的重要程度,明白这一点很重要，这里Log4j有一个规则：假设Loggers级别为P，如果在Loggers中发生了一个级别Q比P高，则可以启动，否则屏蔽掉。假设你定义的级别是info，那么error和warn的日志可以显示而比他低的debug信息就不显示了。 Java程序举例来说： ***建立Logger的一个实例，命名为“com.foo”*** Logger logger = Logger.getLogger("com.foo"); ***"com.foo"是实例进行命名，也可以任意*** ***设置logger的级别。通常不在程序中设置logger的级别。一般在配置文件中设置。*** logger.setLevel(https://www.wendangku.net/doc/7217072912.html,); Logger barlogger = Logger.getLogger("com.foo.Bar"); ***下面这个请求可用，因为W ARN >= INFO*** logger.warn("Low fuel level."); ***下面这个请求不可用，因为DEBUG < INFO*** logger.debug("Starting search for nearest gas station.");

Log4j.properties配置详解

Log4j.properties配置详解一、Log4j简介 Log4j有三个主要的组件：Loggers(记录器)，Appenders (输出源)和Layouts(布局)。这里可简单理解为日志类别，日志要输出的地方和日志以何种形式输出。综合使用这三个组件可以轻松地记录信息的类型和级别，并可以在运行时控制日志输出的样式和位置。 1、Loggers Loggers组件在此系统中被分为五个级别：DEBUG、INFO、WARN、ERROR和FATAL。这五个级别是有顺序的，DEBUG < INFO < WARN < ERROR < FATAL，分别用来指定这条日志信息的重要程度，明白这一点很重要，Log4j有一个规则：只输出级别不低于设定级别的日志信息，假设Loggers级别设定为INFO，则INFO、WARN、ERROR和FATAL级别的日志信息都会输出，而级别比INFO低的DEBUG则不会输出。 2、Appenders 禁用和使用日志请求只是Log4j的基本功能，Log4j日志系统还提供许多强大的功能，比如允许把日志输出到不同的地方，如控制台（Console）、文件（Files）等，可以根据天数或者文件大小产生新的文件，可以以流的形式发送到其它地方等等。常使用的类如下： org.apache.log4j.ConsoleAppender（控制台） org.apache.log4j.FileAppender（文件） org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件） org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件）org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）配置模式： log4j.appender.appenderName = className log4j.appender.appenderName.Option1 = value1 … log4j.appender.appenderName.OptionN = valueN 3、Layouts 有时用户希望根据自己的喜好格式化自己的日志输出，Log4j可以在Appenders的后面附加Layouts来完成这个功能。Layouts提供四种日志输出样式，如根据HTML样式、自由指定样式、包含日志级别与信息的样式和包含日志时间、线程、类别等信息的样式。常使用的类如下： org.apache.log4j.HTMLLayout（以HTML表格形式布局） org.apache.log4j.PatternLayout（可以灵活地指定布局模式） org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串） org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等信息）配置模式： https://www.wendangku.net/doc/7217072912.html,yout =className https://www.wendangku.net/doc/7217072912.html,yout.Option1 = value1 https://www.wendangku.net/doc/7217072912.html,yout.OptionN = valueN 二、配置详解在实际应用中，要使Log4j在系统中运行须事先设定配置文件。配置文件事实上也就是对Logger、Appender及Layout进行相应设定。Log4j支持两种配置文件格式，一种是

log4j.properties详解与例子

首先，在项目中的classes 中新建立一个log4j.properties文件即可；在实际编程时，要使Log4j真正在系统中运行事先还要对配置文件进行定义。定义步骤就是对Logger、Appender及Layout的分别使用。Log4j支持两种配置文件格式，一种是XML格（这里只说明properties 【Java特性文件（键=值）】。式的文件，一种是java properties（key=value）文件） 1、配置根Logger 其语法为： log4j.rootLogger = [ level ] , appenderName1, appenderName2, … level : 是日志记录的优先级，分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者您定义的级别。Log4j建议只使用四个级别，优先级从高到低分别是ERROR、WARN、INFO、DEBUG。通过在这里定义的级别，您可以控制到应用程序中相应级别的日志信息的开关。比如在这里定义了INFO级别，则应用程序中所有DEBUG级别的日志信息将不被打印出来。appenderName:就是指定日志信息输出到哪个地方。您可以同时指定多个输出目的地。例如：log4j.rootLogger＝info,A1,B2,C3 2、配置日志信息输出目的地其语法为： log4j.appender.appenderName = https://www.wendangku.net/doc/7217072912.html,.of.appender.class // "https://www.wendangku.net/doc/7217072912.html,.of.appender.class" 可以指定下面五个目的地中的一个： https://www.wendangku.net/doc/7217072912.html,.apache.log4j.ConsoleAppender（控制台） https://www.wendangku.net/doc/7217072912.html,.apache.log4j.FileAppender（文件） https://www.wendangku.net/doc/7217072912.html,.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件） https://www.wendangku.net/doc/7217072912.html,.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件） https://www.wendangku.net/doc/7217072912.html,.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方） 1.ConsoleAppender选项 Threshold=WARN:指定日志消息的输出最低层次。 ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。 Target=System.err：默认情况下是：System.out,指定输出控制台 2.FileAppender 选项 Threshold=WARN:指定日志消息的输出最低层次。 ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。 File=mylog.txt:指定消息输出到mylog.txt文件。 Append=false:默认值是true,即将消息增加到指定文件中，false指将消息覆盖指定的文件内容。 3.DailyRollingFileAppender 选项 Threshold=WARN:指定日志消息的输出最低层次。 ImmediateFlush=true:默认值是true,意谓着所有的消息都会被立即输出。 File=mylog.txt:指定消息输出到mylog.txt文件。

SSH(整合)简单登录过程详解

MyEclipse开发SSH（Struts+Spring+Hibernate）范例1. 准备工具：MyEclipse 5.1.0 GA、Tomcat 5.5 环境：Struts1.1、Spring1.2、Hibernate3.1、sqlserver2000 1.1. 新建工程本范例使用最简单的登录模块来实践SSH的开发，旨在体会和入门SSH技术的整合操作：[Menu] File/New/Web Project 工程名：login 2. Struts 部分 2.1. 添加Struts 功能支持操作：[Menu] MyEclipse/Project Capabilities/Add Struts Capabilities

修改web.xml 分别创建index.jsp、login.jsp、success.jsp先不对jsp页面做任何修改2.2. 创建ActionForm 类操作：[Ctrl+N] MyEclipse/Web-Struts/Struts 1.1 Form 类名：LoginForm

在"Form Properties" 选项卡为loginForm 新增两个属性：username、password； 2.3. 创建Action 类类名：LoginAction

在"Form" 选项卡的"Name" 项选择"loginForm"，"Input Source" 项输入"/login.jsp"。在Forwards中创建两个forward对象 success登录成功，跳转到success.jsp fail登录失败，跳转到login.jsp重新登录此时struts-config.xml代码如下 2.4. 修改jsp 文件 index.jsp代码

jboss5.0的详细配置

一．下载与安装JBoss 在本文中，我们下载的JBoss版本为：4.2.1.GA。下载地址： https://www.wendangku.net/doc/7217072912.html, 在如上的下载页中下载JBoss-4.2.1.GA.zip文件。下载完成后，将其解压缩后即可完成安装，解压缩后将其放置到一个不带空格的目录(若目录带有空格，例如：C:"Program Files，日后可能会产生一些莫名的错误)，eg：E:"JBoss4.2.1。同时在“环境变量设置”中设置名为JBOSS_HOME的环境变量，值为JBoss的安装路径，如下图所示：在此，JBoss的安装工作已经结束，可通过如下方式测试安装是否成功：运行JBoss安装目录"bin"run.bat，如果窗口中没有出现异常，且出现：10:16:19,765 INFO [Server] JBoss (MX MicroKernel) [4.2.1.GA (build: SVNTag=JBoss_4_2_1_GA date=200707131605)] Started in 30s:828ms字样，则表示安装成功。我们可以通过访问：http://localhost:8080/进入JBoss的欢迎界面，点击JBoss Management下的JMX Console可进入JBoss的控制台。若启动失败，可能由以下原因引起： 1）JBoss所用的端口（8080，1099，1098，8083等）被占用。一般情况下为8080端口被占用（例如，Oracle占用了8080端口），此时需要修改JBoss的端口，方法为进入JBoss安装目录"server"default"deploy"jboss-web.deployer目录，修改其下的server.xml目录，在此文件中搜索8080，将其改成你想要的端口即可（例如8088）； 2）JDK安装不正确； 3）JBoss下载不完全。二．JBoss的目录结构说明

log4j详解与实战

log4j是一个非常强大的log记录软件，下面我们就来看看在项目中如何使 log4j。首先当然是得到log4j的jar档，推荐使用1.2.X版，下载地址： https://www.wendangku.net/doc/7217072912.html,/log4j/1.2/download.html 我们先看一个最简单的示例：【示例1】项目结构：【注：由于这里的多个项目公用一个jar档，我们可以创建一个专门放置jar 档的Java工程，然后将jar档放到lib目录下。在要使用的工程中按图所示进行引用】

Java代码： Java代码 1.package com.coderdream.log4j; 2. 3.import org.apache.log4j.Logger; 4. 5.public class HelloLog4j { 6. 7. private static Logger logger = Logger.getLogger(HelloLog4j. class); 8. 9. /** 10. * @param args 11. */

12. public static void main(String[] args) { 13. // System.out.println("This is println message."); 14. 15. // 记录debug级别的信息 16. logger.debug("This is debug message."); 17. // 记录info级别的信息 18. https://www.wendangku.net/doc/7217072912.html,("This is info message."); 19. // 记录error级别的信息 20. logger.error("This is error message."); 21. } 22.} 配置文件log4j.properties: Properties代码 1.#可以设置级别：debug>info>error 2.#debug：显示debug、info、error 3.#info：显示info、error 4.#error：只error 5.log4j.rootLogger=debug,appender1 6.#log4j.rootLogger=info,appender1 7.#log4j.rootLogger=error,appender1 8. 9.#输出到控制台 10.log4j.appender.appender1=org.apache.log4j.ConsoleAppender 11.#样式为TTCCLayout https://www.wendangku.net/doc/7217072912.html,yout=org.apache.log4j.TTCCLayout 输出结果： Console代码 1.[main] DEBUG com.coderdream.log4j.HelloLog4j - This is debug me ssage. 2.[main] INFO com.coderdream.log4j.HelloLog4j - This is info mess age. 3.[main] ERROR com.coderdream.log4j.HelloLog4j - This is error me ssage. 通过配置文件可知，我们需要配置3个方面的内容： 1、根目录（级别和目的地）；

【2020最新Java面试题资料】20道顶尖的Spring Boot面试题

面试了一些人，简历上都说自己熟悉Spring Boot, 或者说正在学习Spring Boot，一问他们时，都只停留在简单的使用阶段，很多东西都不清楚，也让我对面试者大失所望。下面，我给大家总结下有哪些Spring Boot 的面试题，这是我经常拿来问面试者的，希望对你有帮助。 1、什么是Spring Boot？ Spring Boot 是Spring 开源组织下的子项目，是Spring 组件一站式解决方案，主要是简化了使用Spring 的难度，简省了繁重的配置，提供了各种启动器，开发者能快速上手。 Spring Boot 详细介绍请看这篇文章《什么是Spring Boot?》。 2、为什么要用Spring Boot？ Spring Boot 优点非常多，如： ?独立运行 ?简化配置 ?自动配置 ?无代码生成和XML配置 ?应用监控 ?上手容易

?... Spring Boot 集这么多优点于一身，还有理由不使用它呢？ 3Spring Boot 的核心配置文件有哪几个？它们的区别是什么？ Spring Boot 的核心配置文件是application 和bootstrap 配置文件。 application 配置文件这个容易理解，主要用于Spring Boot 项目的自动化配置。bootstrap 配置文件有以下几个应用场景。 ?使用Spring Cloud Config 配置中心时，这时需要在bootstrap 配置文件中添加连接到配置中心的配置属性来加载外部配置中心的配置信息； ?一些固定的不能被覆盖的属性； ?一些加密/解密的场景；具体请看这篇文章《Spring Boot 核心配置文件详解》。 4Spring Boot 的配置文件有哪几种格式？它们有什么区别？ .properties 和.yml，它们的区别主要是书写格式不同。 1).properties https://www.wendangku.net/doc/7217072912.html,=javastack