Log4j的应用实例

最新推荐文章于 2021-02-25 19:01:52 发布
最新推荐文章于 2021-02-25 19:01:52 发布
阅读量2.1k 收藏 1
点赞数
分类专栏： 框架 文章标签： log4j
在 Log4J使用笔记 中没有怎么写实例，那么在这篇中我将Log4j的一个完整应用实例写出。
在 Log4J使用笔记 中我们已经知道同一个日志信息可以同时输出到多个输出目的地。那么在下面的例子中我将演示将日志信息同时输出到控制台，文件和数据库中。首先创建一张表，如下：

create table log4j
(
    logId int not null auto_increment,--流水号
    createDate varchar(45) default null,--日志生成时间
    thread varchar(45) default null,--当前线程
    level varchar(45) default null,--当前日志的级别
    class varchar(45) default null,--生成日志的类
    message varchar(245) default null,--日志具体信息
    
    primary key(logId)
)
编写配置文件myLog4j.properties
#定义3个输出端
log4j.rootCategory=INFO,A1,A2,A3

#定义A1输出到控制器
log4j.appender.A1=org.apache.log4j.ConsoleAppender
#定义A1的布局模式为PaternLayout
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
# 定义A1的输出格式
log4j.appender.A1.layout.ConversionPattern=%4p [%t] (%F:%L) - %m%n

#定义A2输出到文件
log4j.appender.A2=org.apache.log4j.RollingFileAppender
#定义A2输出到哪个文件
log4j.appender.A2.File=./Sample.log
#定义A2输出文件的最大长度
log4j.appender.A2.MaxFileSize = 1KB
#定义A2的备份文件数
log4j.appender.A2.MaxBackupIndex = 3
#定义A2的布局模式为PatternLayout
log4j.appender.A2.layout=org.apache.log4j.PatternLayout
#定义A2的输出模式
log4j.appender.A2.layout.ConversionPattern=%d{yyyy-MM-dd hh:mm:ss}:%p %t %c - %m%n

