Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
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;
18
 
19
 

Factory for creating 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(s):
Craig R. McClanahan
Costin Manolache
Richard A. Sitze
Version:
$Revision: 1.27 $ $Date: 2004/06/06 21:15:12 $
46
 
47
 
48
 public abstract class LogFactory {
49
 
50
 
51
     // ----------------------------------------------------- Manifest Constants
52
 

    
The name of the property used to identify the LogFactory implementation class name. 
57
 
58
     public static final String FACTORY_PROPERTY =
59
         "org.apache.commons.logging.LogFactory";

    
The fully qualified class name of the fallback LogFactory implementation class to use, if no other can be found. 
64
 
65
     public static final String FACTORY_DEFAULT =
66
         "org.apache.commons.logging.impl.LogFactoryImpl";

    
The name of the properties file to search for. 
70
 
71
     public static final String FACTORY_PROPERTIES =
72
         "commons-logging.properties";

    
JDK1.3+ 'Service Provider' specification. 
78
 
79
     protected static final String SERVICE_ID =
80
         "META-INF/services/org.apache.commons.logging.LogFactory";
81
 
82
 
83
     // ----------------------------------------------------------- Constructors
84
 

    
Protected constructor that is not available for public use. 
88
 
89
     protected LogFactory() { }
90
 
91
 
92
     // --------------------------------------------------------- Public Methods
93
 

    
Return the configuration attribute with the specified name (if any), or null if there is no such attribute.

Parameters:
name Name of the attribute to return
101
    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. 
109
    public abstract String[] getAttributeNames();


    
Convenience method to derive a name from the specified class and call getInstance(String) with it.

Parameters:
clazz Class for which a suitable Log name will be derived
Throws:
LogConfigurationException if a suitable Log instance cannot be returned
121
    public abstract Log getInstance(Class clazz)
122
        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.

Parameters:
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)
Throws:
LogConfigurationException if a suitable Log instance cannot be returned
142
    public abstract Log getInstance(String name)
143
        throws LogConfigurationException;


    
Release any internal references to previously created 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. 
153
    public abstract void release();


    
Remove any configuration attribute associated with the specified name. If there is no such attribute, no action is taken.

Parameters:
name Name of the attribute to remove
162
    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).

Parameters:
name Name of the attribute to set
value Value of the attribute to set, or null to remove any setting for this attribute
174
    public abstract void setAttribute(String name, Object value);
177
    // ------------------------------------------------------- Static Variables
178


    
The previously constructed LogFactory instances, keyed by the ClassLoader with which it was created. 
184
    protected static Hashtable factories = new Hashtable();
187
    // --------------------------------------------------------- Static Methods
188


    

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.

Throws:
LogConfigurationException if the implementation class is not available or cannot be instantiated.
215
    public static LogFactory getFactory() throws LogConfigurationException {
217
        // Identify the class loader we will be using
218
        ClassLoader contextClassLoader =
219
            (ClassLoader)AccessController.doPrivileged(
220
                new PrivilegedAction() {
221
                    public Object run() {
222
                        return getContextClassLoader();
223
                    }
224
                });
226
        // Return any previously registered factory for this class loader
227
        LogFactory factory = getCachedFactory(contextClassLoader);
228
        if (factory != null)
229
            return factory;
232
        // Load properties file.
233
        // Will be used one way or another in the end.
235
        Properties props=null;
236
        try {
237
            InputStream stream = getResourceAsStream(contextClassLoader,
238
                                                     );
240
            if (stream != null) {
241
                props = new Properties();
242
                props.load(stream);
243
                stream.close();
244
            }
245
        } catch (IOException e) {
246
        } catch (SecurityException e) {
247
        }
250
        // First, try the system property
251
        try {
252
            String factoryClass = System.getProperty();
253
            if (factoryClass != null) {
254
                factory = newFactory(factoryClass, contextClassLoader);
255
            }
256
        } catch (SecurityException e) {
257
            ;  // ignore
258
        }
261
        // Second, try to find a service by using the JDK1.3 jar
262
        // discovery mechanism. This will allow users to plug a logger
263
        // by just placing it in the lib/ directory of the webapp ( or in
264
        // CLASSPATH or equivalent ). This is similar to the second
265
        // step, except that it uses the (standard?) jdk1.3 location in the jar.
267
        if (factory == null) {
268
            try {
269
                InputStream is = getResourceAsStream(contextClassLoader,
270
                                                     );
272
                if( is != null ) {
273
                    // This code is needed by EBCDIC and other strange systems.
274
                    // It's a fix for bugs reported in xerces
275
                    BufferedReader rd;
276
                    try {
277
                        rd = new BufferedReader(new InputStreamReader(is, "UTF-8"));
278
                    } catch (java.io.UnsupportedEncodingException e) {
279
                        rd = new BufferedReader(new InputStreamReader(is));
280
                    }
282
                    String factoryClassName = rd.readLine();
283
                    rd.close();
285
                    if (factoryClassName != null &&
286
                        ! "".equals(factoryClassName)) {
288
                        factory= newFactory( factoryClassName, contextClassLoader );
289
                    }
290
                }
291
            } catch( Exception ex ) {
292
                ;
293
            }
294
        }
297
        // Third try a properties file.
298
        // If the properties file exists, it'll be read and the properties
299
        // used. IMHO ( costin ) System property and JDK1.3 jar service
300
        // should be enough for detecting the class name. The properties
301
        // should be used to set the attributes ( which may be specific to
302
        // the webapp, even if a default logger is set at JVM level by a
303
        // system property )
305
        if (factory == null  &&  props != null) {
306
            String factoryClass = props.getProperty();
307
            if (factoryClass != null) {
308
                factory = newFactory(factoryClass, contextClassLoader);
309
            }
310
        }
313
        // Fourth, try the fallback implementation class
315
        if (factory == null) {
316
            factory = newFactory(, LogFactory.class.getClassLoader());
317
        }
319
        if (factory != null) {
            
Always cache using context class loader. 
323
            cacheFactory(contextClassLoader, factory);
325
            if( props!=null ) {
326
                Enumeration names = props.propertyNames();
327
                while (names.hasMoreElements()) {
328
                    String name = (String) names.nextElement();
329
                    String value = props.getProperty(name);
330
                    factory.setAttribute(name, value);
331
                }
332
            }
333
        }
335
        return factory;
336
    }


    
