org.apache.juli.logging.LogFactory Maven / Gradle / Ivy
Show all versions of tomcat10-slf4j-logback Show documentation
/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.juli.logging;
import java.util.Hashtable;
import org.apache.juli.logging.impl.SLF4JLogFactory;
/**
*
* Factory for creating {@link Log} instances, which always delegates to an
* instance of {@link SLF4JLogFactory}.
*
*
*
* @author Craig R. McClanahan
* @author Costin Manolache
* @author Richard A. Sitze
* @author Ceki Gülcü
*/
@SuppressWarnings("rawtypes")
public abstract class LogFactory {
static String UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J = "http://www.slf4j.org/codes.html#unsupported_operation_in_jcl_over_slf4j";
static LogFactory logFactory = new SLF4JLogFactory();
/**
* The name (priority) of the key in the config file used to
* specify the priority of that particular config file. The associated value
* is a floating-point number; higher values take priority over lower values.
*
*
* This property is not used but preserved here for compatibility.
*/
public static final String PRIORITY_KEY = "priority";
/**
* The name (use_tccl) of the key in the config file used to
* specify whether logging classes should be loaded via the thread context
* class loader (TCCL), or not. By default, the TCCL is used.
*
*
* This property is not used but preserved here for compatibility.
*/
public static final String TCCL_KEY = "use_tccl";
/**
* The name of the property used to identify the LogFactory implementation
* class name.
*
* This property is not used but preserved here for compatibility.
*/
public static final String FACTORY_PROPERTY = "org.apache.juli.logging.LogFactory";
/**
* The fully qualified class name of the fallback LogFactory
* implementation class to use, if no other can be found.
*
*
* This property is not used but preserved here for compatibility.
*/
public static final String FACTORY_DEFAULT = "org.apache.juli.logging.impl.SLF4JLogFactory";
/**
* The name of the properties file to search for.
*
* This property is not used but preserved here for compatibility.
*/
public static final String FACTORY_PROPERTIES = "commons-logging.properties";
/**
* JDK1.3+
* 'Service Provider' specification.
*
* This property is not used but preserved here for compatibility.
*/
protected static final String SERVICE_ID = "META-INF/services/org.apache.commons.logging.LogFactory";
/**
* The name (org.apache.juli.logging.diagnostics.dest) of
* the property used to enable internal commons-logging diagnostic output, in
* order to get information on what logging implementations are being
* discovered, what classloaders they are loaded through, etc.
*
*
* This property is not used but preserved here for compatibility.
*/
public static final String DIAGNOSTICS_DEST_PROPERTY = "org.apache.juli.logging.diagnostics.dest";
/**
*
* Setting this system property value allows the Hashtable used
* to store classloaders to be substituted by an alternative implementation.
*
* This property is not used but preserved here for compatibility.
*/
public static final String HASHTABLE_IMPLEMENTATION_PROPERTY = "org.apache.juli.logging.LogFactory.HashtableImpl";
/**
* The previously constructed LogFactory instances, keyed by
* the ClassLoader with which it was created.
*
*
* This property is not used but preserved here for compatibility.
*/
protected static Hashtable factories = null;
/**
*
* This property is not used but preserved here for compatibility.
*/
protected static LogFactory nullClassLoaderFactory = null;
/**
* Protected constructor that is not available for public use.
*/
protected LogFactory() {
}
// --------------------------------------------------------- Public Methods
/**
* Return the configuration attribute with the specified name (if any), or
* null if there is no such attribute.
*
* @param name Name of the attribute to return
* @return configuration attribute
*/
public abstract Object getAttribute(String name);
/**
* Return an array containing the names of all currently defined configuration
* attributes. If there are no such attributes, a zero length array is
* returned.
*
* @return names of all currently defined configuration attributes
*/
public abstract String[] getAttributeNames();
/**
* Convenience method to derive a name from the specified class and call
* getInstance(String) with it.
*
* @param clazz
* Class for which a suitable Log name will be derived
*
* @exception LogConfigurationException
* if a suitable Log instance cannot be
* returned
*/
public abstract Log getInstance(Class clazz) 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.
*
*
* @param 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)
*
* @exception LogConfigurationException
* if a suitable Log instance cannot be
* returned
*/
public abstract Log getInstance(String name) throws LogConfigurationException;
/**
* Release any internal references to previously created {@link 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.
*/
public abstract void release();
/**
* Remove any configuration attribute associated with the specified name. If
* there is no such attribute, no action is taken.
*
* @param name
* Name of the attribute to remove
*/
public abstract void removeAttribute(String name);
/**
* Set the configuration attribute with the specified name. Calling this with
* a null value is equivalent to calling
* removeAttribute(name).
*
* @param name
* Name of the attribute to set
* @param value
* Value of the attribute to set, or null to
* remove any setting for this attribute
*/
public abstract void setAttribute(String name, Object value);
// --------------------------------------------------------- Static Methods
/**
*
* 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.
*
*
* - The
org.apache.juli.logging.LogFactory system
* property.
* - The JDK 1.3 Service Discovery mechanism
* - Use the properties file
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.
* - Fall back to a default implementation class (
*
org.apache.juli.logging.impl.SLF4FLogFactory).
*
*
*
* 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.
*
*
* @exception LogConfigurationException
* if the implementation class is not available or cannot
* be instantiated.
*/
public static LogFactory getFactory() throws LogConfigurationException {
return logFactory;
}
/**
* Convenience method to return a named logger, without the application having
* to care about factories.
*
* @param clazz
* Class from which a log name will be derived
*
* @exception LogConfigurationException
* if a suitable Log instance cannot be
* returned
*/
public static Log getLog(Class clazz) throws LogConfigurationException {
return (getFactory().getInstance(clazz));
}
/**
* Convenience method to return a named logger, without the application having
* to care about factories.
*
* @param 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)
*
* @exception LogConfigurationException
* if a suitable Log instance cannot be
* returned
*/
public static Log getLog(String name) throws LogConfigurationException {
return (getFactory().getInstance(name));
}
/**
* Release any internal references to previously created {@link LogFactory}
* instances that have been associated with the specified class loader (if
* any), after calling the instance method release() on each of
* them.
*
* @param classLoader
* ClassLoader for which to release the LogFactory
*/
public static void release(ClassLoader classLoader) {
// since SLF4J based JCL does not make use of classloaders, there is nothing
// to do here
}
/**
* Release any internal references to previously created {@link LogFactory}
* instances, after calling the instance method release() on
* each of them. 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.
*/
public static void releaseAll() {
// since SLF4J based JCL does not make use of classloaders, there is nothing
// to do here
}
/**
* Returns a string that uniquely identifies the specified object, including
* its class.
*
* The returned string is of form "classname@hashcode", i.e. is the same as the
* return value of the Object.toString() method, but works even when the
* specified object's class has overridden the toString method.
*
* @param o
* may be null.
* @return a string of form classname@hashcode, or "null" if param o is null.
* @since 1.1
*/
public static String objectId(Object o) {
if (o == null) {
return "null";
} else {
return o.getClass().getName() + "@" + System.identityHashCode(o);
}
}
// protected methods which were added in JCL 1.1. These are not used
// by SLF4JLogFactory
/**
* This method exists to ensure signature compatibility.
*/
protected static Object createFactory(String factoryClass, ClassLoader classLoader) {
throw new UnsupportedOperationException(
"Operation [factoryClass] is not supported in jcl-over-slf4j. See also " + UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J);
}
/**
* This method exists to ensure signature compatibility.
*/
protected static ClassLoader directGetContextClassLoader() {
throw new UnsupportedOperationException(
"Operation [directGetContextClassLoader] is not supported in jcl-over-slf4j. See also " + UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J);
}
/**
* This method exists to ensure signature compatibility.
*/
protected static ClassLoader getContextClassLoader() throws LogConfigurationException {
throw new UnsupportedOperationException(
"Operation [getContextClassLoader] is not supported in jcl-over-slf4j. See also " + UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J);
}
/**
* This method exists to ensure signature compatibility.
*/
protected static ClassLoader getClassLoader(Class clazz) {
throw new UnsupportedOperationException(
"Operation [getClassLoader] is not supported in jcl-over-slf4j. See also " + UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J);
}
/**
* This method exists to ensure signature compatibility.
*/
protected static boolean isDiagnosticsEnabled() {
throw new UnsupportedOperationException(
"Operation [isDiagnosticsEnabled] is not supported in jcl-over-slf4j. See also " + UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J);
}
/**
* This method exists to ensure signature compatibility.
*/
protected static void logRawDiagnostic(String msg) {
throw new UnsupportedOperationException(
"Operation [logRawDiagnostic] is not supported in jcl-over-slf4j. See also " + UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J);
}
/**
* This method exists to ensure signature compatibility.
*/
protected static LogFactory newFactory(final String factoryClass, final ClassLoader classLoader, final ClassLoader contextClassLoader) {
throw new UnsupportedOperationException(
"Operation [logRawDiagnostic] is not supported in jcl-over-slf4j. See also " + UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J);
}
/**
* This method exists to ensure signature compatibility.
*/
protected static LogFactory newFactory(final String factoryClass, final ClassLoader classLoader) {
throw new UnsupportedOperationException(
"Operation [newFactory] is not supported in jcl-over-slf4j. See also " + UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J);
}
}