#定义A3输出到数据库
log4j.appender.A3=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.A3.URL=jdbc:mysql://localhost:3306/study
log4j.appender.A3.driver=com.mysql.jdbc.Driver
log4j.appender.A3.user=root
log4j.appender.A3.password=root
#定义A3的布局和执行的SQL语句
log4j.appender.A3.layout=org.apache.log4j.PatternLayout
log4j.appender.A3.layout.ConversionPattern=INSERT INTO log4j(createDate,thread,level,class,message) values(\'%d\',\'%t\',\'%-5p\',\'%c\',\'%m\')


最后测试程序如下：
     public  static  void sample()
     {
        Logger logger = Logger.getLogger(Log4jTest.class);
        
        PropertyConfigurator.configure("myLog4j.properties");
        logger.debug("Here is DEBUG messgae");
        logger.info("Here is INFO message");
        logger.warn("Here is WARN message");
        logger.error("Here is ERROR message");
        logger.fatal("Here is FATAL message");
    }
这样当我们运行该程序的时候会同时将上述日志信息转入到三个地方：
控制台：

数据库：

文件：
 
我们已经看到出现Sample.log文件，该文件我们在配置中指定，当然你也可以修改其它地方，另外Log4j的配置文件也放在项目根目录下。
同时当我们多运行几次该程序时，Sample.log超过1KB时就会将该文件自动改名，同时再将日志记录到新的Sample.log文件中 ，如下：


===================================================================================


简述：

添加logger的日志输出，下面是配置信息供备忘


步骤：

1. 在Maven的porn.xml 文件中添加dependency如下

[html]  view plain copy
  1. <dependency>  
  2.     <groupId>org.slf4j</groupId>  
  3.     <artifactId>slf4j-log4j12</artifactId>  
  4.     <version>1.7.2</version>  
  5. </dependency>  

之后就会添加三个包，


2. 之后在项目下添加log4j.properties

项目路径如下，


log4j.properties

[html]  view plain copy
  1. #config root logger  
  2. log4j.rootLogger = INFO,system.out  
  3. log4j.appender.system.out=org.apache.log4j.ConsoleAppender  
  4. log4j.appender.system.out.layout=org.apache.log4j.PatternLayout  
  5. log4j.appender.system.out.layout.ConversionPattern=MINAServer Logger-->%5p{%F:%L}-%m%n  
  6.   
  7. #config this Project.file logger  
  8. log4j.logger.thisProject.file=INFO,thisProject.file.out  
  9. log4j.appender.thisProject.file.out=org.apache.log4j.DailyRollingFileAppender  
  10. log4j.appender.thisProject.file.out.File=logContentFile.log  
  11. log4j.appender.thisProject.file.out.layout=org.apache.log4j.PatternLayout  


3. 在代码中添加

[java]  view plain copy
  1. private static final Logger logger = LoggerFactory.getLogger(MINAServer.class);  

接下来就能输出了，

[html]  view plain copy
  1. logger.info("now {}" , "starting server");  

输出如下：


下面是log4j.properties的配置信息，在此要感谢前辈提供的资源

#输出格式
#%m 输出代码中指定的消息
#%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
#%r 输出自应用启动到输出该log信息耗费的毫秒数
#%c 输出所属的类目，通常就是所在类的全名
#%t 输出产生该日志事件的线程名
#%n 输出一个回车换行符，Windows平台为“\r\n”，Unix平台为“\n”
#%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921
#%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java:10)

格式化例子：
log4j.appender.thisProject.file.out.layout.ConversionPattern=log4j-->%d{yyyy MMM dd HH:mm:ss,SSS}%5p{%F\:%L}-%m%n


注意：

1.信息格式化的小知识
    这些参数中间可能会参杂一些数字比如：%5p它的意思就是在输出此参数之前加入多少个空格，还有就是里面的“\”的作用是转义字符

2.log4j.properties文件放置位置
    (1)在java project项目中，它放置的位置是在项目的根目录下而不是在项目的src目录下。
    (2)在javaweb项目中它放置的位置是在src目录下，因为这个时候tomcat会去默认的加载它的，不需要我们去手动的加载log4j的配置文件，只需要根据配置获取自己需要的logger实例即可,由此我们可以知道如果我们使用的不是tomcat容器的话，是不是需要自己手动加载或者至少要配置一下呢？比如使用Websphere等非apache服务器。

3.对于java web项目里面的日志的位置配置
    (1)如果是要指定日志文件的位置为D盘下的log.txt文件。
    log4j.appender.thisProject.file.out.File=d:\\log.txt
    (2)如果指定日志文件的位置为当前的tomcat的工作目录下的某个文件
    log4j.appender.thisProject.file.out.File=${catalina.home}/logs/logs_tomcat.log

4.log4j的加载机制

    log4j.properties加载机制？其实log4j.properties只是log4j的配置文件。程序启动时，log4j组件去读log4j.properties，和读取普通配置文件没多大区别。获取用户配置的一些log4j的属性值，调用想应该的方法为log4j属性设置。

    把log4j.properties当作一个struts.xml或者一个hibernate-cfg.xml就可以了。但不同的是，log4j不像struts和hibernate，它不是一个独立的组件,没法自己完成初始化，一般都是什么组件需要它 就去初始化。比如，hibernate默认的日志组件就是log4j，在hibernate初始化的时候它会去初始化log4j。如果你没配置log4j.properties,hibernate会抛出异常，但还是可以正常初始化。

====================================================================================


Log4j的用法： 

第一种: 用Log4j自己单独写个类（src\log4j\LogUtil.java）。 
        
package log4j; 
import java.io.IOException; 
import java.io.UnsupportedEncodingException; 
import java.text.SimpleDateFormat; 
import java.util.Date; 

import org.apache.log4j.Appender; 
import org.apache.log4j.ConsoleAppender; 
import org.apache.log4j.FileAppender; 
import org.apache.log4j.Layout; 
import org.apache.log4j.Level; 
import org.apache.log4j.Logger; 
import org.apache.log4j.PatternLayout; 

public class LogUtil { 
public static Logger log1=Logger.getLogger("appender1"); 
private static LogUtil logUtil=null; 
private static Layout layout=new PatternLayout("%d{yyyy-MM-dd HH:mm:ss}: %p %m\n"); 
private static String logFile; 
private static String todayStr; 

static{ 
try{ 
logFile="F:\\log\\log2.log"; 
todayStr=new SimpleDateFormat("yyyyMMddHHmmss").format(new Date()); 
}catch(Exception e){ 
System.out.println("初始化日志文件失败!"); 
e.printStackTrace(); 
} 

} 
private static void init(){ 
try { 
if(logUtil ==null){ 
logUtil=new LogUtil(); 
if(log1.getAppender("consoleAppender")==null){ 
Appender consoleAppender=new ConsoleAppender(layout,"System.out"); 
consoleAppender.setName("consoleAppender"); 
log1.addAppender(consoleAppender); 
} 
if(log1.getAppender(logFile)==null){ 
Appender fileAppender=new FileAppender(layout,logFile); 
fileAppender.setName(logFile); 
log1.addAppender(fileAppender); 
} 
log1.setLevel(Level.INFO); 
log1.setAdditivity(false); 
}else { 
if(log1.getAppender(logFile)==null){ 
log1.removeAllAppenders(); 
if(log1.getAppender("consoleAppender")==null){ 
Appender consoleAppender=new ConsoleAppender(layout,"System.out"); 
consoleAppender.setName("consoleAppender"); 
log1.addAppender(consoleAppender); 
} 
if(log1.getAppender(logFile)==null){ 
Appender fileAppender=new FileAppender(layout,logFile); 
fileAppender.setName(logFile); 
log1.addAppender(fileAppender); 
} 
//logger.setLevel(Level.INFO); 
org.apache.log4j.BasicConfigurator.configure(); 
} 
} 
} catch (IOException e) { 
System.out.println("初始化日志失败喽!"); 
e.printStackTrace(); 
} 
} 

public static String format(String s){ 
init(); 
try { 
return new String(s.getBytes("GBK")); 
} catch (UnsupportedEncodingException e) { 
log1.warn("Encoding Exception"); 
return s; 
} 

} 

public static void log(Object obj){ 
if(obj==null){ 
obj=null; 
} 
log1.info(format(obj.toString())); 
} 

} 

          

       

第二种：  用配置文件（log4j.properties）的方式 
         具体配置如下： 
#2013-10-16 学习log4j的配置 
#log4j配置三部曲 
# 1.0 配置根Logger 
log4j.rootLogger=debug,appender1,appender2 

# 2.0 配置日志信息输出目的地Appender 
#输出到控制台 
#log4j.appender.appender1=org.apache.log4j.ConsoleAppender 
#输出到文件(默认为追加方式) 
log4j.appender.appender1=org.apache.log4j.FileAppender 
log4j.appender.appender2=org.apache.log4j.ConsoleAppender 
#设置文件输出路径 
log4j.appender.appender1.File=E:/log/log1.log 
#log4j.appender.appender1.File=E:/log/log1.html 

#每天生成一个日志文件 
#log4j.appender.appender1=org.apache.log4j.DailyRollingFileAppender 
#文件大小到达指定尺寸的时候产生一个新的文件 
#log4j.appender.appender1=org.apache.log4j.RollingFileAppender 
#将日志信息以流格式发送到任意指定的地方 
#log4j.appender.appender1=org.apache.log4j.WriterAppender 

# 3.0配置日志信息的格式（布局） 
#包含日志产生的时间，线程，类别等信息 
#log4j.appender.appender1.layout=org.apache.log4j.TTCCLayout 
#包含日志信息的级别和信息字符串等信息 
#log4j.appender.appender1.layout=org.apache.log4j.SimpleLayout 
#可以灵活地指定布局 
log4j.appender.appender1.layout=org.apache.log4j.PatternLayout 
log4j.appender.appender1.layout.ConversionPattern=[%d{yyyy-MM-dd HH:mm:ss,SSS}][%C -%M] %m%n 

#以HTML表格形式布局 
#log4j.appender.appender1.layout=org.apache.log4j.HTMLLayout 

#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) 
# %m 输出代码中指定的讯息，如log(message)中的message   

                

       
       
第三种：配置web.xml 
在此之前需要配置 log4j.xml。然后在web.xml加入如下配置： 

<context-param> 
        <param-name>webAppRootKey</param-name> 
        <param-value>smilecargo.root</param-value> 
    </context-param> 
    <context-param> 
        <param-name>log4jConfigLocation</param-name> 
        <param-value>classpath:log4j.xml</param-value> 
    </context-param> 
    <context-param> 
        <param-name>log4jRefreshInterval</param-name> 
        <param-value>60000</param-value> 
    </context-param> 
<listener> 
        <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class> 
    </listener> 

log4j.xml的配置方式如下： 

<?xml version="1.0" encoding="UTF-8" ?>  
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">  
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">  
  
    <!-- ========================== 自定义输出格式说明================================ -->  
    <!-- %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)  -->  
    <!-- ========================================================================== -->  
      
    <!-- ========================== 输出方式说明================================ -->  
    <!-- Log4j提供的appender有以下几种:  -->  
    <!-- org.apache.log4j.ConsoleAppender(控制台),  -->  
    <!-- org.apache.log4j.FileAppender(文件),  -->  
    <!-- org.apache.log4j.DailyRollingFileAppender(每天产生一个日志文件), -->  
    <!-- org.apache.log4j.RollingFileAppender(文件大小到达指定尺寸的时候产生一个新的文件),  -->  
    <!-- org.apache.log4j.WriterAppender(将日志信息以流格式发送到任意指定的地方)   -->  
