自定义实现log4j的FileAppender

log4j 工作中自己用的FileAppender
功能：默认创建一个文件 ，当文件大小超过配置文件中的限度的时候，压缩到一个压缩包中，
      压缩包中的文件的数量可以再配置文件中配置；

log4j.properties文件的配置（文件大小1M，压缩包中最多压缩8个文件）

log4j.rootLogger=INFO,console,file

# console
log4j.logger.console=ERROR,console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d %-5p [%C] %m%n
#log4j.appender.console.layout.ConversionPattern=%-5p [%C][%L] %m%n

# file
log4j.logger.file=ERROR,file
log4j.appender.file=com.tangdou.BackupRollingFileAppenderProxy
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d %p [%c] - %m%n
# windows
#log4j.appender.file.file=D:/log/mms.log{0}
#log4j.appender.file.backupPath=D:/log/WEB-INF/log/bak
log4j.appender.file.file=D:/tangdou.log{0}
log4j.appender.file.backupPath=${catalina.base}/logs/log/WEB-INF/log/bak

#linux
#log4j.appender.file.file=D:/log/zzEquipmentManager.log{0}
#log4j.appender.file.backupPath=D:/log/WEB-INF/log/bak
log4j.appender.file.maxFileSize=1024KB
log4j.appender.file.maxBackupIndex=8

---------------------------------

package com.tangdou;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.MessageFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import org.apache.commons.io.IOUtils;
import org.apache.log4j.RollingFileAppender;
import org.apache.log4j.helpers.LogLog;

public class BackupRollingFileAppender extends RollingFileAppender {
	public static final String ZIP_SUFFIX = ".zip";
	public static final String ZIP_DATE_FMT = "yyyyMMddHHmmss";
	public static final String ZIP_NAME_LIST_SEPARATOR = "_";
	private String backupPath;
	private String backupFilePrefix;
	private String filePattern;

	public void rollOver() {
		int maxbakIndex = getMaxBackupIndex();
		if (maxbakIndex > 0)
			if (new File(MessageFormat.format(getFilePattern(),
					new Object[] { Integer.valueOf(maxbakIndex) })).exists()) {
				try {
					backup();
				} catch (IOException e) {
					LogLog.error("Cannot backup logs", e);
				}
			}

		if (this.maxBackupIndex > 0) {
			File file = new File(MessageFormat.format(getFilePattern(),
					new Object[] { Integer.valueOf(this.maxBackupIndex) }));
			if (file.exists()) {
				file.delete();
			}

			for (int i = this.maxBackupIndex - 1; i >= 1; --i) {
				file = new File(MessageFormat.format(getFilePattern(),
						new Object[] { Integer.valueOf(i) }));
				if (file.exists()) {
					File target = new File(MessageFormat.format(
							getFilePattern(),
							new Object[] { Integer.valueOf(i + 1) }));
					LogLog.debug("Renaming file " + file + " to " + target);
					file.renameTo(target);
				}
			}

			File target = new File(MessageFormat.format(getFilePattern(),
					new Object[] { Integer.valueOf(1) }));
			closeFile();
			file = new File(getFile());
			LogLog.debug("Renaming file " + file + " to " + target);
			file.renameTo(target);
		}

		try {
			setFile(getFile(), false, this.bufferedIO, this.bufferSize);
		} catch (IOException e) {
			LogLog.error("setFile(" + getFile() + ", false) call failed.", e);
		}
	}

