Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
  /*
2
   * Copyright 2002-2008 the original author or authors.
3
   *
4
   * Licensed under the Apache License, Version 2.0 (the "License");
5
   * you may not use this file except in compliance with the License.
6
   * You may obtain a copy of the License at
7
   *
8
   *      http://www.apache.org/licenses/LICENSE-2.0
9
   *
10
  * Unless required by applicable law or agreed to in writing, software
11
  * distributed under the License is distributed on an "AS IS" BASIS,
12
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
  * See the License for the specific language governing permissions and
14
  * limitations under the License.
15
  */
16
 
17
 package org.springframework.util;
18
 
33
 import java.util.List;
34
 import java.util.Map;
35
 import java.util.Set;

Miscellaneous class utility methods. Mainly for internal use within the framework; consider Jakarta's Commons Lang for a more comprehensive suite of class utilities.

Author(s):
Keith Donald
Rob Harrop
Juergen Hoeller
Since:
1.1
See also:
TypeUtils
ReflectionUtils
48
 
49
 public abstract class ClassUtils {
Suffix for array class names: "[]"
51
 
52
 	public static final String ARRAY_SUFFIX = "[]";
Prefix for internal array class names: "[L"
54
 
55
 	private static final String INTERNAL_ARRAY_PREFIX = "[L";
The package separator character '.'
57
 
58
 	private static final char PACKAGE_SEPARATOR = '.';
The inner class separator character '$'
60
 
61
 	private static final char INNER_CLASS_SEPARATOR = '$';
The CGLIB class separator character "$$"
63
 
64
 	public static final String CGLIB_CLASS_SEPARATOR = "$$";
The ".class" file suffix
66
 
67
 	public static final String CLASS_FILE_SUFFIX = ".class";
Map with primitive wrapper type as key and corresponding primitive type as value, for example: Integer.class -> int.class. 
73
 
74
 	private static final Map primitiveWrapperTypeMap = new HashMap(8);
Map with primitive type name as key and corresponding primitive type as value, for example: "int" -> "int.class". 
79
 
80
 	private static final Map primitiveTypeNameMap = new HashMap(16);
81
 
82
 
83
 	static {
84
 		.put(Boolean.class, boolean.class);
85
 		.put(Byte.class, byte.class);
86
 		.put(Character.class, char.class);
87
 		.put(Double.class, double.class);
88
 		.put(Float.class, float.class);
89
 		.put(Integer.class, int.class);
90
 		.put(Long.class, long.class);
91
 		.put(Short.class, short.class);
92
 
93
 		Set primitiveTypeNames = new HashSet(16);
94
 		primitiveTypeNames.addAll(.values());
95
 		primitiveTypeNames.addAll(Arrays.asList(new Class[] {
96
 				boolean[].class, byte[].class, char[].class, double[].class,
97
 				float[].class, int[].class, long[].class, short[].class}));
98
 		for (Iterator it = primitiveTypeNames.iterator(); it.hasNext();) {
99
 			Class primitiveClass = (Class) it.next();
100
			.put(primitiveClass.getName(), primitiveClass);
101
		}
102
	}
Return the default ClassLoader to use: typically the thread context ClassLoader, if available; the ClassLoader that loaded the ClassUtils class will be used as fallback.

Call this method if you intend to use the thread context ClassLoader in a scenario where you absolutely need a non-null ClassLoader reference: for example, for class path resource loading (but not necessarily for Class.forName, which accepts a null ClassLoader reference as well).

Returns:
the default ClassLoader (never null)
See also:
java.lang.Thread.getContextClassLoader()
117
	public static ClassLoader getDefaultClassLoader() {
118
		ClassLoader cl = null;
119
		try {
121
		}
122
		catch (Throwable ex) {
123
			// Cannot access thread context ClassLoader - falling back to system class loader...
124
		}
125
		if (cl == null) {
126
			// No thread context class loader -> use class loader of this class.
127
			cl = ClassUtils.class.getClassLoader();
128
		}
129
		return cl;
130
	}
Override the thread context ClassLoader with the environment's bean ClassLoader if necessary, i.e. if the bean ClassLoader is not equivalent to the thread context ClassLoader already.

Parameters:
classLoaderToUse the actual ClassLoader to use for the thread context
Returns:
the original thread context ClassLoader, or null if not overridden
139
	public static ClassLoader overrideThreadContextClassLoader(ClassLoader classLoaderToUse) {
140
		Thread currentThread = Thread.currentThread();
141
		ClassLoader threadContextClassLoader = currentThread.getContextClassLoader();
142
		if (classLoaderToUse != null && !classLoaderToUse.equals(threadContextClassLoader)) {
143
			currentThread.setContextClassLoader(classLoaderToUse);
144
			return threadContextClassLoader;
145
		}
146
		else {
147
			return null;
148
		}
149
	}
Determine whether the java.lang.Class identified by the supplied name is present and can be loaded. Will return false if either the class or one of its dependencies is not present or cannot be loaded.

Parameters:
className the name of the class to check
Returns:
whether the specified class is present
158
	public static boolean isPresent(String className) {
159
		return isPresent(className, getDefaultClassLoader());
160
	}
Determine whether the java.lang.Class identified by the supplied name is present and can be loaded. Will return false if either the class or one of its dependencies is not present or cannot be loaded.

Parameters:
className the name of the class to check
classLoader the class loader to use (may be null, which indicates the default class loader)
Returns:
whether the specified class is present
171
	public static boolean isPresent(String className, ClassLoader classLoader) {
172
		try {
173
			forName(className, classLoader);
174
			return true;
175
		}
176
		catch (Throwable ex) {
177
			// Class or one of its dependencies is not present...
178
			return false;
179
		}
180
	}
Replacement for Class.forName() that also returns Class instances for primitives (like "int") and array class names (like "String[]").

Always uses the default class loader: that is, preferably the thread context class loader, or the ClassLoader that loaded the ClassUtils class as fallback.

Parameters:
name the name of the Class
Returns:
Class instance for the supplied name
Throws:
java.lang.ClassNotFoundException if the class was not found
java.lang.LinkageError if the class file could not be loaded
See also:
java.lang.Class.forName(java.lang.String,boolean,java.lang.ClassLoader)
getDefaultClassLoader()
194
	public static Class forName(String name) throws ClassNotFoundException, LinkageError {
195
		return forName(name, getDefaultClassLoader());
196
	}
Replacement for Class.forName() that also returns Class instances for primitives (like "int") and array class names (like "String[]").

Parameters:
name the name of the Class
classLoader the class loader to use (may be null, which indicates the default class loader)
Returns:
Class instance for the supplied name
Throws:
java.lang.ClassNotFoundException if the class was not found
java.lang.LinkageError if the class file could not be loaded
See also:
java.lang.Class.forName(java.lang.String,boolean,java.lang.ClassLoader)
209
	public static Class forName(String name, ClassLoader classLoader) throws ClassNotFoundException, LinkageError {
210
		Assert.notNull(name, "Name must not be null");
213
		if (clazz != null) {
214
			return clazz;
215
		}
217
		// "java.lang.String[]" style arrays
218
		if (name.endsWith()) {
219
			String elementClassName = name.substring(0, name.length() - .length());
220
			Class elementClass = forName(elementClassName, classLoader);
221
			return Array.newInstance(elementClass, 0).getClass();
222
		}
224
		// "[Ljava.lang.String;" style arrays
225
		int internalArrayMarker = name.indexOf();
226
		if (internalArrayMarker != -1 && name.endsWith(";")) {
227
			String elementClassName = null;
228
			if (internalArrayMarker == 0) {
229
				elementClassName = name.substring(.length(), name.length() - 1);
230
			}
231
			else if (name.startsWith("[")) {
232
				elementClassName = name.substring(1);
233
			}
234
			Class elementClass = forName(elementClassName, classLoader);
235
			return Array.newInstance(elementClass, 0).getClass();
236
		}
238
		ClassLoader classLoaderToUse = classLoader;
239
		if (classLoaderToUse == null) {
240
			classLoaderToUse = getDefaultClassLoader();
241
		}
242
		return classLoaderToUse.loadClass(name);
243
	}
Resolve the given class name into a Class instance. Supports primitives (like "int") and array class names (like "String[]").

This is effectively equivalent to the forName method with the same arguments, with the only difference being the exceptions thrown in case of class loading failure.

Parameters:
className the name of the Class
classLoader the class loader to use (may be null, which indicates the default class loader)
Returns:
Class instance for the supplied name
Throws:
java.lang.IllegalArgumentException if the class name was not resolvable (that is, the class could not be found or the class file could not be loaded)
See also:
forName(java.lang.String,java.lang.ClassLoader)
259
	public static Class resolveClassName(String className, ClassLoader classLoader) throws IllegalArgumentException {
260
		try {
261
			return forName(className, classLoader);
262
		}
263
		catch (ClassNotFoundException ex) {
264
			IllegalArgumentException iae = new IllegalArgumentException("Cannot find class [" + className + "]");
265
			iae.initCause(ex);
266
			throw iae;
267
		}
268
		catch (LinkageError ex) {
270
					"Error loading class [" + className + "]: problem with class file or dependent class.");
271
			iae.initCause(ex);
272
			throw iae;
273
		}
274
	}