<!-- ========================================================================== -->  
<!-- 输出到日志文件  -->  
    <appender name="filelog_appender"  
        class="org.apache.log4j.RollingFileAppender">  
        <!-- 设置File参数：日志输出文件名 -->  
        <param name="File" value="log/testlog4jxml_all.log" />  
        <!-- 设置是否在重新启动服务时，在原有日志的基础添加新日志 -->  
        <param name="Append" value="true" />  
        <!-- 设置文件大小 -->  
        <param name="MaxFileSize" value="1MB" />  
        <!-- 设置文件备份 -->  
        <param name="MaxBackupIndex" value="10000" />  
        <!-- 设置输出文件项目和格式 -->  
        <layout class="org.apache.log4j.PatternLayout">  
            <param name="ConversionPattern" value="%d{yyyy-MM-dd HH:mm:ss} %-5p (%c:%L)- %m%n" />  
        </layout>  
    </appender>  
  
<!-- 输出到日志文件 每天一个日志  -->  
    <appender name="filelog_daily" class="org.apache.log4j.DailyRollingFileAppender">     
        <param name="File" value="log/daily.log" />     
        <param name="DatePattern" value="'daily.'yyyy-MM-dd'.log'" />     
        <layout class="org.apache.log4j.PatternLayout">     
            <param name="ConversionPattern" value="[%d{yyyy-MM-dd HH:mm:ss\} %-5p] [%t] (%c:%L) - %m%n" />     
        </layout>     
    </appender>   
  
<!-- 输出到控制台中 -->  
    <appender name="console" class="org.apache.log4j.ConsoleAppender">  
        <layout class="org.apache.log4j.PatternLayout">  
            <param name="ConversionPattern"  
                value="%d{yyyy-MM-dd HH:mm:ss} %-5p: %m%n" />  
            <!-- "%-5p: [%t] [%c{3}.%M(%L)] | %m%n" -->  
        </layout>  
    </appender>  
  