Convenience method to return a named logger, without the application having to care about factories.

Parameters:
clazz Class from which a log name will be derived
Throws:
LogConfigurationException if a suitable Log instance cannot be returned
348
    public static Log getLog(Class clazz)
349
        throws LogConfigurationException {
351
        return (getFactory().getInstance(clazz));
353
    }


    
Convenience method to return a named logger, without the application having to care about factories.

Parameters:
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)
Throws:
LogConfigurationException if a suitable Log instance cannot be returned
367
    public static Log getLog(String name)
368
        throws LogConfigurationException {
370
        return (getFactory().getInstance(name));
372
    }


    
Release any internal references to previously created LogFactory instances that have been associated with the specified class loader (if any), after calling the instance method release() on each of them.

Parameters:
classLoader ClassLoader for which to release the LogFactory
383
    public static void release(ClassLoader classLoader) {
385
        synchronized () {
386
            LogFactory factory = (LogFactory) .get(classLoader);
387
            if (factory != null) {
388
                factory.release();
389
                .remove(classLoader);
390
            }
391
        }
393
    }


    
Release any internal references to previously created 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. 
404
    public static void releaseAll() {
406
        synchronized () {
407
            Enumeration elements = .elements();
408
            while (elements.hasMoreElements()) {
409
                LogFactory element = (LogFactory) elements.nextElement();
410
                element.release();
411
            }
412
            .clear();
413
        }
415
    }
418
    // ------------------------------------------------------ Protected Methods
419


    
Return the thread context class loader if available. Otherwise return null. The thread context class loader is available for JDK 1.2 or later, if certain security conditions are met.

Throws:
LogConfigurationException if a suitable class loader cannot be identified.
431
    protected static ClassLoader getContextClassLoader()
432
        throws LogConfigurationException
433
    {
434
        ClassLoader classLoader = null;
436
        try {
437
            // Are we running on a JDK 1.2 or later system?
438
            Method method = Thread.class.getMethod("getContextClassLoader", null);
440
            // Get the thread context class loader (if there is one)
441
            try {
442
                classLoader = (ClassLoader)method.invoke(Thread.currentThread(), null);
443
            } catch (IllegalAccessException e) {
444
                throw new LogConfigurationException
445
                    ("Unexpected IllegalAccessException", e);
446
            } catch (InvocationTargetException e) {
                
InvocationTargetException is thrown by 'invoke' when the method being invoked (getContextClassLoader) throws an exception. getContextClassLoader() throws SecurityException when the context class loader isn't an ancestor of the calling class's class loader, or if security permissions are restricted. In the first case (not related), we want to ignore and keep going. We cannot help but also ignore the second with the logic below, but other calls elsewhere (to obtain a class loader) will trigger this exception where we can make a distinction. 
463
                if (e.getTargetException() instanceof SecurityException) {
464
                    ;  // ignore
465
                } else {
466
                    // Capture 'e.getTargetException()' exception for details
467
                    // alternate: log 'e.getTargetException()', and pass back 'e'.
468
                    throw new LogConfigurationException
469
                        ("Unexpected InvocationTargetException", e.getTargetException());
470
                }
471
            }
472
        } catch (NoSuchMethodException e) {
473
            // Assume we are running on JDK 1.1
474
            classLoader = LogFactory.class.getClassLoader();
475
        }
477
        // Return the selected class loader
478
        return classLoader;
479
    }

    
