logfactory.java

用java开发的一些实用的短信通信模块其中包含MD5加密、http发送等信息

package lib.commons.logging;

import java.io.StringReader;
import java.util.HashMap;
import java.util.Iterator;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.LogConfigurationException;
import org.apache.commons.configuration.Configuration;
import org.apache.commons.configuration.PropertiesConfiguration;
import org.apache.commons.configuration.XMLConfiguration;

import lib.commons.Utils;
import lib.commons.config.DomConfig;

public final class LogFactory {
	private static class LogWrapper implements Log {

		String logName, newLogName;

		Log log;

		long logFactLoadTimeStamp;

		public LogWrapper(String logName) {
			this.logName = logName;
			logFactLoadTimeStamp = LogFactory.getLogFactLoadTimeStamp();
		}

		public LogWrapper(String logName, String newLogName) {
			this.logName = logName;
			logFactLoadTimeStamp = LogFactory.getLogFactLoadTimeStamp();
			this.newLogName = newLogName;
		}

		private void checkLog() {
			while (LogFactory.isLoading()) {
				try {
					Thread.sleep(10);
				} catch (Exception err) {
				}
			}

			if (null == log
					|| logFactLoadTimeStamp != LogFactory
							.getLogFactLoadTimeStamp()) {
				logFactLoadTimeStamp = LogFactory.getLogFactLoadTimeStamp();
				if (null == newLogName)
					log = LogFactory.getLogger(logName);
				else
					log = LogFactory.getLogger(logName).newLogger(newLogName);
			}

		}

		public boolean isTraceEnabled() {
			checkLog();
			return log.isTraceEnabled();
		}

		public boolean isDebugEnabled() {
			checkLog();
			return log.isDebugEnabled();
		}

		public boolean isInfoEnabled() {
			checkLog();
			return log.isInfoEnabled();
		}

		public boolean isWarnEnabled() {
			checkLog();
			return log.isWarnEnabled();
		}

		public boolean isErrorEnabled() {
			checkLog();
			return log.isErrorEnabled();
		}

		public boolean isFatalEnabled() {
			checkLog();
			return log.isFatalEnabled();
		}

		public void trace(Object message) {
			checkLog();
			log.trace(message);
		}

		public void trace(Object message, Throwable t) {
			checkLog();
			log.trace(message, t);
		}

		public void debug(Object message) {
			checkLog();
			log.debug(message);
		}

		public void debug(Object message, Throwable t) {
			checkLog();
			log.debug(message, t);
		}

		public void info(Object message) {
			checkLog();
			log.info(message);
		}

		public void info(Object message, Throwable t) {
			checkLog();
			log.info(message, t);
		}

		public void warn(Object message) {
			checkLog();
			log.warn(message);
		}

		public void warn(Object message, Throwable t) {
			checkLog();
			log.warn(message, t);
		}

		public void error(Object message) {
			checkLog();
			log.error(message);
		}

		public void error(Object message, Throwable t) {
			checkLog();
			log.error(message, t);
		}

		public void fatal(Object message) {
			checkLog();
			log.fatal(message);
		}

		public void fatal(Object message, Throwable t) {
			checkLog();
			log.fatal(message, t);
		}

		public Log newLog(String logName) {
			return new LogWrapper(this.logName, logName);
		}
	}

	private static Object lockObj = new Object();

	private static HashMap loggerMap, appenderMap, layoutMap;

	private static boolean loading = false;

	public static boolean isLoading() {
		return loading;
	}

	private static long logFactLoadTimeStamp = System.currentTimeMillis();

	public static long getLogFactLoadTimeStamp() {
		return logFactLoadTimeStamp;
	}

	private static LogLayout dfltLogLayout;

	public static LogLayout getDfltLogLayout() {
		return null == dfltLogLayout ? new VasStyleLayout(null) : dfltLogLayout;
	}

	private static LogAppender dfltLogAppender;

	public static LogAppender getDfltLogAppender() {
		return null == dfltLogAppender ? new StdoutAppender(null,
				getDfltLogLayout()) : dfltLogAppender;
	}