<appender name="EMAIL_QQ" class="org.apache.log4j.net.SMTPAppender">  
        <param name="Threshold" value="INFO"/>  
        <param name="BufferSize" value="128" />  
        <param name="SMTPHost" value="smtp.qq.com" />  
        <param name="SMTPUsername" value="cjjvictory" />  
        <param name="SMTPPassword" value="***" />  
        <param name="From" value="cjjvictory@qq.com" />  
        <param name="To" value="cjjvictory@gmail.com" />  
        <param name="Subject" value="测试邮件发送" />  
        <param name="LocationInfo" value="true" />  
        <param name="SMTPDebug" value="true" />  
        <layout class="org.cjj.log4j.extend.PatternLayout_zh">  
            <param name="ConversionPattern" value="[%d{ISO8601}] %-5p %c %m%n"/>  
        </layout>  
    </appender>  
  
<!--- 异步测试，当日志达到缓存区大小时候执行所包的appender -->  
    <appender name="ASYNC_test" class="org.apache.log4j.AsyncAppender">     
     <param name="BufferSize" value="10"/>     
     <appender-ref ref="EMAIL_QQ"/>  
   </appender>  
  
<!-- 设置包限制输出的通道 -->  
    <category name="org.cjj" additivity="false">  
               <!-- 日志输出级别，起码可以有5个级别，可以扩展自己的级别，邮件发送必须是ERROR级别不好用，所以最后自己扩展一个邮件发送级别 -->  
        <level value="ERROR" />  
        <appender-ref ref="filelog_daily" />  
        <appender-ref ref="daily_appender" />  
        <appender-ref ref="console" />  
        <appender-ref ref="ASYNC_test" />  
</category>  
  
</log4j:configuration>  

====================================================================================


      当我们的代码存在有疑问的地方且不想去处理时，我们就需要把程序的日志信息输出，这时我们会用到一个类--Log4j，想用这个类，我们需要下载Log4j的引用包，下载地址如下：

http://logging.apache.org/log4j/2.x/download.html 

      在我们编写测试代码之前，第一步，我们需要把下载的包引用到我们的程序中，右键点击项目选中BuildPath之后选择你的包所在的路径即可。

      下一步是需要一个属性文件，其中配置日志的记录位置，记录格式等内容，我所用到的配置文件如下，从中可以看出，我把日志文件输出到控制台上：

log4j.rootLogger=debug, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

# Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F\:%L) - %m%n
      注意：第一行代表的是输出级别，我这里填写的是最低的一层，也就是Debug，当日志输出不比DEBUG低时，日志内容就会打印到控制台上，当然，DEBUG是最底的级别，所以，只要有日志信息都会打印出来。

      这里，所有的工作都做好了，我们开始编写测试代码：

package com.brucezhang.mytest;

import org.apache.log4j.Logger;


public class MyTest {
static Logger logger = Logger.getLogger(MyTest.class.getName());
  
    public static void main(String[] args) {

  //记录日志,从最低到最高的次序为：debug->info->warn->error
  logger.debug("debug");
  logger.info("info");
  logger.warn("warn");
  logger.error("error");
  
  testLog(0);
    }
    
    public static void testLog(int div){
    	try {
      int value = 8;
      System.out.println(value/div);
    } catch (Exception e) {
      // TODO: handle exception
      e.printStackTrace();
      logger.error("get a error");
    }
    }
}

      运行我们的测试程序，得到结果如下所示： 
DEBUG [main] (MyTest.java:12) - debug
 INFO [main] (MyTest.java:13) - info
 WARN [main] (MyTest.java:14) - warn
ERROR [main] (MyTest.java:15) - error
ERROR [main] (MyTest.java:27) - get a error
java.lang.ArithmeticException: / by zero
  at com.brucezhang.mytest.MyTest.testLog(MyTest.java:23)
  at com.brucezhang.mytest.MyTest.main(MyTest.java:17)

      可以看到，日志信息和异常信息都被打印到了控制台上。


=====================================================================================================

学习了一下JAVA的日志系统slf4j ,这是日志的一个接口。 
通过这个接口，我们可以方便的切换日志的实现框架，比如log4j,commons-logging,logback,jdk-log 等等。 

slf4j的API在 slf4j-api.jar中，核心接口与类是： 

Java代码   收藏代码
  1. org.slf4j.Logger  
  2. org.slf4j.LoggerFactory  


slf4j的实际调用日志在运行时才会动态绑定，基本原理是查找classpath下面的jar包，如果存在slf4j的实现框架，就采用该实现框架。参考下图： 

 

下面分析一下slf4j如何实现运行时的动态绑定日志实现框架 

