org.bushe.swing.event.Logger Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of nifty Show documentation
Show all versions of nifty Show documentation
Nifty GUI is a Java Library that supports the building of interactive user interfaces for games or similar applications. It utilizes OpenGL for rendering and it can be easily integrated into many rendering systems. The configuration of the GUI is stored in xml files with little supporting Java code. In short Nifty helps you to layout stuff, display it in a cool way and interact with it :)
The newest version!
package org.bushe.swing.event;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.HashMap;
/**
* Central Logging class. Shields code from Logging implementation.
*
* The EventBus allows operation in two modes - using java.util.logging so that
* the EventBus can be deployed in its own jar or using any logging system supported
* by apache commons logging, which of course requires other jars.
*
* The EventBus logging uses the names of its classes as the log, primarily
* "org.bushe.swing.event.EventService". This aids in debugging which subscription and publication issues.
*
* Implementation note: There are no imports in this class to make things
* explicit. There is also no explicit use of classes outside java.util,
* anything else is used by reflection to avoid NoClassDefFound errors on class load.
*/
public class Logger {
private java.util.logging.Logger utilLogger;
private /*Untyped to avoid java.lang.NoClassDefFoundError
org.apache.commons.logging.Log*/ Object commonsLogger;
private Map METHOD_CACHE_NO_PARAMS;
private Map METHOD_CACHE_ONE_PARAM;
private Map METHOD_CACHE_TWO_PARAMS;
private static Class logFactoryClass;
private static Class logClass;
private static Method getLogMethod;
private static final Object[] EMPTY_ARGS = new Object[0];
private static final Class[] CLASS_ARGS_EMPTY = new Class[0];
private static final Class[] CLASS_ARGS_ONE = new Class[]{Object.class};
private static final Class[] CLASS_ARGS_TWO = new Class[]{Object.class, Throwable.class};
/** Allows switching between Java and Commons logging.*/
public static enum LoggerType {
/*java.util.logging*/
JAVA,
/*org.apache.commons.logging*/
COMMONS
}
/** Standardized logging levels. */
public static enum Level {
FATAL,
ERROR,
WARN,
INFO,
DEBUG,
TRACE
}
public static LoggerType LOGGER_TYPE= null;
public static Logger getLogger(String name) {
if (LOGGER_TYPE == null) {
LOGGER_TYPE = getLoggerType();
}
if (LOGGER_TYPE == LoggerType.COMMONS) {
try {
Object logger = getLogMethod.invoke(null, name);
return new Logger(logger);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
return new Logger(java.util.logging.Logger.getLogger(name));
}
/**
* This method should only be called once in a JVM run.
* @return
*/
private static LoggerType getLoggerType() {
LoggerType result = null;
//See if apache commons is available
try {
logFactoryClass = Class.forName("org.apache.commons.logging.LogFactory");
getLogMethod = logFactoryClass.getMethod("getLog", new Class[]{String.class});
logClass = Class.forName("org.apache.commons.logging.Log");
return LoggerType.COMMONS;
} catch (Throwable e) {
}
return LoggerType.JAVA;
}
public Logger(java.util.logging.Logger utilLogger) {
this.utilLogger = utilLogger;
}
public Logger(Object commonsLogger) {
this.commonsLogger = commonsLogger;
}
/**
* Returns whether this level is loggable. If there is
* a misconfiguration, this will always return false.
* @param level the EventBus Logger level
* @return whether this level is loggable.
*/
public boolean isLoggable(Level level) {
if (utilLogger != null) {
java.util.logging.Level javaLevel = getJavaLevelFor(level);
return javaLevel != null && utilLogger.isLoggable(javaLevel);
} else if (commonsLogger != null) {
switch (level) {
case ERROR: return (Boolean)callCommonsLogger("isErrorEnabled");
case FATAL: return (Boolean)callCommonsLogger("isFatalEnabled");
case WARN: return (Boolean)callCommonsLogger("isWarnEnabled");
case INFO: return (Boolean)callCommonsLogger("isInfoEnabled");
case DEBUG: return (Boolean)callCommonsLogger("isDebugEnabled");
case TRACE: return (Boolean)callCommonsLogger("isTraceEnabled");
}
}
return false;
}
private java.util.logging.Level getJavaLevelFor(Level level) {
switch (level) {
case FATAL: return java.util.logging.Level.SEVERE;
case ERROR: return java.util.logging.Level.SEVERE;
case WARN: return java.util.logging.Level.WARNING;
case INFO: return java.util.logging.Level.INFO;
case DEBUG: return java.util.logging.Level.FINE;
case TRACE: return java.util.logging.Level.FINEST;
}
return null;
}
public void debug(String message) {
log(Level.DEBUG, message);
}
public void log(Level level, String message) {
log(level, message, null);
}
public void log(Level level, String message, Throwable throwable) {
if (!isLoggable(level)) {
return;
}
if (utilLogger != null) {
java.util.logging.Level javaLevel = getJavaLevelFor(level);
if (throwable == null) {
utilLogger.log(javaLevel, message);
} else {
utilLogger.log(javaLevel, message, throwable);
}
} else if (commonsLogger != null) {
if (throwable == null) {
switch (level) {
case ERROR: callCommonsLogger("error", message); break;
case FATAL: callCommonsLogger("fatal", message); break;
case WARN: callCommonsLogger("warn", message); break;
case INFO: callCommonsLogger("info", message); break;
case DEBUG: callCommonsLogger("debug", message); break;
case TRACE: callCommonsLogger("trace", message); break;
}
} else {
switch (level) {
case ERROR: callCommonsLogger("error", message, throwable); break;
case FATAL: callCommonsLogger("fatal", message, throwable); break;
case WARN: callCommonsLogger("warn", message, throwable); break;
case INFO: callCommonsLogger("info", message, throwable); break;
case DEBUG: callCommonsLogger("debug", message, throwable); break;
case TRACE: callCommonsLogger("trace", message, throwable); break;
}
}
}
}
private Object callCommonsLogger(String methodName) {
if (METHOD_CACHE_NO_PARAMS == null) {
METHOD_CACHE_NO_PARAMS = new HashMap();
}
return callCommonsLogger(METHOD_CACHE_NO_PARAMS, methodName, CLASS_ARGS_EMPTY, EMPTY_ARGS);
}
private Object callCommonsLogger(String methodName, String message) {
if (METHOD_CACHE_ONE_PARAM == null) {
METHOD_CACHE_ONE_PARAM = new HashMap();
}
return callCommonsLogger(METHOD_CACHE_ONE_PARAM, methodName, CLASS_ARGS_ONE, new Object[]{message});
}
private Object callCommonsLogger(String methodName, String message, Throwable throwable) {
if (METHOD_CACHE_TWO_PARAMS == null) {
METHOD_CACHE_TWO_PARAMS = new HashMap();
}
return callCommonsLogger(METHOD_CACHE_TWO_PARAMS, methodName, CLASS_ARGS_TWO, new Object[]{message, throwable});
}
private Object callCommonsLogger(Map cache, String methodName, Class[] classOfArgs, Object[] args) {
Method method = cache.get(methodName);
if (method == null) {
try {
method = logClass.getMethod(methodName, classOfArgs);
cache.put(methodName, method);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
if (method == null) {
return null;
}
try {
return method.invoke(commonsLogger, args);
} catch (IllegalAccessException e) {
return null;
} catch (InvocationTargetException e) {
return null;
}
}
}