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
018 package org.apache.geronimo.kernel;
019
020 import java.lang.reflect.Array;
021 import java.util.HashMap;
022 import java.util.Set;
023 import java.util.LinkedHashSet;
024 import java.util.LinkedList;
025 import java.util.Arrays;
026 import java.util.List;
027 import java.util.ArrayList;
028
029 import org.apache.geronimo.kernel.config.MultiParentClassLoader;
030
031 /**
032 * Utility class for loading classes by a variety of name variations.
033 * <p/>
034 * Supported names types are:
035 * <p/>
036 * 1) Fully qualified class name (e.g., "java.lang.String", "org.apache.geronimo.kernel.ClassLoading"
037 * 2) Method signature encoding ("Ljava.lang.String;", "J", "I", etc.)
038 * 3) Primitive type names ("int", "boolean", etc.)
039 * 4) Method array signature strings ("[I", "[Ljava.lang.String")
040 * 5) Arrays using Java code format ("int[]", "java.lang.String[][]")
041 * <p/>
042 * The classes are loaded using the provided class loader. For the basic types, the primitive
043 * reflection types are returned.
044 *
045 * @version $Rev: 706640 $
046 */
047 public class ClassLoading {
048
049 /**
050 * Table for mapping primitive class names/signatures to the implementing
051 * class object
052 */
053 private static final HashMap PRIMITIVE_CLASS_MAP = new HashMap();
054
055 /**
056 * Table for mapping primitive classes back to their name signature type, which
057 * allows a reverse mapping to be performed from a class object into a resolvable
058 * signature.
059 */
060 private static final HashMap CLASS_TO_SIGNATURE_MAP = new HashMap();
061
062
063 /**
064 * Setup the primitives map. We make any entry for each primitive class using both the
065 * human readable name and the method signature shorthand type.
066 */
067 static {
068 PRIMITIVE_CLASS_MAP.put("boolean", boolean.class);
069 PRIMITIVE_CLASS_MAP.put("Z", boolean.class);
070 PRIMITIVE_CLASS_MAP.put("byte", byte.class);
071 PRIMITIVE_CLASS_MAP.put("B", byte.class);
072 PRIMITIVE_CLASS_MAP.put("char", char.class);
073 PRIMITIVE_CLASS_MAP.put("C", char.class);
074 PRIMITIVE_CLASS_MAP.put("short", short.class);
075 PRIMITIVE_CLASS_MAP.put("S", short.class);
076 PRIMITIVE_CLASS_MAP.put("int", int.class);
077 PRIMITIVE_CLASS_MAP.put("I", int.class);
078 PRIMITIVE_CLASS_MAP.put("long", long.class);
079 PRIMITIVE_CLASS_MAP.put("J", long.class);
080 PRIMITIVE_CLASS_MAP.put("float", float.class);
081 PRIMITIVE_CLASS_MAP.put("F", float.class);
082 PRIMITIVE_CLASS_MAP.put("double", double.class);
083 PRIMITIVE_CLASS_MAP.put("D", double.class);
084 PRIMITIVE_CLASS_MAP.put("void", void.class);
085 PRIMITIVE_CLASS_MAP.put("V", void.class);
086
087 // Now build a reverse mapping table. The table above has a many-to-one mapping for
088 // class names. To do the reverse, we need to pick just one. As long as the
089 // returned name supports "round tripping" of the requests, this will work fine.
090
091 CLASS_TO_SIGNATURE_MAP.put(boolean.class, "Z");
092 CLASS_TO_SIGNATURE_MAP.put(byte.class, "B");
093 CLASS_TO_SIGNATURE_MAP.put(char.class, "C");
094 CLASS_TO_SIGNATURE_MAP.put(short.class, "S");
095 CLASS_TO_SIGNATURE_MAP.put(int.class, "I");
096 CLASS_TO_SIGNATURE_MAP.put(long.class, "J");
097 CLASS_TO_SIGNATURE_MAP.put(float.class, "F");
098 CLASS_TO_SIGNATURE_MAP.put(double.class, "D");
099 CLASS_TO_SIGNATURE_MAP.put(void.class, "V");
100 }
101
102
103 /**
104 * Load a class that matches the requested name, using the provided class loader context.
105 * <p/>
106 * The class name may be a standard class name, the name of a primitive type Java
107 * reflection class (e.g., "boolean" or "int"), or a type in method type signature
108 * encoding. Array classes in either encoding form are also processed.
109 *
110 * @param className The name of the required class.
111 * @param classLoader The class loader used to resolve the class object.
112 * @return The Class object resolved from "className".
113 * @throws ClassNotFoundException When unable to resolve the class object.
114 * @throws IllegalArgumentException If either argument is null.
115 */
116 public static Class loadClass(String className, ClassLoader classLoader) throws ClassNotFoundException {
117
118 // the tests require IllegalArgumentExceptions for null values on either of these.
119 if (className == null) {
120 throw new IllegalArgumentException("className is null");
121 }
122
123 if (classLoader == null) {
124 throw new IllegalArgumentException("classLoader is null");
125 }
126 // The easiest case is a proper class name. We just have the class loader resolve this.
127 // If the class loader throws a ClassNotFoundException, then we need to check each of the
128 // special name encodings we support.
129 try {
130 return classLoader.loadClass(className);
131 } catch (ClassNotFoundException ignore) {
132 // if not found, continue on to the other name forms.
133 }
134
135
136 // The second easiest version to resolve is a direct map to a primitive type name
137 // or method signature. Check our name-to-class map for one of those.
138 Class resolvedClass = (Class) PRIMITIVE_CLASS_MAP.get(className);
139 if (resolvedClass != null) {
140 return resolvedClass;
141 }
142
143 // Class names in method signature have the format "Lfully.resolved.name;",
144 // so if it ends in a semicolon and begins with an "L", this must be in
145 // this format. Have the class loader try to load this. There are no other
146 // options if this fails, so just allow the class loader to throw the
147 // ClassNotFoundException.
148 if (className.endsWith(";") && className.startsWith("L")) {
149 // pick out the name portion
150 String typeName = className.substring(1, className.length() - 1);
151 // and delegate the loading to the class loader.
152 return classLoader.loadClass(typeName);
153 }
154
155 // All we have left now are the array types. Method signature array types
156 // have a series of leading "[" characters to specify the number of dimensions.
157 // The other array type we handle uses trailing "[]" for the dimensions, just
158 // like the Java language syntax.
159
160 // first check for the signature form ([[[[type).
161 if (className.charAt(0) == '[') {
162 // we have at least one array marker, now count how many leading '['s we have
163 // to get the dimension count.
164 int count = 0;
165 int nameLen = className.length();
166
167 while (count < nameLen && className.charAt(count) == '[') {
168 count++;
169 }
170
171 // pull of the name subtype, which is everything after the last '['
172 String arrayTypeName = className.substring(count, className.length());
173 // resolve the type using a recursive call, which will load any of the primitive signature
174 // types as well as class names.
175 Class arrayType = loadClass(arrayTypeName, classLoader);
176
177 // Resolving array types require a little more work. The array classes are
178 // created dynamically when the first instance of a given dimension and type is
179 // created. We need to create one using reflection to do this.
180 return getArrayClass(arrayType, count);
181 }
182
183
184 // ok, last chance. Now check for an array specification in Java language
185 // syntax. This will be a type name followed by pairs of "[]" to indicate
186 // the number of dimensions.
187 if (className.endsWith("[]")) {
188 // get the base component class name and the arrayDimensions
189 int count = 0;
190 int position = className.length();
191
192 while (position > 1 && className.substring(position - 2, position).equals("[]")) {
193 // count this dimension
194 count++;
195 // and step back the probe position.
196 position -= 2;
197 }
198
199 // position now points at the location of the last successful test. This makes it
200 // easy to pick off the class name.
201
202 String typeName = className.substring(0, position);
203
204 // load the base type, again, doing this recursively
205 Class arrayType = loadClass(typeName, classLoader);
206 // and turn this into the class object
207 return getArrayClass(arrayType, count);
208 }
209
210 // We're out of options, just toss an exception over the wall.
211 if (classLoader instanceof MultiParentClassLoader) {
212 MultiParentClassLoader cl = (MultiParentClassLoader) classLoader;
213 throw new ClassNotFoundException("Could not load class " + className + " from classloader: " + cl.getId() + ", destroyed state: " + cl.isDestroyed());
214 }
215 throw new ClassNotFoundException("Could not load class " + className + " from unknown classloader; " + classLoader);
216 }
217
218
219 /**
220 * Map a class object back to a class name. The returned class object
221 * must be "round trippable", which means
222 * <p/>
223 * type == ClassLoading.loadClass(ClassLoading.getClassName(type), classLoader)
224 * <p/>
225 * must be true. To ensure this, the class name is always returned in
226 * method signature format.
227 *
228 * @param type The class object we convert into name form.
229 * @return A string representation of the class name, in method signature
230 * format.
231 */
232 public static String getClassName(Class type) {
233 StringBuffer name = new StringBuffer();
234
235 // we test these in reverse order from the resolution steps,
236 // first handling arrays, then primitive types, and finally
237 // "normal" class objects.
238
239 // First handle arrays. If a class is an array, the type is
240 // element stored at that level. So, for a 2-dimensional array
241 // of ints, the top-level type will be "[I". We need to loop
242 // down the hierarchy until we hit a non-array type.
243 while (type.isArray()) {
244 // add another array indicator at the front of the name,
245 // and continue with the next type.
246 name.append('[');
247 type = type.getComponentType();
248 }
249
250 // we're down to the base type. If this is a primitive, then
251 // we poke in the single-character type specifier.
252 if (type.isPrimitive()) {
253 name.append((String) CLASS_TO_SIGNATURE_MAP.get(type));
254 }
255 // a "normal" class. This gets expressing using the "Lmy.class.name;" syntax.
256 else {
257 name.append('L');
258 name.append(type.getName());
259 name.append(';');
260 }
261 return name.toString();
262 }
263
264 private static Class getArrayClass(Class type, int dimension) {
265 // Array.newInstance() requires an array of the requested number of dimensions
266 // that gives the size for each dimension. We just request 0 in each of the
267 // dimentions, which is not unlike a black hole sigularity.
268 int dimensions[] = new int[dimension];
269 // create an instance and return the associated class object.
270 return Array.newInstance(type, dimensions).getClass();
271 }
272
273 public static Set getAllTypes(Class type) {
274 Set allTypes = new LinkedHashSet();
275 allTypes.add(type);
276 allTypes.addAll(getAllSuperClasses(type));
277 allTypes.addAll(getAllInterfaces(type));
278 return allTypes;
279 }
280
281 private static Set getAllSuperClasses(Class clazz) {
282 Set allSuperClasses = new LinkedHashSet();
283 for (Class superClass = clazz.getSuperclass(); superClass != null; superClass = superClass.getSuperclass()) {
284 allSuperClasses.add(superClass);
285 }
286 return allSuperClasses;
287 }
288
289 private static Set getAllInterfaces(Class clazz) {
290 Set allInterfaces = new LinkedHashSet();
291 LinkedList stack = new LinkedList();
292 stack.addAll(Arrays.asList(clazz.getInterfaces()));
293 while (!stack.isEmpty()) {
294 Class intf = (Class) stack.removeFirst();
295 if (!allInterfaces.contains(intf)) {
296 allInterfaces.add(intf);
297 stack.addAll(Arrays.asList(intf.getInterfaces()));
298 }
299 }
300 return allInterfaces;
301 }
302
303 public static Set reduceInterfaces(Set source) {
304 Class[] classes = (Class[]) source.toArray(new Class[source.size()]);
305 classes = reduceInterfaces(classes);
306 return new LinkedHashSet(Arrays.asList(classes));
307 }
308
309 /**
310 * If there are multiple interfaces, and some of them extend each other,
311 * eliminate the superclass in favor of the subclasses that extend them.
312 *
313 * If one of the entries is a class (not an interface), make sure it's
314 * the first one in the array. If more than one of the entries is a
315 * class, throws an IllegalArgumentException
316 *
317 * @param source the original list of interfaces
318 * @return the equal or smaller list of interfaces
319 */
320 public static Class[] reduceInterfaces(Class[] source) {
321 // use a copy of the sorce array
322 source = (Class[]) source.clone();
323
324 for (int leftIndex = 0; leftIndex < source.length-1; leftIndex++) {
325 Class left = source[leftIndex];
326 if(left == null) {
327 continue;
328 }
329
330 for (int rightIndex = leftIndex +1; rightIndex < source.length; rightIndex++) {
331 Class right = source[rightIndex];
332 if(right == null) {
333 continue;
334 }
335
336 if(left == right || right.isAssignableFrom(left)) {
337 // right is the same as class or a sub class of left
338 source[rightIndex] = null;
339 } else if(left.isAssignableFrom(right)) {
340 // left is the same as class or a sub class of right
341 source[leftIndex] = null;
342
343 // the left has been eliminated; move on to the next left
344 break;
345 }
346 }
347 }
348
349 Class clazz = null;
350 for (int i = 0; i < source.length; i++) {
351 if (source[i] != null && !source[i].isInterface()) {
352 if (clazz != null) {
353 throw new IllegalArgumentException("Source contains two classes which are not subclasses of each other: " + clazz.getName() + ", " + source[i].getName());
354 }
355 clazz = source[i];
356 source[i] = null;
357 }
358 }
359
360 List list = new ArrayList(source.length);
361 if (clazz != null) list.add(clazz);
362 for (int i = 0; i < source.length; i++) {
363 if(source[i] != null) {
364 list.add(source[i]);
365 }
366 }
367 return (Class[]) list.toArray(new Class[list.size()]);
368 }
369 }
370