Log4j生成压缩形式日志

Log4j生成压缩形式日志

转：http://blog.csdn.net/zhaosen241/article/details/3248331

 

Log4j提供了强大的日志功能，但是只能生成文本形式的日志文件，对于输出日志很频繁的应用会产生一些资源的浪费，例如我们的一个项目平均每20分钟就会生成一个大约10M的日志文件。为了节约硬盘资源，最近几天修改了一下Log4j，做了一个自己的版本将日志文件做成压缩包。

 

记录下这几天的工作吧：

 

1.       下载Log4j 1.2.15源代码，链接是：http://logging.apache.org/log4j/1.2/download.html

下载apache-log4j-1.2.15.tar.gz是带有源代码的包

 

2.       Log4j是用Maven2打包的，在链接http://maven.apache.org/download.html中下载

apache-maven-2.1.0-M1-bin.zip，这里需要注意下，2.0.9中有bug，打包会失败。

下载Maven后需要配置一下环境变量，就不细说了。

 

3.       下载安装MinGW，用来构建NTEventLogAppender.dll。下载链接：

http://mmtele3.skycn.com/down/MinGWStudioFullSetup-2_05.exe

 

4.       用Maven打包Log4j工程没问题后就可以开始修改里面的源代码了。在前一篇blog中转载了关于log4j的详细信息，我们主要更改两种方式的log，一种是DailyRollingFileAppender，一种是RollingFileAppender。

DailyRollingFileAppender在往日志文件打log的时候会检测日志文件上次修改的时间，如

果系统当前时间与上次修改时间不是一天，则将日志文件重新命名，在生成一个新的日志文件，例如日志文件是log.log，检测上次修改时间早于当天，则将log.log重命名为log.log.2008-11-7，并将log.log清空来打新的日志，其中2008-11-7是有配置文件指定的。

         RollingFileAppender在往日志文件打log的时候会根据配置文件设置的最大文件大小来与当前日志文件做比较，如果比文件大时，则将log文件重命名，规则为：根据最大日志备份个数做备份，例如最大日志备份个数设置为3，则将log.log更名为log.log.1、log.log.2、log.log.3、每次会判断这三个文件是否存在，如果存在，则将后缀最大的那个删掉，往后顺移一个，将log.log放到log.log.1中。

 

5.       现在需要做的就是将这两种方式的操作做一下修改。

DailyRollingFileAppender在判断需要将log.log重命名为log.log.2008-11-7时，我们将重命名这个操作改成将log.log打到zip包里面即可；同理，RollingFileAppender也是将文件重命名的操作改成打zip包。

 

6.       实现中主要需要修改两个类中的两个方法，相关代码如下：

DailyRollingFileAppender.java

修改方法rollOver

  

1. void rollOver() throws IOException {
5.         // Compute filename, but only if datePattern is specified 
7.         if (datePattern == null) {
9.           errorHandler.error("Missing DatePattern option in rollOver().");
11.           return;
13.         }
17.         String datedFilename = fileName+sdf.format(now);
19.         // It is too early to roll over because we are still within the
21.         // bounds of the current interval. Rollover will occur once the
23.         // next interval is reached.
25.         if (scheduledFilename.equals(datedFilename)) {
27.           return;
29.         }
33.         // close current file, and rename it to datedFilename
35.         this.closeFile();
39.         File target  = new File(scheduledFilename + ".zip");
41.         if (target.exists()) {
43.           target.delete();
45.         }
47.         //log old file 
49.         File file = new File(fileName);
51.         
53.         //creat zip output stream to build zip file
55.         ZipOutputStream out = null;
57.        FileInputStream fin = null;
59.        byte[] buf = new byte[1024];
61.         
63.        //file -> zip
65.        try{
67.            fin = new FileInputStream(file);
69.            out = new ZipOutputStream(new FileOutputStream(scheduledFilename + ".zip"));
71.            out.putNextEntry(new ZipEntry(file.getPath()));
73.        
75.            LogLog.debug(fileName + " -> " + scheduledFilename + ".zip");
77.        
79.            int len;
83.            while ((len = fin.read(buf)) > 0) {
85.               out.write(buf, 0, len);
87.            }
89.            
91.            out.closeEntry();
93.            fin.close();
95.            
97.            LogLog.debug(fileName + " -> " + scheduledFilename + ".zip successful!");
99.        }catch(IOException e) {
101.           errorHandler.error("add zip file("+scheduledFilename+") failed.");
103.         }
105.        finally{
107.            if (out != null) {
109.               out.closeEntry();
111.               out.close();
113.            }
115.            if (fin != null)
117.               fin.close();
119.        }
121.        
123.        //delete old file
125.        file.delete();
127.        
129.         try {
131.           // This will also close the file. This is OK since multiple
133.           // close operations are safe.
135.           this.setFile(fileName, true, this.bufferedIO, this.bufferSize);
137.         }
139.         catch(IOException e) {
141.           errorHandler.error("setFile("+fileName+", true) call failed.");
143.         }
145.         scheduledFilename = datedFilename;
147.   }

 