	private static int dfltLogLevel = LogLevel.MAX_LEVEL;

	public static int getDfltLogLevel() {
		return dfltLogLevel;
	}

	private static Logger dfltLogger;

	private static Logger getDfltLogger() {
		if (null == dfltLogger) {
			synchronized (lockObj) {
				if (null == dfltLogger) {
					dfltLogger = new Logger(null, getDfltLogLevel(), true,
							new LogAppenderList());
				}
			}
		}
		return dfltLogger;
	}

	public static Log getDfltLog() {
		return getDfltLogger();
	}

	public static Log getLog() {
		return getLog(Utils.EMPTY_STRING);
	}

	public static Log getLog(Class clazz) {
		return getLog(null == clazz ? Utils.EMPTY_STRING : clazz.getName());
	}

	public static Log getLog(Class clazz, String newLogName) {
		return getLog(null == clazz ? Utils.EMPTY_STRING : clazz.getName(),
				newLogName);
	}

	public static Log getLog(String logName) {
		return new LogWrapper(logName);
	}

	public static Log getLog(String logName, String newLogName) {
		return new LogWrapper(logName, newLogName);
	}

	private static Logger getLogger(String name)
			throws LogConfigurationException {
		Logger logger = null;
		if (null != loggerMap) {
			synchronized (lockObj) {
				String key = null == name ? Utils.EMPTY_STRING : name;
				if (null != loggerMap && loggerMap.containsKey(key)) {
					logger = (Logger) loggerMap.get(key);
				}
			}
		}
		if (null == logger)
			logger = getDfltLogger();
		logger = logger.newLogger(null == name ? Utils.EMPTY_STRING : name);
		return logger;
	}

	public static void loadPropertiesFile(String filePath) {
		try {
			PropertiesConfiguration propConf = new PropertiesConfiguration(
					filePath);
			loadConfiguration(propConf);
		} catch (Exception err) {
			Log log = getLog(LogFactory.class);
			log.error("Load properties file '" + filePath + " error occurred:"
					+ err.getMessage(), err);
		}
	}

	public static void loadDomConfig(DomConfig logConfig) {
		try {
			loadXml(logConfig.getXmlString());
		} catch (Exception err) {
			Log log = getLog(LogFactory.class);
			log.error("Load DomConfig error occurred:" + err.getMessage(), err);
		}
	}

	public static void loadXmlFile(String filePath) {
		try {
			XMLConfiguration xmlConf = new XMLConfiguration(filePath);
			loadConfiguration(xmlConf);
		} catch (Exception err) {
			Log log = getLog(LogFactory.class);
			log.error("Load xml file '" + filePath + " error occurred:"
					+ err.getMessage(), err);
		}
	}

	public static void loadXml(String xml) {
		try {
			if (!Utils.StringIsNullOrEmpty(xml)) {
				XMLConfiguration xmlConf = new XMLConfiguration();
				xmlConf.load(new StringReader(xml));
				loadConfiguration(xmlConf);
			} else
				loadConfiguration(null);
		} catch (Exception err) {
			Log log = getLog(LogFactory.class);
			log.error("Load xml '" + xml + "' error occurred:"
					+ err.getMessage(), err);
		}
	}

