ServletContextCleaner


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