Prev Class | Next Class | Frames | No Frames |
Summary: Nested | Field | Method | Constr | Detail: Nested | Field | Method | Constr |
java.lang.Object
org.apache.commons.logging.LogFactory
org.apache.commons.logging.impl.LogFactoryImpl
public class LogFactoryImpl
extends LogFactory
LogFactory
that implements the
following algorithm to dynamically select a logging implementation
class to instantiate a wrapper for.
org.apache.commons.logging.Log
to identify the
requested implementation class.org.apache.commons.logging.Log
system property
to identify the requested implementation class.org.apache.commons.logging.impl.Log4JLogger
.org.apache.commons.logging.impl.Jdk14Logger
.org.apache.commons.logging.impl.SimpleLog
.Log
implementation class has a
setLogFactory()
method that accepts a LogFactory
parameter, this method will be called on each newly created instance
to identify the associated factory. This makes factory configuration
attributes available to the Log instance, if it so desires.
This factory will remember previously created Log
instances
for the same name, and will return them on repeated requests to the
getInstance()
method.
Field Summary | |
static String |
|
static String |
|
static String |
|
private static String |
|
private static String |
|
private static String |
|
private static String |
|
static String |
|
protected static String |
|
private static String | |
private static int | |
private boolean |
|
private boolean |
|
private boolean |
|
protected Hashtable |
|
private static String[] |
|
private String |
|
protected Hashtable | |
private String |
|
protected Constructor |
|
protected Class[] |
|
protected Method | |
protected Class[] |
|
private boolean |
|
Fields inherited from class org.apache.commons.logging.LogFactory | |
DIAGNOSTICS_DEST_PROPERTY , FACTORY_DEFAULT , FACTORY_PROPERTIES , FACTORY_PROPERTY , HASHTABLE_IMPLEMENTATION_PROPERTY , PRIORITY_KEY , SERVICE_ID , TCCL_KEY , WEAK_HASHTABLE_CLASSNAME , diagnosticPrefix , diagnosticsStream , factories , nullClassLoaderFactory , thisClassLoader |
Constructor Summary | |
|
Method Summary | |
private Log |
|
private Log |
|
private String |
|
Object |
|
String[] |
|
private ClassLoader |
|
private boolean |
|
protected static ClassLoader |
|
private String |
|
protected static ClassLoader |
|
Log |
|
Log |
|
protected String |
|
protected Constructor |
|
private ClassLoader |
|
private void |
|
private void |
|
private void |
|
private void |
|
private void |
|
protected static boolean |
|
protected boolean |
|
protected boolean |
|
protected boolean |
|
private boolean |
|
protected void |
|
protected Log |
|
void | |
void |
|
void |
|
Methods inherited from class org.apache.commons.logging.LogFactory | |
cacheFactory , createFactory , createFactoryStore , directGetContextClassLoader , getAttribute , getAttributeNames , getCachedFactory , getClassLoader , getConfigurationFile , getContextClassLoader , getFactory , getInstance , getInstance , getLog , getLog , getProperties , getResourceAsStream , getResources , implementsLogFactory , initDiagnostics , isDiagnosticsEnabled , logClassLoaderEnvironment , logDiagnostic , logHierarchy , logRawDiagnostic , newFactory , newFactory , objectId , release , release , releaseAll , removeAttribute , setAttribute |
public static final String ALLOW_FLAWED_CONTEXT_PROPERTY
The name (org.apache.commons.logging.Log.allowFlawedContext
) of the system property which can be set true/false to determine system behaviour when a bad context-classloader is encountered. When set to false, a LogConfigurationException is thrown if LogFactoryImpl is loaded via a child classloader of the TCCL (this should never happen in sane systems). Default behaviour: true (tolerates bad context classloaders) See also method setAttribute.
public static final String ALLOW_FLAWED_DISCOVERY_PROPERTY
The name (org.apache.commons.logging.Log.allowFlawedDiscovery
) of the system property which can be set true/false to determine system behaviour when a bad logging adapter class is encountered during logging discovery. When set to false, an exception will be thrown and the app will fail to start. When set to true, discovery will continue (though the user might end up with a different logging implementation than they expected). Default behaviour: true (tolerates bad logging adapters) See also method setAttribute.
public static final String ALLOW_FLAWED_HIERARCHY_PROPERTY
The name (org.apache.commons.logging.Log.allowFlawedHierarchy
) of the system property which can be set true/false to determine system behaviour when a logging adapter class is encountered which has bound to the wrong Log class implementation. When set to false, an exception will be thrown and the app will fail to start. When set to true, discovery will continue (though the user might end up with a different logging implementation than they expected). Default behaviour: true (tolerates bad Log class hierarchy) See also method setAttribute.
private static final String LOGGING_IMPL_JDK14_LOGGER
Jdk14Logger class name
private static final String LOGGING_IMPL_LOG4J_LOGGER
Log4JLogger class name
private static final String LOGGING_IMPL_LUMBERJACK_LOGGER
Jdk13LumberjackLogger class name
private static final String LOGGING_IMPL_SIMPLE_LOGGER
SimpleLog class name
public static final String LOG_PROPERTY
The name (org.apache.commons.logging.Log
) of the system property identifying ourLog
implementation class.
protected static final String LOG_PROPERTY_OLD
The deprecated system property used for backwards compatibility with old versions of JCL.
private static final String PKG_IMPL
private static final int PKG_LEN
private boolean allowFlawedContext
See getBaseClassLoader and initConfiguration.
private boolean allowFlawedDiscovery
See handleFlawedDiscovery and initConfiguration.
private boolean allowFlawedHierarchy
See handleFlawedHierarchy and initConfiguration.
protected Hashtable attributes
Configuration attributes.
private static final String[] classesToDiscover
The names of classes that will be tried (in order) as logging adapters. Each class is expected to implement the Log interface, and to throw NoClassDefFound or ExceptionInInitializerError when loaded if the underlying logging library is not available. Any other error indicates that the underlying logging library is available but broken/unusable for some reason.
private String diagnosticPrefix
The string prefixed to every message output by the logDiagnostic method.
protected Hashtable instances
TheLog
instances that have already been created, keyed by logger name.
private String logClassName
Name of the class implementing the Log interface.
protected Constructor logConstructor
The one-argument constructor of theLog
implementation class that will be used to create new instances. This value is initialized bygetLogConstructor()
, and then returned repeatedly.
protected Class[] logConstructorSignature
The signature of the Constructor to be used.
protected Method logMethod
The one-argumentsetLogFactory
method of the selectedLog
method, if it exists.
protected Class[] logMethodSignature
The signature of thesetLogFactory
method to be used.
private boolean useTCCL
Determines whether logging classes should be loaded using the thread-context classloader, or via the classloader that loaded this LogFactoryImpl class.
public LogFactoryImpl()
Public no-arguments constructor required by the lookup mechanism.
private Log createLogFromClass(String logAdapterClassName, String logCategory, boolean affectState) throws LogConfigurationException
Attempts to load the given class, find a suitable constructor, and instantiate an instance of Log.
- Parameters:
logAdapterClassName
- classname of the Log implementationlogCategory
- argument to pass to the Log implementation's constructoraffectState
-true
if this object's state should be affected by this method call,false
otherwise.
- Returns:
- an instance of the given class, or null if the logging library associated with the specified adapter is not available.
- Throws:
LogConfigurationException
- if there was a serious error with configuration and the handleFlawedDiscovery method decided this problem was fatal.
private Log discoverLogImplementation(String logCategory) throws LogConfigurationException
Attempts to create a Log instance for the given category name. Follows the discovery process described in the class javadoc.
- Parameters:
logCategory
- the name of the log category
- Throws:
LogConfigurationException
- if an error in discovery occurs, or if no adapter at all can be instantiated
private String findUserSpecifiedLogClassName()
Checks system properties and the attribute map for a Log implementation specified by the user under the property namesLOG_PROPERTY
orLOG_PROPERTY_OLD
.
- Returns:
- classname specified by the user, or
null
public Object getAttribute(String name)
Return the configuration attribute with the specified name (if any), ornull
if there is no such attribute.
- Overrides:
- getAttribute in interface LogFactory
- Parameters:
name
- Name of the attribute to return
public String[] getAttributeNames()
Return an array containing the names of all currently defined configuration attributes. If there are no such attributes, a zero length array is returned.
- Overrides:
- getAttributeNames in interface LogFactory
private ClassLoader getBaseClassLoader() throws LogConfigurationException
Return the classloader from which we should try to load the logging adapter classes. This method usually returns the context classloader. However if it is discovered that the classloader which loaded this class is a child of the context classloader and the allowFlawedContext option has been set then the classloader which loaded this class is returned instead. The only time when the classloader which loaded this class is a descendant (rather than the same as or an ancestor of the context classloader) is when an app has created custom classloaders but failed to correctly set the context classloader. This is a bug in the calling application; however we provide the option for JCL to simply generate a warning rather than fail outright.
private boolean getBooleanConfiguration(String key, boolean dflt)
Get the setting for the user-configurable behaviour specified by key. If nothing has explicitly been set, then return dflt.
protected static ClassLoader getClassLoader(Class clazz)
Workaround for bug in Java1.2; in theory this method is not needed. See LogFactory.getClassLoader.
- Overrides:
- getClassLoader in interface LogFactory
- Since:
- 1.1
private String getConfigurationValue(String property)
Attempt to find an attribute (see method setAttribute) or a system property with the provided name and return its value. The attributes associated with this object are checked before system properties in case someone has explicitly called setAttribute, or a configuration property has been set in a commons-logging.properties file.
- Returns:
- the value associated with the property, or null.
protected static ClassLoader getContextClassLoader() throws LogConfigurationException
Gets the context classloader. This method is a workaround for a java 1.2 compiler bug.
- Overrides:
- getContextClassLoader in interface LogFactory
- Since:
- 1.1
public Log getInstance(Class clazz) throws LogConfigurationException
Convenience method to derive a name from the specified class and callgetInstance(String)
with it.
- Overrides:
- getInstance in interface LogFactory
- Parameters:
clazz
- Class for which a suitable Log name will be derived
- Throws:
LogConfigurationException
- if a suitableLog
instance cannot be returned
public Log getInstance(String name) throws LogConfigurationException
Construct (if necessary) and return aLog
instance, using the factory's current set of configuration attributes. NOTE - Depending upon the implementation of theLogFactory
you are using, theLog
instance you are returned may or may not be local to the current application, and may or may not be returned again on a subsequent call with the same name argument.
- Overrides:
- getInstance in interface LogFactory
- Parameters:
name
- Logical name of theLog
instance to be returned (the meaning of this name is only known to the underlying logging implementation that is being wrapped)
- Throws:
LogConfigurationException
- if a suitableLog
instance cannot be returned
protected String getLogClassName()
Deprecated. Never invoked by this class; subclasses should not assume it will be.
Return the fully qualified Java classname of theLog
implementation we will be using.
protected Constructor getLogConstructor() throws LogConfigurationException
Deprecated. Never invoked by this class; subclasses should not assume it will be.
Return theConstructor
that can be called to instantiate newLog
instances. IMPLEMENTATION NOTE - Race conditions caused by calling this method from more than one thread are ignored, because the sameConstructor
instance will ultimately be derived in all circumstances.
- Throws:
LogConfigurationException
- if a suitable constructor cannot be returned
private ClassLoader getLowestClassLoader(ClassLoader c1, ClassLoader c2)
Given two related classloaders, return the one which is a child of the other.
- Parameters:
c1
- is a classloader (including the null classloader)c2
- is a classloader (including the null classloader)
- Returns:
- c1 if it has c2 as an ancestor, c2 if it has c1 as an ancestor, and null if neither is an ancestor of the other.
private void handleFlawedDiscovery(String logAdapterClassName, ClassLoader classLoader, Throwable discoveryFlaw)
Generates an internal diagnostic logging of the discovery failure and then throws aLogConfigurationException
that wraps the passedThrowable
.
- Parameters:
logAdapterClassName
- is the class name of the Log implementation that could not be instantiated. Cannot benull
.classLoader
- is the classloader that we were trying to load the logAdapterClassName from when the exception occurred.discoveryFlaw
- is the Throwable created by the classloader
private void handleFlawedHierarchy(ClassLoader badClassLoader, Class badClass) throws LogConfigurationException
Report a problem loading the log adapter, then either return (if the situation is considered recoverable) or throw a LogConfigurationException. There are two possible reasons why we successfully loaded the specified log adapter class then failed to cast it to a Log object:Here we try to figure out which case has occurred so we can give the user some reasonable feedback.
- the specific class just doesn't implement the Log interface (user screwed up), or
- the specified class has bound to a Log class loaded by some other classloader; Log@classloaderX cannot be cast to Log@classloaderY.
- Parameters:
badClassLoader
- is the classloader we loaded the problem class from, ie it is equivalent to badClass.getClassLoader().badClass
- is a Class object with the desired name, but which does not implement Log correctly.
- Throws:
LogConfigurationException
- when the situation should not be recovered from.
private void informUponSimilarName(StringBuffer messageBuffer, String name, String candidate)
Appends message if the given name is similar to the candidate.
- Parameters:
messageBuffer
-StringBuffer
the message should be appended to, not nullname
- the (trimmed) name to be test against the candidate, not nullcandidate
- the candidate name (not null)
private void initConfiguration()
Initialize a number of variables that control the behaviour of this class and that can be tweaked by the user. This is done when the first logger is created, not in the constructor of this class, because we need to give the user a chance to call method setAttribute in order to configure this object.
private void initDiagnostics()
Calculate and cache a string that uniquely identifies this instance, including which classloader the object was loaded from. This string will later be prefixed to each "internal logging" message emitted, so that users can clearly see any unexpected behaviour. Note that this method does not detect whether internal logging is enabled or not, nor where to output stuff if it is; that is all handled by the parent LogFactory class. This method just computes its own unique prefix for log messages.
- Overrides:
- initDiagnostics in interface LogFactory
protected static boolean isDiagnosticsEnabled()
Workaround for bug in Java1.2; in theory this method is not needed. See LogFactory.isDiagnosticsEnabled.
- Overrides:
- isDiagnosticsEnabled in interface LogFactory
protected boolean isJdk13LumberjackAvailable()
Deprecated. Never invoked by this class; subclasses should not assume it will be.
Is JDK 1.3 with Lumberjack logging available?
protected boolean isJdk14Available()
Deprecated. Never invoked by this class; subclasses should not assume it will be.
Returntrue
if JDK 1.4 or later logging is available. Also checks that theThrowable
class supportsgetStackTrace()
, which is required by Jdk14Logger.
protected boolean isLog4JAvailable()
Deprecated. Never invoked by this class; subclasses should not assume it will be.
Is a Log4J implementation available?
private boolean isLogLibraryAvailable(String name, String classname)
Utility method to check whether a particular logging library is present and available for use. Note that this does not affect the future behaviour of this class.
protected void logDiagnostic(String msg)
Output a diagnostic message to a user-specified destination (if the user has enabled diagnostic logging).
- Overrides:
- logDiagnostic in interface LogFactory
- Parameters:
msg
- diagnostic message
- Since:
- 1.1
protected Log newInstance(String name) throws LogConfigurationException
Create and return a newLog
instance for the specified name.
- Parameters:
name
- Name of the new logger
- Throws:
LogConfigurationException
- if a new instance cannot be created
public void release()
Release any internal references to previously createdLog
instances returned by this factory. This is useful in environments like servlet containers, which implement application reloading by throwing away a ClassLoader. Dangling references to objects in that class loader would prevent garbage collection.
- Overrides:
- release in interface LogFactory
public void removeAttribute(String name)
Remove any configuration attribute associated with the specified name. If there is no such attribute, no action is taken.
- Overrides:
- removeAttribute in interface LogFactory
- Parameters:
name
- Name of the attribute to remove
public void setAttribute(String name, Object value)
Set the configuration attribute with the specified name. Calling this with anull
value is equivalent to callingremoveAttribute(name)
. This method can be used to set logging configuration programmatically rather than via system properties. It can also be used in code running within a container (such as a webapp) to configure behaviour on a per-component level instead of globally as system properties would do. To use this method instead of a system property, callLogFactory.getFactory().setAttribute(...)This must be done before the first Log object is created; configuration changes after that point will be ignored. This method is also called automatically if LogFactory detects a commons-logging.properties file; every entry in that file is set automatically as an attribute here.
- Overrides:
- setAttribute in interface LogFactory
- Parameters:
name
- Name of the attribute to setvalue
- Value of the attribute to set, ornull
to remove any setting for this attribute