1 /* 2 * Copyright 2001-2004 The Apache Software Foundation. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package org.apache.commons.logging.impl; 18 19 import java.util.Enumeration; 20 import java.util.HashMap; 21 import java.util.Hashtable; 22 import java.util.Map; 23 import java.util.Vector; 24 25 import org.apache.commons.logging.Log; 26 import org.apache.commons.logging.LogConfigurationException; 27 import org.apache.commons.logging.LogFactory; 28 import org.slf4j.Logger; 29 import org.slf4j.LoggerFactory; 30 import org.slf4j.spi.LocationAwareLogger; 31 32 /** 33 * <p> 34 * Concrete subclass of {@link LogFactory} which always delegates to the 35 * {@link LoggerFactory org.slf4j.LoggerFactory} class. 36 * 37 * <p> 38 * This factory generates instances of {@link SLF4JLog}. It will remember 39 * previously created instances for the same name, and will return them on 40 * repeated requests to the <code>getInstance()</code> method. 41 * 42 * <p> 43 * This implementation ignores any configured attributes. 44 * </p> 45 * 46 * @author Rod Waldhoff 47 * @author Craig R. McClanahan 48 * @author Richard A. Sitze 49 * @author Ceki Gülcü 50 */ 51 52 public class SLF4JLogFactory extends LogFactory { 53 54 // ----------------------------------------------------------- Constructors 55 56 /** 57 * The {@link org.apache.commons.logging.Log}instances that have already been 58 * created, keyed by logger name. 59 */ 60 Map loggerMap; 61 62 /** 63 * Public no-arguments constructor required by the lookup mechanism. 64 */ 65 public SLF4JLogFactory() { 66 loggerMap = new HashMap(); 67 } 68 69 // ----------------------------------------------------- Manifest Constants 70 71 /** 72 * The name of the system property identifying our {@link Log}implementation 73 * class. 74 */ 75 public static final String LOG_PROPERTY = "org.apache.commons.logging.Log"; 76 77 // ----------------------------------------------------- Instance Variables 78 79 /** 80 * Configuration attributes. 81 */ 82 protected Hashtable attributes = new Hashtable(); 83 84 // --------------------------------------------------------- Public Methods 85 86 /** 87 * Return the configuration attribute with the specified name (if any), or 88 * <code>null</code> if there is no such attribute. 89 * 90 * @param name 91 * Name of the attribute to return 92 */ 93 public Object getAttribute(String name) { 94 95 return (attributes.get(name)); 96 97 } 98 99 /** 100 * Return an array containing the names of all currently defined configuration 101 * attributes. If there are no such attributes, a zero length array is 102 * returned. 103 */ 104 public String[] getAttributeNames() { 105 106 Vector names = new Vector(); 107 Enumeration keys = attributes.keys(); 108 while (keys.hasMoreElements()) { 109 names.addElement((String) keys.nextElement()); 110 } 111 String results[] = new String[names.size()]; 112 for (int i = 0; i < results.length; i++) { 113 results[i] = (String) names.elementAt(i); 114 } 115 return (results); 116 117 } 118 119 /** 120 * Convenience method to derive a name from the specified class and call 121 * <code>getInstance(String)</code> with it. 122 * 123 * @param clazz 124 * Class for which a suitable Log name will be derived 125 * 126 * @exception LogConfigurationException 127 * if a suitable <code>Log</code> instance cannot be returned 128 */ 129 public Log getInstance(Class clazz) throws LogConfigurationException { 130 131 return (getInstance(clazz.getName())); 132 133 } 134 135 /** 136 * <p> 137 * Construct (if necessary) and return a <code>Log</code> instance, using 138 * the factory's current set of configuration attributes. 139 * </p> 140 * 141 * @param name 142 * Logical name of the <code>Log</code> instance to be returned 143 * (the meaning of this name is only known to the underlying logging 144 * implementation that is being wrapped) 145 * 146 * @exception LogConfigurationException 147 * if a suitable <code>Log</code> instance cannot be returned 148 */ 149 public Log getInstance(String name) throws LogConfigurationException { 150 Log instance = null; 151 // protect against concurrent access of loggerMap 152 synchronized (this) { 153 instance = (Log) loggerMap.get(name); 154 if (instance == null) { 155 Logger logger = LoggerFactory.getLogger(name); 156 if(logger instanceof LocationAwareLogger) { 157 instance = new SLF4JLocationAwareLog((LocationAwareLogger) logger); 158 } else { 159 instance = new SLF4JLog(logger); 160 } 161 loggerMap.put(name, instance); 162 } 163 } 164 return (instance); 165 166 } 167 168 /** 169 * Release any internal references to previously created 170 * {@link org.apache.commons.logging.Log}instances returned by this factory. 171 * This is useful in environments like servlet containers, which implement 172 * application reloading by throwing away a ClassLoader. Dangling references 173 * to objects in that class loader would prevent garbage collection. 174 */ 175 public void release() { 176 // This method is never called by jcl-over-slf4j classes. However, 177 // in certain deployment scenarios, in particular if jcl104-over-slf4j.jar 178 // is 179 // in the the web-app class loader and the official commons-logging.jar is 180 // deployed in some parent class loader (e.g. commons/lib), then it is 181 // possible 182 // for the parent class loader to mask the classes shipping in 183 // jcl104-over-slf4j.jar. 184 System.out.println("WARN: The method " + SLF4JLogFactory.class 185 + "#release() was invoked."); 186 System.out 187 .println("WARN: Please see http://www.slf4j.org/codes.html for an explanation."); 188 System.out.flush(); 189 } 190 191 /** 192 * Remove any configuration attribute associated with the specified name. If 193 * there is no such attribute, no action is taken. 194 * 195 * @param name 196 * Name of the attribute to remove 197 */ 198 public void removeAttribute(String name) { 199 attributes.remove(name); 200 } 201 202 /** 203 * Set the configuration attribute with the specified name. Calling this with 204 * a <code>null</code> value is equivalent to calling 205 * <code>removeAttribute(name)</code>. 206 * 207 * @param name 208 * Name of the attribute to set 209 * @param value 210 * Value of the attribute to set, or <code>null</code> to remove 211 * any setting for this attribute 212 */ 213 public void setAttribute(String name, Object value) { 214 215 if (value == null) { 216 attributes.remove(name); 217 } else { 218 attributes.put(name, value); 219 } 220 221 } 222 }