io.leangen.graphql.util

Class ClassUtils

java.lang.Object

io.leangen.graphql.util.ClassUtils

public class ClassUtils
extends Object

Constructor Summary

Constructors

Constructor and Description
ClassUtils()

Method Summary

Modifier and Type	Method and Description
static AnnotatedType	addAnnotations(AnnotatedType type, Annotation[] annotations)
static void	checkIfResolvable(AnnotatedType declaringType, Member member) Check whether the member has resolvable type.
static boolean	containsTypeAnnotation(AnnotatedType type, Class<? extends Annotation> annotation)
static Method	findGetter(Class<?> type, String fieldName)
static List<AnnotatedType>	findImplementations(AnnotatedType superType, String... packages) Scans classpath for implementations/subtypes of the given AnnotatedType.
static List<Class>	findImplementations(Class superType, String... packages)
static Method	findSetter(Class<?> type, String fieldName, Class<?> fieldType)
static Class<?>	forName(String className)
static Annotation[]	getAllAnnotations(Stream<AnnotatedType> types)
static Set<Field>	getAnnotatedFields(Class<?> type, Class<? extends Annotation> annotation) Retrieves all public fields on the given class (same as Class.getFields()) annotated by the given annotation
static Set<Method>	getAnnotatedMethods(Class<?> type, Class<? extends Annotation> annotation) Retrieves all public methods on the given class (same as Class.getMethods()) annotated by the given annotation
static AnnotatedType	getCommonSuperType(List<AnnotatedType> types) Finds the most specific super type of all given types.
static List<Class<?>>	getCommonSuperTypes(List<Class> classes)
static String	getFieldNameFromGetter(Method getter)
static String	getFieldNameFromSetter(Method setter)
static AnnotatedType	getFieldType(Field field, AnnotatedType declaringType) Returns the exact annotated type of the field declared by the given type, with type variables resolved (if possible)
static <T> T	getFieldValue(Object source, String fieldName)
static AnnotatedType[]	getParameterTypes(Executable executable, AnnotatedType declaringType) Returns the exact annotated parameter types of the executable declared by the given type, with type variables resolved (if possible)
static Class<?>	getRawType(Type type)
static AnnotatedType	getReturnType(Method method, AnnotatedType declaringType) Returns the exact annotated return type of the method declared by the given type, with type variables resolved (if possible)
static Set<Class<?>>	getSuperTypes(Class<?> clazz)
static AnnotatedType[]	getTypeArguments(AnnotatedType type)
static boolean	isAbstract(AnnotatedType type)
static boolean	isAbstract(Class<?> type)
static boolean	isAssignable(Type superType, Type subType)
static boolean	isGetter(Method getter) Checks whether the given method is a JavaBean property getter
static boolean	isProxy(Class<?> clazz) Attempts to discover if the given class is a dynamically generated proxy class.
static boolean	isSetter(Method setter) Checks whether the given method is a JavaBean property setter
static AnnotatedType	stripBounds(AnnotatedType type) Recursively replaces all bounded types found within the structure of the given AnnotatedType with their first bound.
static String	toString(AnnotatedType type)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ClassUtils

public ClassUtils()

Method Detail

getAnnotatedMethods

public static Set<Method> getAnnotatedMethods(Class<?> type,
                                              Class<? extends Annotation> annotation)

Retrieves all public methods on the given class (same as Class.getMethods()) annotated by the given annotation

Parameters:

type - The class to scan

annotation - The annotation to look for

Returns:

All annotated methods

getAnnotatedFields

public static Set<Field> getAnnotatedFields(Class<?> type,
                                            Class<? extends Annotation> annotation)

Retrieves all public fields on the given class (same as Class.getFields()) annotated by the given annotation

Parameters:

type - The class to scan

annotation - The annotation to look for

Returns:

All annotated fields

getReturnType

public static AnnotatedType getReturnType(Method method,
                                          AnnotatedType declaringType)

Returns the exact annotated return type of the method declared by the given type, with type variables resolved (if possible)

Parameters:

method - The method whose return type is to be resolved

declaringType - The declaring annotated type against which to resolve the return type

Returns:

The resolved annotated return type

getFieldType

public static AnnotatedType getFieldType(Field field,
                                         AnnotatedType declaringType)

Returns the exact annotated type of the field declared by the given type, with type variables resolved (if possible)

Parameters:

field - The field whose type is to be resolved

declaringType - The declaring annotated type against which to resolve the field type

Returns:

The resolved annotated field type

getTypeArguments

public static AnnotatedType[] getTypeArguments(AnnotatedType type)

