Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.apache.commons.logging.impl
Class LogFactoryImpl

    java.lang.Object
      org.apache.commons.logging.LogFactory
          org.apache.commons.logging.impl.LogFactoryImpl

public class LogFactoryImpl
extends LogFactory

Concrete subclass of `LogFactory` that implements the following algorithm to dynamically select a logging implementation class to instantiate a wrapper for.

- Use a factory configuration attribute named `org.apache.commons.logging.Log` to identify the requested implementation class.
- Use the `org.apache.commons.logging.Log` system property to identify the requested implementation class.
- If Log4J is available, return an instance of `org.apache.commons.logging.impl.Log4JLogger`.
- If JDK 1.4 or later is available, return an instance of `org.apache.commons.logging.impl.Jdk14Logger`.
- Otherwise, return an instance of `org.apache.commons.logging.impl.SimpleLog`.

If the selected `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.

Version:
  $Revision: 581090 $ $Date: 2007-10-02 00:01:06 +0200 (ti, 02 okt 2007) $
Author:
  Rod Waldhoff, Craig R. McClanahan, Richard A. Sitze, Brian Stansberry

Field Summary
`static java.lang.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.
`static java.lang.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.
`static java.lang.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.
`protected java.util.Hashtable` | `attributes` Configuration attributes.
`protected java.util.Hashtable` | `instances` The `Log` instances that have already been created, keyed by logger name.
`static java.lang.String` | `LOG_PROPERTY` The name (`org.apache.commons.logging.Log`) of the system property identifying our `Log` implementation class.
`protected static java.lang.String` | `LOG_PROPERTY_OLD` The deprecated system property used for backwards compatibility with old versions of JCL.
`protected java.lang.reflect.Constructor` | `logConstructor` The one-argument constructor of the `Log` implementation class that will be used to create new instances.
`protected java.lang.Class[]` | `logConstructorSignature` The signature of the Constructor to be used.
`protected java.lang.reflect.Method` | `logMethod` The one-argument `setLogFactory` method of the selected `Log` method, if it exists.
`protected java.lang.Class[]` | `logMethodSignature` The signature of the `setLogFactory` method to be used.

Fields inherited from class org.apache.commons.logging.LogFactory
`DIAGNOSTICS_DEST_PROPERTY, factories, FACTORY_DEFAULT, FACTORY_PROPERTIES, FACTORY_PROPERTY, HASHTABLE_IMPLEMENTATION_PROPERTY, nullClassLoaderFactory, PRIORITY_KEY, SERVICE_ID, TCCL_KEY`

Constructor Summary
`LogFactoryImpl()` Public no-arguments constructor required by the lookup mechanism.

Method Summary
`java.lang.Object` | `getAttribute(java.lang.String name)` Return the configuration attribute with the specified name (if any), or `null` if there is no such attribute.
`java.lang.String[]` | `getAttributeNames()` Return an array containing the names of all currently defined configuration attributes.
`protected static java.lang.ClassLoader` | `getClassLoader(java.lang.Class clazz)` Workaround for bug in Java1.2; in theory this method is not needed.
`protected static java.lang.ClassLoader` | `getContextClassLoader()` Gets the context classloader.
`Log` | `getInstance(java.lang.Class clazz)` Convenience method to derive a name from the specified class and call `getInstance(String)` with it.
`Log` | `getInstance(java.lang.String name)` Construct (if necessary) and return a `Log` instance, using the factory's current set of configuration attributes.
`protected java.lang.String` | `getLogClassName()` Deprecated. Never invoked by this class; subclasses should not assume it will be.
`protected java.lang.reflect.Constructor` | `getLogConstructor()` Deprecated. Never invoked by this class; subclasses should not assume it will be.
`protected static boolean` | `isDiagnosticsEnabled()` Workaround for bug in Java1.2; in theory this method is not needed.
`protected boolean` | `isJdk13LumberjackAvailable()` Deprecated. Never invoked by this class; subclasses should not assume it will be.
`protected boolean` | `isJdk14Available()` Deprecated. Never invoked by this class; subclasses should not assume it will be.
`protected boolean` | `isLog4JAvailable()` Deprecated. Never invoked by this class; subclasses should not assume it will be.
`protected void` | `logDiagnostic(java.lang.String msg)` Output a diagnostic message to a user-specified destination (if the user has enabled diagnostic logging).
`protected Log` | `newInstance(java.lang.String name)` Create and return a new `Log` instance for the specified name.
`void` | `release()` Release any internal references to previously created `Log` instances returned by this factory.
`void` | `removeAttribute(java.lang.String name)` Remove any configuration attribute associated with the specified name.
`void` | `setAttribute(java.lang.String name, java.lang.Object value)` Set the configuration attribute with the specified name.

Methods inherited from class org.apache.commons.logging.LogFactory
`createFactory, directGetContextClassLoader, getFactory, getLog, getLog, logRawDiagnostic, newFactory, newFactory, objectId, release, releaseAll`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### LOG_PROPERTY

    public static final java.lang.String LOG_PROPERTY

  The name (`org.apache.commons.logging.Log`) of the system property identifying our `Log` implementation class.

  See Also:
    Constant Field Values

### LOG_PROPERTY_OLD

    protected static final java.lang.String LOG_PROPERTY_OLD

  The deprecated system property used for backwards compatibility with old versions of JCL.

  See Also:
    Constant Field Values

### ALLOW_FLAWED_CONTEXT_PROPERTY

    public static final java.lang.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.

  See Also:
    Constant Field Values

### ALLOW_FLAWED_DISCOVERY_PROPERTY

    public static final java.lang.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.

  See Also:
    Constant Field Values