	public void backup() throws IOException {
		File bakDir = getBackupDir();
		File bakFile = new File(bakDir, Long.toString(System
				.currentTimeMillis()));
		long backupFileMinLastModified = -1L;
		long backupFileMaxLastModified = -1L;
		int maxbakIndex = getMaxBackupIndex();

		ZipOutputStream zos = null;
		boolean succeed = false;
		try {
			zos = new ZipOutputStream(new FileOutputStream(bakFile));
			for (int i = 1; i <= maxbakIndex; ++i) {
				File file = new File(MessageFormat.format(getFilePattern(),
						new Object[] { Integer.valueOf(i) }));
				if (file.exists()) {
					long lastModified = file.lastModified();

					if (backupFileMinLastModified == -1L) {
						backupFileMinLastModified = lastModified;
					} else if (backupFileMinLastModified > lastModified) {
						backupFileMinLastModified = lastModified;
					}

					if (backupFileMaxLastModified < lastModified) {
						backupFileMaxLastModified = lastModified;
					}

					ZipEntry entry = new ZipEntry(file.getName());
					entry.setSize(file.length());
					entry.setTime(lastModified);
					zos.putNextEntry(entry);
					FileInputStream fis = null;
					try {
						fis = new FileInputStream(file);
						IOUtils.copyLarge(fis, zos);
					} finally {
						IOUtils.closeQuietly(fis);
					}
					zos.closeEntry();
				}
			}
			zos.finish();
			succeed = true;
		} finally {
			IOUtils.closeQuietly(zos);

			if ((!(succeed)) && (bakFile.exists())) {
				bakFile.delete();
			}
		}

		if ((backupFileMinLastModified != -1L)
				&& (backupFileMaxLastModified != -1L)) {
			StringBuffer name = new StringBuffer(getBackupFilePrefix());
			Date minDate = new Date(backupFileMinLastModified);
			name.append("_").append(toString(minDate, "yyyyMMddHHmmss", ""));
			Date maxDate = new Date(backupFileMaxLastModified);
			name.append("_").append(toString(minDate, "yyyyMMddHHmmss", ""));
			name.append(".zip");
			File f = new File(bakDir, name.toString());
			bakFile.renameTo(f);

			if (succeed) {
				for (int i = 1; i <= maxbakIndex; ++i) {
					File file = new File(MessageFormat.format(getFilePattern(),
							new Object[] { Integer.valueOf(i) }));
					if (file.exists()) {
						file.delete();
					}
				}
			}
		} else {
			LogLog.warn("Not file to backup.");
		}
	}

	public String getBackupFilePrefix() {
		if (StringUtils.isEmpty(this.backupFilePrefix)) {
			String name = new File(StringUtils.replace(getFilePattern(), "{",
					"}", new IStringReplaceProcess() {

						@Override
						public String doReplace(String paramString,
								int paramInt1, int paramInt2) {
							return null;
						}
					})).getName();

			if (name.lastIndexOf(".") != -1) {
				name = StringUtils.substringBeforeLast(name, ".");
			}

			while (name.endsWith(".")) {
				name = StringUtils.substringBeforeLast(name, ".");
			}

			return name;
		}

		return this.backupFilePrefix;
	}

	public void setFile(String file) {
		this.filePattern = file;

		String fileToUse = StringUtils.replace(file, "{", "}",
				new IStringReplaceProcess() {

					@Override
					public String doReplace(String paramString, int paramInt1,
							int paramInt2) {
						// TODO Auto-generated method stub
						return null;
					}
				});
		super.setFile(fileToUse);
	}

	public String getFilePattern() {
		return this.filePattern;
	}

	public void setBackupFilePrefix(String backupFilePrefix) {
		this.backupFilePrefix = backupFilePrefix;
	}

	private File getBackupDir() throws IOException {
		File bakDir = new File(this.backupPath);
		if ((!(bakDir.exists())) && (!(bakDir.mkdirs()))) {
			throw new IOException("Cannot create log backup dir ["
					+ this.backupPath + "]");
		}
		return bakDir;
	}

	public String getBackupPath() {
		return this.backupPath;
	}

	public void setBackupPath(String backupPath) {
		this.backupPath = backupPath;
	}

	public String toString(Date date, String dateFormatString,
			String defaultValue) {
		if (date == null) {
			return defaultValue;
		}

		try {
			return new SimpleDateFormat(dateFormatString).format(date);
		} catch (Throwable e) {
		}
		return defaultValue;
	}
}

-------------------------------------

package com.tangdou;

import java.io.File;
import java.io.IOException;

import org.apache.log4j.Appender;
import org.apache.log4j.Layout;
import org.apache.log4j.Logger;
import org.apache.log4j.spi.ErrorHandler;
import org.apache.log4j.spi.Filter;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.OptionHandler;

public class BackupRollingFileAppenderProxy implements Appender, OptionHandler {
	private static final Logger log = Logger
			.getLogger(BackupRollingFileAppenderProxy.class);
	private BackupRollingFileAppender appender = new BackupRollingFileAppender();
	private String evalPrefix = "${";
	private String evalSuffix = "}";
	private String append;
	private String bufferedIO;
	private String bufferSize;
	private String encoding;
	private String file;
	private String immediateFlush;
	private String maxBackupIndex;
	private String maxFileSize;
	private String maximumFileSize;
	private String backupPath;

	public void addFilter(Filter newFilter) {
		this.appender.addFilter(newFilter);
	}

	public void clearFilters() {
		this.appender.clearFilters();
	}

	public void close() {
		this.appender.close();
	}

	public void doAppend(LoggingEvent event) {
		this.appender.doAppend(event);
	}

	public ErrorHandler getErrorHandler() {
		return this.appender.getErrorHandler();
	}