RollingFileAppender.java

同样是修改rollOver方法：

1. public// synchronization not necessary since doAppend is alreasy synched
3.     void rollOver() {
5.        File target;
7.        File file;
11.        if (qw != null) {
13.            long size = ((CountingQuietWriter) qw).getCount();
15.            LogLog.debug("rolling over count=" + size);
17.            // if operation fails, do not roll again until
19.            // maxFileSize more bytes are written
21.            nextRollover = size + maxFileSize;
23.        }
25.        LogLog.debug("maxBackupIndex=" + maxBackupIndex);
29.        boolean renameSucceeded = true;
31.        // If maxBackups <= 0, then there is no file renaming to be done.
33.        if (maxBackupIndex > 0) {
35.            // Delete the oldest file, to keep Windows happy.
37.            file = new File(fileName + maxBackupIndex + ".zip");
39.            if (file.exists())
41.               renameSucceeded = file.delete();
45.            // Map {(maxBackupIndex - 1), ..., 2, 1} to {maxBackupIndex, ..., 3,
47.            // 2}
49.            for (int i = maxBackupIndex - 1; i >= 1 && renameSucceeded; i--) {
51.               file = new File(fileName + i + ".zip");
53.               if (file.exists()) {
55.                   target = new File(fileName + (i + 1) + ".zip");
57.                   LogLog.debug("Renaming file " + file + " to " + target);
59.                   renameSucceeded = file.renameTo(target);
61.               }
63.            }
67.            if (renameSucceeded) {
69.               // zip fileName to fileName1.zip
71.               
73.               this.closeFile(); // keep windows happy.
77.               file = new File(fileName);
79.               // LogLog.debug("compress file " + file + " to " + target);
83.               ZipOutputStream out = null;
85.               FileInputStream fin = null;
87.               byte[] buf = new byte[8192];
91.               try {
93.                   //create zip out put stream to build zip file
95.                   fin = new FileInputStream(file);
97.                   out = new ZipOutputStream(new FileOutputStream(fileName
99.                          + 1 + ".zip"));
101.                   out.putNextEntry(new ZipEntry(file.getPath()));
105.                   LogLog.debug(fileName + " -> " + fileName + 1
107.                          + ".zip");
111.                   int len;
115.                   while ((len = fin.read(buf)) > 0) {
117.                      out.write(buf, 0, len);
119.                   }
123.                   out.closeEntry();
125.                   fin.close();
129.                   LogLog.debug(fileName + " -> " + fileName + 1
131.                          + ".zip successful!");
133.                   
135.                   file.delete();
139.               } catch (IOException e) {
141.                   errorHandler.error("add zip file(" + fileName + 1
143.                          + ".zip) failed.");
145.               }finally{
147.                   try {
149.                      if (out != null) {
151.                          out.closeEntry();
153.                          out.close();
155.                      }
157.                      if (fin != null)
159.                          fin.close();
161.                   } catch (IOException e) {
163.                      // TODO Auto-generated catch block
165.                      errorHandler.error("close out and fin failed.");
167.                   }
169.               }
173.               // if file compress failed, reopen file with append = true
175.               //
177.               if (!renameSucceeded) {
179.                   try {
181.                      this.setFile(fileName, true, bufferedIO, bufferSize);
183.                   } catch (IOException e) {
185.                      if (e instanceof InterruptedIOException) {
187.                          Thread.currentThread().interrupt();
189.                      }
191.                      LogLog.error("setFile(" + fileName
193.                             + ", true) call failed.", e);
195.                   }
197.               }
199.            }
201.        }
205.        //
207.        // if all renames were successful, then
209.        //
211.        if (renameSucceeded) {
213.            try {
215.               // This will also close the file. This is OK since multiple
217.               // close operations are safe.
219.               this.setFile(fileName, false, bufferedIO, bufferSize);
221.               nextRollover = 0;
223.            } catch (IOException e) {
225.               if (e instanceof InterruptedIOException) {
227.                   Thread.currentThread().interrupt();
229.               }
231.               LogLog
233.                      .error("setFile(" + fileName + ", false) call failed.",
235.                             e);
237.            }
239.        }
241. }

 

7.       最后，由于打zip包的时候用到了Ant中的zip代码，下载带源代码的Ant包，链接是

http://archive.apache.org/dist/ant/source/apache-ant-1.6.5-src.zip 。将里面zip的类放入log4j工程中，并用refactor将包重命名到org.apache.log4j中。

 

 

PS：这样做肯定会影响Log4j对输出日志的性能的影响，需要做进一步的性能方面的测试。