log4j基础

log4j配置文件位置详解

 

自动加载配置文件：

（1）如果采用log4j输出日志，要对log4j加载配置文件的过程有所了解。log4j启动时，默认会寻找source folder下的log4j.xml配置文件，若没有，会寻找log4j.properties文件。然后加载配置。配置文件放置位置正确，不用在程序中手动加载log4j配置文件。如果将配置文件放到了config文件夹下，在build Path中设置下就好了。

若要手动加载配置文件如下：

（1）PropertyConfigurator.configure("log4j.properties") 默认读取的是项目根目录的路径。此时的log4j.properties要放在项目目录下。

如图，log4j.properties和src是同级目录，同在根目录下

 

（2）一般，一个java项目会有很多的配置文件，建议把所有的配置文件放到一个文件夹下，

例如，放到config文件夹。那么在读取这些配置文件的时候要加上子目录名称。

如图在项目目录下创建config文件夹（注意：不是在src文件下）,此时，config和src是同级目录

这时，读取路径改为：

PropertyConfigurator.configure("config/log4j.properties");

（3）：如果不手动设置，不用人为的写加载log.properties文件的代码时，直接放src目录下，千万要记得，如果新建一个JAVA项目，src文件要弄成原文件包才行

我就是用的这个

（4）项目打成jar包时，一般不会把配置文件也打进jar包。

如果是第一种方式，直接将log4j.properties文件和生成的HelloWorld.jar放在同一目录下，项目就能顺利读取配置文件。

如果是第二种方式，要建立config文件夹，把配置文件放入其中，再将config文件和生成的HelloWorld.jar放在同一目录下，项目就能顺利读取配置文件。

 思考：log4j.properties配置文件，配置简单，但不支持复杂过滤器filter，log4j.xml虽然配置文件看似复杂，但支持复杂过滤器和Log4j的新特性。推荐使用log4j.xml

 

 

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

 

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

http://logging.apache.org/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.         logger.info("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  
12. log4j.appender.appender1.layout=org.apache.log4j.TTCCLayout  

 

输出结果：

 

Console代码   