	public static void loadConfiguration(Configuration logConfiguration) {
		loading = true;
		synchronized (lockObj) {
			clear();
			if (null != logConfiguration && !logConfiguration.isEmpty()) {
				Configuration configuration = logConfiguration.subset("LogFactory");
				if (configuration.isEmpty())
					configuration = logConfiguration;
				HashMap tmp_layoutMap = new HashMap();
				HashMap tmp_appenderMap = new HashMap();
				HashMap tmp_loggerMap = new HashMap();
				LogLayout tmp_dfltLayout = null;
				LogAppender tmp_dfltAppender = null;
				int tmp_dfltLogLevel = LogLevel.MAX_LEVEL;
				try {
					String[] layoutNames = configuration
							.getStringArray("layout.name");
					for (int i = 0; layoutNames != null
							&& i < layoutNames.length; i++) {
						if (tmp_layoutMap.containsKey(layoutNames[i]))
							continue;
						try {
							String layoutClass = configuration
									.getString("layout(" + i + ").class");
							Configuration layoutPropConf = configuration
									.subset("layout(" + i + ").properties");
							LogLayout layout = (LogLayout) Class.forName(
									layoutClass).getConstructor(
									new Class[] { Configuration.class })
									.newInstance(
											new Object[] { layoutPropConf });
							if (null != layout)
								tmp_layoutMap.put(layoutNames[i], layout);
						} catch (Exception err) {
							err.printStackTrace();
						}
					}

					String[] appenderNames = configuration
							.getStringArray("appender.name");
					for (int i = 0; appenderNames != null
							&& i < appenderNames.length; i++) {
						if (tmp_appenderMap.containsKey(appenderNames[i]))
							continue;
						try {
							String appenderClass = configuration
									.getString("appender(" + i + ").class");
							String layout_ref = configuration
									.getString("appender(" + i + ").layout-ref");
							LogLayout layout = (LogLayout) tmp_layoutMap
									.get(layout_ref);
							Configuration appenderPropConf = configuration
									.subset("appender(" + i + ").properties");
							LogAppender appender = (LogAppender) Class.forName(
									appenderClass).getConstructor(
									new Class[] { Configuration.class,
											LogLayout.class }).newInstance(
									new Object[] { appenderPropConf, layout });
							if (null != appender)
								tmp_appenderMap.put(appenderNames[i], appender);
						} catch (Exception err) {
							err.printStackTrace();
						}
					}

					String dfltLayout_ref = configuration
							.getString("dfltLayout.ref");
					tmp_dfltLayout = (LogLayout) tmp_layoutMap
							.get(dfltLayout_ref);

					String dfltAppender_ref = configuration
							.getString("dfltAppender.ref");
					tmp_dfltAppender = (LogAppender) tmp_appenderMap
							.get(dfltAppender_ref);

					tmp_dfltLogLevel = LogLevel.getLevel(configuration
							.getString("dfltLogLevel"));

					String[] loggerNames = configuration
							.getStringArray("logger.name");
					for (int i = 0; null != loggerNames
							&& i < loggerNames.length; i++) {
						if (tmp_loggerMap.containsKey(loggerNames[i]))
							continue;
						int logLevel = LogLevel.getLevel(configuration
								.getString("logger(" + i + ").level"));
						boolean printStackTrace = !"false"
								.equalsIgnoreCase(configuration
										.getString("logger(" + i
												+ ").printStackTrace"));
						String appender_refs = configuration
								.getString("logger(" + i + ").appender-refs");
						String[] appender_refArr = StringUtils.split(
								appender_refs, ";");
						LogAppenderList appenderList = new LogAppenderList();
						for (int j = 0; null != appender_refArr
								&& j < appender_refArr.length; j++) {
							LogAppender appender = (LogAppender) tmp_appenderMap
									.get(appender_refArr[j]);
							if (null != appender)
								appenderList.add(appender);
						}
						Logger logger = new Logger(loggerNames[i], logLevel,
								printStackTrace, appenderList);
						tmp_loggerMap.put(loggerNames[i], logger);
					}
				} catch (Exception err) {
					err.printStackTrace();
				}

				layoutMap = tmp_layoutMap;
				appenderMap = tmp_appenderMap;
				loggerMap = tmp_loggerMap;
				dfltLogLayout = tmp_dfltLayout;
				dfltLogAppender = tmp_dfltAppender;
				dfltLogLevel = tmp_dfltLogLevel;
			}
			logFactLoadTimeStamp = System.currentTimeMillis();
		}
		loading = false;
	}

	private static void clear() {
		if (null != appenderMap) {
			Iterator it = appenderMap.values().iterator();
			while (it.hasNext()) {
				LogAppender appender = (LogAppender) it.next();
				if (null != appender) {
					appender.close();
				}
			}

			appenderMap.clear();
			appenderMap = null;
			if (null != loggerMap)
				loggerMap.clear();
			loggerMap = null;
			if (null != layoutMap)
				layoutMap.clear();
			layoutMap = null;
		}
	}
}