Resolve the given class name as primitive class, if appropriate, according to the JVM's naming rules for primitive classes.

Also supports the JVM's internal class names for primitive arrays. Does not support the "[]" suffix notation for primitive arrays; this is only supported by forName(java.lang.String).

Parameters:
name the name of the potentially primitive class
Returns:
the primitive class, or null if the name does not denote a primitive class or primitive array class
286
	public static Class resolvePrimitiveClassName(String name) {
287
		Class result = null;
288
		// Most class names will be quite long, considering that they
289
		// SHOULD sit in a package, so a length check is worthwhile.
290
		if (name != null && name.length() <= 8) {
291
			// Could be a primitive - likely.
292
			result = (Class) .get(name);
293
		}
294
		return result;
295
	}
Return the user-defined class for the given instance: usually simply the class of the given instance, but the original class in case of a CGLIB-generated subclass.

Parameters:
instance the instance to check
Returns:
the user-defined class
304
	public static Class getUserClass(Object instance) {
305
		Assert.notNull(instance, "Instance must not be null");
306
		return getUserClass(instance.getClass());
307
	}
Return the user-defined class for the given class: usually simply the given class, but the original class in case of a CGLIB-generated subclass.

Parameters:
clazz the class to check
Returns:
the user-defined class
315
	public static Class getUserClass(Class clazz) {
316
		return (clazz != null && clazz.getName().indexOf() != -1 ?
317
				clazz.getSuperclass() : clazz);
318
	}