以下代码是org.slf4j.LoggerFactory中的部分 
Java代码   收藏代码
  1. // We need to use the name of the StaticLoggerBinder class, we can't reference  
  2. // the class itseld.  
  3. private static String STATIC_LOGGER_BINDER_PATH = "org/slf4j/impl/StaticLoggerBinder.class";  
  4.   
  5. private static void singleImplementationSanityCheck() {  
  6.   try {  
  7.     ClassLoader loggerFactoryClassLoader = LoggerFactory.class  
  8.         .getClassLoader();  
  9.     Enumeration paths;  
  10.     if (loggerFactoryClassLoader == null) {  
  11.       paths = ClassLoader.getSystemResources(STATIC_LOGGER_BINDER_PATH);  
  12.     } else {  
  13.       paths = loggerFactoryClassLoader  
  14.           .getResources(STATIC_LOGGER_BINDER_PATH);  
  15.     }  
  16.     List implementationList = new ArrayList();  
  17.     while (paths.hasMoreElements()) {  
  18.       URL path = (URL) paths.nextElement();  
  19.       implementationList.add(path);  
  20.     }  
  21.     if (implementationList.size() > 1) {  
  22.       Util.report("Class path contains multiple SLF4J bindings.");  
  23.       for (int i = 0; i < implementationList.size(); i++) {  
  24.         Util.report("Found binding in [" + implementationList.get(i) + "]");  
  25.       }  
  26.       Util.report("See " + MULTIPLE_BINDINGS_URL + " for an explanation.");  
  27.     }  
  28.   } catch (IOException ioe) {  
  29.     Util.report("Error getting resources from path", ioe);  
  30.   }  
  31. }  

我们的日志系统lib中有一个日志API：slf4j-api.jar,以及不少于一个日志框架（比如log4j,commons-logging等等） 
程序运行过程中到底会使用哪个日志框架(log4j or commons-logging)呢。 
这个中间需要一个API -> 实现框架的桥梁： 对接包 
上面代码可以看出，通过ClassLoader来查找资源"org/slf4j/impl/StaticLoggerBinder.class", 
如果有1个资源，这个就是日志实现库对接包了。如果有多个资源，则警告classpath路径下有多个slf4j的实现框架对接包。 
那如果有多个实现框架对接包的情况下，到底会用哪个实现框架呢？这个就靠ClassLoader先加载到哪个了，不能确定。 
因此不要在classpath下放入多个slf4j的实现框架对接包，避免出错。 


上面说到关键的类StaticLoggerBinder.class，这个是判断采用哪个slf4j实现框架的关键。 
StaticLoggerBinder类是slf4j组织来写的，目的是为了对接不同的日志框架。 
如上图所示，slf4j-log12-xxx.jar slf4j-jdk14-xxx.jar 之类jar中就包含StaticLoggerBinder类。 
实际中至少需要在classpath下提供一个实现框架，以及不多于一个对应的对接包 


slf4j还有一个功能是，可以方便的迁移不同的日志框架。 
比如一个项目是使用commons-logging框架来写日志的。 
我们需要迁移到log4j框架来，如何处理呢。 
使用slf4j将会非常方便，我们只需要做三步： 
1.删除原有的commons-logging包 
2.将log4j的jar加入到classpath 
3.引入一个日志转换的jar，在这里是jcl-over-slf4j.jar 

下面分析一下以上步骤的实现原理 
commons-logging框架中的几个核心类是： 
org.apache.commons.logging.Log 
org.apache.commons.logging.LoggerFactory 
老项目采用了commons-logging框架，必然会耦合这几个类，比如使用了如下代码： 
org.apache.commons.logging.Log.error("errror msg"); 

要想使以上代码正常运行，而又实际是调用log4j来处理。这里就需要用到jcl-over-slf4j.jar了 
jcl-over-slf4j.jar实际上是覆写了commons-logging中的几个核心类，内部采用类Adaptor，对接到了slf4j的API上面。 
即jcl-over-slf4j中也有 org.apache.commons.logging.Log这个类， 他与原生的类完全不同，仅仅是适配到了slf4j-api上。 
因为jcl-over-slf4j.jar是slf4j出品，slf4j把代码写到了不属于他们的package下面，感觉有点山寨，怪怪的。 

这里只是举例commons-logging -> log4j， 其他的转换也类似，只是需要下载不同的适配包 

整理一下日志框架迁移的流程 
老日志框架：类比与上例的common-logging代码 
新日志框架：类比与上例的log4j 
适配包：类比与上例的jcl-over-slf4j.jar 
对接包：类比与上上例的slf4j-log4j12-xxx.jar 


老日志框架  ---(适配包)--->  SLF4J API ---(对接包)---> 新日志框架 


=================================================================================================================

方法一、 解决的办法自然是用相对路径代替绝对路径，其实log4j的FileAppender本身就有这样的机制，如：log4j.appender.logfile.File=${WORKDIR}/logs/app.log 
其中“${WORKDIR}/”是个变量，会被System Property中的“WORKDIR”的值代替。这样，我们就可以在log4j加载配置文件之前，先用System.setProperty ("WORKDIR", WORKDIR);设置好根路径，此操作可通过一初始的servlet进行。 

方法二、可以使用服务器环境变量 
log4j的配置文件支持服务器的vm的环境变量，格式类似${catalina.home} 
log4j.appender.R=org.apache.log4j.RollingFileAppender 
log4j.appender.R.File=${catalina.home}/logs/logs_tomcat.log 
log4j.appender.R.MaxFileSize=10KB 
其中的${catalina.home}并非windows系统的环境变量，这个环境变量就不需要在Windows系统的环境变量中设置。之所以这样，你可以看看tomcat\bin\catalina.bat(startup,shutdown都是调用这个)里面自带有-Dcatalina.home= "%CATALINA_HOME%" 。继承这个思想，所以你也可以自己设定一个参数-Dmylog.home="D:/abc/log"到对应的服务器java启动的vm参数中 

