ClassLoaderResolver


1   /* Copyright (C) 2003 Vladimir Roubtsov. All rights reserved.
2    * 
3    * This program and the accompanying materials are made available under
4    * the terms of the Common Public License v1.0 which accompanies this distribution,
5    * and is available at http://www.eclipse.org/legal/cpl-v10.html
6    * 
7    * $Id: ClassLoaderResolver.java,v 1.1.1.1.2.2 2004/07/10 03:34:53 vlad_r Exp $
8    */
9   package com.vladium.util;
10  
11  // ----------------------------------------------------------------------------
12  /**
13   * This non-instantiable non-subclassable class acts as the global point for
14   * choosing a ClassLoader for dynamic class/resource loading at any point
15   * in an application.
16   * 
17   * @see ResourceLoader
18   * @see IClassLoadStrategy
19   * @see DefaultClassLoadStrategy
20   * 
21   * @author Vlad Roubtsov, (C) 2003
22   */
23  public
24  abstract class ClassLoaderResolver
25  {
26      // public: ................................................................
27      
28      // NOTE: don't use Logger in this class to avoid infinite recursion
29  
30      /**
31       * This method selects the "best" classloader instance to be used for
32       * class/resource loading by whoever calls this method. The decision
33       * typically involves choosing between the caller's current, thread context,
34       * system, and other classloaders in the JVM and is made by the {@link IClassLoadStrategy}
35       * instance established by the last call to {@link #setStrategy}.<P>
36       * 
37       * This method does not throw.
38       * 
39       * @param caller [null input eliminates the caller's current classloader
40       * from consideration]
41       * 
42       * @return classloader to be used by the caller ['null' indicates the
43       * primordial loader]
44       */
45      public static synchronized ClassLoader   getClassLoader (final Class   caller)
46      {
47          final ClassLoadContext ctx = new ClassLoadContext (caller);
48          
49          return s_strategy.getClassLoader (ctx); 
50      }
51  
52      /**
53       * This method selects the "best" classloader instance to be used for
54       * class/resource loading by whoever calls this method. The decision
55       * typically involves choosing between the caller's current, thread context,
56       * system, and other classloaders in the JVM and is made by the {@link IClassLoadStrategy}
57       * instance established by the last call to {@link #setStrategy}.<P>
58       * 
59       * This method uses its own caller to set the call context. To be able to
60       * override this decision explicitly, use {@link #getClassLoader(Class)}.<P> 
61       * 
62       * This method does not throw.
63       * 
64       * @return classloader to be used by the caller ['null' indicates the
65       * primordial loader]
66       */
67      public static synchronized ClassLoader   getClassLoader ()
68      {
69          final Class   caller = getCallerClass (1); // 'caller' can be set to null
70          final ClassLoadContext ctx = new ClassLoadContext (caller);
71          
72          return s_strategy.getClassLoader (ctx); 
73      }
74  
75      /*
76       * Indexes into the current method call context with a given offset. Offset 0
77       * corresponds to the immediate caller, offset 1 corresponds to its caller,
78       * etc.<P>
79       * 
80       * Invariant: getCallerClass(0) == class containing code that performs this call 
81       */
82      public static Class   getCallerClass (final int callerOffset)
83      {
84          if (CALLER_RESOLVER == null) return null; // only happens if <clinit> failed
85  
86          return CALLER_RESOLVER.getClassContext () [CALL_CONTEXT_OFFSET + callerOffset];
87      }
88  
89      /**
90       * Returns 'true' if 'loader2' is a delegation child of 'loader1' [or if
91       * 'loader1'=='loader2']. Of course, this works only for classloaders that
92       * set their parent pointers correctly. 'null' is interpreted as the
93       * primordial loader [i.e., everybody's parent].
94       */ 
95      public static boolean isChild (final ClassLoader   loader1, ClassLoader   loader2)
96      {
97          if (loader1 == loader2) return true; 
98          if (loader2 == null) return false; 
99          if (loader1 == null) return true;
100         
101         for ( ; loader2 != null; loader2 = loader2.getParent ())
102         {
103             if (loader2 == loader1) return true;
104         }   
105 
106         return false;
107     }
108 
109     /**
110      * Gets the current classloader selection strategy setting. 
111      */
112     public static synchronized IClassLoadStrategy getStrategy ()
113     {
114         return s_strategy;
115     }
116 
117     /**
118      * Sets the classloader selection strategy to be used by subsequent calls
119      * to {@link #getClassLoader()}. An instance of {@link ClassLoaderResolver.DefaultClassLoadStrategy}
120      * is in effect if this method is never called.
121      *  
122      * @param strategy new strategy [may not be null] 
123      * @return previous setting
124      */    
125     public static synchronized IClassLoadStrategy setStrategy (final IClassLoadStrategy strategy)
126     {
127         if (strategy == null) throw new IllegalArgumentException   ("null input: strategy");
128         
129         final IClassLoadStrategy old = s_strategy;
130         s_strategy = strategy;
131         
132         return old;
133     }
134     
135     // protected: .............................................................
136 
137     // package: ...............................................................
138     
139     // private: ...............................................................
140     
141     
142     private static final class DefaultClassLoadStrategy implements IClassLoadStrategy
143     {
144         public ClassLoader   getClassLoader (final ClassLoadContext ctx)
145         {
146             if (ctx == null) throw new IllegalArgumentException   ("null input: ctx");
147             
148             final Class   caller = ctx.getCallerClass ();
149             final ClassLoader   contextLoader = Thread.currentThread ().getContextClassLoader ();
150             
151             ClassLoader   result;
152             
153             if (caller == null)
154                 result = contextLoader;
155             else
156             {
157                 final ClassLoader   callerLoader = caller.getClassLoader ();
158                 
159                 // if 'callerLoader' and 'contextLoader' are in a parent-child
160                 // relationship, always choose the child:
161                 
162                 // SF BUG 975080: change the sibling case to use 'callerLoader'
163                 // to work around ANT 1.6.x incorrect classloading model:
164                 
165                 if (isChild (callerLoader, contextLoader))
166                     result = contextLoader;
167                 else
168                     result = callerLoader;
169             }
170             
171             final ClassLoader   systemLoader = ClassLoader.getSystemClassLoader ();
172             
173             // precaution for when deployed as a bootstrap or extension class:
174             if (isChild (result, systemLoader))
175                 result = systemLoader;
176             
177             return result;
178         }
179     
180     } // end of nested class
181     
182     
183     /**
184      * A helper class to get the call context. It subclasses SecurityManager
185      * to make getClassContext() accessible. An instance of CallerResolver
186      * only needs to be created, not installed as an actual security
187      * manager.
188      */
189     private static final class CallerResolver extends SecurityManager  
190     {
191         protected Class   [] getClassContext ()
192         {
193             return super.getClassContext ();
194         }
195         
196     } // end of nested class 
197     
198     
199     private ClassLoaderResolver () {} // prevent subclassing
200 
201     
202     private static IClassLoadStrategy s_strategy; // initialized in <clinit>
203     
204     private static final int CALL_CONTEXT_OFFSET = 2; // may need to change if this class is redesigned
205     private static final CallerResolver CALLER_RESOLVER; // set in <clinit>
206     //private static Throwable CLINIT_FAILURE;
207     
208     static
209     {
210         CallerResolver temp = null;
211         try
212         {
213             // this can fail if the current SecurityManager does not allow
214             // RuntimePermission ("createSecurityManager"):
215             
216             temp = new CallerResolver ();
217         }
218         catch (Throwable   t)
219         {
220             //CLINIT_FAILURE = t;
221         }
222         CALLER_RESOLVER = temp;
223         
224         s_strategy = new DefaultClassLoadStrategy ();
225     }
226 
227 } // end of class
228 // ----------------------------------------------------------------------------
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Free Books Free Magazines
Popular Tags