Check whether the given class is cache-safe in the given context, i.e. whether it is loaded by the given ClassLoader or a parent of it.

Parameters:
clazz the class to analyze
classLoader the ClassLoader to potentially cache metadata in
326
	public static boolean isCacheSafe(Class clazz, ClassLoader classLoader) {
327
		Assert.notNull(clazz, "Class must not be null");
328
		ClassLoader target = clazz.getClassLoader();
329
		if (target == null) {
330
			return false;
331
		}
332
		ClassLoader cur = classLoader;
333
		if (cur == target) {
334
			return true;
335
		}
336
		while (cur != null) {
337
			cur = cur.getParent();
338
			if (cur == target) {
339
				return true;
340
			}
341
		}
342
		return false;
343
	}
Get the class name without the qualified package name.

Parameters:
className the className to get the short name for
Returns:
the class name of the class without the package name
Throws:
java.lang.IllegalArgumentException if the className is empty
352
	public static String getShortName(String className) {
353
		Assert.hasLength(className, "Class name must not be empty");
354
		int lastDotIndex = className.lastIndexOf();
355
		int nameEndIndex = className.indexOf();
356
		if (nameEndIndex == -1) {
357
			nameEndIndex = className.length();
358
		}
359
		String shortName = className.substring(lastDotIndex + 1, nameEndIndex);
361
		return shortName;
362
	}
Get the class name without the qualified package name.

Parameters:
clazz the class to get the short name for
Returns:
the class name of the class without the package name
369
	public static String getShortName(Class clazz) {
371
	}
Return the short string name of a Java class in decapitalized JavaBeans property format. Strips the outer class name in case of an inner class.

Parameters:
clazz the class
Returns:
the short name rendered in a standard JavaBeans property format
See also:
java.beans.Introspector.decapitalize(java.lang.String)
380
	public static String getShortNameAsProperty(Class clazz) {
381
		String shortName = ClassUtils.getShortName(clazz);
382
		int dotIndex = shortName.lastIndexOf('.');
383
		shortName = (dotIndex != -1 ? shortName.substring(dotIndex + 1) : shortName);
384
		return Introspector.decapitalize(shortName);
385
	}