方法三、通过servlet初始化init()方法中加载file属性实现相对路径 
具体实现:做一个servlet,在系统加载的时候,就把properties的文件读到一个properties文件中.那个file的属性值(我使用的是相对目录)改掉(前面加上系统的根目录),让后把这个properties对象设置到propertyConfig中去,这样就初始化了log的设置.在后面的使用中就用不着再配置了 
一般在我们开发项目过程中,log4j日志输出路径固定到某个文件夹,这样如果我换一个环境,日志路径又需要重新修改,比较不方便,目前我采用了动态改变日志路径方法来实现相对路径保存日志文件 
(1).在项目启动时,装入初始化类: 
public class Log4jInit extends HttpServlet { 
         static Logger logger = Logger.getLogger(Log4jInit.class); 
         public Log4jInit() { 
         } 

         public void init(ServletConfig config) throws ServletException { 
             String prefix = config.getServletContext().getRealPath("/"); 
             String file = config.getInitParameter("log4j"); 
             String filePath = prefix + file; 
             Properties props = new Properties(); 
             try { 
                 FileInputStream istream = new FileInputStream(filePath); 
                 props.load(istream); 
                 istream.close(); 
                 //toPrint(props.getProperty("log4j.appender.file.File")); 
                 String logFile = prefix + props.getProperty("log4j.appender.file.File");//设置路径 
                 props.setProperty("log4j.appender.file.File",logFile); 
                 PropertyConfigurator.configure(props);//装入log4j配置信息 
             } catch (IOException e) { 
                 toPrint("Could not read configuration file [" + filePath + "]."); 
                 toPrint("Ignoring configuration file [" + filePath + "]."); 
                 return; 
             } 
         } 

         public static void toPrint(String content) { 
             System.out.println(content); 
         } 
} 
实际上log4j的配置文件log4j.properties如为默认名，可放置在JVM能读到的classpath里的任意地方，一般是放在WEB- INF/classes目录下。当log4j的配置文件不再是默认名，则需要另外加载并给出参数，如上 “ropertyConfigurator.configure(props);//装入log4j配置信息” 

(2).Web.xml中的配置 
<servlet> 
         <servlet-name>log4j-init</servlet-name> 
         <servlet-class>Log4jInit</servlet-class> 
         <init-param> 
           <param-name>log4j</param-name> 
           <param-value>WEB-INF/classes/log4j.properties</param-value> 
         </init-param> 
         <load-on-startup>1</load-on-startup> 
       </servlet> 

注意：上面的load-on-startup设为0，以便在Web容器启动时即装入该Servlet。log4j.properties文件放在根的properties子目录中，也可以把它放在其它目录中。应该把.properties文件集中存放，这样方便管理。 
(3).log4j.properties中即可配置log4j.appender.file.File为当前应用的相对路径. 


以上是网上log4j日志文件的相对路径配置的三种方法（我能找到的就三种），分析： 

方法一主要是扩展了log4j的RollingFileAppender类，其他的FileAppender同样道理。扩展的方法，就是用一个子类去覆盖setFile方法，这个方法在log4j读取配置文件生成appender的时候调用，传入的就是配 
置文件中的路径，这样我就可以按照自己的想法在路径前面加上根路径了。这种方法可以在log4j.properties中用相对路径自由配置log4j.appender.A1.File属性来决定生成的日志相对web应用根 
目录的位置。 

方法二是利用服务器vm中已经存在的环境变量如${catalina.home}来设置相对于${catalina.home}的日志路径，日志只能放到服务器子目录里，而且如果是用的其它服务器，则要改对应的环境变量。此方法平台移植不方便。 

方法三是扩展ActionServlet类，覆盖其init()方法，新方法中载入log4j.properties位置的参数，可以自由配置log4j的配置文件的名字和存放位置。也可自由配置log4j日志文件的相对于当前应用的路径。详 
细代码如下： 

程序代码 
package wbb.bysxxglxt.util; 

import org.apache.struts.action.*; 
import org.apache.commons.logging.LogFactory; 
import org.apache.commons.logging.Log; 
import javax.servlet.ServletException; 
import java.util.Properties; 
import java.io.InputStream; 
import org.apache.log4j.PropertyConfigurator; 
import java.io.FileInputStream; 
import java.io.IOException; 

public class ExtendedActionServlet extends ActionServlet { 
        private Log log = LogFactory.getLog(this.getClass().getName()); 

        public ExtendedActionServlet() {} 

