    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one or more
    003 * contributor license agreements.  See the NOTICE file distributed with
    004 * this work for additional information regarding copyright ownership.
    005 * The ASF licenses this file to You under the Apache License, Version 2.0
    006 * (the "License"); you may not use this file except in compliance with
    007 * the License.  You may obtain a copy of the License at
    008 *
    009 *      http://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 * Unless required by applicable law or agreed to in writing, software
    012 * distributed under the License is distributed on an "AS IS" BASIS,
    013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 * See the License for the specific language governing permissions and
    015 * limitations under the License.
    016 */
    017
    018package org.apache.commons.logging.impl;
    019
    020import java.lang.reflect.InvocationTargetException;
    021import java.lang.reflect.Method;
    022
    023import javax.servlet.ServletContextEvent;
    024import javax.servlet.ServletContextListener;
    025
    026import org.apache.commons.logging.LogFactory;
    027
    028/**
    029 * This class is capable of receiving notifications about the undeployment of
    030 * a webapp, and responds by ensuring that commons-logging releases all
    031 * memory associated with the undeployed webapp.
    032 * <p>
    033 * In general, the WeakHashtable support added in commons-logging release 1.1
    034 * ensures that logging classes do not hold references that prevent an
    035 * undeployed webapp's memory from being garbage-collected even when multiple
    036 * copies of commons-logging are deployed via multiple class loaders (a
    037 * situation that earlier versions had problems with). However there are
    038 * some rare cases where the WeakHashtable approach does not work; in these
    039 * situations specifying this class as a listener for the web application will
    040 * ensure that all references held by commons-logging are fully released.
    041 * <p>
    042 * To use this class, configure the webapp deployment descriptor to call
    043 * this class on webapp undeploy; the contextDestroyed method will tell
    044 * every accessible LogFactory class that the entry in its map for the
    045 * current webapp's context class loader should be cleared.
    046 *
    047 * @since 1.1
    048 */
    049public class ServletContextCleaner implements ServletContextListener {
    050
    051    private static final Class<?>[] RELEASE_SIGNATURE = { ClassLoader.class };
    052
    053    /**
    054     * Constructs a new instance.
    055     */
    056    public ServletContextCleaner() {
    057        // empty
    058    }
    059
    060    /**
    061     * Invoked when a webapp is undeployed, this tells the LogFactory
    062     * class to release any logging information related to the current
    063     * contextClassloader.
    064     */
    065    @Override
    066    public void contextDestroyed(final ServletContextEvent sce) {
    067        final ClassLoader tccl = Thread.currentThread().getContextClassLoader();
    068
    069        final Object[] params = new Object[1];
    070        params[0] = tccl;
    071
    072        // Walk up the tree of class loaders, finding all the available
    073        // LogFactory classes and releasing any objects associated with
    074        // the tccl (ie the webapp).
    075        //
    076        // When there is only one LogFactory in the classpath, and it
    077        // is within the webapp being undeployed then there is no problem;
    078        // garbage collection works fine.
    079        //
    080        // When there are multiple LogFactory classes in the classpath but
    081        // parent-first classloading is used everywhere, this loop is really
    082        // short. The first instance of LogFactory found will
    083        // be the highest in the classpath, and then no more will be found.
    084        // This is ok, as with this setup this will be the only LogFactory
    085        // holding any data associated with the tccl being released.
    086        //
    087        // When there are multiple LogFactory classes in the classpath and
    088        // child-first classloading is used in any class loader, then multiple
    089        // LogFactory instances may hold info about this TCCL; whenever the
    090        // webapp makes a call into a class loaded via an ancestor class loader
    091        // and that class calls LogFactory the tccl gets registered in
    092        // the LogFactory instance that is visible from the ancestor
    093        // class loader. However the concrete logging library it points
    094        // to is expected to have been loaded via the TCCL, so the
    095        // underlying logging lib is only initialized/configured once.
    096        // These references from ancestor LogFactory classes down to
    097        // TCCL class loaders are held via weak references and so should
    098        // be released but there are circumstances where they may not.
    099        // Walking up the class loader ancestry ladder releasing
    100        // the current tccl at each level tree, though, will definitely
    101        // clear any problem references.
    102        ClassLoader loader = tccl;
    103        while (loader != null) {
    104            // Load via the current loader. Note that if the class is not accessible
    105            // via this loader, but is accessible via some ancestor then that class
    106            // will be returned.
    107            try {
    108                @SuppressWarnings("unchecked")
    109                final Class<LogFactory> logFactoryClass = (Class<LogFactory>) loader.loadClass("org.apache.commons.logging.LogFactory");
    110                final Method releaseMethod = logFactoryClass.getMethod("release", RELEASE_SIGNATURE);
    111                releaseMethod.invoke(null, params);
    112                loader = logFactoryClass.getClassLoader().getParent();
    113            } catch (final ClassNotFoundException ex) {
    114                // Neither the current class loader nor any of its ancestors could find
    115                // the LogFactory class, so we can stop now.
    116                loader = null;
    117            } catch (final NoSuchMethodException ex) {
    118                // This is not expected; every version of JCL has this method
    119                System.err.println("LogFactory instance found which does not support release method!");
    120                loader = null;
    121            } catch (final IllegalAccessException ex) {
    122                // This is not expected; every ancestor class should be accessible
    123                System.err.println("LogFactory instance found which is not accessible!");
    124                loader = null;
    125            } catch (final InvocationTargetException ex) {
    126                // This is not expected
    127                System.err.println("LogFactory instance release method failed!");
    128                loader = null;
    129            }
    130        }
    131
    132        // Just to be sure, invoke release on the LogFactory that is visible from
    133        // this ServletContextCleaner class too. This should already have been caught
    134        // by the above loop but just in case...
    135        LogFactory.release(tccl);
    136    }
    137
    138    /**
    139     * Invoked when a webapp is deployed. Nothing needs to be done here.
    140     */
    141    @Override
    142    public void contextInitialized(final ServletContextEvent sce) {
    143        // do nothing
    144    }
    145}