logging/impl/SLF4JLogFactory.java

/**
 * Copyright (c) 2004-2011 QOS.ch
 * All rights reserved.
 *
 * Permission is hereby granted, free  of charge, to any person obtaining
 * a  copy  of this  software  and  associated  documentation files  (the
 * "Software"), to  deal in  the Software without  restriction, including
 * without limitation  the rights to  use, copy, modify,  merge, publish,
 * distribute,  sublicense, and/or sell  copies of  the Software,  and to
 * permit persons to whom the Software  is furnished to do so, subject to
 * the following conditions:
 *
 * The  above  copyright  notice  and  this permission  notice  shall  be
 * included in all copies or substantial portions of the Software.
 *
 * THE  SOFTWARE IS  PROVIDED  "AS  IS", WITHOUT  WARRANTY  OF ANY  KIND,
 * EXPRESS OR  IMPLIED, INCLUDING  BUT NOT LIMITED  TO THE  WARRANTIES OF
 * MERCHANTABILITY,    FITNESS    FOR    A   PARTICULAR    PURPOSE    AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE,  ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */
package org.apache.commons.logging.impl;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogConfigurationException;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.spi.LocationAwareLogger;

/**
 * <p>
 * Concrete subclass of {@link LogFactory} which always delegates to the
 * {@link LoggerFactory org.slf4j.LoggerFactory} class.
 *
 * <p>
 * This factory generates instances of {@link SLF4JLog}. It will remember
 * previously created instances for the same name, and will return them on
 * repeated requests to the <code>getInstance()</code> method.
 *
 * <p>
 * This implementation ignores any configured attributes.
 * </p>
 *
 * @author Rod Waldhoff
 * @author Craig R. McClanahan
 * @author Richard A. Sitze
 * @author Ceki G&uuml;lc&uuml;
 */

public class SLF4JLogFactory extends LogFactory {

  // ----------------------------------------------------------- Constructors

  /**
   * The {@link org.apache.commons.logging.Log}instances that have already been
   * created, keyed by logger name.
   */
  Map loggerMap;

  /**
   * Public no-arguments constructor required by the lookup mechanism.
   */
  public SLF4JLogFactory() {
    loggerMap = new HashMap();
  }

  // ----------------------------------------------------- Manifest Constants

  /**
   * The name of the system property identifying our {@link Log}implementation
   * class.
   */
  public static final String LOG_PROPERTY = "org.apache.commons.logging.Log";

  // ----------------------------------------------------- Instance Variables

  /**
   * Configuration attributes.
   */
  protected Hashtable attributes = new Hashtable();

  // --------------------------------------------------------- Public Methods

  /**
   * Return the configuration attribute with the specified name (if any), or
   * <code>null</code> if there is no such attribute.
   *
   * @param name
   *          Name of the attribute to return
   */
  public Object getAttribute(String name) {

    return (attributes.get(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.
   */
  public String[] getAttributeNames() {

    List names = new ArrayList();
    Enumeration keys = attributes.keys();
    while (keys.hasMoreElements()) {
      names.add((String) keys.nextElement());
    }
    String results[] = new String[names.size()];
    for (int i = 0; i < results.length; i++) {
      results[i] = (String) names.get(i);
    }
    return (results);

  }

  /**
   * Convenience method to derive a name from the specified class and call
   * <code>getInstance(String)</code> with it.
   *
   * @param clazz
   *          Class for which a suitable Log name will be derived
   *
   * @exception LogConfigurationException
   *              if a suitable <code>Log</code> instance cannot be returned
   */
  public Log getInstance(Class clazz) throws LogConfigurationException {

    return (getInstance(clazz.getName()));

  }

  /**
   * <p>
   * Construct (if necessary) and return a <code>Log</code> instance, using
   * the factory's current set of configuration attributes.
   * </p>
   *
   * @param name
   *          Logical name of the <code>Log</code> 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 <code>Log</code> instance cannot be returned
   */
  public Log getInstance(String name) throws LogConfigurationException {
    Log instance = null;
    // protect against concurrent access of loggerMap
    synchronized (loggerMap) {
      instance = (Log) loggerMap.get(name);
      if (instance == null) {
        Logger logger = LoggerFactory.getLogger(name);
        if(logger instanceof LocationAwareLogger) {
          instance = new SLF4JLocationAwareLog((LocationAwareLogger) logger);
        } else {
          instance = new SLF4JLog(logger);
        }
        loggerMap.put(name, instance);
      }
    }
    return (instance);

  }

  /**
   * Release any internal references to previously created
   * {@link org.apache.commons.logging.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 void release() {
    // This method is never called by jcl-over-slf4j classes. However,
    // in certain deployment scenarios, in particular if jcl-over-slf4j.jar
    // is
    // in the the web-app class loader and the official commons-logging.jar is
    // deployed in some parent class loader (e.g. commons/lib), then it is
    // possible
    // for the parent class loader to mask the classes shipping in
    // jcl-over-slf4j.jar.
    System.out.println("WARN: The method " + SLF4JLogFactory.class
        + "#release() was invoked.");
    System.out
        .println("WARN: Please see http://www.slf4j.org/codes.html#release for an explanation.");
    System.out.flush();
  }

  /**
   * 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 void removeAttribute(String name) {
    attributes.remove(name);
  }

  /**
   * Set the configuration attribute with the specified name. Calling this with
   * a <code>null</code> value is equivalent to calling
   * <code>removeAttribute(name)</code>.
   *
   * @param name
   *          Name of the attribute to set
   * @param value
   *          Value of the attribute to set, or <code>null</code> to remove
   *          any setting for this attribute
   */
  public void setAttribute(String name, Object value) {

    if (value == null) {
      attributes.remove(name);
    } else {
      attributes.put(name, value);
    }

  }
}