	public Filter getFilter() {
		return this.appender.getFilter();
	}

	public Layout getLayout() {
		return this.appender.getLayout();
	}

	public String getName() {
		return this.appender.getName();
	}

	public boolean requiresLayout() {
		return this.appender.requiresLayout();
	}

	public void setErrorHandler(ErrorHandler errorHandler) {
		this.appender.setErrorHandler(errorHandler);
	}

	public void setLayout(Layout layout) {
		this.appender.setLayout(layout);
	}

	public void setName(String name) {
		this.appender.setName(name);
	}

	public void activateOptions() {
		String value;
		if (StringUtils.isNotEmpty(this.append)) {
			String flag = BIPropertiesBean.replace(this.append,
					this.evalPrefix, this.evalSuffix);
			this.appender.setAppend(ConvertUtils.toBool(flag));
		}
		if (StringUtils.isNotEmpty(this.bufferedIO)) {
			String bio = BIPropertiesBean.replace(this.bufferedIO,
					this.evalPrefix, this.evalSuffix);
			this.appender.setBufferedIO(ConvertUtils.toBool(bio));
		}
		if (StringUtils.isNotEmpty(this.bufferSize)) {
			String bs = BIPropertiesBean.replace(this.bufferSize,
					this.evalPrefix, this.evalSuffix);
			this.appender.setBufferSize(ConvertUtils.toInt(bs));
		}
		if (StringUtils.isNotEmpty(this.encoding)) {
			value = BIPropertiesBean.replace(this.encoding, this.evalPrefix,
					this.evalSuffix);
			this.appender.setEncoding(value);
		}
		if (StringUtils.isNotEmpty(this.file)) {
			String f = BIPropertiesBean.replace(this.file, this.evalPrefix,
					this.evalSuffix);
			this.appender.setFile(f);
		}
		if (StringUtils.isNotEmpty(this.immediateFlush)) {
			value = BIPropertiesBean.replace(this.immediateFlush,
					this.evalPrefix, this.evalSuffix);
			this.appender.setImmediateFlush(ConvertUtils.toBool(value));
		}
		if (StringUtils.isNotEmpty(this.maxBackupIndex)) {
			String maxBackups = BIPropertiesBean.replace(this.maxBackupIndex,
					this.evalPrefix, this.evalSuffix);
			this.appender.setMaxBackupIndex(ConvertUtils.toInt(maxBackups));
		}
		if (StringUtils.isNotEmpty(this.maxFileSize)) {
			value = BIPropertiesBean.replace(this.maxFileSize, this.evalPrefix,
					this.evalSuffix);
			this.appender.setMaxFileSize(value);
		}
		if (StringUtils.isNotEmpty(this.maximumFileSize)) {
			String maxFileSize = BIPropertiesBean.replace(this.maximumFileSize,
					this.evalPrefix, this.evalSuffix);
			this.appender.setMaximumFileSize(ConvertUtils.toLong(maxFileSize));
		}
		if (StringUtils.isNotEmpty(this.backupPath)) {
			String bp = BIPropertiesBean.replace(this.backupPath,
					this.evalPrefix, this.evalSuffix);
			this.appender.setBackupPath(bp);
		}

		boolean hasFile = true;
		File testFile = new File(this.appender.getFile());
		if (!(testFile.exists())) {
			hasFile = false;

			boolean mkd = true;
			boolean cnf = true;

			String parentName = new File(this.appender.getFile()).getParent();
			if (parentName != null) {
				File parentDir = new File(parentName);

				if (!(parentDir.exists())) {
					mkd = parentDir.mkdirs();
					if (mkd) {
						log.info("Success");
					} else {
						log.error("Fail");
					}

				}

				try {
					cnf = testFile.createNewFile();
					if (cnf) {
						log.info("Success to create new file.");
					} else {
						log.error("Fail to create new file.");
					}

					hasFile = true;
				} catch (IOException e) {
					log.error(null, e);
				}
			}
		}
		if (hasFile) {
			this.appender.activateOptions();
		}
	}

	public void setAppend(String append) {
		this.append = append;
	}

	public void setBufferedIO(String bufferedIO) {
		this.bufferedIO = bufferedIO;
	}

	public void setBufferSize(String bufferSize) {
		this.bufferSize = bufferSize;
	}

	public void setEncoding(String encoding) {
		this.encoding = encoding;
	}

	public void setFile(String file) {
		this.file = file;
	}

	public String getFile() {
		return this.appender.getFile();
	}

	public void setImmediateFlush(String immediateFlush) {
		this.immediateFlush = immediateFlush;
	}