Determine the name of the class file, relative to the containing package: e.g. "String.class"

Parameters:
clazz the class
Returns:
the file name of the ".class" file
393
	public static String getClassFileName(Class clazz) {
394
		Assert.notNull(clazz, "Class must not be null");
395
		String className = clazz.getName();
396
		int lastDotIndex = className.lastIndexOf();
397
		return className.substring(lastDotIndex + 1) + ;
398
	}
Determine the name of the package of the given class: e.g. "java.lang" for the java.lang.String class.

Parameters:
clazz the class
Returns:
the package name, or the empty String if the class is defined in the default package
407
	public static String getPackageName(Class clazz) {
408
		Assert.notNull(clazz, "Class must not be null");
409
		String className = clazz.getName();
410
		int lastDotIndex = className.lastIndexOf();
411
		return (lastDotIndex != -1 ? className.substring(0, lastDotIndex) : "");
412
	}
Return the qualified name of the given class: usually simply the class name, but component type class name + "[]" for arrays.

Parameters:
clazz the class
Returns:
the qualified name of the class
420
	public static String getQualifiedName(Class clazz) {
421
		Assert.notNull(clazz, "Class must not be null");
422
		if (clazz.isArray()) {
424
		}
425
		else {
426
			return clazz.getName();
427
		}
428
	}
Build a nice qualified name for an array: component type class name + "[]".

Parameters:
clazz the array class
Returns:
a qualified name for the array class
436
	private static String getQualifiedNameForArray(Class clazz) {
437
		StringBuffer buffer = new StringBuffer();
438
		while (clazz.isArray()) {
439
			clazz = clazz.getComponentType();
441
		}
442
		buffer.insert(0, clazz.getName());
443
		return buffer.toString();
444
	}
Return the qualified name of the given method, consisting of fully qualified interface/class name + "." + method name.

Parameters:
method the method
Returns:
the qualified name of the method
452
	public static String getQualifiedMethodName(Method method) {
453
		Assert.notNull(method, "Method must not be null");
454
		return method.getDeclaringClass().getName() + "." + method.getName();
455
	}
Return a descriptive name for the given object's type: usually simply the class name, but component type class name + "[]" for arrays, and an appended list of implemented interfaces for JDK proxies.

Parameters:
value the value to introspect
Returns:
the qualified name of the class
464
	public static String getDescriptiveType(Object value) {
465
		if (value == null) {
466
			return null;
467
		}
468
		Class clazz = value.getClass();
469
		if (Proxy.isProxyClass(clazz)) {
470
			StringBuffer buf = new StringBuffer(clazz.getName());
471
			buf.append(" implementing ");
472
			Class[] ifcs = clazz.getInterfaces();
473
			for (int i = 0; i < ifcs.length; i++) {
474
				buf.append(ifcs[i].getName());
475
				if (i < ifcs.length - 1) {
476
					buf.append(',');
477
				}
478
			}
479
			return buf.toString();
480
		}
481
		else if (clazz.isArray()) {
483
		}
484
		else {
485
			return clazz.getName();
486
		}
487
	}
Determine whether the given class has a constructor with the given signature.

Essentially translates NoSuchMethodException to "false".

Parameters:
clazz the clazz to analyze
paramTypes the parameter types of the method
Returns:
whether the class has a corresponding constructor
See also:
java.lang.Class.getMethod(java.lang.String,java.lang.Class[])
498
	public static boolean hasConstructor(Class clazz, Class[] paramTypes) {
499
		return (getConstructorIfAvailable(clazz, paramTypes) != null);
500
	}
Determine whether the given class has a constructor with the given signature, and return it if available (else return null).

Essentially translates NoSuchMethodException to null.

Parameters:
clazz the clazz to analyze
paramTypes the parameter types of the method
Returns:
the constructor, or null if not found
See also:
java.lang.Class.getConstructor(java.lang.Class[])
511
	public static Constructor getConstructorIfAvailable(Class clazz, Class[] paramTypes) {
512
		Assert.notNull(clazz, "Class must not be null");
513
		try {
514
			return clazz.getConstructor(paramTypes);
515
		}
516
		catch (NoSuchMethodException ex) {
517
			return null;
518
		}
519
	}
Determine whether the given class has a method with the given signature.

Essentially translates NoSuchMethodException to "false".

