| java.lang.Object
 org.springframework.util.ClassUtils
| ClassUtils | | abstract public class ClassUtils (Code) | | 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:
Keith Donald
author:
Rob Harrop
author:
Juergen Hoeller
since:
1.1
See Also: TypeUtils
See Also: ReflectionUtils |
| Method Summary | |
| public static String | addResourcePathToPackagePath(Class clazz, String resourceName)
Return a path suitable for use with ClassLoader.getResource
(also suitable for use with Class.getResource by prepending a
slash ('/') to the return value. | | public static String | classNamesToString(Class[] classes)
Build a String that consists of the names of the classes/interfaces
in the given array. | | public static String | classNamesToString(Collection classes)
Build a String that consists of the names of the classes/interfaces
in the given collection. | | public static String | classPackageAsResourcePath(Class clazz)
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 ('/'). | | public static String | convertClassNameToResourcePath(String className)
Convert a "."-based fully qualified class name to a "/"-based resource path. | | public static String | convertResourcePathToClassName(String resourcePath)
Convert a "/"-based resource path to a "."-based fully qualified class name. | | public static Class | createCompositeInterface(Class[] interfaces, ClassLoader classLoader)
Create a composite interface Class for the given interfaces,
implementing the given interfaces in one single Class. | | public static Class | forName(String name)
Replacement for Class.forName() that also returns Class instances
for primitives (like "int") and array class names (like "String[]"). | | public static Class | forName(String name, ClassLoader classLoader)
Replacement for Class.forName() that also returns Class instances
for primitives (like "int") and array class names (like "String[]"). | | public static Class[] | getAllInterfaces(Object instance)
Return all interfaces that the given instance implements as array,
including ones implemented by superclasses. | | public static Set | getAllInterfacesAsSet(Object instance)
Return all interfaces that the given instance implements as Set,
including ones implemented by superclasses. | | public static Class[] | getAllInterfacesForClass(Class clazz)
Return all interfaces that the given class implements as array,
including ones implemented by superclasses. | | public static Set | getAllInterfacesForClassAsSet(Class clazz)
Return all interfaces that the given class implements as Set,
including ones implemented by superclasses. | | public static String | getClassFileName(Class clazz)
Determine the name of the class file, relative to the containing
package: e.g. | | public static Constructor | getConstructorIfAvailable(Class clazz, Class[] paramTypes)
Determine whether the given class has a constructor with the given signature,
and return it if available (else return null). | | public static ClassLoader | getDefaultClassLoader()
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. | | public static int | getMethodCountForName(Class clazz, String methodName)
Return the number of methods with a given name (with any argument types),
for the given class and/or its superclasses. | | public static Method | getMethodIfAvailable(Class clazz, String methodName, Class[] paramTypes)
Determine whether the given class has a method with the given signature,
and return it if available (else return null). | | public static Method | getMostSpecificMethod(Method method, Class targetClass)
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. | | public static String | getPackageName(Class clazz)
Determine the name of the package of the given class:
e.g. | | public static String | getQualifiedMethodName(Method method)
Return the qualified name of the given method, consisting of
fully qualified interface/class name + "." + method name. | | public static String | getQualifiedName(Class clazz)
Return the qualified name of the given class: usually simply
the class name, but component type class name + "[]" for arrays. | | public static String | getShortName(String className)
Get the class name without the qualified package name. | | public static String | getShortName(Class clazz)
Get the class name without the qualified package name. | | public static String | getShortNameAsProperty(Class clazz)
Return the short string name of a Java class in decapitalized JavaBeans
property format. | | public static Method | getStaticMethod(Class clazz, String methodName, Class[] args)
Return a static method of a class. | | public static Class | getUserClass(Object instance)
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. | | public static Class | getUserClass(Class clazz)
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. | | public static boolean | hasAtLeastOneMethodWithName(Class clazz, String methodName)
Does the given class and/or its superclasses at least have one or more
methods (with any argument types)? Includes non-public methods. | | public static boolean | hasConstructor(Class clazz, Class[] paramTypes)
Determine whether the given class has a constructor with the given signature. | | public static boolean | hasMethod(Class clazz, String methodName, Class[] paramTypes)
Determine whether the given class has a method with the given signature. | | public static boolean | isAssignable(Class lhsType, Class rhsType)
Check if the right-hand side type may be assigned to the left-hand side
type, assuming setting by reflection. | | public static boolean | isAssignableValue(Class type, Object value)
Determine if the given type is assignable from the given value,
assuming setting by reflection. | | public static boolean | isPresent(String className)
Determine whether the
Class identified by the supplied name is present
and can be loaded. | | public static boolean | isPresent(String className, ClassLoader classLoader)
Determine whether the
Class identified by the supplied name is present
and can be loaded. | | public static boolean | isPrimitiveArray(Class clazz)
Check if the given class represents an array of primitives,
i.e. | | public static boolean | isPrimitiveOrWrapper(Class clazz)
Check if the given class represents a primitive (i.e. | | public static boolean | isPrimitiveWrapper(Class clazz)
Check if the given class represents a primitive wrapper,
i.e. | | public static boolean | isPrimitiveWrapperArray(Class clazz)
Check if the given class represents an array of primitive wrappers,
i.e. | | public static Class | resolveClassName(String className, ClassLoader classLoader)
Resolve the given class name into a Class instance. | | public static Class | resolvePrimitiveClassName(String name)
Resolve the given class name as primitive class, if appropriate,
according to the JVM's naming rules for primitive classes. |
| ARRAY_SUFFIX | | final public static String ARRAY_SUFFIX(Code) | | Suffix for array class names: "[]"
|
| CGLIB_CLASS_SEPARATOR | | final public static String CGLIB_CLASS_SEPARATOR(Code) | | The CGLIB class separator character "$$"
|
| CLASS_FILE_SUFFIX | | final public static String CLASS_FILE_SUFFIX(Code) | | The ".class" file suffix
|
| addResourcePathToPackagePath | | public static String addResourcePathToPackagePath(Class clazz, String resourceName)(Code) | | 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
Parameters:
resourceName - the resource name to append. A leading slash is optional. the built-up resource path
See Also: java.lang.ClassLoader.getResource
See Also: java.lang.Class.getResource |
| classNamesToString | | public static String classNamesToString(Class[] classes)(Code) | | 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) a String of form "[com.foo.Bar, com.foo.Baz]"
See Also: java.util.AbstractCollection.toString |
| classNamesToString | | public static String classNamesToString(Collection classes)(Code) | | 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) a String of form "[com.foo.Bar, com.foo.Baz]"
See Also: java.util.AbstractCollection.toString |
| classPackageAsResourcePath | | public static String classPackageAsResourcePath(Class clazz)(Code) | | 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. a path which represents the package name
See Also: ClassLoader.getResource
See Also: Class.getResource |
| convertClassNameToResourcePath | | public static String convertClassNameToResourcePath(String className)(Code) | | Convert a "."-based fully qualified class name to a "/"-based resource path.
Parameters:
className - the fully qualified class name the corresponding resource path, pointing to the class |
| convertResourcePathToClassName | | public static String convertResourcePathToClassName(String resourcePath)(Code) | | Convert a "/"-based resource path to a "."-based fully qualified class name.
Parameters:
resourcePath - the resource path pointing to a class the corresponding fully qualified class name |
| createCompositeInterface | | public static Class createCompositeInterface(Class[] interfaces, ClassLoader classLoader)(Code) | | 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
Parameters:
classLoader - the ClassLoader to create the composite Class in the merged interface as Class
See Also: java.lang.reflect.Proxy.getProxyClass |
| getAllInterfaces | | public static Class[] getAllInterfaces(Object instance)(Code) | | Return all interfaces that the given instance implements as array,
including ones implemented by superclasses.
Parameters:
instance - the instance to analyse for interfaces all interfaces that the given instance implements as array |
| getAllInterfacesAsSet | | public static Set getAllInterfacesAsSet(Object instance)(Code) | | Return all interfaces that the given instance implements as Set,
including ones implemented by superclasses.
Parameters:
instance - the instance to analyse for interfaces all interfaces that the given instance implements as Set |
| getAllInterfacesForClass | | public static Class[] getAllInterfacesForClass(Class clazz)(Code) | | 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 all interfaces that the given object implements as array |
| getAllInterfacesForClassAsSet | | public static Set getAllInterfacesForClassAsSet(Class clazz)(Code) | | 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 all interfaces that the given object implements as Set |
| getClassFileName | | public static String getClassFileName(Class clazz)(Code) | | Determine the name of the class file, relative to the containing
package: e.g. "String.class"
Parameters:
clazz - the class the file name of the ".class" file |
| getConstructorIfAvailable | | public static Constructor getConstructorIfAvailable(Class clazz, Class[] paramTypes)(Code) | | 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
Parameters:
paramTypes - the parameter types of the method the constructor, or null if not found
See Also: java.lang.Class.getConstructor |
| getDefaultClassLoader | | public static ClassLoader getDefaultClassLoader()(Code) | | 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).
the default ClassLoader (never null)
See Also: java.lang.Thread.getContextClassLoader |
| getMethodCountForName | | public static int getMethodCountForName(Class clazz, String methodName)(Code) | | 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
Parameters:
methodName - the name of the method the number of methods with the given name |
| getMethodIfAvailable | | public static Method getMethodIfAvailable(Class clazz, String methodName, Class[] paramTypes)(Code) | | 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
Parameters:
methodName - the name of the method
Parameters:
paramTypes - the parameter types of the method the method, or null if not found
See Also: java.lang.Class.getMethod |
| getMostSpecificMethod | | public static Method getMostSpecificMethod(Method method, Class targetClass)(Code) | | 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.getMostSpecificMethod ,
this method does not resolve Java 5 bridge methods automatically.
Call
org.springframework.core.BridgeMethodResolver.findBridgedMethod 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
Parameters:
targetClass - the target class for the current invocation.May be null or may not even implement the method. the specific target method, or the original method if thetargetClass doesn't implement it or is null
See Also: org.springframework.aop.support.AopUtils.getMostSpecificMethod |
| getPackageName | | public static String getPackageName(Class clazz)(Code) | | Determine the name of the package of the given class:
e.g. "java.lang" for the java.lang.String class.
Parameters:
clazz - the class the package name, or the empty String if the classis defined in the default package |
| getQualifiedMethodName | | public static String getQualifiedMethodName(Method method)(Code) | | Return the qualified name of the given method, consisting of
fully qualified interface/class name + "." + method name.
Parameters:
method - the method the qualified name of the method |
| getQualifiedName | | public static String getQualifiedName(Class clazz)(Code) | | Return the qualified name of the given class: usually simply
the class name, but component type class name + "[]" for arrays.
Parameters:
clazz - the class the qualified name of the class |
| getShortName | | public static String getShortName(String className)(Code) | | Get the class name without the qualified package name.
Parameters:
className - the className to get the short name for the class name of the class without the package name
throws:
IllegalArgumentException - if the className is empty |
| getShortName | | public static String getShortName(Class clazz)(Code) | | Get the class name without the qualified package name.
Parameters:
clazz - the class to get the short name for the class name of the class without the package name |
| getShortNameAsProperty | | public static String getShortNameAsProperty(Class clazz)(Code) | | 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 the short name rendered in a standard JavaBeans property format
See Also: java.beans.Introspector.decapitalize(String) |
| getStaticMethod | | public static Method getStaticMethod(Class clazz, String methodName, Class[] args)(Code) | | Return a static method of a class.
Parameters:
methodName - the static method name
Parameters:
clazz - the class which defines the method
Parameters:
args - the parameter types to the method the static method, or null if no static method was found
throws:
IllegalArgumentException - if the method name is blank or the clazz is null |
| getUserClass | | public static Class getUserClass(Object instance)(Code) | | 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 the user-defined class |
| getUserClass | | public static Class getUserClass(Class clazz)(Code) | | 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 the user-defined class |
| hasAtLeastOneMethodWithName | | public static boolean hasAtLeastOneMethodWithName(Class clazz, String methodName)(Code) | | 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
Parameters:
methodName - the name of the method whether there is at least one method with the given name |
| hasConstructor | | public static boolean hasConstructor(Class clazz, Class[] paramTypes)(Code) | | Determine whether the given class has a constructor with the given signature.
Essentially translates NoSuchMethodException to "false".
Parameters:
clazz - the clazz to analyze
Parameters:
paramTypes - the parameter types of the method whether the class has a corresponding constructor
See Also: java.lang.Class.getMethod |
| hasMethod | | public static boolean hasMethod(Class clazz, String methodName, Class[] paramTypes)(Code) | | Determine whether the given class has a method with the given signature.
Essentially translates NoSuchMethodException to "false".
Parameters:
clazz - the clazz to analyze
Parameters:
methodName - the name of the method
Parameters:
paramTypes - the parameter types of the method whether the class has a corresponding method
See Also: java.lang.Class.getMethod |
| isAssignable | | public static boolean isAssignable(Class lhsType, Class rhsType)(Code) | | 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
Parameters:
rhsType - the value type that should be assigned to the target type if the target type is assignable from the value type
See Also: TypeUtils.isAssignable |
| isAssignableValue | | public static boolean isAssignableValue(Class type, Object value)(Code) | | 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
Parameters:
value - the value that should be assigned to the type if the type is assignable from the value |
| isPresent | | public static boolean isPresent(String className)(Code) | | Determine whether the
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 whether the specified class is present |
| isPresent | | public static boolean isPresent(String className, ClassLoader classLoader)(Code) | | Determine whether the
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
Parameters:
classLoader - the class loader to use(may be null, which indicates the default class loader) whether the specified class is present |
| isPrimitiveArray | | public static boolean isPrimitiveArray(Class clazz)(Code) | | 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 whether the given class is a primitive array class |
| isPrimitiveOrWrapper | | public static boolean isPrimitiveOrWrapper(Class clazz)(Code) | | 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 whether the given class is a primitive or primitive wrapper class |
| isPrimitiveWrapper | | public static boolean isPrimitiveWrapper(Class clazz)(Code) | | 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 whether the given class is a primitive wrapper class |
| isPrimitiveWrapperArray | | public static boolean isPrimitiveWrapperArray(Class clazz)(Code) | | 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 whether the given class is a primitive wrapper array class |
| resolveClassName | | public static Class resolveClassName(String className, ClassLoader classLoader) throws IllegalArgumentException(Code) | | 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
Parameters:
classLoader - the class loader to use(may be null, which indicates the default class loader) Class instance for the supplied name
throws:
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: ClassUtils.forName(String,ClassLoader) |
| resolvePrimitiveClassName | | public static Class resolvePrimitiveClassName(String name)(Code) | | 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
ClassUtils.forName .
Parameters:
name - the name of the potentially primitive class the primitive class, or null if the name does not denotea primitive class or primitive array class |
|
|