public class LogFactory extends Object
ServiceLoader based
discovery mechanism with a default of using JDK based logging. An
implementation that uses the full Commons Logging discovery mechanism is
available as part of the Tomcat extras download.
Why? It is an attempt to strike a balance between simpler code (no discovery)
and providing flexibility - particularly for those projects that embed Tomcat
or some of Tomcat's components - is an alternative logging
implementation is desired.
Note that this implementation is not just a wrapper around JDK logging (like
the original commons-logging impl). It adds 2 features - a simpler
configuration (which is in fact a subset of log4j.properties) and a
formatter that is less ugly.
The removal of 'abstract' preserves binary backward compatibility. It is
possible to preserve the abstract - and introduce another (hardcoded) factory
- but I see no benefit.
Since this class is not intended to be extended - all protected methods are
removed. This can be changed - but again, there is little value in keeping
dead code. Just take a quick look at the removed code ( and it's complexity).
--------------
Original comment:
Factory for creating Log instances, with discovery and
configuration features similar to that employed by standard Java APIs
such as JAXP.
IMPLEMENTATION NOTE - This implementation is heavily based on the SAXParserFactory and DocumentBuilderFactory implementations (corresponding to the JAXP pluggability APIs) found in Apache Xerces.
| Modifier and Type | Method and Description |
|---|---|
static LogFactory |
getFactory()
Construct (if necessary) and return a
LogFactory
instance, using the following ordered lookup procedure to determine
the name of the implementation class to be loaded. |
Log |
getInstance(Class<?> clazz)
Convenience method to derive a name from the specified class and
call
getInstance(String) with it. |
Log |
getInstance(String name)
Construct (if necessary) and return a
Log instance,
using the factory's current set of configuration attributes. |
static Log |
getLog(Class<?> clazz)
Convenience method to return a named logger, without the application
having to care about factories.
|
static Log |
getLog(String name)
Convenience method to return a named logger, without the application
having to care about factories.
|
static void |
release(ClassLoader classLoader)
Release any internal references to previously created
LogFactory
instances that have been associated with the specified class loader
(if any), after calling the instance method release() on
each of them. |
public Log getInstance(String name) throws LogConfigurationException
Construct (if necessary) and return a Log instance,
using the factory's current set of configuration attributes.
NOTE - Depending upon the implementation of
the LogFactory you are using, the Log
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.
name - Logical name of the Log instance to be
returned (the meaning of this name is only known to the underlying
logging implementation that is being wrapped)LogConfigurationException - if a suitable Log
instance cannot be returnedpublic Log getInstance(Class<?> clazz) throws LogConfigurationException
getInstance(String) with it.clazz - Class for which a suitable Log name will be derivedLogConfigurationException - if a suitable Log
instance cannot be returnedpublic static LogFactory getFactory() throws LogConfigurationException
Construct (if necessary) and return a LogFactory
instance, using the following ordered lookup procedure to determine
the name of the implementation class to be loaded.
org.apache.commons.logging.LogFactory system
property.commons-logging.properties
file, if found in the class path of this class. The configuration
file is in standard java.util.Properties format and
contains the fully qualified name of the implementation class
with the key being the system property defined above.org.apache.commons.logging.impl.LogFactoryImpl).NOTE - If the properties file method of identifying the
LogFactory implementation class is utilized, all of the
properties defined in this file will be set as configuration attributes
on the corresponding LogFactory instance.
LogConfigurationException - if the implementation class is not
available or cannot be instantiated.public static Log getLog(Class<?> clazz) throws LogConfigurationException
clazz - Class from which a log name will be derivedLogConfigurationException - if a suitable Log
instance cannot be returnedpublic static Log getLog(String name) throws LogConfigurationException
name - Logical name of the Log instance to be
returned (the meaning of this name is only known to the underlying
logging implementation that is being wrapped)LogConfigurationException - if a suitable Log
instance cannot be returnedpublic static void release(ClassLoader classLoader)
LogFactory
instances that have been associated with the specified class loader
(if any), after calling the instance method release() on
each of them.classLoader - ClassLoader for which to release the LogFactoryCopyright © 2000-2014 Apache Software Foundation. All Rights Reserved.