Parameters:
clazz the clazz to analyze
methodName the name of the method
paramTypes the parameter types of the method
Returns:
whether the class has a corresponding method
See also:
java.lang.Class.getMethod(java.lang.String,java.lang.Class[])
530
	public static boolean hasMethod(Class clazz, String methodName, Class[] paramTypes) {
531
		return (getMethodIfAvailable(clazz, methodName, paramTypes) != null);
532
	}
Determine whether the given class has a method with the given signature, and return it if available (else return null).

Essentially translates NoSuchMethodException to null.

Parameters:
clazz the clazz to analyze
methodName the name of the method
paramTypes the parameter types of the method
Returns:
the method, or null if not found
See also:
java.lang.Class.getMethod(java.lang.String,java.lang.Class[])
544
	public static Method getMethodIfAvailable(Class clazz, String methodName, Class[] paramTypes) {
545
		Assert.notNull(clazz, "Class must not be null");
546
		Assert.notNull(methodName, "Method name must not be null");
547
		try {
548
			return clazz.getMethod(methodName, paramTypes);
549
		}
550
		catch (NoSuchMethodException ex) {
551
			return null;
552
		}
553
	}
Return the number of methods with a given name (with any argument types), for the given class and/or its superclasses. Includes non-public methods.

Parameters:
clazz the clazz to check
methodName the name of the method
Returns:
the number of methods with the given name
562
	public static int getMethodCountForName(Class clazz, String methodName) {
563
		Assert.notNull(clazz, "Class must not be null");
564
		Assert.notNull(methodName, "Method name must not be null");
565
		int count = 0;
566
		Method[] declaredMethods = clazz.getDeclaredMethods();
567
		for (int i = 0; i < declaredMethods.length; i++) {
568
			Method method = declaredMethods[i];
569
			if (methodName.equals(method.getName())) {
570
				count++;
571
			}
572
		}
573
		Class[] ifcs = clazz.getInterfaces();
574
		for (int i = 0; i < ifcs.length; i++) {
575
			count += getMethodCountForName(ifcs[i], methodName);
576
		}
577
		if (clazz.getSuperclass() != null) {
578
			count += getMethodCountForName(clazz.getSuperclass(), methodName);
579
		}
580
		return count;
581
	}
Does the given class and/or its superclasses at least have one or more methods (with any argument types)? Includes non-public methods.

Parameters:
clazz the clazz to check
methodName the name of the method
Returns:
whether there is at least one method with the given name
590
	public static boolean hasAtLeastOneMethodWithName(Class clazz, String methodName) {
591
		Assert.notNull(clazz, "Class must not be null");
592
		Assert.notNull(methodName, "Method name must not be null");
593
		Method[] declaredMethods = clazz.getDeclaredMethods();
594
		for (int i = 0; i < declaredMethods.length; i++) {
595
			Method method = declaredMethods[i];
596
			if (method.getName().equals(methodName)) {
597
				return true;
598
			}
599
		}
600
		Class[] ifcs = clazz.getInterfaces();
601
		for (int i = 0; i < ifcs.length; i++) {
602
			if (hasAtLeastOneMethodWithName(ifcs[i], methodName)) {
603
				return true;
604
			}
605
		}
606
		return (clazz.getSuperclass() != null && hasAtLeastOneMethodWithName(clazz.getSuperclass(), methodName));
607
	}
Given a method, which may come from an interface, and a target class used in the current reflective invocation, find the corresponding target method if there is one. E.g. the method may be IFoo.bar() and the target class may be DefaultFoo. In this case, the method may be DefaultFoo.bar(). This enables attributes on that method to be found.

NOTE: In contrast to org.springframework.aop.support.AopUtils, this method does not resolve Java 5 bridge methods automatically. Call org.springframework.core.BridgeMethodResolver.findBridgedMethod(java.lang.reflect.Method) if bridge method resolution is desirable (e.g. for obtaining metadata from the original method definition).

Parameters:
method the method to be invoked, which may come from an interface
targetClass the target class for the current invocation. May be null or may not even implement the method.
Returns:
the specific target method, or the original method if the targetClass doesn't implement it or is null
See also:
org.springframework.aop.support.AopUtils.getMostSpecificMethod
627
	public static Method getMostSpecificMethod(Method method, Class targetClass) {
628
		if (method != null && targetClass != null && !targetClass.equals(method.getDeclaringClass())) {
629
			try {
630
				method = targetClass.getMethod(method.getName(), method.getParameterTypes());
631
			}
632
			catch (NoSuchMethodException ex) {
633
				// Perhaps the target class doesn't implement this method:
634
				// that's fine, just use the original method.
635
			}
636
		}
637
		return method;
638
	}