getParameterTypes

public static AnnotatedType[] getParameterTypes(Executable executable,
                                                AnnotatedType declaringType)

Returns the exact annotated parameter types of the executable declared by the given type, with type variables resolved (if possible)

Parameters:

executable - The executable whose parameter types are to be resolved

declaringType - The declaring annotated type against which to resolve the types of the parameters of the given executable

Returns:

The resolved annotated types of the parameters of the given executable

getRawType

public static Class<?> getRawType(Type type)

checkIfResolvable

public static void checkIfResolvable(AnnotatedType declaringType,
                                     Member member)

Check whether the member has resolvable type. A convenience method for easier fail-fast logic.

Parameters:

declaringType - The type declaring the member (against which the member's type will be resolved)

member - The field of method to be checked

isGetter

public static boolean isGetter(Method getter)

Checks whether the given method is a JavaBean property getter

Parameters:

getter - The method to be checked

Returns:

Boolean indicating whether the method is a getter

See Also:

isSetter(Method)

isSetter

public static boolean isSetter(Method setter)

Checks whether the given method is a JavaBean property setter

Parameters:

setter - The method to be checked

Returns:

Boolean indicating whether the method is a setter

See Also:

isGetter(Method)

getFieldNameFromGetter

public static String getFieldNameFromGetter(Method getter)

getFieldNameFromSetter

public static String getFieldNameFromSetter(Method setter)

findGetter

public static Method findGetter(Class<?> type,
                                String fieldName)
                         throws NoSuchMethodException

Throws:

NoSuchMethodException

findSetter

public static Method findSetter(Class<?> type,
                                String fieldName,
                                Class<?> fieldType)
                         throws NoSuchMethodException

Throws:

NoSuchMethodException

getFieldValue

public static <T> T getFieldValue(Object source,
                                  String fieldName)

findImplementations

public static List<AnnotatedType> findImplementations(AnnotatedType superType,
                                                      String... packages)

Scans classpath for implementations/subtypes of the given AnnotatedType. Only the matching classes are loaded.

Parameters:

superType - The type whose implementations/subtypes are to be looked for

Returns:

A collection of AnnotatedTypes found on the classpath that are implementations/subtypes of superType

Throws:

RuntimeException - If a class file could not be parsed or a class could not be loaded

findImplementations

public static List<Class> findImplementations(Class superType,
                                              String... packages)

isAbstract

public static boolean isAbstract(AnnotatedType type)

isAbstract

public static boolean isAbstract(Class<?> type)

isAssignable

public static boolean isAssignable(Type superType,
                                   Type subType)

toString

public static String toString(AnnotatedType type)

containsTypeAnnotation

public static boolean containsTypeAnnotation(AnnotatedType type,
                                             Class<? extends Annotation> annotation)

getAllAnnotations

public static Annotation[] getAllAnnotations(Stream<AnnotatedType> types)

addAnnotations

public static AnnotatedType addAnnotations(AnnotatedType type,
                                           Annotation[] annotations)

stripBounds

public static AnnotatedType stripBounds(AnnotatedType type)

Recursively replaces all bounded types found within the structure of the given AnnotatedType with their first bound. I.e.

• All AnnotatedWildcardTypes are replaced with their first lower bound if it exists, or their first upper bound otherwise. All annotations are preserved.
• All AnnotatedTypeVariables are replaced with their first bound. All annotations are preserved.
• Other types are kept as they are.

Parameters:

type - A potentially bounded type

Returns:

The first bound of bounded types, or the unchanged type itself

getCommonSuperType

public static AnnotatedType getCommonSuperType(List<AnnotatedType> types)

Finds the most specific super type of all given types. Currently broken, so it is expected all provided types are actually the same.

Parameters:

types - Types whose most specific super types is to be found

Returns:

The most specific super type

getCommonSuperTypes

public static List<Class<?>> getCommonSuperTypes(List<Class> classes)

Parameters:

classes - Types whose most specific super types is to be found

Returns:

The most specific super type

See Also:

getCommonSuperType(List)

getSuperTypes

public static Set<Class<?>> getSuperTypes(Class<?> clazz)

isProxy

public static boolean isProxy(Class<?> clazz)

Attempts to discover if the given class is a dynamically generated proxy class. Standard Java proxies, cglib and Javassist proxies are detected.

Parameters:

clazz - The class to test

Returns:

true if the given class is a known proxy, false otherwise

forName

public static Class<?> forName(String className)
                        throws ClassNotFoundException

Throws:

ClassNotFoundException