Package org.springframework.util

Class ClassUtils

java.lang.Object

org.springframework.util.ClassUtils

public abstract class ClassUtils
extends Object

Miscellaneous java.lang.Class utility methods.

Mainly for internal use within the framework.

Since:

1.1

Author:

Juergen Hoeller, Keith Donald, Rob Harrop, Sam Brannen, Sebastien Deleuze, Sungbin Yang

See Also:

• TypeUtils
• ReflectionUtils

Field Summary

Fields

Modifier and Type	Field	Description
static final String	ARRAY_SUFFIX	Suffix for array class names: "[]".
static final String	CGLIB_CLASS_SEPARATOR	The CGLIB class separator: "$$".
static final String	CLASS_FILE_SUFFIX	The ".class" file suffix.

Constructor Summary

Constructors

Constructor	Description
ClassUtils()

Method Summary

Modifier and Type	Method	Description
static String	addResourcePathToPackagePath(Class<?> clazz, String resourceName)	Return a path suitable for use with ClassLoader.getResource (also suitable for use with Class.getResource by prepending a slash ('/') to the return value).
static String	classNamesToString(Class<?>... classes)	Build a String that consists of the names of the classes/interfaces in the given array.
static String	classNamesToString(Collection<Class<?>> classes)	Build a String that consists of the names of the classes/interfaces in the given collection.
static String	classPackageAsResourcePath(Class<?> clazz)	Given an input class object, return a string which consists of the class's package name as a pathname, i.e., all dots ('.') are replaced by slashes ('/').
static String	convertClassNameToResourcePath(String className)	Convert a "."-based fully qualified class name to a "/"-based resource path.
static String	convertResourcePathToClassName(String resourcePath)	Convert a "/"-based resource path to a "."-based fully qualified class name.
static Class<?>	createCompositeInterface(Class<?>[] interfaces, ClassLoader classLoader)	Create a composite interface Class for the given interfaces, implementing the given interfaces in one single Class.
static Class<?>	determineCommonAncestor(Class<?> clazz1, Class<?> clazz2)	Determine the common ancestor of the given classes, if any.
static Class<?>	forName(String name, ClassLoader classLoader)	Replacement for Class.forName() that also returns Class instances for primitives (for example, "int") and array class names (for example, "String[]").
static Class<?>[]	getAllInterfaces(Object instance)	Return all interfaces that the given instance implements as an array, including ones implemented by superclasses.
static Set<Class<?>>	getAllInterfacesAsSet(Object instance)	Return all interfaces that the given instance implements as a Set, including ones implemented by superclasses.
static Class<?>[]	getAllInterfacesForClass(Class<?> clazz)	Return all interfaces that the given class implements as an array, including ones implemented by superclasses.
static Class<?>[]	getAllInterfacesForClass(Class<?> clazz, ClassLoader classLoader)	Return all interfaces that the given class implements as an array, including ones implemented by superclasses.
static Set<Class<?>>	getAllInterfacesForClassAsSet(Class<?> clazz)	Return all interfaces that the given class implements as a Set, including ones implemented by superclasses.
static Set<Class<?>>	getAllInterfacesForClassAsSet(Class<?> clazz, ClassLoader classLoader)	Return all interfaces that the given class implements as a Set, including ones implemented by superclasses.
static String	getClassFileName(Class<?> clazz)	Determine the name of the class file, relative to the containing package: for example, "String.class".
static <T> Constructor<T>	getConstructorIfAvailable(Class<T> clazz, Class<?>... paramTypes)	Determine whether the given class has a public constructor with the given signature, and return it if available (else return null).
static ClassLoader	getDefaultClassLoader()	Return the default ClassLoader to use: typically the thread context ClassLoader, if available; the ClassLoader that loaded the ClassUtils class will be used as fallback.
static String	getDescriptiveType(Object value)	Return a descriptive name for the given object's type: usually simply the class name, but component type class name + "[]" for arrays, and an appended list of implemented interfaces for JDK proxies.
static Method	getInterfaceMethodIfPossible(Method method)	Deprecated. in favor of getInterfaceMethodIfPossible(Method, Class)
static Method	getInterfaceMethodIfPossible(Method method, Class<?> targetClass)	Determine a corresponding interface method for the given method handle, if possible.
static Method	getMethod(Class<?> clazz, String methodName, 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(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 public 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 — for example, the method may be IFoo.bar(), and the target class may be DefaultFoo.
static String	getPackageName(Class<?> clazz)	Determine the name of the package of the given class, for example, "java.lang" for the java.lang.String class.
static String	getPackageName(String fqClassName)	Determine the name of the package of the given fully-qualified class name, for example, "java.lang" for the java.lang.String class name.
static Method	getPubliclyAccessibleMethodIfPossible(Method method, Class<?> targetClass)	Get the first publicly accessible method in the supplied method's type hierarchy that has a method signature equivalent to the supplied method, if possible.
static String	getQualifiedMethodName(Method method)	Return the qualified name of the given method, consisting of fully qualified interface/class name + "." + method name.
static String	getQualifiedMethodName(Method method, Class<?> clazz)	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 uncapitalized JavaBeans property format.
static Method	getStaticMethod(Class<?> clazz, String methodName, Class<?>... args)	Return a public 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 or one of its superclasses at least have one or more methods with the supplied name (with any argument types)? Includes non-public methods.
static boolean	hasConstructor(Class<?> clazz, Class<?>... paramTypes)	Determine whether the given class has a public constructor with the given signature.
static boolean	hasMethod(Class<?> clazz, Method method)	Determine whether the given class has a public method with the given signature.
static boolean	hasMethod(Class<?> clazz, String methodName, Class<?>... paramTypes)	Determine whether the given class has a public method with the given signature.
static boolean	isAssignable(Class<?> lhsType, Class<?> rhsType)	Check if the right-hand side type may be assigned to the left-hand side type, assuming setting by reflection.
static boolean	isAssignableValue(Class<?> type, Object value)	Determine if the given type is assignable from the given value, assuming setting by reflection.
static boolean	isCacheSafe(Class<?> clazz, ClassLoader classLoader)	Check whether the given class is cache-safe in the given context, i.e.
static boolean	isCglibProxy(Object object)	Deprecated. as of 5.2, in favor of custom (possibly narrower) checks such as for a Spring AOP proxy
static boolean	isCglibProxyClass(Class<?> clazz)	Deprecated. as of 5.2, in favor of custom (possibly narrower) checks or simply a check for containing CGLIB_CLASS_SEPARATOR
static boolean	isCglibProxyClassName(String className)	Deprecated. as of 5.2, in favor of custom (possibly narrower) checks or simply a check for containing CGLIB_CLASS_SEPARATOR
static boolean	isInnerClass(Class<?> clazz)	Determine if the supplied class is an inner class, i.e.
static boolean	isJavaLanguageInterface(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	isLambdaClass(Class<?> clazz)	Determine if the supplied Class is a JVM-generated implementation class for a lambda expression or method reference.
static boolean	isPresent(String className, ClassLoader classLoader)	Determine whether the Class identified by the supplied name is present and can be loaded.
static boolean	isPrimitiveArray(Class<?> clazz)	Check if the given class represents an array of primitives, i.e.
static boolean	isPrimitiveOrWrapper(Class<?> clazz)	Check if the given class represents a primitive (i.e.
static boolean	isPrimitiveWrapper(Class<?> clazz)	Check if the given class represents a primitive wrapper, i.e.
static boolean	isPrimitiveWrapperArray(Class<?> clazz)	Check if the given class represents an array of primitive wrappers, i.e.
static boolean	isSimpleValueType(Class<?> type)	Delegate for BeanUtils.isSimpleValueType(java.lang.Class<?>).
static boolean	isStaticClass(Class<?> clazz)	Determine if the supplied class is a static class.
static boolean	isUserLevelMethod(Method method)	Determine whether the given method is declared by the user or at least pointing to a user-declared method.
static boolean	isVisible(Class<?> clazz, ClassLoader classLoader)	Check whether the given class is visible in the given ClassLoader.
static boolean	isVoidType(Class<?> type)	Determine if the given type represents either Void or void.
static boolean	matchesTypeName(Class<?> clazz, String typeName)	Check whether the given class matches the user-specified type name.
static ClassLoader	overrideThreadContextClassLoader(ClassLoader classLoaderToUse)	Override the thread context ClassLoader with the environment's bean ClassLoader if necessary, i.e.
static Class<?>	resolveClassName(String className, ClassLoader classLoader)	Resolve the given class name into a Class instance.
static Class<?>	resolvePrimitiveClassName(String name)	Resolve the given class name as primitive class, if appropriate, according to the JVM's naming rules for primitive classes.
static Class<?>	resolvePrimitiveIfNecessary(Class<?> clazz)	Resolve the given class if it is a primitive class, returning the corresponding primitive wrapper type instead.
static Class<?>[]	toClassArray(Collection<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 Details

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: "$$".

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 Details

ClassUtils

public ClassUtils()

Method Details

getDefaultClassLoader

@Nullable
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 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 ClassLoader overrideThreadContextClassLoader(@Nullable
 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 Class<?> forName(String name,
 @Nullable
 ClassLoader classLoader)
                        throws ClassNotFoundException,
LinkageError

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

Parameters:

name - the name of the Class

classLoader - the class loader to use (can be null, which indicates the default class loader)

Returns:

a 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,
 @Nullable
 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 (can be null, which indicates the default class loader)

Returns:

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

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 Java Module System 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(String className,
 @Nullable
 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 (can be null which indicates the default class loader)

Returns:

whether the specified class is present (including all of its superclasses and interfaces)

Throws:

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 Java Module System module definition for a superclass or interface implemented by the class to be checked here)

isVisible

public static boolean isVisible(Class<?> clazz,
 @Nullable
 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 (can be null in which case this method will always return true)

isCacheSafe

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

resolvePrimitiveClassName

@Nullable
public static Class<?> resolvePrimitiveClassName(@Nullable
 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(Class<?> clazz)

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

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), void, or a wrapper for those types (i.e. Boolean, Byte, Character, Short, Integer, Long, Float, Double, or Void).

Parameters:

clazz - the class to check

Returns:

true if the given class represents a primitive, void, or a 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

resolvePrimitiveIfNecessary

public static Class<?> resolvePrimitiveIfNecessary(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

isVoidType

public static boolean isVoidType(@Nullable
 Class<?> type)

Determine if the given type represents either Void or void.

Parameters:

type - the type to check

Returns:

true if the type represents Void or void

Since:

6.1.4

See Also:

• Void
• Void.TYPE

isSimpleValueType

public static boolean isSimpleValueType(Class<?> type)

Delegate for BeanUtils.isSimpleValueType(java.lang.Class<?>). Also used by ObjectUtils.nullSafeConciseToString(java.lang.Object).

Check if the given type represents a common "simple" value type: primitive or primitive wrapper, Enum, String or other CharSequence, Number, Date, Temporal, ZoneId, TimeZone, File, Path, URI, URL, InetAddress, Charset, Currency, Locale, UUID, Pattern, or Class.

Void and void are not considered simple value types.

Parameters:

type - the type to check

Returns:

whether the given type represents a "simple" value type, suggesting value-based data binding and toString output

Since:

6.1

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 (left-hand side (LHS) type)

rhsType - the value type (right-hand side (RHS) type) that should be assigned to the target type

Returns:

true if rhsType is assignable to lhsType

See Also:

• TypeUtils.isAssignable(java.lang.reflect.Type, java.lang.reflect.Type)

isAssignableValue

public static boolean isAssignableValue(Class<?> type,
 @Nullable
 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 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 String classPackageAsResourcePath(@Nullable
 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 - an array of Class objects

Returns:

a String of form "[com.foo.Bar, com.foo.Baz]"

See Also:

• AbstractCollection.toString()

classNamesToString

public static String classNamesToString(@Nullable
 Collection<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 (can be null)

Returns:

a String of form "[com.foo.Bar, com.foo.Baz]"

See Also:

• AbstractCollection.toString()

toClassArray

public static Class<?>[] toClassArray(@Nullable
 Collection<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 Class<?>[] getAllInterfaces(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 Class<?>[] getAllInterfacesForClass(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 Class<?>[] getAllInterfacesForClass(Class<?> clazz,
 @Nullable
 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 (can be null when accepting all declared interfaces)

Returns:

all interfaces that the given object implements as an array

getAllInterfacesAsSet

public static Set<Class<?>> getAllInterfacesAsSet(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 Set<Class<?>> getAllInterfacesForClassAsSet(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 Set<Class<?>> getAllInterfacesForClassAsSet(Class<?> clazz,
 @Nullable
 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 (can be null when accepting all declared interfaces)

Returns:

all interfaces that the given object implements as a Set

createCompositeInterface

public static Class<?> createCompositeInterface(Class<?>[] interfaces,
 @Nullable
 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:

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 Class<?> determineCommonAncestor(@Nullable
 Class<?> clazz1,
 @Nullable
 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(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

isStaticClass

public static boolean isStaticClass(Class<?> clazz)

Determine if the supplied class is a static class.

Returns:

true if the supplied class is a static class

Since:

6.0

See Also:

• Modifier.isStatic(int)
• isInnerClass(Class)

isInnerClass

public static boolean isInnerClass(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()
• isStaticClass(Class)

isLambdaClass

public static boolean isLambdaClass(Class<?> clazz)

Determine if the supplied Class is a JVM-generated implementation class for a lambda expression or method reference.

This method makes a best-effort attempt at determining this, based on checks that work on modern, mainstream JVMs.

Parameters:

clazz - the class to check

Returns:

true if the class is a lambda implementation class

Since:

5.3.19

isCglibProxy

@Deprecated
public static boolean isCglibProxy(Object object)

Deprecated.

as of 5.2, in favor of custom (possibly narrower) checks such as for a Spring AOP proxy

Check whether the given object is a CGLIB proxy.

Parameters:

object - the object to check

See Also:

• AopUtils.isCglibProxy(Object)

isCglibProxyClass

@Deprecated
public static boolean isCglibProxyClass(@Nullable
 Class<?> clazz)

Deprecated.

as of 5.2, in favor of custom (possibly narrower) checks or simply a check for containing CGLIB_CLASS_SEPARATOR

Check whether the specified class is a CGLIB-generated class.

Parameters:

clazz - the class to check

See Also:

• getUserClass(Class)

isCglibProxyClassName

@Deprecated
public static boolean isCglibProxyClassName(@Nullable
 String className)

Deprecated.

as of 5.2, in favor of custom (possibly narrower) checks or simply a check for containing CGLIB_CLASS_SEPARATOR

Check whether the specified class name is a CGLIB-generated class.

Parameters:

className - the class name to check

See Also:

• CGLIB_CLASS_SEPARATOR

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

See Also:

• CGLIB_CLASS_SEPARATOR

getDescriptiveType

@Nullable
public static String getDescriptiveType(@Nullable
 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(Class<?> clazz,
 @Nullable
 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 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 uncapitalized JavaBeans property format. Strips the outer class name in case of a nested class.

Parameters:

clazz - the class

Returns:

the short name rendered in a standard JavaBeans property format

See Also:

• StringUtils.uncapitalizeAsProperty(String)

getClassFileName

public static String getClassFileName(Class<?> clazz)

Determine the name of the class file, relative to the containing package: for example, "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, for example, "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 String getPackageName(String fqClassName)

Determine the name of the package of the given fully-qualified class name, for example, "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 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

getQualifiedMethodName

public static String getQualifiedMethodName(Method method,
 @Nullable
 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 (can 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(Class<?> clazz,
 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.getConstructor(java.lang.Class<?>...)

getConstructorIfAvailable

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

Determine whether the given class has a public constructor with the given signature, and return it if available (else return null).

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,
 Method method)

Determine whether the given class has a public method with the given signature.

Parameters:

clazz - the clazz to analyze

method - the method to look for

Returns:

whether the class has a corresponding method

Since:

5.2.3

hasMethod

public static boolean hasMethod(Class<?> clazz,
 String methodName,
 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 Method getMethod(Class<?> clazz,
 String methodName,
 @Nullable
 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 (can be null to indicate any signature)

Returns:

the method (never null)

Throws:

IllegalStateException - if the method has not been found

See Also:

• Class.getMethod(java.lang.String, java.lang.Class<?>...)

getMethodIfAvailable

@Nullable
public static Method getMethodIfAvailable(Class<?> clazz,
 String methodName,
 @Nullable
 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 (can 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(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 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 Method getMostSpecificMethod(Method method,
 @Nullable
 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 — for example, 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 bridge methods automatically. Call BridgeMethodResolver.findBridgedMethod(java.lang.reflect.Method) if bridge method resolution is desirable — for example, to obtain metadata from the original method definition.

NOTE: If Java security settings disallow reflective access — for example, 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 (can 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(Method, Class)

getInterfaceMethodIfPossible

@Deprecated
public static Method getInterfaceMethodIfPossible(Method method)

Deprecated.

in favor of getInterfaceMethodIfPossible(Method, Class)

Determine a corresponding interface method for the given method handle, if possible.

This is particularly useful for arriving at a public exported type on the Java Module System which allows the method to be invoked via reflection 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:

• getPubliclyAccessibleMethodIfPossible(Method, Class)

getInterfaceMethodIfPossible

public static Method getInterfaceMethodIfPossible(Method method,
 @Nullable
 Class<?> targetClass)

Determine a corresponding interface method for the given method handle, if possible.

This is particularly useful for arriving at a public exported type on the Java Module System which allows the method to be invoked via reflection without an illegal access warning.

Parameters:

method - the method to be invoked, potentially from an implementation class

targetClass - the target class to invoke the method on, or null if unknown

Returns:

the corresponding interface method, or the original method if none found

Since:

5.3.16

See Also:

• getPubliclyAccessibleMethodIfPossible(Method, Class)
• getMostSpecificMethod(java.lang.reflect.Method, java.lang.Class<?>)

getPubliclyAccessibleMethodIfPossible

public static Method getPubliclyAccessibleMethodIfPossible(Method method,
 @Nullable
 Class<?> targetClass)

Get the first publicly accessible method in the supplied method's type hierarchy that has a method signature equivalent to the supplied method, if possible.

If the supplied method is public and declared in a public type, the supplied method will be returned.

Otherwise, this method recursively searches the class hierarchy and implemented interfaces for an equivalent method that is public and declared in a public type.

If a publicly accessible equivalent method cannot be found, the supplied method will be returned, indicating that no such equivalent method exists. Consequently, callers of this method must manually validate the accessibility of the returned method if public access is a requirement.

This is particularly useful for arriving at a public exported type on the Java Module System which allows the method to be invoked via reflection without an illegal access warning. This is also useful for invoking methods via a public API in bytecode — for example, for use with the Spring Expression Language (SpEL) compiler. For example, if a non-public class overrides toString(), this method will traverse up the type hierarchy to find the first public type that declares the method (if there is one). For toString(), it may traverse as far as Object.

Parameters:

method - the method to be invoked, potentially from an implementation class

targetClass - the target class to invoke the method on, or null if unknown

Returns:

the corresponding publicly accessible method, or the original method if none found

Since:

6.2

See Also:

• getInterfaceMethodIfPossible(Method, Class)
• getMostSpecificMethod(Method, Class)

isUserLevelMethod

public static boolean isUserLevelMethod(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; false otherwise

getStaticMethod

@Nullable
public static Method getStaticMethod(Class<?> clazz,
 String methodName,
 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:

IllegalArgumentException - if the method name is blank or the clazz is null