View Javadoc

    1   // ========================================================================
    2   // $Id: ContextFactory.java 1327 2006-11-27 18:40:14Z janb $
    3   // Copyright 1999-2006 Mort Bay Consulting Pty. Ltd.
    4   // ------------------------------------------------------------------------
    5   // Licensed under the Apache License, Version 2.0 (the "License");
    6   // you may not use this file except in compliance with the License.
    7   // You may obtain a copy of the License at
    8   // http://www.apache.org/licenses/LICENSE-2.0
    9   // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  // ========================================================================
    15
    16  package org.mortbay.naming;
    17
    18
    19  import java.util.Hashtable;
    20  import java.util.WeakHashMap;
    21
    22  import javax.naming.Context;
    23  import javax.naming.Name;
    24  import javax.naming.NameParser;
    25  import javax.naming.Reference;
    26  import javax.naming.StringRefAddr;
    27  import javax.naming.spi.ObjectFactory;
    28
    29  import org.mortbay.jetty.handler.ContextHandler;
    30  import org.mortbay.log.Log;
    31
    32
    33
    34  /**
    35   * ContextFactory.java
    36   *
    37   * This is an object factory that produces a jndi naming
    38   * context based on a classloader.
    39   *
    40   *  It is used for the java:comp context.
    41   *
    42   *  This object factory is bound at java:comp. When a
    43   *  lookup arrives for java:comp,  this object factory
    44   *  is invoked and will return a context specific to
    45   *  the caller's environment (so producing the java:comp/env
    46   *  specific to a webapp).
    47   *
    48   *  The context selected is based on classloaders. First
    49   *  we try looking in at the classloader that is associated
    50   *  with the current webapp context (if there is one). If
    51   *  not, we use the thread context classloader.
    52   *
    53   * Created: Fri Jun 27 09:26:40 2003
    54   *
    55   * @author <a href="mailto:janb@mortbay.com">Jan Bartel</a>
    56   *
    57   */
    58  public class ContextFactory implements ObjectFactory
    59  {
    60      /**
    61       * Map of classloaders to contexts.
    62       */
    63      private static WeakHashMap _contextMap;
    64
    65      /**
    66       * Threadlocal for injecting a context to use
    67       * instead of looking up the map.
    68       */
    69      private static ThreadLocal _threadContext;
    70
    71      static
    72      {
    73          _contextMap = new WeakHashMap();
    74          _threadContext = new ThreadLocal();
    75      }
    76
    77
    78
    79      /**
    80       * Find or create a context which pertains to a classloader.
    81       *
    82       * We use either the classloader for the current ContextHandler if
    83       * we are handling a request, OR we use the thread context classloader
    84       * if we are not processing a request.
    85       * @see javax.naming.spi.ObjectFactory#getObjectInstance(java.lang.Object, javax.naming.Name, javax.naming.Context, java.util.Hashtable)
    86       */
    87      public Object getObjectInstance (Object obj,
    88                                       Name name,
    89                                       Context nameCtx,
    90                                       Hashtable env)
    91          throws Exception
    92      {
    93          //First, see if we have had a context injected into us to use.
    94          Context ctx = (Context)_threadContext.get();
    95          if (ctx != null)
    96          {
    97              if(Log.isDebugEnabled()) Log.debug("Using the Context that is bound on the thread");
    98              return ctx;
    99          }
    100
    101         // Next, see if we are in a webapp context, if we are, use
    102         // the classloader of the webapp to find the right jndi comp context
    103         ClassLoader loader = null;
    104         if (ContextHandler.getCurrentContext() != null)
    105         {
    106             loader = ContextHandler.getCurrentContext().getContextHandler().getClassLoader();
    107         }
    108
    109
    110         if (loader != null)
    111         {
    112             if (Log.isDebugEnabled()) Log.debug("Using classloader of current org.mortbay.jetty.handler.ContextHandler");
    113         }
    114         else
    115         {
    116             //Not already in a webapp context, in that case, we try the
    117             //curren't thread's classloader instead
    118             loader = Thread.currentThread().getContextClassLoader();
    119             if (Log.isDebugEnabled()) Log.debug("Using thread context classloader");
    120         }
    121
    122         //Get the context matching the classloader
    123         ctx = (Context)_contextMap.get(loader);
    124
    125         //The map does not contain an entry for this classloader
    126         if (ctx == null)
    127         {
    128             //Check if a parent classloader has created the context
    129             ctx = getParentClassLoaderContext(loader);
    130
    131             //Didn't find a context to match any of the ancestors
    132             //of the classloader, so make a context
    133             if (ctx == null)
    134             {
    135                 Reference ref = (Reference)obj;
    136                 StringRefAddr parserAddr = (StringRefAddr)ref.get("parser");
    137                 String parserClassName = (parserAddr==null?null:(String)parserAddr.getContent());
    138                 NameParser parser = (NameParser)(parserClassName==null?null:loader.loadClass(parserClassName).newInstance());
    139
    140                 ctx = new NamingContext (env,
    141                                          name.get(0),
    142                                          nameCtx,
    143                                          parser);
    144                 if(Log.isDebugEnabled())Log.debug("No entry for classloader: "+loader);
    145                 _contextMap.put (loader, ctx);
    146             }
    147         }
    148
    149         return ctx;
    150     }
    151
    152     /**
    153      * Keep trying ancestors of the given classloader to find one to which
    154      * the context is bound.
    155      * @param loader
    156      * @return
    157      */
    158     public Context getParentClassLoaderContext (ClassLoader loader)
    159     {
    160         Context ctx = null;
    161         ClassLoader cl = loader;
    162         for (cl = cl.getParent(); (cl != null) && (ctx == null); cl = cl.getParent())
    163         {
    164             ctx = (Context)_contextMap.get(cl);
    165         }
    166
    167         return ctx;
    168     }
    169
    170
    171     /**
    172      * Associate the given Context with the current thread.
    173      * resetComponentContext method should be called to reset the context.
    174      * @param ctx the context to associate to the current thread.
    175      * @return the previous context associated on the thread (can be null)
    176      */
    177     public static Context setComponentContext(final Context ctx)
    178     {
    179         Context previous = (Context)_threadContext.get();
    180         _threadContext.set(ctx);
    181         return previous;
    182     }
    183
    184     /**
    185      * Set back the context with the given value.
    186      * Don't return the previous context, use setComponentContext() method for this.
    187      * @param ctx the context to associate to the current thread.
    188      */
    189     public static void resetComponentContext(final Context ctx)
    190     {
    191         _threadContext.set(ctx);
    192     }
    193
    194 }