Return a static method of a class.

Parameters:
methodName the static method name
clazz the class which defines the method
args the parameter types to the method
Returns:
the static method, or null if no static method was found
Throws:
java.lang.IllegalArgumentException if the method name is blank or the clazz is null
648
	public static Method getStaticMethod(Class clazz, String methodName, Class[] args) {
649
		Assert.notNull(clazz, "Class must not be null");
650
		Assert.notNull(methodName, "Method name must not be null");
651
		try {
652
			Method method = clazz.getDeclaredMethod(methodName, args);
653
			if ((method.getModifiers() & .) != 0) {
654
				return method;
655
			}
656
		}
657
		catch (NoSuchMethodException ex) {
658
		}
659
		return null;
660
	}
Check if the given class represents a primitive wrapper, i.e. Boolean, Byte, Character, Short, Integer, Long, Float, or Double.

Parameters:
clazz the class to check
Returns:
whether the given class is a primitive wrapper class
669
	public static boolean isPrimitiveWrapper(Class clazz) {
670
		Assert.notNull(clazz, "Class must not be null");
672
	}
Check if the given class represents a primitive (i.e. boolean, byte, char, short, int, long, float, or double) or a primitive wrapper (i.e. Boolean, Byte, Character, Short, Integer, Long, Float, or Double).

Parameters:
clazz the class to check
Returns:
whether the given class is a primitive or primitive wrapper class
681
	public static boolean isPrimitiveOrWrapper(Class clazz) {
682
		Assert.notNull(clazz, "Class must not be null");
683
		return (clazz.isPrimitive() || isPrimitiveWrapper(clazz));
684
	}
Check if the given class represents an array of primitives, i.e. boolean, byte, char, short, int, long, float, or double.

Parameters:
clazz the class to check
Returns:
whether the given class is a primitive array class
692
	public static boolean isPrimitiveArray(Class clazz) {
693
		Assert.notNull(clazz, "Class must not be null");
694
		return (clazz.isArray() && clazz.getComponentType().isPrimitive());
695
	}
Check if the given class represents an array of primitive wrappers, i.e. Boolean, Byte, Character, Short, Integer, Long, Float, or Double.

Parameters:
clazz the class to check
Returns:
whether the given class is a primitive wrapper array class
703
	public static boolean isPrimitiveWrapperArray(Class clazz) {
704
		Assert.notNull(clazz, "Class must not be null");
705
		return (clazz.isArray() && isPrimitiveWrapper(clazz.getComponentType()));
706
	}
Check if the right-hand side type may be assigned to the left-hand side type, assuming setting by reflection. Considers primitive wrapper classes as assignable to the corresponding primitive types.

