ClassUtils (Spring Framework API 2.0) - Spring Framework 2.0.5 API 文档英文版

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

The Spring Framework

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.springframework.util
Class ClassUtils

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

public abstract class ClassUtils
extends Object
extends Object

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

Since:: 1.1
Author:: Keith Donald, Rob Harrop, Juergen Hoeller

Field Summary

static String ARRAY_SUFFIX
          Suffix for array class names

Constructor Summary

ClassUtils()


Method Summary

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 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 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)
          Replacement for Class.forName() that also returns Class instances for primitives (like "int") and array class names (like "String[]").

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[]").

static Class[] getAllInterfaces(Object instance)
          Return all interfaces that the given instance implements as array, including ones implemented by superclasses.

static Set getAllInterfacesAsSet(Object instance)
          Return all interfaces that the given instance implements as Set, 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 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 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).

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 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 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(Class clazz)
          Get the class name without the qualified package name.

static String getShortName(String className)
          Get the class name without the qualified package name.

static String getShortNameAsProperty(Class clazz)
          Return the short string name of a Java class in decapitalized JavaBeans property format.

static Method getStaticMethod(Class clazz, String methodName, Class[] args)
          Return a static method of a class.

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

static boolean hasConstructor(Class clazz, Class[] paramTypes)
          Determine whether the given class has a 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 targetType, Class valueType)
          Determine if the given target type is assignable from the given value 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 isPresent(String className)
          Determine whether the Class identified by the supplied name is present and can be loaded.

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. boolean, byte, char, short, int, long, float, or double.

static boolean isPrimitiveOrWrapper(Class clazz)
          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.

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

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Summary
`static String`	`ARRAY_SUFFIX` Suffix for array class names

Constructor Summary
`ClassUtils()`

