类 ClassUtils
- java.lang.Object
- org.springframework.util.ClassUtils
public abstract class ClassUtils extends Object
Miscellaneousjava.lang.Class
utility methods. Mainly for internal use within the framework.- 从以下版本开始:
- 1.1
- 作者:
- Juergen Hoeller, Keith Donald, Rob Harrop, Sam Brannen
- 另请参阅:
TypeUtils
,ReflectionUtils
字段概要
字段 修饰符和类型 字段 说明 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.
构造器概要
构造器 构造器 说明 ClassUtils()
方法概要
所有方法 静态方法 具体方法 已过时的方法 修饰符和类型 方法 说明 static String
addResourcePathToPackagePath(Class<?> clazz, String resourceName)
Return a path suitable for use withClassLoader.getResource
(also suitable for use withClass.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 "."static String
convertResourcePathToClassName(String resourcePath)
Convert a "/"-based resource path to a "."static Class<?>
createCompositeInterface(Class<?>[] interfaces, ClassLoader classLoader)
Create a composite interface Class for the given interfaces, implementing the given interfaces in one single Class.static Class<?>
determineCommonAncestor(Class<?> clazz1, Class<?> clazz2)
Determine the common ancestor of the given classes, if any.static Class<?>
forName(String name, ClassLoader classLoader)
Replacement forClass.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 returnnull
).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 anIllegalStateException
).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 returnnull
).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)?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. whether it is loaded by the given ClassLoader or a parent of it.static boolean
isCglibProxy(Object object)
已过时。as of 5.2, in favor of custom (possibly narrower) checksstatic boolean
isCglibProxyClass(Class<?> clazz)
已过时。as of 5.2, in favor of custom (possibly narrower) checksstatic boolean
isCglibProxyClassName(String className)
已过时。as of 5.2, in favor of custom (possibly narrower) checksstatic boolean
isInnerClass(Class<?> clazz)
Determine if the supplied class is an inner class, i.e. a non-static member of an enclosing class.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 theClass
identified by the supplied name is present and can be loaded.static boolean
isPrimitiveArray(Class<?> clazz)
Check if the given class represents an array of primitives, i.e. boolean, byte, char, short, int, long, float, or double.static boolean
isPrimitiveOrWrapper(Class<?> clazz)
Check if the given class represents a primitive (i.e. boolean, byte, char, short, int, long, float, or double),void
, or a wrapper for those types (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. if the bean ClassLoader is not equivalent to the thread context ClassLoader already.static Class<?>
resolveClassName(String className, ClassLoader classLoader)
Resolve the given class name into a Class instance.static Class<?>
resolvePrimitiveClassName(String name)
Resolve the given class name as primitive class, if appropriate, according to the JVM's naming rules for primitive classes.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 givenCollection
into aClass
array.
字段详细资料
ARRAY_SUFFIX
public static final String ARRAY_SUFFIX
Suffix for array class names:"[]"
.- 另请参阅:
- 常量字段值
CGLIB_CLASS_SEPARATOR
public static final String CGLIB_CLASS_SEPARATOR
The CGLIB class separator:"$$"
.- 另请参阅:
- 常量字段值
CLASS_FILE_SUFFIX
public static final String CLASS_FILE_SUFFIX
The ".class" file suffix.- 另请参阅:
- 常量字段值
构造器详细资料
ClassUtils
public ClassUtils()
方法详细资料
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 anull
ClassLoader reference as well).- 返回:
- the default ClassLoader (only
null
if even the system ClassLoader isn't accessible) - 另请参阅:
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.- 参数:
classLoaderToUse
- the actual ClassLoader to use for the thread context- 返回:
- the original thread context ClassLoader, or
null
if not overridden
forName
public static Class<?> forName(String name, @Nullable ClassLoader classLoader) throws ClassNotFoundException, LinkageError
Replacement forClass.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 benull
, which indicates the default class loader)- 返回:
- a class instance for the supplied name
- 抛出:
ClassNotFoundException
- if the class was not foundLinkageError
- if the class file could not be loaded- 另请参阅:
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.- 参数:
className
- the name of the ClassclassLoader
- the class loader to use (may benull
, which indicates the default class loader)- 返回:
- a class instance for the supplied name
- 抛出:
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)
isPresent
public static boolean isPresent(String className, @Nullable ClassLoader classLoader)
Determine whether theClass
identified by the supplied name is present and can be loaded. Will returnfalse
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 benull
which indicates the default class loader)- 返回:
- whether the specified class is present (including all of its superclasses and interfaces)
- 抛出:
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(Class<?> clazz, @Nullable ClassLoader classLoader)
Check whether the given class is visible in the given ClassLoader.- 参数:
clazz
- the class to check (typically an interface)classLoader
- the ClassLoader to check against (may benull
in which case this method will always returntrue
)
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.- 参数:
clazz
- the class to analyzeclassLoader
- the ClassLoader to potentially cache metadata in (may benull
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)
.- 参数:
name
- the name of the potentially primitive class- 返回:
- 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.- 参数:
clazz
- the class to check- 返回:
- 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).- 参数:
clazz
- the class to check- 返回:
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.- 参数:
clazz
- the class to check- 返回:
- 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.- 参数:
clazz
- the class to check- 返回:
- 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.- 参数:
clazz
- the class to check- 返回:
- the original class, or a primitive wrapper for the original primitive type
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.- 参数:
lhsType
- the target typerhsType
- the value type that should be assigned to the target type- 返回:
- if the target type is assignable from the value type
- 另请参阅:
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.- 参数:
type
- the target typevalue
- the value that should be assigned to the type- 返回:
- 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.- 参数:
resourcePath
- the resource path pointing to a class- 返回:
- 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.- 参数:
className
- the fully qualified class name- 返回:
- the corresponding resource path, pointing to the class
addResourcePathToPackagePath
public static String addResourcePathToPackagePath(Class<?> clazz, String resourceName)
Return a path suitable for use withClassLoader.getResource
(also suitable for use withClass.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, althoughClassPathResource
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.- 返回:
- the built-up resource path
- 另请参阅:
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 toClassLoader.getResource()
. For it to be fed toClass.getResource
instead, a leading slash would also have to be prepended to the returned value.- 参数:
clazz
- the input class. Anull
value or the default (empty) package will result in an empty string ("") being returned.- 返回:
- a path which represents the package name
- 另请参阅:
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.- 参数:
classes
- an array of Class objects- 返回:
- a String of form "[com.foo.Bar, com.foo.Baz]"
- 另请参阅:
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.- 参数:
classes
- a Collection of Class objects (may benull
)- 返回:
- a String of form "[com.foo.Bar, com.foo.Baz]"
- 另请参阅:
AbstractCollection.toString()
toClassArray
public static Class<?>[] toClassArray(@Nullable Collection<Class<?>> collection)
Copy the givenCollection
into aClass
array.The
Collection
must containClass
elements only.- 参数:
collection
- theCollection
to copy- 返回:
- the
Class
array - 从以下版本开始:
- 3.1
- 另请参阅:
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.- 参数:
instance
- the instance to analyze for interfaces- 返回:
- 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.
- 参数:
clazz
- the class to analyze for interfaces- 返回:
- 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.
- 参数:
clazz
- the class to analyze for interfacesclassLoader
- the ClassLoader that the interfaces need to be visible in (may benull
when accepting all declared interfaces)- 返回:
- 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.- 参数:
instance
- the instance to analyze for interfaces- 返回:
- 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.
- 参数:
clazz
- the class to analyze for interfaces- 返回:
- 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.
- 参数:
clazz
- the class to analyze for interfacesclassLoader
- the ClassLoader that the interfaces need to be visible in (may benull
when accepting all declared interfaces)- 返回:
- 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.
- 参数:
interfaces
- the interfaces to mergeclassLoader
- the ClassLoader to create the composite Class in- 返回:
- the merged interface as Class
- 抛出:
IllegalArgumentException
- if the specified interfaces expose conflicting method signatures (or a similar constraint is violated)- 另请参阅:
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.- 参数:
clazz1
- the class to introspectclazz2
- the other class to introspect- 返回:
- the common ancestor (i.e. common superclass, one interface extending the other), or
null
if none found. If any of the given classes isnull
, the other class will be returned. - 从以下版本开始:
- 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.- 参数:
ifc
- the interface to check- 从以下版本开始:
- 5.0.3
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.- 返回:
true
if the supplied class is an inner class- 从以下版本开始:
- 5.0.5
- 另请参阅:
Class.isMemberClass()
isCglibProxy
@Deprecated public static boolean isCglibProxy(Object object)
已过时。as of 5.2, in favor of custom (possibly narrower) checksCheck whether the given object is a CGLIB proxy.- 参数:
object
- the object to check- 另请参阅:
isCglibProxyClass(Class)
,AopUtils.isCglibProxy(Object)
isCglibProxyClass
@Deprecated public static boolean isCglibProxyClass(@Nullable Class<?> clazz)
已过时。as of 5.2, in favor of custom (possibly narrower) checksCheck whether the specified class is a CGLIB-generated class.- 参数:
clazz
- the class to check- 另请参阅:
isCglibProxyClassName(String)
isCglibProxyClassName
@Deprecated public static boolean isCglibProxyClassName(@Nullable String className)
已过时。as of 5.2, in favor of custom (possibly narrower) checksCheck whether the specified class name is a CGLIB-generated class.- 参数:
className
- the class name to check
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.- 参数:
instance
- the instance to check- 返回:
- 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.- 参数:
clazz
- the class to check- 返回:
- the user-defined class
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.- 参数:
value
- the value to introspect- 返回:
- 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.- 参数:
clazz
- the class to checktypeName
- the type name to match
getShortName
public static String getShortName(String className)
Get the class name without the qualified package name.- 参数:
className
- the className to get the short name for- 返回:
- the class name of the class without the package name
- 抛出:
IllegalArgumentException
- if the className is empty
getShortName
public static String getShortName(Class<?> clazz)
Get the class name without the qualified package name.- 参数:
clazz
- the class to get the short name for- 返回:
- 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 an inner class.- 参数:
clazz
- the class- 返回:
- the short name rendered in a standard JavaBeans property format
- 另请参阅:
Introspector.decapitalize(String)
getClassFileName
public static String getClassFileName(Class<?> clazz)
Determine the name of the class file, relative to the containing package: e.g. "String.class"- 参数:
clazz
- the class- 返回:
- the file name of the ".class" file
getPackageName
public static String getPackageName(Class<?> clazz)
Determine the name of the package of the given class, e.g. "java.lang" for thejava.lang.String
class.- 参数:
clazz
- the class- 返回:
- 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, e.g. "java.lang" for thejava.lang.String
class name.- 参数:
fqClassName
- the fully-qualified class name- 返回:
- 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.- 参数:
clazz
- the class- 返回:
- 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.- 参数:
method
- the method- 返回:
- 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.- 参数:
method
- the methodclazz
- the clazz that the method is being invoked on (may benull
to indicate the method's declaring class)- 返回:
- the qualified name of the method
- 从以下版本开始:
- 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".- 参数:
clazz
- the clazz to analyzeparamTypes
- the parameter types of the method- 返回:
- whether the class has a corresponding constructor
- 另请参阅:
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 returnnull
).Essentially translates
NoSuchMethodException
tonull
.- 参数:
clazz
- the clazz to analyzeparamTypes
- the parameter types of the method- 返回:
- the constructor, or
null
if not found - 另请参阅:
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.- 参数:
clazz
- the clazz to analyzemethod
- the method to look for- 返回:
- whether the class has a corresponding method
- 从以下版本开始:
- 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".- 参数:
clazz
- the clazz to analyzemethodName
- the name of the methodparamTypes
- the parameter types of the method- 返回:
- whether the class has a corresponding method
- 另请参阅:
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 anIllegalStateException
).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
toIllegalStateException
.- 参数:
clazz
- the clazz to analyzemethodName
- the name of the methodparamTypes
- the parameter types of the method (may benull
to indicate any signature)- 返回:
- the method (never
null
) - 抛出:
IllegalStateException
- if the method has not been found- 另请参阅:
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 returnnull
).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
tonull
.- 参数:
clazz
- the clazz to analyzemethodName
- the name of the methodparamTypes
- the parameter types of the method (may benull
to indicate any signature)- 返回:
- the method, or
null
if not found - 另请参阅:
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.- 参数:
clazz
- the clazz to checkmethodName
- the name of the method- 返回:
- 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.- 参数:
clazz
- the clazz to checkmethodName
- the name of the method- 返回:
- 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. E.g. the method may beIFoo.bar()
and the target class may beDefaultFoo
. In this case, the method may beDefaultFoo.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. CallBridgeMethodResolver.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 benull
or may not even implement the method)- 返回:
- the specific target method, or the original method if the
targetClass
does not implement it - 另请参阅:
getInterfaceMethodIfPossible(java.lang.reflect.Method)
getInterfaceMethodIfPossible
public static Method getInterfaceMethodIfPossible(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.
- 参数:
method
- the method to be invoked, potentially from an implementation class- 返回:
- the corresponding interface method, or the original method if none found
- 从以下版本开始:
- 5.1
- 另请参阅:
getMostSpecificMethod(java.lang.reflect.Method, java.lang.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 theGroovyObject
interface (for interface methods; on an implementation class, implementations of theGroovyObject
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 check- 返回:
true
if the method can be considered as user-declared; [@code false} otherwise
getStaticMethod
@Nullable public static Method getStaticMethod(Class<?> clazz, String methodName, Class<?>... args)
Return a public static method of a class.- 参数:
clazz
- the class which defines the methodmethodName
- the static method nameargs
- the parameter types to the method- 返回:
- the static method, or
null
if no static method was found - 抛出:
IllegalArgumentException
- if the method name is blank or the clazz is null