1. [main] DEBUG com.coderdream.log4j.HelloLog4j - This is debug message.  
2. [main] INFO com.coderdream.log4j.HelloLog4j - This is info message.  
3. [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文件

 

Porperties代码   

1. #设置级别：  
2. log4j.rootLogger=debug,appender1  
3.   
4. #输出到文件(这里默认为追加方式)  
5. log4j.appender.appender1=org.apache.log4j.FileAppender  
6. #设置文件输出路径  
7. #【1】文本文件  
8. #log4j.appender.appender1.File=c:/Log4JDemo02.log  
9. #【2】HTML文件  
10. log4j.appender.appender1.File=c:/Log4JDemo02.html  
11. #设置文件输出样式  
12. #log4j.appender.appender1.layout=org.apache.log4j.TTCCLayout  
13. log4j.appender.appender1.layout=org.apache.log4j.HTMLLayout  

 

 

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

 

Properties代码   

1. #设置级别和多个目的地  
2. log4j.rootLogger=debug,appender1,appender2  
3.   
4. #输出到控制台  
5. log4j.appender.appender1=org.apache.log4j.ConsoleAppender  
6. #设置输出样式  
7. log4j.appender.appender1.layout=org.apache.log4j.TTCCLayout  
8.   
9. #输出到文件(这里默认为追加方式)  
10. log4j.appender.appender2=org.apache.log4j.FileAppender  
11. #设置文件输出路径  
12. #【1】文本文件  
13. #log4j.appender.appender2.File=c:/Log4JDemo02.log  
14. #【2】HTML文件  
15. log4j.appender.appender2.File=c:/Log4JDemo02.html  
16. #设置文件输出样式  
17. #log4j.appender.appender2.layout=org.apache.log4j.TTCCLayout  
18. log4j.appender.appender2.layout=org.apache.log4j.HTMLLayout  

 

【示例4】 SimpleLayout样式

 

Properties代码   

1. #设置级别和目的地  
2. log4j.rootLogger=debug,appender1  
3.   
4. #输出到控制台  
5. log4j.appender.appender1=org.apache.log4j.ConsoleAppender  
6. #设置输出样式  
7. log4j.appender.appender1.layout=org.apache.log4j.SimpleLayout  

 

  输出结果：

 

控制台代码   

1. DEBUG - This is debug message.  
2. INFO - This is info message.  
3. ERROR - This is error message.  

 

【示例5】 自定义样式

 

Java代码   

1. #设置级别和目的地  
2. log4j.rootLogger=debug,appender1  
3.   
4. #输出到控制台  
5. log4j.appender.appender1=org.apache.log4j.ConsoleAppender  
6. #设置输出样式  
7. log4j.appender.appender1.layout=org.apache.log4j.PatternLayout  
8. #自定义样式  
9. # %r 时间 0  
10. # %t 方法名 main  
11. # %p 优先级 DEBUG/INFO/ERROR  
12. # %c 所属类的全名(包括包名)  
13. # %l 发生的位置，在某个类的某行  
14. # %m 输出代码中指定的讯息，如log(message)中的message  
15. # %n 输出一个换行  
16.   
17. log4j.appender.appender1.layout.ConversionPattern=%r [%t] [%p] - %c -%l -%m%n  

 

输出结果：

 

控制台代码   

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

 

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

 

Properties代码   

1. #设置级别和目的地  
2. log4j.rootLogger=debug,appender1,appender2  
3.   
4. #输出到控制台  
5. log4j.appender.appender1=org.apache.log4j.ConsoleAppender  
6. #设置输出样式  
7. log4j.appender.appender1.layout=org.apache.log4j.PatternLayout  
8. #自定义样式  
9. # %r 时间 0  
10. # %t 方法名 main  
11. # %p 优先级 DEBUG/INFO/ERROR  
12. # %c 所属类的全名(包括包名)  
13. # %l 发生的位置，在某个类的某行  
14. # %m 输出代码中指定的讯息，如log(message)中的message  
15. # %n 输出一个换行符号  
16. log4j.appender.appender1.layout.ConversionPattern=[%d{yy/MM/dd HH:mm:ss:SSS}][%C-%M] %m%n  
17.   
18. #输出到文件(这里默认为追加方式)  
19. log4j.appender.appender2=org.apache.log4j.FileAppender  
20. #设置文件输出路径  
21. #【1】文本文件  
22. log4j.appender.appender2.File=c:/Log4JDemo06.log  
23. #设置文件输出样式  
24. log4j.appender.appender2.layout=org.apache.log4j.PatternLayout  
25. log4j.appender.appender2.layout.ConversionPattern=[%d{HH:mm:ss:SSS}][%C-%M] -%m%n  

 

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

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

 

Java代码   

1. package com.coderdream.log4jDao;  
2.   
3. import org.apache.log4j.Logger;  
4.   
5. public class HelloDao {  
6.     private static Logger logger = Logger.getLogger(HelloDao.class);  
7.   
8.     /** 
9.      * @param args 
10.      */  
11.     public static void main(String[] args) {  
12.         // 记录debug级别的信息  
13.         logger.debug("This is debug message from Dao.");  
14.         // 记录info级别的信息  
15.         logger.info("This is info message from Dao.");  
16.         // 记录error级别的信息  
17.         logger.error("This is error message from Dao.");  
18.     }  
19. }  

 

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

 

 

Properties代码   

1. #省略根，只设置特定包的级别和目的地  
2. log4j.logger.com.coderdream.log4j=debug,appender1  
3. log4j.logger.com.coderdream.log4jDao=info,appender1,appender2  
4.   
5. #输出到控制台  
6. log4j.appender.appender1=org.apache.log4j.ConsoleAppender  
7. #设置输出样式  
8. log4j.appender.appender1.layout=org.apache.log4j.PatternLayout  
9. #自定义样式  
10. # %r 时间 0  
11. # %t 方法名 main  
12. # %p 优先级 DEBUG/INFO/ERROR  
13. # %c 所属类的全名(包括包名)  
14. # %l 发生的位置，在某个类的某行  
15. # %m 输出代码中指定的讯息，如log(message)中的message  
16. # %n 输出一个换行符号  
17. log4j.appender.appender1.layout.ConversionPattern=[%d{yy/MM/dd HH:mm:ss:SSS}][%C-%M] %m%n  
18.   
19. #输出到文件(这里默认为追加方式)  
20. log4j.appender.appender2=org.apache.log4j.FileAppender  
21. #设置文件输出路径  
22. #【1】文本文件  
23. log4j.appender.appender2.File=c:/Log4JDemo07_Dao.log  
24. #设置文件输出样式  
25. log4j.appender.appender2.layout=org.apache.log4j.PatternLayout  
26. log4j.appender.appender2.layout.ConversionPattern=[%d{HH:mm:ss:SSS}][%C-%M] -%m%n  

 

【示例8】 log4j.xml的配置方式

 

Xml代码   

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">  
3.   
4. <log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">  
5.   
6.     <appender name="appender1"  
7.         class="org.apache.log4j.RollingFileAppender">  
8.         <param name="File" value="logfile08.html" />  
9.         <param name="MaxFileSize" value="1MB" />  
10.         <param name="MaxBackupIndex" value="5" />  
11.         <layout class="org.apache.log4j.HTMLLayout">  
12.         </layout>  
13.     </appender>  
14.   
15.     <root>  
16.         <level value="debug" />  
17.         <appender-ref ref="appender1" />  
18.     </root>  
19. </log4j:configuration>  

 

 

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

 

Java代码   

1. // 记录debug级别的信息  
2. if (logger.isDebugEnabled()) {  
3.     logger.debug("This is debug message from Dao.");  
4. }  
5.   
6. // 记录info级别的信息  
7. if (logger.isInfoEnabled()) {  
8.     logger.info("This is info message from Dao.");  
9. }  
10.   
11. // 记录error级别的信息  
12. logger.error("This is error message from Dao."); 
    

<logger>标签的作用：为不同的包使用不同的log配置。
如配置了
<logger name="com.runway" additivity="false">
        <priority value ="info"/>   
        <appender-ref ref="activexAppender" />   
</logger> 

则com.runway包及其子包下的所有类使用的log配置都是info,且输出到activeXAppender.
其他类使用的log配置都是根logger

logger的默认配置具有继承特性， 即所有的logger配置继承根logger,
name为“a.b.c"的logger配置继承name为"a.b"的配置, name为"a.b"又继承name为"a"的logger而配置。。。
若使用了additivity="false"表示不继承父logger的配置。

Logger.getLogger()和LogFactory.getLog()的区别

Logger来自log4j自己的包。如果用Logger.getLogger，需要一个log4j的jar包，用此方式你只能依靠log4j：

LogFactory来自common-logging包。如果用LogFactory.getLog，你可以用任何实现了通用日志接口的日志记录器替换log4j，而程序不受影响。apache的common-logging包是通用日志接口，通过这个中间层，你可以随便指定到底用哪个日志系统。增加系统的灵活性。若log4j它不存在, commons-logging 会另行选择其它的日志实现类。 这样保证了程序中不一定要使用log4j这个日志文件了
增强灵活性的理由：
1)首先在 classpath 下寻找自己的配置文件 commons-logging.properties ，如果找到，则使用其中定义的 Log 实现类；