	public void setMaxBackupIndex(String maxBackupIndex) {
		this.maxBackupIndex = maxBackupIndex;
	}

	public void setMaxFileSize(String maxFileSize) {
		this.maxFileSize = maxFileSize;
	}

	public void setMaximumFileSize(String maximumFileSize) {
		this.maximumFileSize = maximumFileSize;
	}

	public String getBackupPath() {
		return this.appender.getBackupPath();
	}

	public void setBackupPath(String backupPath) {
		this.backupPath = backupPath;
	}

	public void setEvalPrefix(String evalPrefix) {
		this.evalPrefix = evalPrefix;
	}

	public void setEvalSuffix(String evalSuffix) {
		this.evalSuffix = evalSuffix;
	}
}

--------------------------------------------------------------------

package com.tangdou;

import java.util.Enumeration;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.Vector;
import org.apache.log4j.Logger;

public class BIPropertiesBean {
	private static final Logger log = Logger.getLogger(BIPropertiesBean.class);
	private static Properties properties = new Properties();
	public static final String WEB_APP_ROOT_KEY = "webAppRootKey";
	public static final String WEB_APP_TEMP_ROOT_KEY = "webAppTempRootKey";
	public static final String BI_ENCODING_KEY = "bi.i18n.encoding";
	public static final String WEB_SERVERINFO_KEY = "webServerInfo";
	public static final String TOMCAT_WEB_SERVER_PREFIX = "Apache Tomcat";
	public static final String WEBLOGIC_WEB_SERVER_PREFIX = "WebLogic Server";
	private static Vector<BIPropertiesListener> propertiesListeners = new Vector();

	protected static void setProperties(Properties properties) {
		Properties desProperties = properties;
		properties = properties;
		desProperties.clear();

		fireBIPropertiesListener();
	}

	protected static void clear() {
		properties.clear();
	}

	protected static Object put(Object key, Object value) {
		return properties.put(key, value);
	}

	protected static void putAll(Map t) {
		properties.putAll(t);
	}

	protected static Object remove(Object key) {
		return properties.remove(key);
	}

	protected static void fireBIPropertiesListener() {
		Vector bipll = null;
		synchronized (propertiesListeners) {
			bipll = (Vector) propertiesListeners.clone();
		}
		for (Iterator localIterator = bipll.iterator(); localIterator.hasNext();) {
			BIPropertiesListener bipl = (BIPropertiesListener) localIterator
					.next();
			try {
				bipl.onBIPropertiesChange();
			} catch (Throwable t) {
				log.error(null, t);
			}
		}
	}

	public static void addBIPropertiesListener(BIPropertiesListener l) {
		synchronized (propertiesListeners) {
			if (!(propertiesListeners.contains(l))) {
				propertiesListeners.add(l);
			}
		}
	}

	public static void removeBIPropertiesListener(BIPropertiesListener l) {
		synchronized (propertiesListeners) {
			if (propertiesListeners.contains(l)) {
				propertiesListeners.remove(l);
			}
		}
	}

	public static String getServerInfo() {
		return properties.getProperty("webServerInfo");
	}

	public static boolean isTomcatServer() {
		String serverInfo = getServerInfo();
		if (log.isDebugEnabled()) {
			StringBuffer msg = new StringBuffer();
			msg.append("isTomcatServer() [").append(serverInfo).append("]");
			msg.append(" startsWith [").append("Apache Tomcat").append("]?");
			log.debug(msg.toString());
		}
		if (serverInfo != null) {
			return serverInfo.startsWith("Apache Tomcat");
		}

		return false;
	}

	public static boolean isWeblogicServer() {
		String serverInfo = getServerInfo();
		if (log.isDebugEnabled()) {
			StringBuffer msg = new StringBuffer();
			msg.append("isWeblogicServer() [").append(serverInfo).append("]");
			msg.append(" startsWith [").append("WebLogic Server").append("]?");
			log.debug(msg.toString());
		}
		if (serverInfo != null) {
			return serverInfo.startsWith("WebLogic Server");
		}

		return false;
	}

	public static boolean contains(Object value) {
		return properties.contains(value);
	}

	public static boolean containsKey(Object key) {
		return properties.containsKey(key);
	}

	public static boolean containsValue(Object value) {
		return properties.containsValue(value);
	}

	public static int getProperty(String key, int defaultValue) {
		String property = getProperty(key);
		return ConvertUtils.toInt(property, defaultValue);
	}

	public static long getProperty(String key, long defaultValue) {
		String property = getProperty(key);
		return ConvertUtils.toLong(property, defaultValue);
	}

