org.springframework.util

Class ClassUtils

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


  • public abstract class ClassUtils
    extends java.lang.Object
    Miscellaneous class utility methods. Mainly for internal use within the framework.
    Since:
    1.1
    Author:
    Juergen Hoeller, Keith Donald, Rob Harrop, Sam Brannen
    See Also:
    TypeUtils, ReflectionUtils
    • Field Summary

      Fields 
      Modifier and Type Field and Description
      static java.lang.String ARRAY_SUFFIX
      Suffix for array class names: "[]".
      static java.lang.String CGLIB_CLASS_SEPARATOR
      The CGLIB class separator: "$$".
      static java.lang.String CLASS_FILE_SUFFIX
      The ".class" file suffix.
    • Constructor Summary

      Constructors 
      Constructor and Description
      ClassUtils() 
    • Method Summary

      All Methods Static Methods Concrete Methods 
      Modifier and Type Method and Description
      static java.lang.String addResourcePathToPackagePath(java.lang.Class<?> clazz, java.lang.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 java.lang.String classNamesToString(java.lang.Class<?>... classes)
      Build a String that consists of the names of the classes/interfaces in the given array.
      static java.lang.String classNamesToString(java.util.Collection<java.lang.Class<?>> classes)
      Build a String that consists of the names of the classes/interfaces in the given collection.
      static java.lang.String classPackageAsResourcePath(java.lang.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 java.lang.String convertClassNameToResourcePath(java.lang.String className)
      Convert a "."-based fully qualified class name to a "/"-based resource path.
      static java.lang.String convertResourcePathToClassName(java.lang.String resourcePath)
      Convert a "/"-based resource path to a "."-based fully qualified class name.
      static java.lang.Class<?> createCompositeInterface(java.lang.Class<?>[] interfaces, java.lang.ClassLoader classLoader)
      Create a composite interface Class for the given interfaces, implementing the given interfaces in one single Class.
      static java.lang.Class<?> determineCommonAncestor(java.lang.Class<?> clazz1, java.lang.Class<?> clazz2)
      Determine the common ancestor of the given classes, if any.
      static java.lang.Class<?> forName(java.lang.String name, java.lang.ClassLoader classLoader)
      Replacement for Class.forName() that also returns Class instances for primitives (e.g.
      static java.lang.Class<?>[] getAllInterfaces(java.lang.Object instance)
      Return all interfaces that the given instance implements as an array, including ones implemented by superclasses.
      static java.util.Set<java.lang.Class<?>> getAllInterfacesAsSet(java.lang.Object instance)
      Return all interfaces that the given instance implements as a Set, including ones implemented by superclasses.
      static java.lang.Class<?>[] getAllInterfacesForClass(java.lang.Class<?> clazz)
      Return all interfaces that the given class implements as an array, including ones implemented by superclasses.
      static java.lang.Class<?>[] getAllInterfacesForClass(java.lang.Class<?> clazz, java.lang.ClassLoader classLoader)
      Return all interfaces that the given class implements as an array, including ones implemented by superclasses.
      static java.util.Set<java.lang.Class<?>> getAllInterfacesForClassAsSet(java.lang.Class<?> clazz)
      Return all interfaces that the given class implements as a Set, including ones implemented by superclasses.
      static java.util.Set<java.lang.Class<?>> getAllInterfacesForClassAsSet(java.lang.Class<?> clazz, java.lang.ClassLoader classLoader)
      Return all interfaces that the given class implements as a Set, including ones implemented by superclasses.
      static java.lang.String getClassFileName(java.lang.Class<?> clazz)
      Determine the name of the class file, relative to the containing package: e.g.
      static <T> java.lang.reflect.Constructor<T> getConstructorIfAvailable(java.lang.Class<T> clazz, java.lang.Class<?>... paramTypes)
      Determine whether the given class has a public constructor with the given signature, and return it if available (else return null).
      static java.lang.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 java.lang.String getDescriptiveType(java.lang.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 java.lang.reflect.Method getInterfaceMethodIfPossible(java.lang.reflect.Method method)
      Determine a corresponding interface method for the given method handle, if possible.
      static java.lang.reflect.Method getMethod(java.lang.Class<?> clazz, java.lang.String methodName, java.lang.Class<?>... paramTypes)
      Determine whether the given class has a public method with the given signature, and return it if available (else throws an IllegalStateException).
      static int getMethodCountForName(java.lang.Class<?> clazz, java.lang.String methodName)
      Return the number of methods with a given name (with any argument types), for the given class and/or its superclasses.
      static java.lang.reflect.Method getMethodIfAvailable(java.lang.Class<?> clazz, java.lang.String methodName, java.lang.Class<?>... paramTypes)
      Determine whether the given class has a public method with the given signature, and return it if available (else return null).
      static java.lang.reflect.Method getMostSpecificMethod(java.lang.reflect.Method method, java.lang.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 java.lang.String getPackageName(java.lang.Class<?> clazz)
      Determine the name of the package of the given class, e.g.
      static java.lang.String getPackageName(java.lang.String fqClassName)
      Determine the name of the package of the given fully-qualified class name, e.g.
      static java.lang.String getQualifiedMethodName(java.lang.reflect.Method method)
      Return the qualified name of the given method, consisting of fully qualified interface/class name + "." + method name.
      static java.lang.String getQualifiedMethodName(java.lang.reflect.Method method, java.lang.Class<?> clazz)
      Return the qualified name of the given method, consisting of fully qualified interface/class name + "." + method name.
      static java.lang.String getQualifiedName(java.lang.Class<?> clazz)
      Return the qualified name of the given class: usually simply the class name, but component type class name + "[]" for arrays.
      static java.lang.String getShortName(java.lang.Class<?> clazz)
      Get the class name without the qualified package name.
      static java.lang.String getShortName(java.lang.String className)
      Get the class name without the qualified package name.
      static java.lang.String getShortNameAsProperty(java.lang.Class<?> clazz)
      Return the short string name of a Java class in uncapitalized JavaBeans property format.
      static java.lang.reflect.Method getStaticMethod(java.lang.Class<?> clazz, java.lang.String methodName, java.lang.Class<?>... args)
      Return a public static method of a class.
      static java.lang.Class<?> getUserClass(java.lang.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 java.lang.Class<?> getUserClass(java.lang.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(java.lang.Class<?> clazz, java.lang.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(java.lang.Class<?> clazz, java.lang.Class<?>... paramTypes)
      Determine whether the given class has a public constructor with the given signature.
      static boolean hasMethod(java.lang.Class<?> clazz, java.lang.String methodName, java.lang.Class<?>... paramTypes)
      Determine whether the given class has a public method with the given signature.
      static boolean isAssignable(java.lang.Class<?> lhsType, java.lang.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(java.lang.Class<?> type, java.lang.Object value)
      Determine if the given type is assignable from the given value, assuming setting by reflection.
      static boolean isCacheSafe(java.lang.Class<?> clazz, java.lang.ClassLoader classLoader)
      Check whether the given class is cache-safe in the given context, i.e.
      static boolean isCglibProxy(java.lang.Object object)
      Check whether the given object is a CGLIB proxy.
      static boolean isCglibProxyClass(java.lang.Class<?> clazz)
      Check whether the specified class is a CGLIB-generated class.
      static boolean isCglibProxyClassName(java.lang.String className)
      Check whether the specified class name is a CGLIB-generated class.
      static boolean isInnerClass(java.lang.Class<?> clazz)
      Determine if the supplied class is an inner class, i.e.
      static boolean isJavaLanguageInterface(java.lang.Class<?> ifc)
      Determine whether the given interface is a common Java language interface: Serializable, Externalizable, Closeable, AutoCloseable, Cloneable, Comparable - all of which can be ignored when looking for 'primary' user-level interfaces.
      static boolean isPresent(java.lang.String className, java.lang.ClassLoader classLoader)
      Determine whether the Class identified by the supplied name is present and can be loaded.
      static boolean isPrimitiveArray(java.lang.Class<?> clazz)
      Check if the given class represents an array of primitives, i.e.
      static boolean isPrimitiveOrWrapper(java.lang.Class<?> clazz)
      Check if the given class represents a primitive (i.e.
      static boolean isPrimitiveWrapper(java.lang.Class<?> clazz)
      Check if the given class represents a primitive wrapper, i.e.
      static boolean isPrimitiveWrapperArray(java.lang.Class<?> clazz)
      Check if the given class represents an array of primitive wrappers, i.e.
      static boolean isUserLevelMethod(java.lang.reflect.Method method)
      Determine whether the given method is declared by the user or at least pointing to a user-declared method.
      static boolean isVisible(java.lang.Class<?> clazz, java.lang.ClassLoader classLoader)
      Check whether the given class is visible in the given ClassLoader.
      static boolean matchesTypeName(java.lang.Class<?> clazz, java.lang.String typeName)
      Check whether the given class matches the user-specified type name.
      static java.lang.ClassLoader overrideThreadContextClassLoader(java.lang.ClassLoader classLoaderToUse)
      Override the thread context ClassLoader with the environment's bean ClassLoader if necessary, i.e.
      static java.lang.Class<?> resolveClassName(java.lang.String className, java.lang.ClassLoader classLoader)
      Resolve the given class name into a Class instance.
      static java.lang.Class<?> resolvePrimitiveClassName(java.lang.String name)
      Resolve the given class name as primitive class, if appropriate, according to the JVM's naming rules for primitive classes.
      static java.lang.Class<?> resolvePrimitiveIfNecessary(java.lang.Class<?> clazz)
      Resolve the given class if it is a primitive class, returning the corresponding primitive wrapper type instead.
      static java.lang.Class<?>[] toClassArray(java.util.Collection<java.lang.Class<?>> collection)
      Copy the given Collection into a Class array.
      • 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 java.lang.String ARRAY_SUFFIX
        Suffix for array class names: "[]".
        See Also:
        Constant Field Values
      • CGLIB_CLASS_SEPARATOR

        public static final java.lang.String CGLIB_CLASS_SEPARATOR
        The CGLIB class separator: "$$".
        See Also:
        Constant Field Values
      • CLASS_FILE_SUFFIX

        public static final java.lang.String CLASS_FILE_SUFFIX
        The ".class" file suffix.
        See Also:
        Constant Field Values
    • Constructor Detail

      • ClassUtils

        public ClassUtils()
    • Method Detail

      • getDefaultClassLoader

        @Nullable
        public static java.lang.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 clearly prefer 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 (only null if even the system ClassLoader isn't accessible)
        See Also:
        Thread.getContextClassLoader(), ClassLoader.getSystemClassLoader()
      • overrideThreadContextClassLoader

        @Nullable
        public static java.lang.ClassLoader overrideThreadContextClassLoader(@Nullable
                                                                                       java.lang.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
      • forName

        public static java.lang.Class<?> forName(java.lang.String name,
                                                 @Nullable
                                                 java.lang.ClassLoader classLoader)
                                          throws java.lang.ClassNotFoundException,
                                                 java.lang.LinkageError
        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:
        a class instance for the supplied name
        Throws:
        java.lang.ClassNotFoundException - if the class was not found
        java.lang.LinkageError - if the class file could not be loaded
        See Also:
        Class.forName(String, boolean, ClassLoader)
      • resolveClassName

        public static java.lang.Class<?> resolveClassName(java.lang.String className,
                                                          @Nullable
                                                          java.lang.ClassLoader classLoader)
                                                   throws java.lang.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:
        a class instance for the supplied name
        Throws:
        java.lang.IllegalArgumentException - if the class name was not resolvable (that is, the class could not be found or the class file could not be loaded)
        java.lang.IllegalStateException - if the corresponding class is resolvable but there was a readability mismatch in the inheritance hierarchy of the class (typically a missing dependency declaration in a Jigsaw module definition for a superclass or interface implemented by the class to be loaded here)
        See Also:
        forName(String, ClassLoader)
      • isPresent

        public static boolean isPresent(java.lang.String className,
                                        @Nullable
                                        java.lang.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 (including all of its superclasses and interfaces)
        Throws:
        java.lang.IllegalStateException - if the corresponding class is resolvable but there was a readability mismatch in the inheritance hierarchy of the class (typically a missing dependency declaration in a Jigsaw module definition for a superclass or interface implemented by the class to be checked here)
      • isVisible

        public static boolean isVisible(java.lang.Class<?> clazz,
                                        @Nullable
                                        java.lang.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)
      • isCacheSafe

        public static boolean isCacheSafe(java.lang.Class<?> clazz,
                                          @Nullable
                                          java.lang.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 (may be null which indicates the system class loader)
      • resolvePrimitiveClassName

        @Nullable
        public static java.lang.Class<?> resolvePrimitiveClassName(@Nullable
                                                                             java.lang.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(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
      • isPrimitiveWrapper

        public static boolean isPrimitiveWrapper(java.lang.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(java.lang.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(java.lang.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(java.lang.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
      • resolvePrimitiveIfNecessary

        public static java.lang.Class<?> resolvePrimitiveIfNecessary(java.lang.Class<?> clazz)
        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
      • isAssignable

        public static boolean isAssignable(java.lang.Class<?> lhsType,
                                           java.lang.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(java.lang.Class<?> type,
                                                @Nullable
                                                java.lang.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 java.lang.String convertResourcePathToClassName(java.lang.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 java.lang.String convertClassNameToResourcePath(java.lang.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 java.lang.String addResourcePathToPackagePath(java.lang.Class<?> clazz,
                                                                    java.lang.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 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:
        ClassLoader.getResource(java.lang.String), Class.getResource(java.lang.String)
      • classPackageAsResourcePath

        public static java.lang.String classPackageAsResourcePath(@Nullable
                                                                  java.lang.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 java.lang.String classNamesToString(java.lang.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 - an array of Class objects
        Returns:
        a String of form "[com.foo.Bar, com.foo.Baz]"
        See Also:
        AbstractCollection.toString()
      • classNamesToString

        public static java.lang.String classNamesToString(@Nullable
                                                          java.util.Collection<java.lang.Class<?>> 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()
      • toClassArray

        public static java.lang.Class<?>[] toClassArray(java.util.Collection<java.lang.Class<?>> collection)
        Copy the given Collection into a Class array.

        The Collection must contain Class elements only.

        Parameters:
        collection - the Collection to copy
        Returns:
        the Class array
        Since:
        3.1
        See Also:
        StringUtils.toStringArray(java.util.Collection<java.lang.String>)
      • getAllInterfaces

        public static java.lang.Class<?>[] getAllInterfaces(java.lang.Object instance)
        Return all interfaces that the given instance implements as an array, including ones implemented by superclasses.
        Parameters:
        instance - the instance to analyze for interfaces
        Returns:
        all interfaces that the given instance implements as an array
      • getAllInterfacesForClass

        public static java.lang.Class<?>[] getAllInterfacesForClass(java.lang.Class<?> clazz)
        Return all interfaces that the given class implements as an 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 an array
      • getAllInterfacesForClass

        public static java.lang.Class<?>[] getAllInterfacesForClass(java.lang.Class<?> clazz,
                                                                    @Nullable
                                                                    java.lang.ClassLoader classLoader)
        Return all interfaces that the given class implements as an 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 an array
      • getAllInterfacesAsSet

        public static java.util.Set<java.lang.Class<?>> getAllInterfacesAsSet(java.lang.Object instance)
        Return all interfaces that the given instance implements as a Set, including ones implemented by superclasses.
        Parameters:
        instance - the instance to analyze for interfaces
        Returns:
        all interfaces that the given instance implements as a Set
      • getAllInterfacesForClassAsSet

        public static java.util.Set<java.lang.Class<?>> getAllInterfacesForClassAsSet(java.lang.Class<?> clazz)
        Return all interfaces that the given class implements as a 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 a Set
      • getAllInterfacesForClassAsSet

        public static java.util.Set<java.lang.Class<?>> getAllInterfacesForClassAsSet(java.lang.Class<?> clazz,
                                                                                      @Nullable
                                                                                      java.lang.ClassLoader classLoader)
        Return all interfaces that the given class implements as a 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 a Set
      • createCompositeInterface

        public static java.lang.Class<?> createCompositeInterface(java.lang.Class<?>[] interfaces,
                                                                  @Nullable
                                                                  java.lang.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
        Throws:
        java.lang.IllegalArgumentException - if the specified interfaces expose conflicting method signatures (or a similar constraint is violated)
        See Also:
        Proxy.getProxyClass(java.lang.ClassLoader, java.lang.Class<?>...)
      • determineCommonAncestor

        @Nullable
        public static java.lang.Class<?> determineCommonAncestor(@Nullable
                                                                           java.lang.Class<?> clazz1,
                                                                           @Nullable
                                                                           java.lang.Class<?> clazz2)
        Determine the common ancestor of the given classes, if any.
        Parameters:
        clazz1 - the class to introspect
        clazz2 - the other class to introspect
        Returns:
        the common ancestor (i.e. common superclass, one interface extending the other), or null if none found. If any of the given classes is null, the other class will be returned.
        Since:
        3.2.6
      • isJavaLanguageInterface

        public static boolean isJavaLanguageInterface(java.lang.Class<?> ifc)
        Determine whether the given interface is a common Java language interface: Serializable, Externalizable, Closeable, AutoCloseable, Cloneable, Comparable - all of which can be ignored when looking for 'primary' user-level interfaces. Common characteristics: no service-level operations, no bean property methods, no default methods.
        Parameters:
        ifc - the interface to check
        Since:
        5.0.3
      • isInnerClass

        public static boolean isInnerClass(java.lang.Class<?> clazz)
        Determine if the supplied class is an inner class, i.e. a non-static member of an enclosing class.
        Returns:
        true if the supplied class is an inner class
        Since:
        5.0.5
        See Also:
        Class.isMemberClass()
      • isCglibProxyClass

        public static boolean isCglibProxyClass(@Nullable
                                                java.lang.Class<?> clazz)
        Check whether the specified class is a CGLIB-generated class.
        Parameters:
        clazz - the class to check
        See Also:
        isCglibProxyClassName(String)
      • isCglibProxyClassName

        public static boolean isCglibProxyClassName(@Nullable
                                                    java.lang.String className)
        Check whether the specified class name is a CGLIB-generated class.
        Parameters:
        className - the class name to check
      • getUserClass

        public static java.lang.Class<?> getUserClass(java.lang.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 java.lang.Class<?> getUserClass(java.lang.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
      • getDescriptiveType

        @Nullable
        public static java.lang.String getDescriptiveType(@Nullable
                                                                    java.lang.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
      • matchesTypeName

        public static boolean matchesTypeName(java.lang.Class<?> clazz,
                                              @Nullable
                                              java.lang.String typeName)
        Check whether the given class matches the user-specified type name.
        Parameters:
        clazz - the class to check
        typeName - the type name to match
      • getShortName

        public static java.lang.String getShortName(java.lang.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:
        java.lang.IllegalArgumentException - if the className is empty
      • getShortName

        public static java.lang.String getShortName(java.lang.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 java.lang.String getShortNameAsProperty(java.lang.Class<?> clazz)
        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:
        Introspector.decapitalize(String)
      • getClassFileName

        public static java.lang.String getClassFileName(java.lang.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 java.lang.String getPackageName(java.lang.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
      • getPackageName

        public static java.lang.String getPackageName(java.lang.String fqClassName)
        Determine the name of the package of the given fully-qualified class name, e.g. "java.lang" for the java.lang.String class name.
        Parameters:
        fqClassName - the fully-qualified class name
        Returns:
        the package name, or the empty String if the class is defined in the default package
      • getQualifiedName

        public static java.lang.String getQualifiedName(java.lang.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 java.lang.String getQualifiedMethodName(java.lang.reflect.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
      • getQualifiedMethodName

        public static java.lang.String getQualifiedMethodName(java.lang.reflect.Method method,
                                                              @Nullable
                                                              java.lang.Class<?> clazz)
        Return the qualified name of the given method, consisting of fully qualified interface/class name + "." + method name.
        Parameters:
        method - the method
        clazz - the clazz that the method is being invoked on (may be null to indicate the method's declaring class)
        Returns:
        the qualified name of the method
        Since:
        4.3.4
      • hasConstructor

        public static boolean hasConstructor(java.lang.Class<?> clazz,
                                             java.lang.Class<?>... paramTypes)
        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:
        Class.getMethod(java.lang.String, java.lang.Class<?>...)
      • getConstructorIfAvailable

        @Nullable
        public static <T> java.lang.reflect.Constructor<T> getConstructorIfAvailable(java.lang.Class<T> clazz,
                                                                                               java.lang.Class<?>... paramTypes)
        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:
        Class.getConstructor(java.lang.Class<?>...)
      • hasMethod

        public static boolean hasMethod(java.lang.Class<?> clazz,
                                        java.lang.String methodName,
                                        java.lang.Class<?>... paramTypes)
        Determine whether the given class has a public 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<?>...)
      • getMethod

        public static java.lang.reflect.Method getMethod(java.lang.Class<?> clazz,
                                                         java.lang.String methodName,
                                                         @Nullable
                                                         java.lang.Class<?>... paramTypes)
        Determine whether the given class has a public method with the given signature, and return it if available (else throws an IllegalStateException).

        In case of any signature specified, only returns the method if there is a unique candidate, i.e. a single public method with the specified name.

        Essentially translates NoSuchMethodException to IllegalStateException.

        Parameters:
        clazz - the clazz to analyze
        methodName - the name of the method
        paramTypes - the parameter types of the method (may be null to indicate any signature)
        Returns:
        the method (never null)
        Throws:
        java.lang.IllegalStateException - if the method has not been found
        See Also:
        Class.getMethod(java.lang.String, java.lang.Class<?>...)
      • getMethodIfAvailable

        @Nullable
        public static java.lang.reflect.Method getMethodIfAvailable(java.lang.Class<?> clazz,
                                                                              java.lang.String methodName,
                                                                              @Nullable
                                                                              java.lang.Class<?>... paramTypes)
        Determine whether the given class has a public method with the given signature, and return it if available (else return null).

        In case of any signature specified, only returns the method if there is a unique candidate, i.e. a single public method with the specified name.

        Essentially translates NoSuchMethodException to null.

        Parameters:
        clazz - the clazz to analyze
        methodName - the name of the method
        paramTypes - the parameter types of the method (may be null to indicate any signature)
        Returns:
        the method, or null if not found
        See Also:
        Class.getMethod(java.lang.String, java.lang.Class<?>...)
      • getMethodCountForName

        public static int getMethodCountForName(java.lang.Class<?> clazz,
                                                java.lang.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(java.lang.Class<?> clazz,
                                                          java.lang.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.
        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 java.lang.reflect.Method getMostSpecificMethod(java.lang.reflect.Method method,
                                                                     @Nullable
                                                                     java.lang.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).

        NOTE: Since Spring 3.1.1, if Java security settings disallow reflective access (e.g. calls to Class#getDeclaredMethods etc, this implementation will fall back to returning the originally provided method.

        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 does not implement it
        See Also:
        getInterfaceMethodIfPossible(java.lang.reflect.Method)
      • getInterfaceMethodIfPossible

        public static java.lang.reflect.Method getInterfaceMethodIfPossible(java.lang.reflect.Method method)
        Determine a corresponding interface method for the given method handle, if possible.

        This is particularly useful for arriving at a public exported type on Jigsaw which can be reflectively invoked without an illegal access warning.

        Parameters:
        method - the method to be invoked, potentially from an implementation class
        Returns:
        the corresponding interface method, or the original method if none found
        Since:
        5.1
        See Also:
        getMostSpecificMethod(java.lang.reflect.Method, java.lang.Class<?>)
      • isUserLevelMethod

        public static boolean isUserLevelMethod(java.lang.reflect.Method method)
        Determine whether the given method is declared by the user or at least pointing to a user-declared method.

        Checks Method.isSynthetic() (for implementation methods) as well as the GroovyObject interface (for interface methods; on an implementation class, implementations of the GroovyObject methods will be marked as synthetic anyway). Note that, despite being synthetic, bridge methods (Method.isBridge()) are considered as user-level methods since they are eventually pointing to a user-declared generic method.

        Parameters:
        method - the method to check
        Returns:
        true if the method can be considered as user-declared; [@code false} otherwise
      • getStaticMethod

        @Nullable
        public static java.lang.reflect.Method getStaticMethod(java.lang.Class<?> clazz,
                                                                         java.lang.String methodName,
                                                                         java.lang.Class<?>... args)
        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:
        java.lang.IllegalArgumentException - if the method name is blank or the clazz is null