Check cached factories (keyed by contextClassLoader) 
484
    private static LogFactory getCachedFactory(ClassLoader contextClassLoader)
485
    {
486
        LogFactory factory = null;
488
        if (contextClassLoader != null)
489
            factory = (LogFactory) .get(contextClassLoader);
491
        return factory;
492
    }
494
    private static void cacheFactory(ClassLoader classLoader, LogFactory factory)
495
    {
496
        if (classLoader != null && factory != null)
497
            .put(classLoader, factory);
498
    }

    
Return a new instance of the specified LogFactory implementation class, loaded by the specified class loader. If that fails, try the class loader used to load this (abstract) LogFactory.

Parameters:
factoryClass Fully qualified name of the LogFactory implementation class
classLoader ClassLoader from which to load this class
Throws:
LogConfigurationException if a suitable instance cannot be created
513
    protected static LogFactory newFactory(final String factoryClass,
514
                                           final ClassLoader classLoader)
515
        throws LogConfigurationException
516
    {
517
        Object result = AccessController.doPrivileged(
518
            new PrivilegedAction() {
519
                public Object run() {
520
                    // This will be used to diagnose bad configurations
521
                    // and allow a useful message to be sent to the user
522
                    Class logFactoryClass = null;
523
                    try {
524
                        if (classLoader != null) {
525
                            try {
526
                                // First the given class loader param (thread class loader)
528
                                // Warning: must typecast here & allow exception
529
                                // to be generated/caught & recast properly.
530
                                logFactoryClass = classLoader.loadClass(factoryClass);
531
                                return (LogFactory) logFactoryClass.newInstance();
533
                            } catch (ClassNotFoundException ex) {
534
                                if (classLoader == LogFactory.class.getClassLoader()) {
535
                                    // Nothing more to try, onwards.
536
                                    throw ex;
537
                                }
538
                                // ignore exception, continue
539
                            } catch (NoClassDefFoundError e) {
540
                                if (classLoader == LogFactory.class.getClassLoader()) {
541
                                    // Nothing more to try, onwards.
542
                                    throw e;
543
                                }
545
                            } catch(ClassCastException e){
547
                              if (classLoader == LogFactory.class.getClassLoader()) {
548
                                    // Nothing more to try, onwards (bug in loader implementation).
549
                                    throw e;
550
                               }
551
                            }
552
                            // Ignore exception, continue
553
                        }
555
                        /* At this point, either classLoader == null, OR
556
                         * classLoader was unable to load factoryClass.
557
                         * Try the class loader that loaded this class:
558
                         * LogFactory.getClassLoader().
559
                         *
560
                         * Notes:
561
                         * a) LogFactory.class.getClassLoader() may return 'null'
562
                         *    if LogFactory is loaded by the bootstrap classloader.
563
                         * b) The Java endorsed library mechanism is instead
564
                         *    Class.forName(factoryClass);
565
                         */
566
                        // Warning: must typecast here & allow exception
567
                        // to be generated/caught & recast properly.
568
                        logFactoryClass = Class.forName(factoryClass);
569
                        return (LogFactory) logFactoryClass.newInstance();
570
                    } catch (Exception e) {
571
                        // Check to see if we've got a bad configuration
572
                        if (logFactoryClass != null
573
                            && !LogFactory.class.isAssignableFrom(logFactoryClass)) {
574
                            return new LogConfigurationException(
575
                                "The chosen LogFactory implementation does not extend LogFactory."
576
                                + " Please check your configuration.",
577
                                e);
578
                        }
579
                        return new LogConfigurationException(e);
580
                    }
581
                }
582
            });
584
        if (result instanceof LogConfigurationException)
585
            throw (LogConfigurationException)result;
587
        return (LogFactory)result;
588
    }
590
    private static InputStream getResourceAsStream(final ClassLoader loader,
591
                                                   final String name)
592
    {
593
        return (InputStream)AccessController.doPrivileged(
594
            new PrivilegedAction() {
595
                public Object run() {
596
                    if (loader != null) {
597
                        return loader.getResourceAsStream(name);
598
                    } else {
599
                        return ClassLoader.getSystemResourceAsStream(name);
600
                    }
601
                }
602
            });
603
    }
New to GrepCode? Check out our FAQ X