	public static boolean getProperty(String key, boolean defaultValue) {
		String property = getProperty(key);
		return ConvertUtils.toBool(property, defaultValue);
	}

	public static String getProperty(String key) {
		return  getProperty(key, null);
	}

	public static String getProperty(String key, IPropertyProcess process) {
		return getProperty(key, null, process);
	}

	

	public static String getProperty(String key, String defaultValue,
			IPropertyProcess process) {
		String value = properties.getProperty(key, defaultValue);
		if (process != null) {
			StringBuffer msg;
			if (log.isDebugEnabled()) {
				msg = new StringBuffer();
				msg.append("before process property key [").append(key)
						.append("]");
				msg.append(" value [").append(value).append("]");
				log.debug(msg.toString());
			}
			value = process.process(key, value);
			if (log.isDebugEnabled()) {
				msg = new StringBuffer();
				msg.append("after process property key [").append(key)
						.append("]");
				msg.append(" value [").append(value).append("]");
				log.debug(msg.toString());
			}
		}
		return value;
	}

	public static String replaceEval(String valueString) {
		return replaceEval(valueString, null);
	}

	public static String replaceEval(String valueString, IPropertyProcess process)
  {
    return StringUtils.replaceEval(valueString, new IStringReplaceProcess() {
		
		@Override
		public String doReplace(String paramString, int paramInt1, int paramInt2) {
			// TODO Auto-generated method stub
			return null;
		}
	});
  }

	public static String replace(String valueString, String prefix,
			String suffix) {
		return replace(valueString, prefix, suffix, null);
	}

	public static String replace(String valueString, String prefix, String suffix, IPropertyProcess process)
  {
    return StringUtils.replace(valueString, prefix, suffix, new IStringReplaceProcess() {
		
		@Override
		public String doReplace(String paramString, int paramInt1, int paramInt2) {
			// TODO Auto-generated method stub
			return null;
		}
	});
  }

	public static boolean isEmpty() {
		return properties.isEmpty();
	}

	public static Enumeration propertyNames() {
		return properties.propertyNames();
	}

	public static int size() {
		return properties.size();
	}

}

-------------------------------------------

package com.tangdou;

public abstract interface BIPropertiesListener {
    public abstract void onBIPropertiesChange();
}

-----------------------------

package com.tangdou;

import org.apache.log4j.Logger;

public abstract class ConvertUtils {
	private static final Logger log = Logger.getLogger(ConvertUtils.class);
	private static final String WEB_INF = "/WEB-INF/";
	public static final String DATE_FMT = "yyyy-MM-dd";
	public static final String TIME_FMT = "HH:mm:ss";
	public static final String DT_FMT = "yyyy-MM-dd HH:mm:ss";
	public static final String DEFAULT_FMT = "yyyy-MM-dd";

	public static int[] toInt(Object[] objects) {
		if (objects == null) {
			return null;
		}

		int[] intObjects = new int[objects.length];
		for (int i = 0; i < intObjects.length; ++i) {
			intObjects[i] = toInt(objects[i]);
		}
		return intObjects;
	}

	public static int toInt(Object object) {

		if (object instanceof Integer) {
			return ((Integer) object).intValue();
		}
		if (object instanceof Short) {
			return ((Short) object).intValue();
		}
		if (object instanceof Double) {
			return ((Double) object).intValue();
		}
		if (object instanceof Long) {
			return ((Long) object).intValue();
		}
		if (object instanceof Float) {
			return ((Float) object).intValue();
		}
		if (object instanceof Number) {
			return ((Number) object).intValue();
		}

		return Integer.parseInt(object.toString());
	}

	public static int toInt(Object object, int defaultValue) {
		try {
			return toInt(object);
		} catch (Throwable e) {
		}
		return defaultValue;
	}

	public static short toShort(Object object) {

		if (object instanceof Short) {
			return ((Short) object).shortValue();
		}
		if (object instanceof Integer) {
			return ((Integer) object).shortValue();
		}
		if (object instanceof Double) {
			return ((Double) object).shortValue();
		}
		if (object instanceof Long) {
			return ((Long) object).shortValue();
		}
		if (object instanceof Float) {
			return ((Float) object).shortValue();
		}
		if (object instanceof Number) {
			return ((Number) object).shortValue();
		}

		return Short.parseShort(object.toString());
	}

	public static short toShort(Object object, short defaultValue) {
		try {
			return toShort(object);
		} catch (Throwable e) {
		}
		return defaultValue;
	}

