public abstract class ClassUtils extends Object
java.lang.Class
utility methods.
Mainly for internal use within the framework.TypeUtils
,
ReflectionUtils
Modifier and Type | Field and Description |
---|---|
static String |
ARRAY_SUFFIX
Suffix for array class names:
"[]" . |
static String |
CGLIB_CLASS_SEPARATOR
The CGLIB class separator:
"$$" . |
static String |
CLASS_FILE_SUFFIX
The ".class" file suffix.
|
Constructor and Description |
---|
ClassUtils() |
Modifier and Type | Method and 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 (e.g. |
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: e.g.
|
static <T> Constructor<T> |
getConstructorIfAvailable(Class<T> clazz,
Class<?>... paramTypes)
Determine whether the given class has a public constructor with the given signature,
and return it if available (else return
null ). |
static ClassLoader |
getDefaultClassLoader()
Return the default ClassLoader to use: typically the thread context
ClassLoader, if available; the ClassLoader that loaded the ClassUtils
class will be used as fallback.
|
static String |
getDescriptiveType(Object value)
Return a descriptive name for the given object's type: usually simply
the class name, but component type class name + "[]" for arrays,
and an appended list of implemented interfaces for JDK proxies.
|
static Method |
getInterfaceMethodIfPossible(Method method)
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.
|
static String |
getPackageName(Class<?> clazz)
Determine the name of the package of the given class,
e.g.
|
static String |
getPackageName(String fqClassName)
Determine the name of the package of the given fully-qualified class name,
e.g.
|
static String |
getQualifiedMethodName(Method method)
Return the qualified name of the given method, consisting of
fully qualified interface/class name + "." + method name.
|
static String |
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
|
static boolean |
isCglibProxyClass(Class<?> clazz)
Deprecated.
as of 5.2, in favor of custom (possibly narrower) checks
|
static boolean |
isCglibProxyClassName(String className)
Deprecated.
as of 5.2, in favor of custom (possibly narrower) checks
|
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 |
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 |
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 |
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. |
public static final String ARRAY_SUFFIX
"[]"
.public static final String CGLIB_CLASS_SEPARATOR
"$$"
.public static final String CLASS_FILE_SUFFIX
@Nullable public static ClassLoader getDefaultClassLoader()
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).
null
if even the system
ClassLoader isn't accessible)Thread.getContextClassLoader()
,
ClassLoader.getSystemClassLoader()
@Nullable public static ClassLoader overrideThreadContextClassLoader(@Nullable ClassLoader classLoaderToUse)
classLoaderToUse
- the actual ClassLoader to use for the thread contextnull
if not overriddenpublic static Class<?> forName(String name, @Nullable ClassLoader classLoader) throws ClassNotFoundException, LinkageError
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").name
- the name of the ClassclassLoader
- the class loader to use
(may be null
, which indicates the default class loader)ClassNotFoundException
- if the class was not foundLinkageError
- if the class file could not be loadedClass.forName(String, boolean, ClassLoader)
public static Class<?> resolveClassName(String className, @Nullable ClassLoader classLoader) throws IllegalArgumentException
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.
className
- the name of the ClassclassLoader
- the class loader to use
(may be null
, which indicates the default class loader)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 Jigsaw module definition
for a superclass or interface implemented by the class to be loaded here)forName(String, ClassLoader)
public static boolean isPresent(String className, @Nullable ClassLoader classLoader)
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.className
- the name of the class to checkclassLoader
- the class loader to use
(may be null
which indicates the default class loader)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)public static boolean isVisible(Class<?> clazz, @Nullable ClassLoader classLoader)
clazz
- the class to check (typically an interface)classLoader
- the ClassLoader to check against
(may be null
in which case this method will always return true
)public static boolean isCacheSafe(Class<?> clazz, @Nullable ClassLoader classLoader)
clazz
- the class to analyzeclassLoader
- the ClassLoader to potentially cache metadata in
(may be null
which indicates the system class loader)@Nullable public static Class<?> resolvePrimitiveClassName(@Nullable String name)
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)
.
name
- the name of the potentially primitive classnull
if the name does not denote
a primitive class or primitive array classpublic static boolean isPrimitiveWrapper(Class<?> clazz)
clazz
- the class to checkpublic static boolean isPrimitiveOrWrapper(Class<?> clazz)
void
, or a wrapper for
those types (i.e. Boolean, Byte, Character, Short, Integer, Long, Float,
Double, or Void).clazz
- the class to checktrue
if the given class represents a primitive, void, or
a wrapper classpublic static boolean isPrimitiveArray(Class<?> clazz)
clazz
- the class to checkpublic static boolean isPrimitiveWrapperArray(Class<?> clazz)
clazz
- the class to checkpublic static Class<?> resolvePrimitiveIfNecessary(Class<?> clazz)
clazz
- the class to checkpublic static boolean isAssignable(Class<?> lhsType, Class<?> rhsType)
lhsType
- the target typerhsType
- the value type that should be assigned to the target typeTypeUtils.isAssignable(java.lang.reflect.Type, java.lang.reflect.Type)
public static boolean isAssignableValue(Class<?> type, @Nullable Object value)
type
- the target typevalue
- the value that should be assigned to the typepublic static String convertResourcePathToClassName(String resourcePath)
resourcePath
- the resource path pointing to a classpublic static String convertClassNameToResourcePath(String className)
className
- the fully qualified class namepublic static String addResourcePathToPackagePath(Class<?> clazz, String resourceName)
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.
ClassPathResource
is usually
even more convenient.clazz
- the Class whose package will be used as the baseresourceName
- the resource name to append. A leading slash is optional.ClassLoader.getResource(java.lang.String)
,
Class.getResource(java.lang.String)
public static String classPackageAsResourcePath(@Nullable Class<?> clazz)
ClassLoader.getResource()
. For it to be fed to
Class.getResource
instead, a leading slash would also have
to be prepended to the returned value.clazz
- the input class. A null
value or the default
(empty) package will result in an empty string ("") being returned.ClassLoader.getResource(java.lang.String)
,
Class.getResource(java.lang.String)
public static String classNamesToString(Class<?>... classes)
Basically like AbstractCollection.toString()
, but stripping
the "class "/"interface " prefix before every class name.
classes
- an array of Class objectsAbstractCollection.toString()
public static String classNamesToString(@Nullable Collection<Class<?>> classes)
Basically like AbstractCollection.toString()
, but stripping
the "class "/"interface " prefix before every class name.
classes
- a Collection of Class objects (may be null
)AbstractCollection.toString()
public static Class<?>[] toClassArray(@Nullable Collection<Class<?>> collection)
Collection
into a Class
array.
The Collection
must contain Class
elements only.
collection
- the Collection
to copyClass
arrayStringUtils.toStringArray(java.util.Collection<java.lang.String>)
public static Class<?>[] getAllInterfaces(Object instance)
instance
- the instance to analyze for interfacespublic static Class<?>[] getAllInterfacesForClass(Class<?> clazz)
If the class itself is an interface, it gets returned as sole interface.
clazz
- the class to analyze for interfacespublic static Class<?>[] getAllInterfacesForClass(Class<?> clazz, @Nullable ClassLoader classLoader)
If the class itself is an interface, it gets returned as sole interface.
clazz
- the class to analyze for interfacesclassLoader
- the ClassLoader that the interfaces need to be visible in
(may be null
when accepting all declared interfaces)public static Set<Class<?>> getAllInterfacesAsSet(Object instance)
instance
- the instance to analyze for interfacespublic static Set<Class<?>> getAllInterfacesForClassAsSet(Class<?> clazz)
If the class itself is an interface, it gets returned as sole interface.
clazz
- the class to analyze for interfacespublic static Set<Class<?>> getAllInterfacesForClassAsSet(Class<?> clazz, @Nullable ClassLoader classLoader)
If the class itself is an interface, it gets returned as sole interface.
clazz
- the class to analyze for interfacesclassLoader
- the ClassLoader that the interfaces need to be visible in
(may be null
when accepting all declared interfaces)public static Class<?> createCompositeInterface(Class<?>[] interfaces, @Nullable ClassLoader classLoader)
This implementation builds a JDK proxy class for the given interfaces.
interfaces
- the interfaces to mergeclassLoader
- the ClassLoader to create the composite Class inIllegalArgumentException
- if the specified interfaces expose
conflicting method signatures (or a similar constraint is violated)Proxy.getProxyClass(java.lang.ClassLoader, java.lang.Class<?>...)
@Nullable public static Class<?> determineCommonAncestor(@Nullable Class<?> clazz1, @Nullable Class<?> clazz2)
clazz1
- the class to introspectclazz2
- the other class to introspectnull
if none found. If any of the
given classes is null
, the other class will be returned.public static boolean isJavaLanguageInterface(Class<?> ifc)
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.ifc
- the interface to checkpublic static boolean isInnerClass(Class<?> clazz)
true
if the supplied class is an inner classClass.isMemberClass()
@Deprecated public static boolean isCglibProxy(Object object)
object
- the object to checkisCglibProxyClass(Class)
,
AopUtils.isCglibProxy(Object)
@Deprecated public static boolean isCglibProxyClass(@Nullable Class<?> clazz)
clazz
- the class to checkisCglibProxyClassName(String)
@Deprecated public static boolean isCglibProxyClassName(@Nullable String className)
className
- the class name to checkpublic static Class<?> getUserClass(Object instance)
instance
- the instance to checkpublic static Class<?> getUserClass(Class<?> clazz)
clazz
- the class to check@Nullable public static String getDescriptiveType(@Nullable Object value)
value
- the value to introspectpublic static boolean matchesTypeName(Class<?> clazz, @Nullable String typeName)
clazz
- the class to checktypeName
- the type name to matchpublic static String getShortName(String className)
className
- the className to get the short name forIllegalArgumentException
- if the className is emptypublic static String getShortName(Class<?> clazz)
clazz
- the class to get the short name forpublic static String getShortNameAsProperty(Class<?> clazz)
clazz
- the classIntrospector.decapitalize(String)
public static String getClassFileName(Class<?> clazz)
clazz
- the classpublic static String getPackageName(Class<?> clazz)
java.lang.String
class.clazz
- the classpublic static String getPackageName(String fqClassName)
java.lang.String
class name.fqClassName
- the fully-qualified class namepublic static String getQualifiedName(Class<?> clazz)
clazz
- the classpublic static String getQualifiedMethodName(Method method)
method
- the methodpublic static String getQualifiedMethodName(Method method, @Nullable Class<?> clazz)
method
- the methodclazz
- the clazz that the method is being invoked on
(may be null
to indicate the method's declaring class)public static boolean hasConstructor(Class<?> clazz, Class<?>... paramTypes)
Essentially translates NoSuchMethodException
to "false".
clazz
- the clazz to analyzeparamTypes
- the parameter types of the methodClass.getConstructor(java.lang.Class<?>...)
@Nullable public static <T> Constructor<T> getConstructorIfAvailable(Class<T> clazz, Class<?>... paramTypes)
null
).
Essentially translates NoSuchMethodException
to null
.
clazz
- the clazz to analyzeparamTypes
- the parameter types of the methodnull
if not foundClass.getConstructor(java.lang.Class<?>...)
public static boolean hasMethod(Class<?> clazz, Method method)
clazz
- the clazz to analyzemethod
- the method to look forpublic static boolean hasMethod(Class<?> clazz, String methodName, Class<?>... paramTypes)
Essentially translates NoSuchMethodException
to "false".
clazz
- the clazz to analyzemethodName
- the name of the methodparamTypes
- the parameter types of the methodClass.getMethod(java.lang.String, java.lang.Class<?>...)
public static Method getMethod(Class<?> clazz, String methodName, @Nullable Class<?>... paramTypes)
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
.
clazz
- the clazz to analyzemethodName
- the name of the methodparamTypes
- the parameter types of the method
(may be null
to indicate any signature)null
)IllegalStateException
- if the method has not been foundClass.getMethod(java.lang.String, java.lang.Class<?>...)
@Nullable public static Method getMethodIfAvailable(Class<?> clazz, String methodName, @Nullable Class<?>... paramTypes)
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
.
clazz
- the clazz to analyzemethodName
- the name of the methodparamTypes
- the parameter types of the method
(may be null
to indicate any signature)null
if not foundClass.getMethod(java.lang.String, java.lang.Class<?>...)
public static int getMethodCountForName(Class<?> clazz, String methodName)
clazz
- the clazz to checkmethodName
- the name of the methodpublic static boolean hasAtLeastOneMethodWithName(Class<?> clazz, String methodName)
clazz
- the clazz to checkmethodName
- the name of the methodpublic static Method getMostSpecificMethod(Method method, @Nullable Class<?> targetClass)
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.
method
- the method to be invoked, which may come from an interfacetargetClass
- the target class for the current invocation
(may be null
or may not even implement the method)targetClass
does not implement itgetInterfaceMethodIfPossible(java.lang.reflect.Method)
public static Method getInterfaceMethodIfPossible(Method method)
This is particularly useful for arriving at a public exported type on Jigsaw which can be reflectively invoked without an illegal access warning.
method
- the method to be invoked, potentially from an implementation classgetMostSpecificMethod(java.lang.reflect.Method, java.lang.Class<?>)
public static boolean isUserLevelMethod(Method 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.
method
- the method to checktrue
if the method can be considered as user-declared; [@code false} otherwise@Nullable public static Method getStaticMethod(Class<?> clazz, String methodName, Class<?>... args)
clazz
- the class which defines the methodmethodName
- the static method nameargs
- the parameter types to the methodnull
if no static method was foundIllegalArgumentException
- if the method name is blank or the clazz is null