View Javadoc

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  
19  package org.apache.commons.logging.impl;
20  
21  import java.lang.reflect.InvocationTargetException;
22  import java.lang.reflect.Method;
23  
24  import javax.servlet.ServletContextEvent;
25  import javax.servlet.ServletContextListener;
26  
27  import org.apache.commons.logging.LogFactory;
28  
29  
30  /**
31   * This class is capable of receiving notifications about the undeployment of
32   * a webapp, and responds by ensuring that commons-logging releases all
33   * memory associated with the undeployed webapp.
34   * <p>
35   * In general, the WeakHashtable support added in commons-logging release 1.1
36   * ensures that logging classes do not hold references that prevent an
37   * undeployed webapp's memory from being garbage-collected even when multiple
38   * copies of commons-logging are deployed via multiple classloaders (a
39   * situation that earlier versions had problems with). However there are
40   * some rare cases where the WeakHashtable approach does not work; in these
41   * situations specifying this class as a listener for the web application will
42   * ensure that all references held by commons-logging are fully released.
43   * <p>
44   * To use this class, configure the webapp deployment descriptor to call
45   * this class on webapp undeploy; the contextDestroyed method will tell
46   * every accessable LogFactory class that the entry in its map for the
47   * current webapp's context classloader should be cleared.
48   * 
49   * @since 1.1
50   */
51  
52  public class ServletContextCleaner implements ServletContextListener {
53  
54      private Class[] RELEASE_SIGNATURE = {ClassLoader.class};
55      
56      /**
57       * Invoked when a webapp is undeployed, this tells the LogFactory
58       * class to release any logging information related to the current
59       * contextClassloader.
60       */
61      public void contextDestroyed(ServletContextEvent sce) {
62          ClassLoader tccl = Thread.currentThread().getContextClassLoader();
63  
64          Object[] params = new Object[1];
65          params[0] = tccl;
66  
67          // Walk up the tree of classloaders, finding all the available
68          // LogFactory classes and releasing any objects associated with
69          // the tccl (ie the webapp).
70          //
71          // When there is only one LogFactory in the classpath, and it
72          // is within the webapp being undeployed then there is no problem;
73          // garbage collection works fine.
74          //
75          // When there are multiple LogFactory classes in the classpath but
76          // parent-first classloading is used everywhere, this loop is really
77          // short. The first instance of LogFactory found will
78          // be the highest in the classpath, and then no more will be found.
79          // This is ok, as with this setup this will be the only LogFactory
80          // holding any data associated with the tccl being released.
81          //
82          // When there are multiple LogFactory classes in the classpath and
83          // child-first classloading is used in any classloader, then multiple
84          // LogFactory instances may hold info about this TCCL; whenever the
85          // webapp makes a call into a class loaded via an ancestor classloader
86          // and that class calls LogFactory the tccl gets registered in
87          // the LogFactory instance that is visible from the ancestor
88          // classloader. However the concrete logging library it points
89          // to is expected to have been loaded via the TCCL, so the 
90          // underlying logging lib is only initialised/configured once.
91          // These references from ancestor LogFactory classes down to
92          // TCCL classloaders are held via weak references and so should
93          // be released but there are circumstances where they may not.
94          // Walking up the classloader ancestry ladder releasing
95          // the current tccl at each level tree, though, will definitely
96          // clear any problem references.
97          ClassLoader loader = tccl;
98          while (loader != null) {
99              // Load via the current loader. Note that if the class is not accessable
100             // via this loader, but is accessable via some ancestor then that class
101             // will be returned.
102             try {
103                 Class logFactoryClass = loader.loadClass("org.apache.commons.logging.LogFactory");
104                 Method releaseMethod = logFactoryClass.getMethod("release", RELEASE_SIGNATURE);
105                 releaseMethod.invoke(null, params);
106                 loader = logFactoryClass.getClassLoader().getParent();
107             } catch(ClassNotFoundException ex) {
108                 // Neither the current classloader nor any of its ancestors could find
109                 // the LogFactory class, so we can stop now.
110                 loader = null;
111             } catch(NoSuchMethodException ex) {
112                 // This is not expected; every version of JCL has this method
113                 System.err.println("LogFactory instance found which does not support release method!");
114                 loader = null;
115             } catch(IllegalAccessException ex) {
116                 // This is not expected; every ancestor class should be accessable
117                 System.err.println("LogFactory instance found which is not accessable!");
118                 loader = null;
119             } catch(InvocationTargetException ex) {
120                 // This is not expected
121                 System.err.println("LogFactory instance release method failed!");
122                 loader = null;
123             }
124         }
125         
126         // Just to be sure, invoke release on the LogFactory that is visible from
127         // this ServletContextCleaner class too. This should already have been caught
128         // by the above loop but just in case...
129         LogFactory.release(tccl);
130     }
131     
132     /**
133      * Invoked when a webapp is deployed. Nothing needs to be done here.
134      */
135     public void contextInitialized(ServletContextEvent sce) {
136         // do nothing
137     }
138 }