	public static float toFloat(Object object) {

		if (object instanceof Float) {
			return ((Float) object).floatValue();
		}
		if (object instanceof Short) {
			return ((Short) object).floatValue();
		}
		if (object instanceof Integer) {
			return ((Integer) object).floatValue();
		}
		if (object instanceof Long) {
			return ((Long) object).floatValue();
		}
		if (object instanceof Double) {
			return ((Double) object).floatValue();
		}
		if (object instanceof Number) {
			return ((Number) object).floatValue();
		}

		return Float.parseFloat(object.toString());
	}

	public static float toFloat(Object object, float defaultValue) {
		try {
			return toFloat(object);
		} catch (Throwable e) {
		}
		return defaultValue;
	}

	public static double toDouble(Object object) {

		if (object instanceof Double) {
			return ((Double) object).doubleValue();
		}
		if (object instanceof Short) {
			return ((Short) object).doubleValue();
		}
		if (object instanceof Integer) {
			return ((Integer) object).doubleValue();
		}
		if (object instanceof Long) {
			return ((Long) object).doubleValue();
		}
		if (object instanceof Float) {
			return ((Float) object).doubleValue();
		}
		if (object instanceof Number) {
			return ((Number) object).doubleValue();
		}

		return Double.parseDouble(object.toString());
	}

	public static double toDouble(Object object, double defaultValue) {
		try {
			return toDouble(object);
		} catch (Throwable e) {
		}
		return defaultValue;
	}

	public static double[] toDouble(Object[] doubleArray) {
		if (doubleArray == null) {
			return null;
		}

		double[] returnDoubleArray = new double[doubleArray.length];
		for (int i = 0; i < returnDoubleArray.length; ++i) {
			returnDoubleArray[i] = toDouble(doubleArray[i]);
		}
		return returnDoubleArray;
	}

	public static double[] toDouble(Object[] doubleArray, double[] defaultValue) {
		try {
			return toDouble(doubleArray);
		} catch (Throwable e) {
		}
		return defaultValue;
	}

	public static Double toDoubleObject(Object object) {
		return Double.valueOf(toDouble(object));
	}

	public static Double toDoubleObject(Object object, Double defaultValue) {
		try {
			return toDoubleObject(object);
		} catch (Throwable e) {
		}
		return defaultValue;
	}

	public static Double[] toDoubleObject(Object[] doubleArray) {
		if (doubleArray == null) {
			return null;
		}

		Double[] returnDoubleArray = new Double[doubleArray.length];
		for (int i = 0; i < returnDoubleArray.length; ++i) {
			returnDoubleArray[i] = toDoubleObject(doubleArray[i]);
		}
		return returnDoubleArray;
	}

	public static Double[] toDoubleObject(Object[] doubleArray,
			Double[] defaultValues) {
		try {
			return toDoubleObject(doubleArray);
		} catch (Throwable e) {
		}
		return defaultValues;
	}

	public static long toLong(Object object) {

		if (object instanceof Long) {
			return ((Long) object).longValue();
		}
		if (object instanceof Double) {
			return ((Double) object).longValue();
		}
		if (object instanceof Short) {
			return ((Short) object).longValue();
		}
		if (object instanceof Integer) {
			return ((Integer) object).longValue();
		}
		if (object instanceof Float) {
			return ((Float) object).longValue();
		}
		if (object instanceof Number) {
			return ((Number) object).longValue();
		}

		return Long.parseLong(object.toString());
	}

	public static long toLong(Object object, long defaultValue) {
		try {
			return toLong(object);
		} catch (Throwable e) {
		}
		return defaultValue;
	}

	public static Boolean toBoolean(Object object) {
		if (object == null) {
			Boolean obj = null;
			return obj;
		}

		return Boolean.valueOf(toBool(object));
	}

	public static boolean toBool(Object object) {

		if (object instanceof Boolean) {
			return ((Boolean) object).booleanValue();
		}
		return Boolean.parseBoolean(object.toString());
	}

	public static boolean toBool(Object object, boolean defaultValue) {
		try {
			return toBool(object);
		} catch (Throwable e) {
		}
		return defaultValue;
	}

	public static boolean toBool(int object) {
		return (object == 1);
	}

}

-----------------------------------------------------------

package com.tangdou;

public abstract interface IPropertyProcess {
    public abstract String process(String paramString1, String paramString2);
}

--------------------------------------------

</pre><pre name="code" class="java">package com.tangdou;

public abstract interface IStringReplaceProcess
{
  public abstract String doReplace(String paramString, int paramInt1, int paramInt2);
}

--------------------------------------------

package com.tangdou;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.StringTokenizer;

import org.apache.commons.lang.ArrayUtils;

public abstract class StringUtils extends org.apache.commons.lang.StringUtils {
	public static final String EVAL_PREFIX = "${";
	public static final String EVAL_SUFFIX = "}";