### ALLOW_FLAWED_HIERARCHY_PROPERTY

    public static final java.lang.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.

  See Also:
    Constant Field Values

### attributes

    protected java.util.Hashtable attributes

  Configuration attributes.

### instances

    protected java.util.Hashtable instances

  The `Log` instances that have already been created, keyed by logger name.

### logConstructor

    protected java.lang.reflect.Constructor logConstructor

  The one-argument constructor of the `Log` implementation class that will be used to create new instances. This value is initialized by `getLogConstructor()`, and then returned repeatedly.

### logConstructorSignature

    protected java.lang.Class[] logConstructorSignature

  The signature of the Constructor to be used.

### logMethod

    protected java.lang.reflect.Method logMethod

  The one-argument `setLogFactory` method of the selected `Log` method, if it exists.

### logMethodSignature

    protected java.lang.Class[] logMethodSignature

  The signature of the `setLogFactory` method to be used.

Constructor Detail

### LogFactoryImpl

    public LogFactoryImpl()

  Public no-arguments constructor required by the lookup mechanism.

Method Detail

### getAttribute

    public java.lang.Object getAttribute(java.lang.String name)

  Return the configuration attribute with the specified name (if any), or `null` if there is no such attribute.

  Specified by:
    `getAttribute` in class `LogFactory`
  Parameters:
    `name` - Name of the attribute to return

### getAttributeNames

    public java.lang.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.

  Specified by:
    `getAttributeNames` in class `LogFactory`

### getInstance

    public Log getInstance(java.lang.Class clazz)
                    throws LogConfigurationException

  Convenience method to derive a name from the specified class and call `getInstance(String)` with it.

  Specified by:
    `getInstance` in class `LogFactory`
  Parameters:
    `clazz` - Class for which a suitable Log name will be derived
  Throws:
    `LogConfigurationException` - if a suitable `Log` instance cannot be returned

### getInstance

    public Log getInstance(java.lang.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.

  Specified by:
    `getInstance` in class `LogFactory`
  Parameters:
    `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)
  Throws:
    `LogConfigurationException` - if a suitable `Log` instance cannot be returned

### release

    public void release()

  Release any internal references to previously created `Log` 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.

  Specified by:
    `release` in class `LogFactory`

### removeAttribute

    public void removeAttribute(java.lang.String name)

  Remove any configuration attribute associated with the specified name. If there is no such attribute, no action is taken.

  Specified by:
    `removeAttribute` in class `LogFactory`
  Parameters:
    `name` - Name of the attribute to remove

### setAttribute

    public void setAttribute(java.lang.String name,
                             java.lang.Object value)

  Set the configuration attribute with the specified name. Calling this with a `null` value is equivalent to calling `removeAttribute(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, call

       LogFactory.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.

  Specified by:
    `setAttribute` in class `LogFactory`
  Parameters:
    `name` - Name of the attribute to set
    `value` - Value of the attribute to set, or `null` to remove any setting for this attribute

### getContextClassLoader

    protected static java.lang.ClassLoader getContextClassLoader()
                                                          throws LogConfigurationException

  Gets the context classloader. This method is a workaround for a java 1.2 compiler bug.

  Throws:
    `LogConfigurationException`
  Since:
    1.1

### isDiagnosticsEnabled

    protected static boolean isDiagnosticsEnabled()

  Workaround for bug in Java1.2; in theory this method is not needed. See LogFactory.isDiagnosticsEnabled.

### getClassLoader

    protected static java.lang.ClassLoader getClassLoader(java.lang.Class clazz)

  Workaround for bug in Java1.2; in theory this method is not needed. See LogFactory.getClassLoader.

  Since:
    1.1

### logDiagnostic

    protected void logDiagnostic(java.lang.String msg)

  Output a diagnostic message to a user-specified destination (if the user has enabled diagnostic logging).

  Parameters:
    `msg` - diagnostic message
  Since:
    1.1

### getLogClassName

    protected java.lang.String getLogClassName()

  Deprecated. Never invoked by this class; subclasses should not assume it will be.

  Return the fully qualified Java classname of the `Log` implementation we will be using.

### getLogConstructor

    protected java.lang.reflect.Constructor getLogConstructor()
                                                       throws LogConfigurationException

  Deprecated. Never invoked by this class; subclasses should not assume it will be.

  Return the `Constructor` that can be called to instantiate new `Log` instances.

  IMPLEMENTATION NOTE - Race conditions caused by calling this method from more than one thread are ignored, because the same `Constructor` instance will ultimately be derived in all circumstances.

  Throws:
    `LogConfigurationException` - if a suitable constructor cannot be returned

### isJdk13LumberjackAvailable

    protected boolean isJdk13LumberjackAvailable()

  Deprecated. Never invoked by this class; subclasses should not assume it will be.

  Is JDK 1.3 with Lumberjack logging available?

### isJdk14Available

    protected boolean isJdk14Available()

  Deprecated. Never invoked by this class; subclasses should not assume it will be.

  Return `true` if JDK 1.4 or later logging is available. Also checks that the `Throwable` class supports `getStackTrace()`, which is required by Jdk14Logger.

### isLog4JAvailable

    protected boolean isLog4JAvailable()

  Deprecated. Never invoked by this class; subclasses should not assume it will be.

  Is a Log4J implementation available?

### newInstance

    protected Log newInstance(java.lang.String name)
                       throws LogConfigurationException

  Create and return a new `Log` instance for the specified name.

  Parameters:
    `name` - Name of the new logger
  Throws:
    `LogConfigurationException` - if a new instance cannot be created

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2001-2007 The Apache Software Foundation. All Rights Reserved.