Parameters:
lhsType the target type
rhsType the value type that should be assigned to the target type
Returns:
if the target type is assignable from the value type
See also:
TypeUtils.isAssignable(java.lang.reflect.Type,java.lang.reflect.Type)
717
	public static boolean isAssignable(Class lhsType, Class rhsType) {
718
		Assert.notNull(lhsType, "Left-hand side type must not be null");
719
		Assert.notNull(rhsType, "Right-hand side type must not be null");
720
		return (lhsType.isAssignableFrom(rhsType) ||
722
	}
Determine if the given type is assignable from the given value, assuming setting by reflection. Considers primitive wrapper classes as assignable to the corresponding primitive types.

Parameters:
type the target type
value the value that should be assigned to the type
Returns:
if the type is assignable from the value
732
	public static boolean isAssignableValue(Class type, Object value) {
733
		Assert.notNull(type, "Type must not be null");
734
		return (value != null ? isAssignable(type, value.getClass()) : !type.isPrimitive());
735
	}
Convert a "/"-based resource path to a "."-based fully qualified class name.

Parameters:
resourcePath the resource path pointing to a class
Returns:
the corresponding fully qualified class name
743
	public static String convertResourcePathToClassName(String resourcePath) {
744
		return resourcePath.replace('/', '.');
745
	}
Convert a "."-based fully qualified class name to a "/"-based resource path.

Parameters:
className the fully qualified class name
Returns:
the corresponding resource path, pointing to the class
752
	public static String convertClassNameToResourcePath(String className) {
753
		return className.replace('.', '/');
754
	}
Return a path suitable for use with ClassLoader.getResource (also suitable for use with Class.getResource by prepending a slash ('/') to the return value. Built by taking the package of the specified class file, converting all dots ('.') to slashes ('/'), adding a trailing slash if necesssary, and concatenating the specified resource name to this.
As such, this function may be used to build a path suitable for loading a resource file that is in the same package as a class file, although org.springframework.core.io.ClassPathResource is usually even more convenient.

Parameters:
clazz the Class whose package will be used as the base
resourceName the resource name to append. A leading slash is optional.
Returns:
the built-up resource path
See also:
java.lang.ClassLoader.getResource(java.lang.String)
java.lang.Class.getResource(java.lang.String)
772
	public static String addResourcePathToPackagePath(Class clazz, String resourceName) {
773
		Assert.notNull(resourceName, "Resource name must not be null");
774
		if (!resourceName.startsWith("/")) {
775
			return classPackageAsResourcePath(clazz) + "/" + resourceName;
776
		}
777
		return classPackageAsResourcePath(clazz) + resourceName;
778
	}
Given an input class object, return a string which consists of the class's package name as a pathname, i.e., all dots ('.') are replaced by slashes ('/'). Neither a leading nor trailing slash is added. The result could be concatenated with a slash and the name of a resource, and fed directly to ClassLoader.getResource(). For it to be fed to Class.getResource instead, a leading slash would also have to be prepended to the returned value.

Parameters:
clazz the input class. A null value or the default (empty) package will result in an empty string ("") being returned.
Returns:
a path which represents the package name
See also:
java.lang.ClassLoader.getResource(java.lang.String)
java.lang.Class.getResource(java.lang.String)
794
	public static String classPackageAsResourcePath(Class clazz) {
795
		if (clazz == null) {
796
			return "";
797
		}
798
		String className = clazz.getName();
799
		int packageEndIndex = className.lastIndexOf('.');
800
		if (packageEndIndex == -1) {
801
			return "";
802
		}
803
		String packageName = className.substring(0, packageEndIndex);
804
		return packageName.replace('.', '/');
805
	}
Build a String that consists of the names of the classes/interfaces in the given array.

Basically like AbstractCollection.toString(), but stripping the "class "/"interface " prefix before every class name.

Parameters:
classes a Collection of Class objects (may be null)
Returns:
a String of form "[com.foo.Bar, com.foo.Baz]"
See also:
java.util.AbstractCollection.toString()
816
	public static String classNamesToString(Class[] classes) {
817
		return classNamesToString(Arrays.asList(classes));
818
	}
Build a String that consists of the names of the classes/interfaces in the given collection.

Basically like AbstractCollection.toString(), but stripping the "class "/"interface " prefix before every class name.

Parameters:
classes a Collection of Class objects (may be null)
Returns:
a String of form "[com.foo.Bar, com.foo.Baz]"
See also:
java.util.AbstractCollection.toString()
829
	public static String classNamesToString(Collection classes) {
830
		if (CollectionUtils.isEmpty(classes)) {
831
			return "[]";
832
		}
833
		StringBuffer sb = new StringBuffer("[");
834
		for (Iterator it = classes.iterator(); it.hasNext(); ) {
835
			Class clazz = (Class) it.next();
836
			sb.append(clazz.getName());
837
			if (it.hasNext()) {
838
				sb.append(", ");
839
			}
840
		}
841
		sb.append("]");
842
		return sb.toString();
843
	}
Return all interfaces that the given instance implements as array, including ones implemented by superclasses.

Parameters:
instance the instance to analyse for interfaces
Returns:
all interfaces that the given instance implements as array
852
	public static Class[] getAllInterfaces(Object instance) {
853
		Assert.notNull(instance, "Instance must not be null");
855
	}
Return all interfaces that the given class implements as array, including ones implemented by superclasses.

If the class itself is an interface, it gets returned as sole interface.

Parameters:
clazz the class to analyse for interfaces
Returns:
all interfaces that the given object implements as array
864
	public static Class[] getAllInterfacesForClass(Class clazz) {
865
		return getAllInterfacesForClass(clazz, null);
866
	}
Return all interfaces that the given class implements as array, including ones implemented by superclasses.

If the class itself is an interface, it gets returned as sole interface.

Parameters:
clazz the class to analyse for interfaces
classLoader the ClassLoader that the interfaces need to be visible in (may be null when accepting all declared interfaces)
Returns:
all interfaces that the given object implements as array
877
	public static Class[] getAllInterfacesForClass(Class clazz, ClassLoader classLoader) {
878
		Assert.notNull(clazz, "Class must not be null");
879
		if (clazz.isInterface()) {
880
			return new Class[] {clazz};
881
		}
882
		List interfaces = new ArrayList();
883
		while (clazz != null) {
884
			for (int i = 0; i < clazz.getInterfaces().length; i++) {
885
				Class ifc = clazz.getInterfaces()[i];
886
				if (!interfaces.contains(ifc) &&
887
						(classLoader == null || isVisible(ifc, classLoader))) {
888
					interfaces.add(ifc);
889
				}
890
			}
891
			clazz = clazz.getSuperclass();
892
		}
893
		return (Class[]) interfaces.toArray(new Class[interfaces.size()]);
894
	}
Return all interfaces that the given instance implements as Set, including ones implemented by superclasses.

Parameters:
instance the instance to analyse for interfaces
Returns:
all interfaces that the given instance implements as Set
902
	public static Set getAllInterfacesAsSet(Object instance) {
903
		Assert.notNull(instance, "Instance must not be null");
905
	}
Return all interfaces that the given class implements as Set, including ones implemented by superclasses.

If the class itself is an interface, it gets returned as sole interface.

Parameters:
clazz the class to analyse for interfaces
Returns:
all interfaces that the given object implements as Set
914
	public static Set getAllInterfacesForClassAsSet(Class clazz) {
915
		return getAllInterfacesForClassAsSet(clazz, null);
916
	}
Return all interfaces that the given class implements as Set, including ones implemented by superclasses.

If the class itself is an interface, it gets returned as sole interface.

Parameters:
clazz the class to analyse for interfaces
classLoader the ClassLoader that the interfaces need to be visible in (may be null when accepting all declared interfaces)
Returns:
all interfaces that the given object implements as Set
927
	public static Set getAllInterfacesForClassAsSet(Class clazz, ClassLoader classLoader) {
928
		Assert.notNull(clazz, "Class must not be null");
929
		if (clazz.isInterface()) {
930
			return Collections.singleton(clazz);
931
		}
932
		Set interfaces = new LinkedHashSet();
933
		while (clazz != null) {
934
			for (int i = 0; i < clazz.getInterfaces().length; i++) {
935
				Class ifc = clazz.getInterfaces()[i];
936
				if (classLoader == null || isVisible(ifc, classLoader)) {
937
					interfaces.add(ifc);
938
				}
939
			}
940
			clazz = clazz.getSuperclass();
941
		}
942
		return interfaces;
943
	}
Create a composite interface Class for the given interfaces, implementing the given interfaces in one single Class.

This implementation builds a JDK proxy class for the given interfaces.

Parameters:
interfaces the interfaces to merge
classLoader the ClassLoader to create the composite Class in
Returns:
the merged interface as Class
See also:
java.lang.reflect.Proxy.getProxyClass(java.lang.ClassLoader,java.lang.Class[])
954
	public static Class createCompositeInterface(Class[] interfaces, ClassLoader classLoader) {
955
		Assert.notEmpty(interfaces, "Interfaces must not be empty");
956
		Assert.notNull(classLoader, "ClassLoader must not be null");
957
		return Proxy.getProxyClass(classLoader, interfaces);
958
	}
Check whether the given class is visible in the given ClassLoader.

Parameters:
clazz the class to check (typically an interface)
classLoader the ClassLoader to check against (may be null, in which case this method will always return true)
966
	public static boolean isVisible(Class clazz, ClassLoader classLoader) {
967
		if (classLoader == null) {
968
			return true;
969
		}
970
		try {
971
			Class actualClass = classLoader.loadClass(clazz.getName());
972
			return (clazz == actualClass);
973
			// Else: different interface class found...
974
		}
975
		catch (ClassNotFoundException ex) {
976
			// No interface class found...
977
			return false;
978
		}
979
	}
New to GrepCode? Check out our FAQ X