	public static String removeEnd(String src, int length) {
		if ((src == null) || (src.length() <= 1)) {
			return null;
		}

		return src.substring(0, src.length() - length);
	}

	public static String deleteExceptBlank(String psql) {
		String sql = deleteHtml(psql);
		StringBuffer sb = new StringBuffer(sql + " $");
		int blankCount = 0;
		char ch = sb.charAt(0);
		int i = 0;
		int k = 0;
		int[] pos = new int[sb.length()];
		while (ch != '$') {
			ch = sb.charAt(i);
			if (ch == ' ') {
				++blankCount;
			} else {
				blankCount = 0;
			}
			if (blankCount > 1) {
				pos[k] = i;
				++k;
			}
			++i;
		}
		StringBuffer sb1 = new StringBuffer();
		boolean isBlank = false;
		for (int i1 = 0; i1 < sb.length(); ++i1) {
			isBlank = false;
			if ((k > 0) && (i1 <= pos[(k - 1)])) {
				for (int i2 = 0; i2 < k; ++i2) {
					if (i1 == pos[i2]) {
						isBlank = true;
					}
				}
				if (!(isBlank)) {
					sb1.append(sb.charAt(i1));
				}
			} else {
				sb1.append(sb.charAt(i1));
			}
		}

		sb1.deleteCharAt(sb1.lastIndexOf("$"));
		sql = sb1.toString();
		return sql;
	}

	public static String deleteHtml(String psql) {
		psql = psql + "$";
		StringBuffer sb = new StringBuffer(psql);
		for (int i = 0; i < psql.length() - 1; ++i) {
			char ch = psql.charAt(i);
			if ((ch == '\r') || (ch == '\n')) {
				sb.replace(i, i + 1, " ");
			}
		}
		sb.deleteCharAt(sb.length() - 1);
		String sql2 = sb.toString();
		return sql2;
	}

	public static String deleteAllBlank(String str) {
		String sql1 = str;
		StringBuffer sb = new StringBuffer(sql1);
		if (sql1.indexOf("$") == -1) {
			sb.append("$");
		}
		char ch = sb.charAt(0);
		int i = 0;
		int k = 0;
		int[] pos = new int[sb.length() + 1];
		while (ch != '$') {
			if (ch == ' ') {
				pos[k] = i;
				++k;
			}
			++i;
			ch = sb.charAt(i);
		}
		for (i = 0; i < k; ++i) {
			sb.deleteCharAt(pos[i] - i);
		}

		sb.deleteCharAt(sb.lastIndexOf("$"));
		return sb.toString();
	}

	public static String blankIfNull(Object obj) {
		return ((obj == null) ? "" : obj.toString());
	}

	public static String repeatSymbolSplittedString(String element, int num,
			String split) {
		StringBuffer sb = new StringBuffer(250);
		for (int i = 0; i < num; ++i) {
			if (i != 0) {
				sb.append(split);
			}
			sb.append(element);
		}
		return sb.toString();
	}

	public static String repeatSymbolSplittedString(String element, int num) {
		return repeatSymbolSplittedString(element, num, ", ");
	}

	public static int getRepeatCount(String src, char c) {
		int count = 0;
		for (int i = 0; i < src.length(); ++i) {
			if (src.charAt(i) == c) {
				++count;
			}
		}
		return count;
	}

	public static String addQuoteToStr(String inputStr, String token,
			String quote) {
		String result = inputStr;
		String[] splitStr = inputStr.split(token);
		for (int i = 0; i < splitStr.length; ++i) {
			splitStr[i] = quote + splitStr[i] + quote;
		}
		result = ArrayUtils.toString(splitStr);
		return result;
	}

	public static String addQuoteToStr(String inputStr) {
		return addQuoteToStr(inputStr, ",", "'");
	}

	public static String addQuoteToStr(String[] str) {
		String inputStr = "";
		if ((str != null) && (str.length > 0)) {
			for (int i = 0; i < str.length; ++i) {
				inputStr = inputStr + str[i] + ",";
			}
			return addQuoteToStr(inputStr, ",", "'");
		}

		return "''";
	}

	public static String[][] lstToTwoDimStringArr(List lst) {
		if (lst == null) {
			return null;
		}

		String[][] arr = new String[lst.size()][];
		for (int i = 0; i < lst.size(); ++i) {
			List _lst = (List) lst.get(i);
			String[] str = (String[]) _lst.toArray(new String[_lst.size()]);
			arr[i] = str;
		}
		return arr;
	}