        public void init() throws ServletException { 
            log.info( 
                    "Initializing, My MyActionServlet init this System's Const Variable");
            String prefix = this.getServletConfig().getServletContext().getRealPath( 
                    "/"); 
            String file = this.getServletConfig().getInitParameter("log4j"); 
            String filePath = prefix + file; 
            Properties props = new Properties(); 
            System.out.println(prefix); 
            System.out.println(file); 
            System.out.println(filePath); 

            try { 
                FileInputStream log4jStream = new FileInputStream(filePath); 
                props.load(log4jStream); 
                log4jStream.close(); 
                String logFile = prefix + 
                                 props.getProperty("log4j.appender.A1.File"); //设置路径 

                System.out.println(logFile); 
                props.setProperty("log4j.appender.A1.File", logFile); 
                PropertyConfigurator.configure(props); //装入log4j配置信息 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
            log.info("Initializing, end My Init"); 
            super.init();//应用了struts,此方法不能省，ActionServlet覆盖了的此方法中有很多重要操作 
        } 
} 


**********************应用web.xml 关键部分*************************** 

      
程序代码 
<servlet> 
        <servlet-name>action</servlet-name> 
        <servlet-class>wbb.bysxxglxt.util.ExtendedActionServlet</servlet-class> 
        <init-param> 
          <param-name>config</param-name> 
          <param-value>/WEB-INF/struts-config.xml</param-value> 
        </init-param> 
        <init-param> 
            <param-name>log4j</param-name> 
            <param-value>properties\log4j.properties</param-value>                    
          </init-param> 
        <init-param> 
          <param-name>debug</param-name> 
          <param-value>0</param-value> 
        </init-param> 
        <init-param> 
          <param-name>application</param-name> 
          <param-value>ApplicationResources</param-value> 
        </init-param> 
        <load-on-startup>0</load-on-startup> 
      </servlet> 
      <servlet-mapping> 
        <servlet-name>action</servlet-name> 
        <url-pattern>*.do</url-pattern> 
      </servlet-mapping> 


注意log4j参数中相对路径的斜杠线的写法，而且log4j属性文件如放置在web-inf/classes目录或web-inf等目录中最好改名，因为在加载此Servlet之前，服务器如tomcat启动时会自动搜索web-inf目录和web-inf/classes目录中log4j.properties文件，如有则自动加载。log4j属性文件加载后,由于该属性文件中log4j.appender.A1.File的值用的是相对路径，自动加载配置便会出错： 
log4j:ERROR setFile(null,true) call failed. 
java.io.FileNotFoundException: WEB-INF\logs\bysxxglxt.log (系统找不到指定的路径。) 
不知道log4j为什么会这么早自动启动。尽管后面加载扩展的ActionServlet中正确设置了log4j属性文件并正常加载了，但报的这个错还是怪不爽的，于是只有更改log4j属性文件名字或者更改其存放位置，让其不能自动加载了，不过还是有两个警告： 
log4j:WARN No appenders could be found for logger (org.apache.commons.digester.Digester.sax). 
log4j:WARN Please initialize the log4j system properly. 
这样做就算是掩耳盗铃了，如果你有更好的解决办法，希望能在此贴出来，大家一起研究。 

********************log4j.properties***************************** 
### 设置logger级别 ### 

程序代码 
log4j.rootLogger=DEBUG,stdout,A1 

### appender.stdout输出到控制台 ### 
log4j.appender.stdout=org.apache.log4j.ConsoleAppender 
log4j.appender.stdout.Target=System.out 
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 
log4j.appender.stdout.layout.ConversionPattern= [%5p] [BYSXXGLXT] %d{yyyy-MM-dd HH:mm:ss}: %-4r [%-5p] [%t] ( %F,%L ) - %m%n 

### appender.A1输出到日志文件 ### 
log4j.appender.A1=org.apache.log4j.DailyRollingFileAppender 
log4j.appender.A1.File=WEB-INF\\logs\\bysxxglxt.log 
##注意上面日志文件相对应用根目录路径的写法 
log4j.appender.A1.DatePattern='.'yyyy-MM-dd'.log' 
log4j.appender.A1.Append=true 
## 输出DEBUG级别以上的日志 
log4j.appender.A1.Threshold=DEBUG 
log4j.appender.A1.layout=org.apache.log4j.PatternLayout 
log4j.appender.A1.layout.ConversionPattern= [%5p] [BYSXXGLXT] %d{yyyy-MM-dd HH:mm:ss}: %-4r     [%t] ( %F,%L ) - %m%n



滕百川
关注
专栏目录
log4j的简单例子
01-14
关系log4j的简单使用，相信会让大家对log4j有一个很好的认识
Log4j的原理及应用详解（一）
最新发布
凛鼕将至的博客
07-12 1529
Log4j是Apache的一个开源项目，它是一个可靠、快速、灵活的日志框架（API），主要用于Java语言编写的应用程序中。始于1996年，作为记录E.U. SEMPER（Secure Electronic Marketplace for Europe）项目跟踪信息的API。经过大量的完善和蜕变，最终演进为Log4j。
log4j的具体应用
pwlazy的专栏
04-23 1627
本篇假设你已了解log4j的基本概念.下面给出一个具体的实例:安装环节见前面的文章step1 配置文件log4j.xmlhttp://jakarta.apache.org/log4j/">                                                         在这个应用中,该文件位于src文件夹下,编译后编译到class文件夹下st
Log4j的基本应用
weixin_33834910的博客
07-21 109
Introduction    Log4j是一个开源代码的项目(Opensourceproject),它使开发人员能最大限度的灵活控制程序调试信息的输出，这一点它是通过额外的配置文件实现的。而且log4j开发包很容易上手，同时可能会使一些开发人员上瘾。    绝大多数的大型开发项目都有它们自己专门用于记录程序日志和对程序跟踪调试的API。许多经验证明，调试信息的管理在软件开发过程中扮演了十分重...
log4j的应用
zhjk_001的专栏
08-23 550
一、为什么我们要使用Log4jlog4j是一个可以帮助开发人员进行日志管理的API类库。正如我们所知，如果在一个项目或产品中不做任何日志管理的话，那后果是十分可怕的。设想一下，有时客户会点出某些BUG，当维护人员赶去时，客户却发现自己怎么也点不出那个BUG了，还有即使点出来，如果一个空空的白页，维护人员也是难以解决的。这样几次下来，我想任谁都会崩溃。可如果实现我们做了日志处理，那情况就会好的多
log4j使用实例.zip
08-12
这个"log4j使用实例.zip"压缩包包含了关于如何在Java项目中配置和使用Log4j的示例代码，非常适合Java后端初学者学习。 首先，Log4j的核心组件包括Logger、Appender和Layout。Logger是日志信息的生产者，负责生成...
log4j-api-2.17.1.jar和log4j-core-2.17.1.jar
03-11
这些接口包括最基本的`org.apache.logging.log4j.Logger`，它是所有日志记录的起点，以及`org.apache.logging.log4j.LogManager`，它负责管理日志配置和日志器实例。API库的主要目标是与实现层解耦，允许开发者在不...
扫描log4j2 版本扫描log4j2 版本
12-16
1. **识别系统中的Log4j2实例**：首先，需要识别系统中所有使用Log4j2的组件和应用程序，包括内部开发的项目以及第三方库。 2. **版本确认**：然后，通过查看项目配置文件（如`log4j2.xml`或`log4j2.json`）或依赖...
log4j2的配置案例，可直接使用
03-22
文件输出器“debug_appender”只会输出级别为“debug”和“info”之间的日志信息，输出到文件“debug.log”中，每天产生一个新的日志文件，同时在日志文件大小达到10MB时，会产生一个新的文件。输出格式同控制台输出...
log4j使用jar包和log4j.properties配置文件
09-26
Log4j作为Java日志处理的重要工具，通过其灵活的配置和强大的功能，可以帮助开发者更好地理解和管理应用的运行状态。1.2.17版本的Log4j jar包和`log4j.properties`配置文件是实现这一目标的基础。正确地引入和配置这...
log4j简单例子
04-01
NULL 博文链接：https://eeelin.iteye.com/blog/776954
log4j 实例
chance_66的博客
08-18 620
代码：package test;import org.apache.log4j.Logger;public class myTest { //获取日志记录器Logger，名字为本类类名 static Logger logger = Logger.getLogger(myTest.class); public static void main(String[] args) {
log4j的用法---含例子
weixin_50797718的博客
02-25 693
log4j的一些配置文章 http://www.cnblogs.com/gaishishengzhu/articles/1735441.html http://www.ibm.com/developerworks/cn/java/l-connpoolproxy/ http://www.iteye.com/topic/378077 http://hi.baidu.com/annleecn/blog/item/1ffedba3692f6fabcaefd048.html log4j是一个非常强大的log记录软件，
Log4j使用实例
08-01 2352
Log4j使用实例    通过Logger类的静态方法Logger.getRootLogger得到RootLogger。所有其他的loggers是通过静态方法Logger.getLogger来实例化并获取的。这个方法Logger.getLogger把所想要的logger的名字作为参数。 Logger类的一些其它基本方法在下面列出：
log4j使用实例
北冥有雨
01-17 230
导入log4j-1.2.17.jar包 创建log4j.properties属性文件，内容如下： ### 配置根Logger log4j.rootLogger = debug,console,D,I,E ### 控制台输出日志 log4j.appender.console = org.apache.log4j.ConsoleAppender log4j.appender.console.T...
Log4j应用
ryudoooo的博客
11-23 121
1.Log4j初始化: 最简单的配置方式：将配置文件取名log4j.properties，放到WEB-INF/classes下 2.log4j日志分级输出到不同文件的配置 例如想只把log4j的debug信息输出到debug.log.error信息输出到error.log，info信息输出到info.log log4j提供了下面一种方式来实现. 必须使用xml方式进行配置才能够支持filter...
log4j的简单应用
CynthiaLLL的博客
06-08 176
目录引入配置应用 引入 首先需要准备log4j的相关.jar包，将它拖到project下面 右键需要引入log4j的project –>build path –>configure build path –>add JARs –>选择log4j的.jar包 –>apply and close 配置 src内创建log4j2.xml，用记事本打开，另存为将其编码方式改为UTF-8 `<?xml version="1.0" encoding="UTF-8"?>
Log4j例子
Ferrerooo 成长
07-23 108
Log4j是Apache的一个开放源代码项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件、甚至是套接口服务器、NT的事件记录器、UNIX   Syslog守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。 一、L...
Log4j配置详解与应用实例
本文将深入解析log4j的使用方法，特别关注于在Java项目中的应用实例。首先，你需要在项目的classes目录下创建一个名为"log4j.properties"的配置文件，这是log4j的核心配置文件，用于定义日志行为。 log4j支持两种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值