org.apache.juli.logging.LogFactory Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ServiceLoader;
import java.util.logging.LogManager;
/**
* This is a modified LogFactory that uses a simple {@link 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 {@link 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.
*
*
* @author Craig R. McClanahan
* @author Costin Manolache
* @author Richard A. Sitze
*/
public class LogFactory {
private static final LogFactory singleton = new LogFactory();
private final Constructor discoveredLogConstructor;
/**
* Private constructor that is not available for public use.
*/
private LogFactory() {
// Look via a ServiceLoader for a Log implementation that has a
// constructor taking the String name.
ServiceLoader logLoader = ServiceLoader.load(Log.class);
Constructor m=null;
for (Log log: logLoader) {
Class c=log.getClass();
try {
m=c.getConstructor(String.class);
break;
}
catch (NoSuchMethodException | SecurityException e) {
throw new Error(e);
}
}
discoveredLogConstructor=m;
}
// --------------------------------------------------------- Public Methods
// only those 2 methods need to change to use a different direct logger.
/**
* 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 Log getInstance(String name) throws LogConfigurationException {
if (discoveredLogConstructor == null) {
return DirectJDKLog.getInstance(name);
}
try {
return discoveredLogConstructor.newInstance(name);
} catch (InstantiationException | IllegalAccessException | IllegalArgumentException |
InvocationTargetException e) {
throw new LogConfigurationException(e);
}
}
/**
* 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 Log getInstance(Class clazz) throws LogConfigurationException {
return getInstance( clazz.getName());
}
// ------------------------------------------------------- Static Variables
// --------------------------------------------------------- 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.commons.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.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.
*
* @exception LogConfigurationException if the implementation class is not
* available or cannot be instantiated.
*/
public static LogFactory getFactory() throws LogConfigurationException {
return singleton;
}
/**
* 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) {
// JULI's log manager looks at the current classLoader so there is no
// need to use the passed in classLoader, the default implementation
// does not so calling reset in that case will break things
if (!LogManager.getLogManager().getClass().getName().equals(
"java.util.logging.LogManager")) {
LogManager.getLogManager().reset();
}
}
}