	public static String addCommaToArray(Object[] obj) {
		String inputStr = "";
		if ((obj != null) && (obj.length > 0)) {
			for (int i = 0; i < obj.length; ++i) {
				if (!("".equals(obj[i]))) {
					inputStr = inputStr + obj[i].toString() + ",";
				}
			}
			return inputStr.substring(0, inputStr.length() - 1);
		}

		return "";
	}

	public static String ellipse(String src, int byteLength, String tail) {
		char c;
		if (src == null)
			return src;

		StringBuffer s = new StringBuffer();
		for (int i = 0; (i < src.length()) && (byteLength > 0); ++i) {
			c = src.charAt(i);
			s.append(c);
			byteLength -= String.valueOf(c).getBytes().length;
		}
		if ((tail != null) && (byteLength <= 0)) {
			byteLength = tail.getBytes().length;
			for (int i = s.length() - 1; (i >= 0) && (byteLength > 0); --i) {
				c = s.charAt(i);
				s.deleteCharAt(i);
				byteLength -= String.valueOf(c).getBytes().length;
			}
			return tail;
		}

		return s.toString();
	}

	public static String[] ellipse(String[] src, int byteLength, String tail) {
		String[] returnSrc = new String[src.length];
		for (int i = 0; i < src.length; ++i) {
			returnSrc[i] = ellipse(src[i], byteLength, tail);
		}
		return returnSrc;
	}

	public static String replace(String valueString, String prefix,
			String suffix, IStringReplaceProcess process) {
		StringBuffer valueStringBuffer = new StringBuffer(valueString);
		int prefixIndex = 0;
		while ((prefixIndex = valueStringBuffer.indexOf(prefix, prefixIndex)) != -1) {
			int suffixIndex = valueStringBuffer.indexOf(suffix, prefixIndex
					+ prefix.length());
			if (suffixIndex == -1) {
				break;
			}
			int start = prefixIndex + prefix.length();
			String code = valueStringBuffer.substring(start, suffixIndex);
			String msg = process.doReplace(code, start, suffixIndex);
			valueStringBuffer
					.delete(prefixIndex, suffixIndex + suffix.length());
			if (isNotEmpty(msg)) {
				valueStringBuffer.insert(prefixIndex, msg);
				prefixIndex += msg.length();
			}
		}

		return valueStringBuffer.toString();
	}

	public static String replaceEval(String valueString,
			IStringReplaceProcess process) {
		return replace(valueString, "${", "}", process);
	}

	public static String valueOf(Collection collection, String token) {
		if ((collection == null) || (collection.isEmpty()) || (token == null)) {
			return null;
		}
		StringBuffer sb = new StringBuffer();
		for (Iterator it = collection.iterator(); it.hasNext();) {
			String value = it.next().toString();
			sb.append(value + token);
		}
		sb.delete(sb.length() - token.length(), sb.length());
		return sb.toString();
	}

	public static boolean startsWithIgnoreCase(String s1, String s2) {
		if ((s1 == null) || (s2 == null)) {
			return false;
		}
		return s1.toLowerCase(Locale.ENGLISH).startsWith(
				s2.toLowerCase(Locale.ENGLISH));
	}

	public static boolean endsWithIgnoreCase(String s1, String s2) {
		if ((s1 == null) || (s2 == null)) {
			return false;
		}
		return s1.toLowerCase(Locale.ENGLISH).endsWith(
				s2.toLowerCase(Locale.ENGLISH));
	}

	public static String trimBlank(String s) {
		return trimTrailingBlank(trimLeadingBlank(s));
	}

	public static String trimLeadingBlank(String s) {
		if ((isEmpty(s)) || (!(s.startsWith(" ")))) {
			return s;
		}
		return trimLeadingBlank(substring(s, 1));
	}

	public static String trimTrailingBlank(String s) {
		if ((isEmpty(s)) || (!(s.endsWith(" ")))) {
			return s;
		}
		return trimTrailingBlank(substring(s, 0, s.length() - 1));
	}

	public static Map<String, String> strToMap(String value, String itemSplit,
			String keyValueSplit) {
		Map result = new HashMap();
		if (value == null) {
			return result;
		}

		StringTokenizer token = new StringTokenizer(value, itemSplit);

		while (token.hasMoreElements()) {
			String item = token.nextToken();
			result.put(substringBefore(item, keyValueSplit),
					substringAfter(item, keyValueSplit));
		}

		return result;
	}
}

最后测试

package com.tangdou;

import org.apache.log4j.Logger;

public class TestLog {
	public static void main(String[] args) {
		Logger log = Logger.getLogger(TestLog.class);
		log.info("aaaaa");
	}

}