001/* 002 * Copyright 2002-2012 the original author or authors. 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); 005 * you may not use this file except in compliance with the License. 006 * You may obtain a copy of the License at 007 * 008 * https://www.apache.org/licenses/LICENSE-2.0 009 * 010 * Unless required by applicable law or agreed to in writing, software 011 * distributed under the License is distributed on an "AS IS" BASIS, 012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 013 * See the License for the specific language governing permissions and 014 * limitations under the License. 015 */ 016 017package org.springframework.web.util; 018 019import java.beans.Introspector; 020import javax.servlet.ServletContextEvent; 021import javax.servlet.ServletContextListener; 022 023import org.springframework.beans.CachedIntrospectionResults; 024 025/** 026 * Listener that flushes the JDK's {@link java.beans.Introspector JavaBeans Introspector} 027 * cache on web app shutdown. Register this listener in your {@code web.xml} to 028 * guarantee proper release of the web application class loader and its loaded classes. 029 * 030 * <p><b>If the JavaBeans Introspector has been used to analyze application classes, 031 * the system-level Introspector cache will hold a hard reference to those classes. 032 * Consequently, those classes and the web application class loader will not be 033 * garbage-collected on web app shutdown!</b> This listener performs proper cleanup, 034 * to allow for garbage collection to take effect. 035 * 036 * <p>Unfortunately, the only way to clean up the Introspector is to flush 037 * the entire cache, as there is no way to specifically determine the 038 * application's classes referenced there. This will remove cached 039 * introspection results for all other applications in the server too. 040 * 041 * <p>Note that this listener is <i>not</i> necessary when using Spring's beans 042 * infrastructure within the application, as Spring's own introspection results 043 * cache will immediately flush an analyzed class from the JavaBeans Introspector 044 * cache and only hold a cache within the application's own ClassLoader. 045 * 046 * <b>Although Spring itself does not create JDK Introspector leaks, note that this 047 * listener should nevertheless be used in scenarios where the Spring framework classes 048 * themselves reside in a 'common' ClassLoader (such as the system ClassLoader).</b> 049 * In such a scenario, this listener will properly clean up Spring's introspection cache. 050 * 051 * <p>Application classes hardly ever need to use the JavaBeans Introspector 052 * directly, so are normally not the cause of Introspector resource leaks. 053 * Rather, many libraries and frameworks do not clean up the Introspector: 054 * e.g. Struts and Quartz. 055 * 056 * <p>Note that a single such Introspector leak will cause the entire web 057 * app class loader to not get garbage collected! This has the consequence that 058 * you will see all the application's static class resources (like singletons) 059 * around after web app shutdown, which is not the fault of those classes! 060 * 061 * <p><b>This listener should be registered as the first one in {@code web.xml}, 062 * before any application listeners such as Spring's ContextLoaderListener.</b> 063 * This allows the listener to take full effect at the right time of the lifecycle. 064 * 065 * @author Juergen Hoeller 066 * @since 1.1 067 * @see java.beans.Introspector#flushCaches() 068 * @see org.springframework.beans.CachedIntrospectionResults#acceptClassLoader 069 * @see org.springframework.beans.CachedIntrospectionResults#clearClassLoader 070 */ 071public class IntrospectorCleanupListener implements ServletContextListener { 072 073 @Override 074 public void contextInitialized(ServletContextEvent event) { 075 CachedIntrospectionResults.acceptClassLoader(Thread.currentThread().getContextClassLoader()); 076 } 077 078 @Override 079 public void contextDestroyed(ServletContextEvent event) { 080 CachedIntrospectionResults.clearClassLoader(Thread.currentThread().getContextClassLoader()); 081 Introspector.flushCaches(); 082 } 083 084}