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 }