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

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
See Also:
  `TypeUtils`, `ReflectionUtils`

Field Summary
`static String` | `ARRAY_SUFFIX` Suffix for array class names: "[]"
`static String` | `CGLIB_CLASS_SEPARATOR` The CGLIB class separator character "$$"
`static String` | `CLASS_FILE_SUFFIX` The ".class" file suffix

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 String` | `convertClassNameToResourcePath(String className)` Convert a "."
`static String` | `convertResourcePathToClassName(String resourcePath)` Convert a "/"-based resource path to a "."
`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 Class[]` | `getAllInterfacesForClass(Class clazz, ClassLoader classLoader)` 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 Set` | `getAllInterfacesForClassAsSet(Class clazz, ClassLoader classLoader)` 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 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(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 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. whether it is loaded by the given ClassLoader or a parent of it.
`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 boolean` | `isVisible(Class clazz, ClassLoader classLoader)` Check whether the given class is visible in the given ClassLoader.
`static ClassLoader` | `overrideThreadContextClassLoader(ClassLoader classLoaderToUse)` 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.
`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.

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

### CGLIB_CLASS_SEPARATOR

    public static final String CGLIB_CLASS_SEPARATOR

  The CGLIB class separator character "$$"

  See Also:
    Constant Field Values

### CLASS_FILE_SUFFIX

    public static final String CLASS_FILE_SUFFIX

  The ".class" file suffix

  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()`

### overrideThreadContextClassLoader

    public static ClassLoader overrideThreadContextClassLoader(ClassLoader classLoaderToUse)

  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

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

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

### isCacheSafe

    public static boolean isCacheSafe(Class clazz,
                                      ClassLoader classLoader)

  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

### 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. 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:
    `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

### getPackageName

    public static String getPackageName(Class clazz)

  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

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

### getDescriptiveType

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

  Parameters:
    `value` - the value to introspect
  Returns:
    the qualified name of the class

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

### getMostSpecificMethod

    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. 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 `AopUtils.getMostSpecificMethod(java.lang.reflect.Method, java.lang.Class)`, this method does not resolve Java 5 bridge methods automatically. Call `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:
    `AopUtils.getMostSpecificMethod(java.lang.reflect.Method, java.lang.Class)`

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

  Parameters:
    `clazz` - the class to check
  Returns:
    whether the given class is a primitive wrapper class

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

  Parameters:
    `clazz` - the class to check
  Returns:
    whether the given class is a primitive or primitive wrapper class

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

  Parameters:
    `clazz` - the class to check
  Returns:
    whether the given class is a primitive array class

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

  Parameters:
    `clazz` - the class to check
  Returns:
    whether the given class is a primitive wrapper array class

### isAssignable

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

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

### convertResourcePathToClassName

    public static String convertResourcePathToClassName(String resourcePath)

  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

### convertClassNameToResourcePath

    public static String convertClassNameToResourcePath(String className)

  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

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

### getAllInterfacesForClass

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

  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

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

### getAllInterfacesForClassAsSet

    public static Set getAllInterfacesForClassAsSet(Class clazz,
                                                    ClassLoader classLoader)

  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

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

### isVisible

    public static boolean isVisible(Class clazz,
                                    ClassLoader classLoader)

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

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

Copyright © 2002-2008 The Spring Framework.