2) 如果找不到 commons-logging.properties 文件，则在查找是否已定义系统环境变量 org.apache.commons.logging.Log ，找到则使用其定义的 Log 实现类；

3) 否则，查看 classpath 中是否有 Log4j 的包，如果发现，则自动使用 Log4j 作为日志实现类；

4)   否则，使用 JDK 自身的日志实现类（ JDK1.4 以后才有日志实现类）；

5)   否则，使用 commons-logging 自己提供的一个简单的日志实现类 SimpleLog ；


为了简化配置 commons-logging ，一般不使用 commons-logging 的配置文件，也不设置与 commons-logging 相关的系统环境变量，而只需将 Log4j 的 Jar 包放置到 classpash 中就可以了。这样就很简单地完成了 commons-logging 与 Log4j 的融合。

根据不同的性质，日志信息通常被分成不同的级别，从低到高依次是：“调试（ DEBUG ）”“信息（ INFO ）”“警告（ WARN ）”“错误（ERROR ）”“致命错误（ FATAL ）”。


基于common-logging的运行方式：
package org;
import org.apache.commons.logging.Log;
import org.apache.log4j.Logger;
public class Test extends TagSupport{
public static Log log=LogFactory.getLog(Test.class);
public static void test()
{
log.debug("111");
log.info("125");
log.warn("485");
log.error("error");

}
public static void main(String[] a)
{
Test.test();
}
}

基于log4j的运行方式
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
public class TestLog4j {

static Logger logger = Logger.getLogger(TestLog4j.class);
   public static void main(String args[]) {
   PropertyConfigurator.configure("log4j.properties");
   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");
   }
}

-----------
commons-logging 仅仅对 Log4j( 当然还包括其它 LOG 实现 ) 作了一层包装，具体的日志输出还是在内部转交给身后的 Log4j 来处理，还有log4j会默认的去classes目录下去寻找log4j.properties 文件