public abstract class

ClassUtils

extends Object
java.lang.Object
   ↳ org.springframework.util.ClassUtils

Class Overview

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

See Also

Summary

Constants
String ARRAY_SUFFIX Suffix for array class names: "[]"
String CGLIB_CLASS_SEPARATOR The CGLIB class separator character "$$"
String CLASS_FILE_SUFFIX The ".class" file suffix
Public Constructors
ClassUtils()
Public Methods
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).
static String classNamesToString(Class... classes)
Build a String that consists of the names of the classes/interfaces in the given array.
static String classNamesToString(Collection<Class> classes)
Build a String that consists of the names of the classes/interfaces in the given collection.
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 ('/').
static String convertClassNameToResourcePath(String className)
Convert a "."-based fully qualified class name to a "/"-based resource path.
static String convertResourcePathToClassName(String resourcePath)
Convert a "/"-based resource path to a "."-based fully qualified class name.
static Class<?> createCompositeInterface(Class[]<?> interfaces, ClassLoader classLoader)
Create a composite interface Class for the given interfaces, implementing the given interfaces in one single Class.
static Class<?> forName(String name, ClassLoader classLoader)
Replacement for Class.forName() that also returns Class instances for primitives (e.g."int") and array class names (e.g.
static Class<?> forName(String name)
This method is deprecated. as of Spring 3.0, in favor of specifying a ClassLoader explicitly: see forName(String, ClassLoader)
static Class[] getAllInterfaces(Object instance)
Return all interfaces that the given instance implements as array, including ones implemented by superclasses.
static Set<Class> getAllInterfacesAsSet(Object instance)
Return all interfaces that the given instance implements as Set, including ones implemented by superclasses.
static Class[]<?> getAllInterfacesForClass(Class<?> clazz, ClassLoader classLoader)
Return all interfaces that the given class implements as array, including ones implemented by superclasses.
static Class[]<?> getAllInterfacesForClass(Class<?> clazz)
Return all interfaces that the given class implements as array, including ones implemented by superclasses.
static Set<Class> getAllInterfacesForClassAsSet(Class clazz, ClassLoader classLoader)
Return all interfaces that the given class implements as Set, including ones implemented by superclasses.
static Set<Class> getAllInterfacesForClassAsSet(Class clazz)
Return all interfaces that the given class implements as Set, including ones implemented by superclasses.
static String getClassFileName(Class<?> clazz)
Determine the name of the class file, relative to the containing package: e.g.
static <T> Constructor<T> getConstructorIfAvailable(Class<T> clazz, Class...<?> paramTypes)
Determine whether the given class has a public constructor with the given signature, and return it if available (else return null).
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.
static String getDescriptiveType(Object value)
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.
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.
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).
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.
static String getPackageName(Class<?> clazz)
Determine the name of the package of the given class: e.g.
static String getQualifiedMethodName(Method method)
Return the qualified name of the given method, consisting of fully qualified interface/class name + "." + method name.
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.
static String getShortName(String className)
Get the class name without the qualified package name.
static String getShortName(Class<?> clazz)
Get the class name without the qualified package name.
static String getShortNameAsProperty(Class<?> clazz)
Return the short string name of a Java class in uncapitalized JavaBeans property format.
static Method getStaticMethod(Class<?> clazz, String methodName, Class...<?> args)
Return a public static method of a class.
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.
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.
static boolean hasAtLeastOneMethodWithName(Class<?> clazz, String methodName)
Does the given class or one of its superclasses at least have one or more methods with the supplied name (with any argument types)? Includes non-public methods.
static boolean hasConstructor(Class<?> clazz, Class...<?> paramTypes)
Determine whether the given class has a public constructor with the given signature.
static boolean hasMethod(Class<?> clazz, String methodName, Class...<?> paramTypes)
Determine whether the given class has a method with the given signature.
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.
static boolean isAssignableValue(Class<?> type, Object value)
Determine if the given type is assignable from the given value, assuming setting by reflection.
static boolean isCacheSafe(Class<?> clazz, ClassLoader classLoader)
Check whether the given class is cache-safe in the given context, i.e.
static boolean isPresent(String className)
This method is deprecated. as of Spring 2.5, in favor of isPresent(String, ClassLoader)
static boolean isPresent(String className, ClassLoader classLoader)
Determine whether the Class identified by the supplied name is present and can be loaded.
static boolean isPrimitiveArray(Class<?> clazz)
Check if the given class represents an array of primitives, i.e.
static boolean isPrimitiveOrWrapper(Class<?> clazz)
Check if the given class represents a primitive (i.e.
static boolean isPrimitiveWrapper(Class<?> clazz)
Check if the given class represents a primitive wrapper, i.e.
static boolean isPrimitiveWrapperArray(Class<?> clazz)
Check if the given class represents an array of primitive wrappers, i.e.
static boolean isVisible(Class<?> clazz, ClassLoader classLoader)
Check whether the given class is visible in the given ClassLoader.
static boolean matchesTypeName(Class<?> clazz, String typeName)
Check whether the given class matches the user-specified type name.
static ClassLoader overrideThreadContextClassLoader(ClassLoader classLoaderToUse)
Override the thread context ClassLoader with the environment's bean ClassLoader if necessary, i.e.
static Class<?> resolveClassName(String className, ClassLoader classLoader)
Resolve the given class name into a Class instance.
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.
static Class<?> resolvePrimitiveIfNecessary(Class<?> clazz)
Resolve the given class if it is a primitive class, returning the corresponding primitive wrapper type instead.
[Expand]
Inherited Methods
From class java.lang.Object

Constants

public static final String ARRAY_SUFFIX

Also: SpringCore

Suffix for array class names: "[]"

Constant Value: "[]"

public static final String CGLIB_CLASS_SEPARATOR

Also: SpringCore

The CGLIB class separator character "$$"

Constant Value: "$$"

public static final String CLASS_FILE_SUFFIX

Also: SpringCore

The ".class" file suffix

Constant Value: ".class"

Public Constructors

public ClassUtils ()

Also: SpringCore

Public Methods

public static String addResourcePathToPackagePath (Class<?> clazz, String resourceName)

Also: SpringCore

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 necessary, 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 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

public static String classNamesToString (Class... classes)

Also: SpringCore

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

public static String classNamesToString (Collection<Class> classes)

Also: SpringCore

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

public static String classPackageAsResourcePath (Class<?> clazz)

Also: SpringCore

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

public static String convertClassNameToResourcePath (String className)

Also: SpringCore

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

public static String convertResourcePathToClassName (String resourcePath)

Also: SpringCore

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

public static Class<?> createCompositeInterface (Class[]<?> interfaces, ClassLoader classLoader)

Also: SpringCore

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

public static Class<?> forName (String name, ClassLoader classLoader)

Also: SpringCore

Replacement for Class.forName() that also returns Class instances for primitives (e.g."int") and array class names (e.g. "String[]"). Furthermore, it is also capable of resolving inner class names in Java source style (e.g. "java.lang.Thread.State" instead of "java.lang.Thread$State").

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
ClassNotFoundException if the class was not found
LinkageError if the class file could not be loaded
See Also

public static Class<?> forName (String name)

Also: SpringCore

This method is deprecated.
as of Spring 3.0, in favor of specifying a ClassLoader explicitly: see forName(String, ClassLoader)

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
ClassNotFoundException if the class was not found
LinkageError if the class file could not be loaded
See Also

public static Class[] getAllInterfaces (Object instance)

Also: SpringCore

Return all interfaces that the given instance implements as array, including ones implemented by superclasses.

Parameters
instance the instance to analyze for interfaces
Returns
  • all interfaces that the given instance implements as array

public static Set<Class> getAllInterfacesAsSet (Object instance)

Also: SpringCore

Return all interfaces that the given instance implements as Set, including ones implemented by superclasses.

Parameters
instance the instance to analyze for interfaces
Returns
  • all interfaces that the given instance implements as Set

public static Class[]<?> getAllInterfacesForClass (Class<?> clazz, ClassLoader classLoader)

Also: SpringCore

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 analyze 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

public static Class[]<?> getAllInterfacesForClass (Class<?> clazz)

Also: SpringCore

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 analyze for interfaces
Returns
  • all interfaces that the given object implements as array

public static Set<Class> getAllInterfacesForClassAsSet (Class clazz, ClassLoader classLoader)

Also: SpringCore

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 analyze 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

public static Set<Class> getAllInterfacesForClassAsSet (Class clazz)

Also: SpringCore

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 analyze for interfaces
Returns
  • all interfaces that the given object implements as Set

public static String getClassFileName (Class<?> clazz)

Also: SpringCore

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

public static Constructor<T> getConstructorIfAvailable (Class<T> clazz, Class...<?> paramTypes)

Also: SpringCore

Determine whether the given class has a public 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

public static ClassLoader getDefaultClassLoader ()

Also: SpringCore

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

public static String getDescriptiveType (Object value)

Also: SpringCore

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

public static int getMethodCountForName (Class<?> clazz, String methodName)

Also: SpringCore

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

public static Method getMethodIfAvailable (Class<?> clazz, String methodName, Class...<?> paramTypes)

Also: SpringCore

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

public static Method getMostSpecificMethod (Method method, Class<?> targetClass)

Also: SpringCore

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 getMostSpecificMethod(Method, Class), this method does not resolve Java 5 bridge methods automatically. Call findBridgedMethod(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

public static String getPackageName (Class<?> clazz)

Also: SpringCore

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

public static String getQualifiedMethodName (Method method)

Also: SpringCore

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

public static String getQualifiedName (Class<?> clazz)

Also: SpringCore

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

public static String getShortName (String className)

Also: SpringCore

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
IllegalArgumentException if the className is empty

public static String getShortName (Class<?> clazz)

Also: SpringCore

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

public static String getShortNameAsProperty (Class<?> clazz)

Also: SpringCore

Return the short string name of a Java class in uncapitalized 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

public static Method getStaticMethod (Class<?> clazz, String methodName, Class...<?> args)

Also: SpringCore

Return a public static method of a class.

Parameters
clazz the class which defines the method
methodName the static method name
args the parameter types to the method
Returns
  • the static method, or null if no static method was found
Throws
IllegalArgumentException if the method name is blank or the clazz is null

public static Class<?> getUserClass (Object instance)

Also: SpringCore

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

public static Class<?> getUserClass (Class<?> clazz)

Also: SpringCore

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

public static boolean hasAtLeastOneMethodWithName (Class<?> clazz, String methodName)

Also: SpringCore

Does the given class or one of its superclasses at least have one or more methods with the supplied name (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

public static boolean hasConstructor (Class<?> clazz, Class...<?> paramTypes)

Also: SpringCore

Determine whether the given class has a public 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

public static boolean hasMethod (Class<?> clazz, String methodName, Class...<?> paramTypes)

Also: SpringCore

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

public static boolean isAssignable (Class<?> lhsType, Class<?> rhsType)

Also: SpringCore

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

public static boolean isAssignableValue (Class<?> type, Object value)

Also: SpringCore

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

public static boolean isCacheSafe (Class<?> clazz, ClassLoader classLoader)

Also: SpringCore

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

public static boolean isPresent (String className)

Also: SpringCore

This method is deprecated.
as of Spring 2.5, in favor of isPresent(String, ClassLoader)

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
Returns
  • whether the specified class is present

public static boolean isPresent (String className, ClassLoader classLoader)

Also: SpringCore

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
classLoader the class loader to use (may be null, which indicates the default class loader)
Returns
  • whether the specified class is present

public static boolean isPrimitiveArray (Class<?> clazz)

Also: SpringCore

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

public static boolean isPrimitiveOrWrapper (Class<?> clazz)

Also: SpringCore

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

public static boolean isPrimitiveWrapper (Class<?> clazz)

Also: SpringCore

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

public static boolean isPrimitiveWrapperArray (Class<?> clazz)

Also: SpringCore

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

public static boolean isVisible (Class<?> clazz, ClassLoader classLoader)

Also: SpringCore

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)

public static boolean matchesTypeName (Class<?> clazz, String typeName)

Also: SpringCore

Check whether the given class matches the user-specified type name.

Parameters
clazz the class to check
typeName the type name to match

public static ClassLoader overrideThreadContextClassLoader (ClassLoader classLoaderToUse)

Also: SpringCore

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

public static Class<?> resolveClassName (String className, ClassLoader classLoader)

Also: SpringCore

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
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

public static Class<?> resolvePrimitiveClassName (String name)

Also: SpringCore

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(String, ClassLoader).

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

public static Class<?> resolvePrimitiveIfNecessary (Class<?> clazz)

Also: SpringCore

Resolve the given class if it is a primitive class, returning the corresponding primitive wrapper type instead.

Parameters
clazz the class to check
Returns
  • the original class, or a primitive wrapper for the original primitive type