Java tutorial
package com.pr7.logging; /** * CustomDailyRollingFileAppender.java * Adapted from the Apache Log4j DailyRollingFileAppender to extend the functionality * of the existing class so that the user can limit the number of log backups * and compress the backups to conserve disk space. * @author Ryan Kimber * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import java.io.File; import java.io.FileFilter; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; import java.util.Locale; import java.util.TimeZone; import java.util.zip.ZipEntry; import java.util.zip.ZipOutputStream; import org.apache.commons.lang.StringUtils; import org.apache.log4j.FileAppender; import org.apache.log4j.Layout; import org.apache.log4j.helpers.LogLog; import org.apache.log4j.spi.LoggingEvent; import com.pr7.util.DateUtil; import com.pr7.util.PropertyHelper; /** * CustomDailyRollingFileAppender is based on * {@link org.apache.log4j.appender.DailyRollingFileAppender} so most of the * configuration options can be taken from the documentation on that class. * http://developerselixir.blogspot.com/2008/07/improving-log4j-dailyrollingfileappende.html */ public class CustomDailyRollingFileAppender extends FileAppender { // The code assumes that the following constants are in a increasing // sequence. static final int TOP_OF_TROUBLE = -1; static final int TOP_OF_MINUTE = 0; static final int TOP_OF_HOUR = 1; static final int HALF_DAY = 2; static final int TOP_OF_DAY = 3; static final int TOP_OF_WEEK = 4; static final int TOP_OF_MONTH = 5; /** * The date pattern. By default, the pattern is set to "'.'yyyy-MM-dd" * meaning daily rollover. */ private String datePattern = "'.'yyyy-MM-dd"; private String jndiName; private String archiveMaxDays = "30"; private String archiveCompress = "true"; private String archiveTiming = "03:00:00";//11am GMT+8 private Date lastBackup; /** * The log file will be renamed to the value of the scheduledFilename * variable when the next interval is entered. For example, if the rollover * period is one hour, the log file will be renamed to the value of * "scheduledFilename" at the beginning of the next hour. * * The precise time when a rollover occurs depends on logging activity. */ private String scheduledFilename; /** * The next time we estimate a rollover should occur. */ private long nextCheck = System.currentTimeMillis() - 1; Date now = new Date(); SimpleDateFormat sdf; RollingCalendar rc = new RollingCalendar(); int checkPeriod = TOP_OF_TROUBLE; // The gmtTimeZone is used only in computeCheckPeriod() method. static final TimeZone gmtTimeZone = TimeZone.getTimeZone("GMT"); /** * The default constructor does nothing. */ public CustomDailyRollingFileAppender() { } /** * Instantiate a CustomDailyRollingFileAppender and open the file designated * by filename. The opened filename will become the ouput destination for * this appender. */ public CustomDailyRollingFileAppender(Layout layout, String filename, String datePattern) throws IOException { super(layout, filename, true); this.datePattern = datePattern; activateOptions(); } /** * The DatePattern takes a string in the same format as expected by * {@link SimpleDateFormat}. This options determines the rollover schedule. */ public void setDatePattern(String pattern) { datePattern = pattern; } /** Returns the value of the DatePattern option. */ public String getDatePattern() { return datePattern; } public void activateOptions() { super.activateOptions(); if (datePattern != null && fileName != null) { now.setTime(System.currentTimeMillis()); sdf = new SimpleDateFormat(datePattern); int type = computeCheckPeriod(); System.out .println("CustomDailyRollingFileAppender:: type = " + type + ", append = " + this.getAppend()); printPeriodicity(type); rc.setType(type); File file = new File(fileName); scheduledFilename = fileName + sdf.format(new Date(file.lastModified())); } else { LogLog.error("Either File or DatePattern options are not set for appender [" + name + "]."); } } void printPeriodicity(int type) { switch (type) { case TOP_OF_MINUTE: LogLog.debug("Appender [" + name + "] to be rolled every minute."); break; case TOP_OF_HOUR: LogLog.debug("Appender [" + name + "] to be rolled on top of every hour."); break; case HALF_DAY: LogLog.debug("Appender [" + name + "] to be rolled at midday and midnight."); break; case TOP_OF_DAY: LogLog.debug("Appender [" + name + "] to be rolled at midnight."); break; case TOP_OF_WEEK: LogLog.debug("Appender [" + name + "] to be rolled at start of week."); break; case TOP_OF_MONTH: LogLog.debug("Appender [" + name + "] to be rolled at start of every month."); break; default: LogLog.warn("Unknown periodicity for appender [" + name + "]."); } } // This method computes the roll over period by looping over the // periods, starting with the shortest, and stopping when the r0 is // different from from r1, where r0 is the epoch formatted according // the datePattern (supplied by the user) and r1 is the // epoch+nextMillis(i) formatted according to datePattern. All date // formatting is done in GMT and not local format because the test // logic is based on comparisons relative to 1970-01-01 00:00:00 // GMT (the epoch). int computeCheckPeriod() { RollingCalendar rollingCalendar = new RollingCalendar(gmtTimeZone, Locale.ENGLISH); // set sate to 1970-01-01 00:00:00 GMT Date epoch = new Date(0); if (datePattern != null) { for (int i = TOP_OF_MINUTE; i <= TOP_OF_MONTH; i++) { SimpleDateFormat simpleDateFormat = new SimpleDateFormat(datePattern); simpleDateFormat.setTimeZone(gmtTimeZone); // do all date // formatting in GMT String r0 = simpleDateFormat.format(epoch); rollingCalendar.setType(i); Date next = new Date(rollingCalendar.getNextCheckMillis(epoch)); String r1 = simpleDateFormat.format(next); // System.out.println("Type = "+i+", r0 = "+r0+", r1 = "+r1); if (r0 != null && r1 != null && !r0.equals(r1)) { return i; } } } return TOP_OF_TROUBLE; // Deliberately head for trouble... } /** * Rollover the current file to a new file. */ void rollOver() throws IOException { /* Compute filename, but only if datePattern is specified */ if (datePattern == null) { errorHandler.error("Missing DatePattern option in rollOver()."); return; } String datedFilename = fileName + sdf.format(now); // It is too early to roll over because we are still within the // bounds of the current interval. Rollover will occur once the // next interval is reached. if (scheduledFilename.equals(datedFilename)) { return; } // close current file, and rename it to datedFilename this.closeFile(); File target = new File(scheduledFilename); if (target.exists()) { target.delete(); } File file = new File(fileName); boolean result = file.renameTo(target); if (result) { LogLog.debug(fileName + " -> " + scheduledFilename); } else { LogLog.error("Failed to rename [" + fileName + "] to [" + scheduledFilename + "]."); } try { // This will also close the file. This is OK since multiple // close operations are safe. this.setFile(fileName, false, this.bufferedIO, this.bufferSize); } catch (IOException e) { errorHandler.error("setFile(" + fileName + ", false) call failed."); } scheduledFilename = datedFilename; } /** * This method differentiates DailyRollingFileAppender from its super class. * * * Before actually logging, this method will check whether it is time to do * a rollover. If it is, it will schedule the next rollover time and then * rollover. * */ protected void subAppend(LoggingEvent event) { long n = System.currentTimeMillis(); if (n >= nextCheck) { now.setTime(n); nextCheck = rc.getNextCheckMillis(now); try { cleanupAndRollOver(); } catch (IOException ioe) { LogLog.error("cleanupAndRollover() failed.", ioe); } } super.subAppend(event); } public String getJndiName() { return jndiName; } public void setJndiName(String jndiName) { this.jndiName = jndiName; } public String getArchiveMaxDays() { return archiveMaxDays; } public void setArchiveMaxDays(String archiveMaxDays) { String jndiKey = StringUtils.substringBetween(archiveMaxDays, "{", "}"); this.archiveMaxDays = PropertyHelper.getProperty(jndiName, jndiKey); if (this.archiveMaxDays == null) { this.archiveMaxDays = "30"; } System.out.println("archiveMaxDays = " + this.archiveMaxDays); } public String getArchiveCompress() { return archiveCompress; } public void setArchiveCompress(String archiveCompress) { String jndiKey = StringUtils.substringBetween(archiveCompress, "{", "}"); this.archiveCompress = PropertyHelper.getProperty(jndiName, jndiKey); if (this.archiveCompress == null) { this.archiveCompress = "true"; } System.out.println("archiveCompress = " + this.archiveCompress); } public String getArchiveTiming() { return archiveTiming; } public void setArchiveTiming(String archiveTiming) { String jndiKey = StringUtils.substringBetween(archiveTiming, "{", "}"); this.archiveTiming = PropertyHelper.getProperty(jndiName, jndiKey); if (this.archiveTiming == null) { this.archiveTiming = "07:00:00"; } System.out.println("archiveTiming = " + this.archiveTiming); } public Date getLastBackup() { return lastBackup; } public void setLastBackup(Date lastBackup) { this.lastBackup = lastBackup; } /* * This method checks to see if we're exceeding the number of log backups * that we are supposed to keep, and if so, deletes the offending files. It * then delegates to the rollover method to rollover to a new file if * required. */ protected void cleanupAndRollOver() throws IOException { // try { // customCleanUp(); // } catch(Exception e) { // e.printStackTrace(); // } rollOver(); } private void customCleanUp() { // Check to see if there are already 5 files File file = new File(fileName); Calendar cal = Calendar.getInstance(); int maxDays = 30; try { maxDays = Integer.parseInt(archiveMaxDays); } catch (Exception e) { // just leave it at 30. } cal.add(Calendar.DATE, -maxDays); Date cutoffDate = cal.getTime(); Date timeBackup = DateUtil.parse(DateUtil.format(new Date(), "dd/MM/yyyy ") + archiveTiming, "dd/MM/yyyy HH:mm:ss"); //This make sure only backup once per day //System.out.println("cleanupAndRollOver checked:: cutoffDate = " + cutoffDate + ", timeBackup = " + timeBackup + ", lastBackup = " + lastBackup + ", file.getParentFile().exists() = " + file.getParentFile().exists()); if ((lastBackup == null || timeBackup.after(lastBackup)) && timeBackup.compareTo(new Date()) <= 0 && file.getParentFile().exists()) { System.out.println("cleanupAndRollOver executed:: cutoffDate = " + cutoffDate + ", timeBackup = " + timeBackup + ", lastBackup = " + lastBackup); File[] files = file.getParentFile().listFiles(new StartsWithFileFilter(file.getName(), false)); System.out.println("cleanupAndRollOver executed:: files size = " + files.length + ", file.getName() = " + file.getName()); int nameLength = file.getName().length(); for (int i = 0; i < files.length; i++) { String datePart = null; try { if (!file.getName().equals(files[i].getName())) { datePart = files[i].getName().substring(nameLength); Date date = sdf.parse(datePart); //System.out.println("date = " + date + " vs cutoffDate " + cutoffDate); if (date.before(cutoffDate)) { if (archiveCompress.equalsIgnoreCase("TRUE")) { zipAndDelete(files[i]); } else { System.out.println("delete file = " + files[i].getName()); files[i].delete(); } } } } catch (Exception e) { // e.printStackTrace(); // This isn't a file we should touch (it isn't named // correctly) } } lastBackup = new Date(); } } /** * Compresses the passed file to a .zip file, stores the .zip in the same * directory as the passed file, and then deletes the original, leaving only * the .zipped archive. * * @param file */ private void zipAndDelete(File file) throws IOException { if (!file.getName().endsWith(".zip")) { System.out.println("zipAndDelete file = " + file.getName()); String folderName = "archive"; File folder = new File(file.getParent(), folderName); if (!folder.exists()) { if (folder.mkdir()) { System.out.println("Create " + folderName + " success."); } else { System.out.println("Create " + folderName + " failed."); } } File zipFile = new File(folder, file.getName() + ".zip"); FileInputStream fis = new FileInputStream(file); FileOutputStream fos = new FileOutputStream(zipFile); ZipOutputStream zos = new ZipOutputStream(fos); ZipEntry zipEntry = new ZipEntry(file.getName()); zos.putNextEntry(zipEntry); byte[] buffer = new byte[4096]; while (true) { int bytesRead = fis.read(buffer); if (bytesRead == -1) break; else { zos.write(buffer, 0, bytesRead); } } zos.closeEntry(); fis.close(); zos.close(); file.delete(); } } class StartsWithFileFilter implements FileFilter { private String startsWith; private boolean inclDirs = false; /** * */ public StartsWithFileFilter(String startsWith, boolean includeDirectories) { super(); this.startsWith = startsWith.toUpperCase(); inclDirs = includeDirectories; } /* * (non-Javadoc) * * @see java.io.FileFilter#accept(java.io.File) */ public boolean accept(File pathname) { if (!inclDirs && pathname.isDirectory()) { return false; } else return pathname.getName().toUpperCase().startsWith(startsWith); } } } /** * RollingCalendar is a helper class to DailyRollingFileAppender. Given a * periodicity type and the current time, it computes the start of the next * interval. * */ class RollingCalendar extends GregorianCalendar { private static final long serialVersionUID = -3560331770601814177L; int type = CustomDailyRollingFileAppender.TOP_OF_TROUBLE; RollingCalendar() { super(); } RollingCalendar(TimeZone tz, Locale locale) { super(tz, locale); } void setType(int type) { this.type = type; } public long getNextCheckMillis(Date now) { return getNextCheckDate(now).getTime(); } public Date getNextCheckDate(Date now) { this.setTime(now); switch (type) { case CustomDailyRollingFileAppender.TOP_OF_MINUTE: this.set(Calendar.SECOND, 0); this.set(Calendar.MILLISECOND, 0); this.add(Calendar.MINUTE, 1); break; case CustomDailyRollingFileAppender.TOP_OF_HOUR: this.set(Calendar.MINUTE, 0); this.set(Calendar.SECOND, 0); this.set(Calendar.MILLISECOND, 0); this.add(Calendar.HOUR_OF_DAY, 1); break; case CustomDailyRollingFileAppender.HALF_DAY: this.set(Calendar.MINUTE, 0); this.set(Calendar.SECOND, 0); this.set(Calendar.MILLISECOND, 0); int hour = get(Calendar.HOUR_OF_DAY); if (hour < 12) { this.set(Calendar.HOUR_OF_DAY, 12); } else { this.set(Calendar.HOUR_OF_DAY, 0); this.add(Calendar.DAY_OF_MONTH, 1); } break; case CustomDailyRollingFileAppender.TOP_OF_DAY: this.set(Calendar.HOUR_OF_DAY, 0); this.set(Calendar.MINUTE, 0); this.set(Calendar.SECOND, 0); this.set(Calendar.MILLISECOND, 0); this.add(Calendar.DATE, 1); break; case CustomDailyRollingFileAppender.TOP_OF_WEEK: this.set(Calendar.DAY_OF_WEEK, getFirstDayOfWeek()); this.set(Calendar.HOUR_OF_DAY, 0); this.set(Calendar.MINUTE, 0); this.set(Calendar.SECOND, 0); this.set(Calendar.MILLISECOND, 0); this.add(Calendar.WEEK_OF_YEAR, 1); break; case CustomDailyRollingFileAppender.TOP_OF_MONTH: this.set(Calendar.DATE, 1); this.set(Calendar.HOUR_OF_DAY, 0); this.set(Calendar.MINUTE, 0); this.set(Calendar.SECOND, 0); this.set(Calendar.MILLISECOND, 0); this.add(Calendar.MONTH, 1); break; default: throw new IllegalStateException("Unknown periodicity type."); } return getTime(); } }