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