Method Summary
`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 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 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)` Replacement for `Class.forName()` that also returns Class instances for primitives (like "int") and array class names (like "String[]").
`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[]").
`static Class[]`	`getAllInterfaces(Object instance)` Return all interfaces that the given instance implements as array, including ones implemented by superclasses.
`static Set`	`getAllInterfacesAsSet(Object instance)` Return all interfaces that the given instance implements as Set, 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`	`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 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`).
`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 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 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(Class clazz)` Get the class name without the qualified package name.
`static String`	`getShortName(String className)` Get the class name without the qualified package name.
`static String`	`getShortNameAsProperty(Class clazz)` Return the short string name of a Java class in decapitalized JavaBeans property format.
`static Method`	`getStaticMethod(Class clazz, String methodName, Class[] args)` Return a static method of a class.
`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 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 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)?
`static boolean`	`hasConstructor(Class clazz, Class[] paramTypes)` Determine whether the given class has a 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 targetType, Class valueType)` Determine if the given target type is assignable from the given value 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`	`isPresent(String className)` Determine whether the `Class` identified by the supplied name is present and can be loaded.
`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. boolean, byte, char, short, int, long, float, or double.
`static boolean`	`isPrimitiveOrWrapper(Class clazz)` 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.
`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 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.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

ARRAY_SUFFIX

public static final String ARRAY_SUFFIX

Suffix for array class names

See Also:: Constant Field Values

Constructor Detail

ClassUtils

public ClassUtils()

Method Detail

getDefaultClassLoader

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.

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:: Thread.getContextClassLoader()

isPresent

public static boolean isPresent(String className)

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

isPresent

public static boolean isPresent(String className,
                                ClassLoader 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; classLoader - the class loader to use (may be null, which indicates the default class loader)
Returns:: whether the specified class is present

forName

public static Class forName(String name)
                     throws ClassNotFoundException,
                            LinkageError

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:: Class.forName(String, boolean, ClassLoader), getDefaultClassLoader()

forName

public static Class forName(String name,
                            ClassLoader classLoader)
                     throws ClassNotFoundException,
                            LinkageError

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:: ClassNotFoundException - if the class was not found; LinkageError - if the class file could not be loaded
See Also:: Class.forName(String, boolean, ClassLoader)

resolveClassName

public static Class resolveClassName(String className,
                                     ClassLoader classLoader)
                              throws IllegalArgumentException

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

resolvePrimitiveClassName

public static Class resolvePrimitiveClassName(String name)

Resolve the given class name as primitive class, if appropriate.

Parameters:: name - the name of the potentially primitive class
Returns:: the primitive class, or null if the name does not denote a primitive class

getUserClass

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.

Parameters:: instance - the instance to check
Returns:: the user-defined class

getUserClass

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.

Parameters:: clazz - the class to check
Returns:: the user-defined class

getShortName

public static String getShortName(String className)

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

getShortName

public static String getShortName(Class clazz)

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

getShortNameAsProperty

public static String getShortNameAsProperty(Class clazz)

Return the short string name of a Java class in decapitalized JavaBeans property format.

Parameters:: clazz - the class
Returns:: the short name rendered in a standard JavaBeans property format
See Also:: Introspector.decapitalize(String)

getClassFileName

public static String getClassFileName(Class clazz)

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

getQualifiedName

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.

Parameters:: clazz - the class
Returns:: the qualified name of the class

getQualifiedMethodName

public static String getQualifiedMethodName(Method method)

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

hasConstructor

public static boolean hasConstructor(Class clazz,
                                     Class[] paramTypes)

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:: Class.getMethod(java.lang.String, java.lang.Class...)

getConstructorIfAvailable

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

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:: Class.getConstructor(java.lang.Class...)

hasMethod

public static boolean hasMethod(Class clazz,
                                String methodName,
                                Class[] paramTypes)

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:: Class.getMethod(java.lang.String, java.lang.Class...)

getMethodIfAvailable

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

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:: Class.getMethod(java.lang.String, java.lang.Class...)

getMethodCountForName

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

hasAtLeastOneMethodWithName

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.

Parameters:: clazz - the clazz to check; methodName - the name of the method
Returns:: whether there is at least one method with the given name

getStaticMethod

public static Method getStaticMethod(Class clazz,
                                     String methodName,
                                     Class[] args)

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:: IllegalArgumentException - if the method name is blank or the clazz is null

isPrimitiveWrapper

public static boolean isPrimitiveWrapper(Class clazz)

Check if the given class represents a primitive wrapper, i.e. Boolean, Byte, Character, Short, Integer, Long, Float, or Double.

isPrimitiveOrWrapper

public static boolean isPrimitiveOrWrapper(Class clazz)

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

isPrimitiveArray

public static boolean isPrimitiveArray(Class clazz)

Check if the given class represents an array of primitives, i.e. boolean, byte, char, short, int, long, float, or double.

isPrimitiveWrapperArray

public static boolean isPrimitiveWrapperArray(Class clazz)

Check if the given class represents an array of primitive wrappers, i.e. Boolean, Byte, Character, Short, Integer, Long, Float, or Double.

isAssignable

public static boolean isAssignable(Class targetType,
                                   Class valueType)

Determine if the given target type is assignable from the given value type, assuming setting by reflection. Considers primitive wrapper classes as assignable to the corresponding primitive types.

Parameters:: targetType - the target type; valueType - the value type that should be assigned to the target type
Returns:: if the target type is assignable from the value type

isAssignableValue

public static boolean isAssignableValue(Class type,
                                        Object value)

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

addResourcePathToPackagePath

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. 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 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:: ClassLoader.getResource(java.lang.String), Class.getResource(java.lang.String)

classPackageAsResourcePath

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 ('/'). 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:: ClassLoader.getResource(java.lang.String), Class.getResource(java.lang.String)

classNamesToString

public static String classNamesToString(Class[] classes)

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:: AbstractCollection.toString()

classNamesToString

public static String classNamesToString(Collection classes)

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:: AbstractCollection.toString()

getAllInterfaces

public static Class[] getAllInterfaces(Object instance)

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

getAllInterfacesForClass

public static Class[] getAllInterfacesForClass(Class clazz)

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

getAllInterfacesAsSet

public static Set getAllInterfacesAsSet(Object instance)

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

getAllInterfacesForClassAsSet

public static Set getAllInterfacesForClassAsSet(Class clazz)

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

createCompositeInterface

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.

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:: Proxy.getProxyClass(java.lang.ClassLoader, java.lang.Class...)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

The Spring Framework

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

ClassUtils (Spring Framework API 2.0) - Spring Framework 2.0.5 API 文档英文版

org.springframework.util Class ClassUtils

ARRAY_SUFFIX

ClassUtils

getDefaultClassLoader

isPresent

isPresent

forName

forName

resolveClassName

resolvePrimitiveClassName

getUserClass

getUserClass

getShortName

getShortName

getShortNameAsProperty

getClassFileName

getQualifiedName

getQualifiedMethodName

hasConstructor

getConstructorIfAvailable

hasMethod

getMethodIfAvailable

getMethodCountForName

hasAtLeastOneMethodWithName

getStaticMethod

isPrimitiveWrapper

isPrimitiveOrWrapper

isPrimitiveArray

isPrimitiveWrapperArray

isAssignable

isAssignableValue

addResourcePathToPackagePath

classPackageAsResourcePath

classNamesToString

classNamesToString

getAllInterfaces

getAllInterfacesForClass

getAllInterfacesAsSet

getAllInterfacesForClassAsSet

createCompositeInterface

org.springframework.util
Class ClassUtils