1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 package org.apache.commons.logging; 19 20 21 import java.lang.reflect.Constructor; 22 import java.util.Hashtable; 23 24 import org.apache.commons.logging.impl.NoOpLog; 25 26 27 /** 28 * <p>Factory for creating {@link Log} instances. Applications should call 29 * the <code>makeNewLogInstance()</code> method to instantiate new instances 30 * of the configured {@link Log} implementation class.</p> 31 * 32 * <p>By default, calling <code>getInstance()</code> will use the following 33 * algorithm:</p> 34 * <ul> 35 * <li>If Log4J is available, return an instance of 36 * <code>org.apache.commons.logging.impl.Log4JLogger</code>.</li> 37 * <li>If JDK 1.4 or later is available, return an instance of 38 * <code>org.apache.commons.logging.impl.Jdk14Logger</code>.</li> 39 * <li>Otherwise, return an instance of 40 * <code>org.apache.commons.logging.impl.NoOpLog</code>.</li> 41 * </ul> 42 * 43 * <p>You can change the default behavior in one of two ways:</p> 44 * <ul> 45 * <li>On the startup command line, set the system property 46 * <code>org.apache.commons.logging.log</code> to the name of the 47 * <code>org.apache.commons.logging.Log</code> implementation class 48 * you want to use.</li> 49 * <li>At runtime, call <code>LogSource.setLogImplementation()</code>.</li> 50 * </ul> 51 * 52 * @deprecated Use {@link LogFactory} instead - The default factory 53 * implementation performs exactly the same algorithm as this class did 54 * 55 * @author Rod Waldhoff 56 * @version $Id: LogSource.java 424107 2006-07-20 23:15:42Z skitching $ 57 */ 58 public class LogSource { 59 60 // ------------------------------------------------------- Class Attributes 61 62 static protected Hashtable logs = new Hashtable(); 63 64 /** Is log4j available (in the current classpath) */ 65 static protected boolean log4jIsAvailable = false; 66 67 /** Is JDK 1.4 logging available */ 68 static protected boolean jdk14IsAvailable = false; 69 70 /** Constructor for current log class */ 71 static protected Constructor logImplctor = null; 72 73 74 // ----------------------------------------------------- Class Initializers 75 76 static { 77 78 // Is Log4J Available? 79 try { 80 if (null != Class.forName("org.apache.log4j.Logger")) { 81 log4jIsAvailable = true; 82 } else { 83 log4jIsAvailable = false; 84 } 85 } catch (Throwable t) { 86 log4jIsAvailable = false; 87 } 88 89 // Is JDK 1.4 Logging Available? 90 try { 91 if ((null != Class.forName("java.util.logging.Logger")) && 92 (null != Class.forName("org.apache.commons.logging.impl.Jdk14Logger"))) { 93 jdk14IsAvailable = true; 94 } else { 95 jdk14IsAvailable = false; 96 } 97 } catch (Throwable t) { 98 jdk14IsAvailable = false; 99 } 100 101 // Set the default Log implementation 102 String name = null; 103 try { 104 name = System.getProperty("org.apache.commons.logging.log"); 105 if (name == null) { 106 name = System.getProperty("org.apache.commons.logging.Log"); 107 } 108 } catch (Throwable t) { 109 } 110 if (name != null) { 111 try { 112 setLogImplementation(name); 113 } catch (Throwable t) { 114 try { 115 setLogImplementation 116 ("org.apache.commons.logging.impl.NoOpLog"); 117 } catch (Throwable u) { 118 ; 119 } 120 } 121 } else { 122 try { 123 if (log4jIsAvailable) { 124 setLogImplementation 125 ("org.apache.commons.logging.impl.Log4JLogger"); 126 } else if (jdk14IsAvailable) { 127 setLogImplementation 128 ("org.apache.commons.logging.impl.Jdk14Logger"); 129 } else { 130 setLogImplementation 131 ("org.apache.commons.logging.impl.NoOpLog"); 132 } 133 } catch (Throwable t) { 134 try { 135 setLogImplementation 136 ("org.apache.commons.logging.impl.NoOpLog"); 137 } catch (Throwable u) { 138 ; 139 } 140 } 141 } 142 143 } 144 145 146 // ------------------------------------------------------------ Constructor 147 148 149 /** Don't allow others to create instances */ 150 private LogSource() { 151 } 152 153 154 // ---------------------------------------------------------- Class Methods 155 156 157 /** 158 * Set the log implementation/log implementation factory 159 * by the name of the class. The given class 160 * must implement {@link Log}, and provide a constructor that 161 * takes a single {@link String} argument (containing the name 162 * of the log). 163 */ 164 static public void setLogImplementation(String classname) throws 165 LinkageError, ExceptionInInitializerError, 166 NoSuchMethodException, SecurityException, 167 ClassNotFoundException { 168 try { 169 Class logclass = Class.forName(classname); 170 Class[] argtypes = new Class[1]; 171 argtypes[0] = "".getClass(); 172 logImplctor = logclass.getConstructor(argtypes); 173 } catch (Throwable t) { 174 logImplctor = null; 175 } 176 } 177 178 179 /** 180 * Set the log implementation/log implementation factory 181 * by class. The given class must implement {@link Log}, 182 * and provide a constructor that takes a single {@link String} 183 * argument (containing the name of the log). 184 */ 185 static public void setLogImplementation(Class logclass) throws 186 LinkageError, ExceptionInInitializerError, 187 NoSuchMethodException, SecurityException { 188 Class[] argtypes = new Class[1]; 189 argtypes[0] = "".getClass(); 190 logImplctor = logclass.getConstructor(argtypes); 191 } 192 193 194 /** Get a <code>Log</code> instance by class name */ 195 static public Log getInstance(String name) { 196 Log log = (Log) (logs.get(name)); 197 if (null == log) { 198 log = makeNewLogInstance(name); 199 logs.put(name, log); 200 } 201 return log; 202 } 203 204 205 /** Get a <code>Log</code> instance by class */ 206 static public Log getInstance(Class clazz) { 207 return getInstance(clazz.getName()); 208 } 209 210 211 /** 212 * Create a new {@link Log} implementation, based 213 * on the given <i>name</i>. 214 * <p> 215 * The specific {@link Log} implementation returned 216 * is determined by the value of the 217 * <tt>org.apache.commons.logging.log</tt> property. 218 * The value of <tt>org.apache.commons.logging.log</tt> may be set to 219 * the fully specified name of a class that implements 220 * the {@link Log} interface. This class must also 221 * have a public constructor that takes a single 222 * {@link String} argument (containing the <i>name</i> 223 * of the {@link Log} to be constructed. 224 * <p> 225 * When <tt>org.apache.commons.logging.log</tt> is not set, 226 * or when no corresponding class can be found, 227 * this method will return a Log4JLogger 228 * if the log4j Logger class is 229 * available in the {@link LogSource}'s classpath, or a 230 * Jdk14Logger if we are on a JDK 1.4 or later system, or 231 * NoOpLog if neither of the above conditions is true. 232 * 233 * @param name the log name (or category) 234 */ 235 static public Log makeNewLogInstance(String name) { 236 237 Log log = null; 238 try { 239 Object[] args = new Object[1]; 240 args[0] = name; 241 log = (Log) (logImplctor.newInstance(args)); 242 } catch (Throwable t) { 243 log = null; 244 } 245 if (null == log) { 246 log = new NoOpLog(name); 247 } 248 return log; 249 250 } 251 252 253 /** 254 * Returns a {@link String} array containing the names of 255 * all logs known to me. 256 */ 257 static public String[] getLogNames() { 258 return (String[]) (logs.keySet().toArray(new String[logs.size()])); 259 } 260 261 262 }