自定义实现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");
}

}