com.blazebit.reflection

Class ReflectionUtils

java.lang.Object

com.blazebit.reflection.ReflectionUtils

public final class ReflectionUtils
extends Object

Utillity class for reflection specific actions. This class only uses basic reflection mechanisms provided by the Reflection API. It provides methods that are missing in the standard API and Apache Commons Utils.

Since:

0.1.2

Author:

Christian Beikov

Method Summary

Modifier and Type	Method and Description
static Class<?>	getClass(String className) Returns the class object for the specified qualified class name.
static Field	getField(Class<?> clazz, String fieldName) Returns the field object found for the given field name in the given class.
static Class<?>	getFieldType(Class<?> clazz, String fieldName) Returns the type of a field if it exists within the class.
static Method	getGetter(Class<?> clazz, String fieldName) Retrieves the getter method of the given class for the specified field name.
static Field[]	getInstanceFields(Class<?> clazz) Returns the static field objects that are declared in the given class or any of it's super types.
static Field[]	getMatchingFields(Class<?> clazz, int modifiers) Returns the field objects that are declared in the given class or any of it's super types that have any of the given modifiers.
static Method	getMethod(Class<?> clazz, Class<? extends Annotation> annotation) Returns the method object for a method which is annotated with the given annotation of the given class.
static Method	getMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes) Returns the method object found for the given method name in the given class.
static MethodException[]	getMethodExceptions(Class<?> clazz, Method m)
static MethodException[]	getMethodExceptions(Class<?> clazz, String methodName, Class<?>... parameterTypes)
static Class<?>[]	getMethodExceptionTypes(Class<?> clazz, String methodName, Class<?>... parameterTypes)
static MethodParameter[]	getMethodParameters(Class<?> clazz, Method m)
static MethodParameter[]	getMethodParameters(Class<?> clazz, String methodName, Class<?>... parameterTypes)
static Class<?>[]	getMethodParameterTypes(Class<?> clazz, String methodName, Class<?>... parameterTypes)
static Class<?>	getMethodReturnType(Class<?> clazz, String methodName, Class<?>... parameterTypes) Returns the return type of a method if it exists within the class.
static List<Method>	getMethods(Class<?> clazz, Class<? extends Annotation> annotation) Returns the method objects for methods which are annotated with the given annotation of the given class.
static Field[]	getNonMatchingFields(Class<?> clazz, int modifiers) Returns the field objects that are declared in the given class or any of it's super types that have none of the given modifiers.
static Class<?>	getObjectClassOfPrimitve(Class<?> primitive) Returns the wrapper class of the given primitive class or the given class.
static Class<?>	getPrimitiveClassOfWrapper(Class<?> wrapperClass) Returns the primitive class of the given wrapper class or null.
static Class<?>	getResolvedFieldType(Class<?> clazz, Field f)
static Class<?>	getResolvedFieldType(Class<?> clazz, String fieldName)
static Class<?>[]	getResolvedFieldTypeArguments(Class<?> clazz, Field f)
static Class<?>[]	getResolvedFieldTypeArguments(Class<?> clazz, String fieldName)
static Class<?>[]	getResolvedMethodExceptionTypes(Class<?> clazz, Method m)
static Class<?>[]	getResolvedMethodExceptionTypes(Class<?> clazz, String methodName, Class<?>... parameterTypes)
static Class<?>[]	getResolvedMethodParameterTypes(Class<?> clazz, Method m)
static Class<?>[]	getResolvedMethodParameterTypes(Class<?> clazz, String methodName, Class<?>... parameterTypes)
static Class<?>[][]	getResolvedMethodParameterTypesArguments(Class<?> clazz, Method method)
static Class<?>[][]	getResolvedMethodParameterTypesArguments(Class<?> clazz, String methodName, Class<?>... parameterTypes)
static Class<?>	getResolvedMethodReturnType(Class<?> clazz, Method m)
static Class<?>	getResolvedMethodReturnType(Class<?> clazz, String methodName, Class<?>... parameterTypes)
static Class<?>[]	getResolvedMethodReturnTypeArguments(Class<?> clazz, Method m)
static Class<?>[]	getResolvedMethodReturnTypeArguments(Class<?> clazz, String methodName, Class<?>... parameterTypes)
static Method	getSetter(Class<?> clazz, String fieldName) Retrieves the setter method of the given class for the specified field name.
static Field[]	getStaticFields(Class<?> clazz) Returns the static field objects that are declared in the given class or any of it's super types.
static Set<Class<?>>	getSuperTypes(Class<?> clazz) Retrieves all super types of the given class type.
static Set<Class<?>>	getSuperTypes(Class<?> clazz, Class<?> commonSuperType)
static int	getTypeVariablePosition(GenericDeclaration genericDeclartion, TypeVariable<?> typeVariable) Tries to find the position of the given type variable in the type parameters of the given class.
static int	getTypeVariablePosition(TypeVariable<?> typeVariable) Returns the position of the type variable for the class in which it is declared.
static Class<?>	getWrapperClassOfPrimitve(Class<?> primitive) Returns the wrapper class of the given primitive class or null.
static boolean	isGetter(Method m)
static boolean	isSetter(Method m)
static boolean	isSubtype(Class<?> targetClazz, Class<?> superType) Checks if the target class is a subtype of the supertype or not.
static Type	resolve(Class<?> concreteClass, Type type)
static Class<?>	resolveType(Class<?> concreteClass, Type type)
static Class<?>[]	resolveTypeArguments(Class<?> concreteClass, ParameterizedType parameterizedType)
static Class<?>[]	resolveTypeArguments(Class<?> concreteClass, Type type)
static Class<?>	resolveTypeVariable(Class<?> concreteClass, TypeVariable<?> typeVariable) Tries to resolve the type variable against the concrete class.
static Type	resolveTypeVariableType(Class<?> concreteClass, TypeVariable<?> typeVariable) Tries to resolve the type variable against the concrete class.

Methods inherited from class java.lang.Object

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

Method Detail

getClass

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

Returns the class object for the specified qualified class name. Calling this method is equal to #Class.forName(java.lang.String) except that also primitive types can be get via this method. The names for the primitive types needed for this method are equal to the type literals used in the java language.

Example:

ReflectionUtil.getClass("void").equals(void.class) ReflectionUtil.getClass("int").equals(int.class)

Parameters:

className -

Returns:

Throws:

ClassNotFoundException

getObjectClassOfPrimitve

public static Class<?> getObjectClassOfPrimitve(Class<?> primitive)

Returns the wrapper class of the given primitive class or the given class.

Parameters:

primitive - The primitive class

Returns:

The wrapper class or the given class

getWrapperClassOfPrimitve

public static Class<?> getWrapperClassOfPrimitve(Class<?> primitive)

Returns the wrapper class of the given primitive class or null.

Parameters:

primitive - The primitive class

Returns:

The wrapper class or null

getPrimitiveClassOfWrapper

public static Class<?> getPrimitiveClassOfWrapper(Class<?> wrapperClass)

Returns the primitive class of the given wrapper class or null.

Parameters:

wrapperClass - The wrapper class

Returns:

The primitive class or null

isSubtype

public static boolean isSubtype(Class<?> targetClazz,
                                Class<?> superType)

Checks if the target class is a subtype of the supertype or not. Basically this method calls @link{java.lang.Class#isAssignableFrom(Class)} and therefore only acts as an alias.

Parameters:

targetClazz - the class to check wether it is a subtype of the supertype or not

superType - the supertype class

Returns:

true if targetClazz is subtype of superType or targetClazz equals superType, otherwise false

getSuperTypes

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

Retrieves all super types of the given class type. Super types are all types the given class extends or implements. The given class type is also included in the set. The iteration order of the set has to be from most concrete to most general.

Parameters:

clazz - The class from which the super types should be retrieved

Returns:

The super types of the given class

getSuperTypes

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

getFieldType

public static Class<?> getFieldType(Class<?> clazz,
                                    String fieldName)

Returns the type of a field if it exists within the class. Calling this method is equal to calling # getField(java.lang.Class, java.lang.String) with a null check and finally return the type via getType().

Parameters:

clazz - The class within to look for the field with the given field name

fieldName - The name of the field to be returned

Returns:

The type of the field if it can be found, otherwise null

See Also:

getField(java.lang.Class, java.lang.String)

getResolvedFieldType

public static Class<?> getResolvedFieldType(Class<?> clazz,
                                            String fieldName)

getResolvedFieldType

public static Class<?> getResolvedFieldType(Class<?> clazz,
                                            Field f)

getResolvedFieldTypeArguments

public static Class<?>[] getResolvedFieldTypeArguments(Class<?> clazz,
                                                       String fieldName)

getResolvedFieldTypeArguments

public static Class<?>[] getResolvedFieldTypeArguments(Class<?> clazz,
                                                       Field f)

resolveTypeArguments

public static Class<?>[] resolveTypeArguments(Class<?> concreteClass,
                                              Type type)

resolveTypeArguments

public static Class<?>[] resolveTypeArguments(Class<?> concreteClass,
                                              ParameterizedType parameterizedType)

resolve

public static Type resolve(Class<?> concreteClass,
                           Type type)

resolveType

public static Class<?> resolveType(Class<?> concreteClass,
                                   Type type)

resolveTypeVariableType

public static Type resolveTypeVariableType(Class<?> concreteClass,
                                           TypeVariable<?> typeVariable)

Tries to resolve the type variable against the concrete class. The concrete class has to be a subtype of the type in which the type variable has been declared. This method tries to resolve the given type variable by inspecting the subclasses of the class in which the type variable was declared and as soon as the resolved type is instance of java.lang.Class it stops and returns that class.

Parameters:

concreteClass - The class which is used to resolve the type. The type for the type variable must be bound in this class or a superclass.

typeVariable - The type variable to resolve.

Returns:

The resolved type

Throws:

IllegalArgumentException - Is thrown when the concrete class is not a subtype of the class in which the type variable has been declared.

resolveTypeVariable

public static Class<?> resolveTypeVariable(Class<?> concreteClass,
                                           TypeVariable<?> typeVariable)

Tries to resolve the type variable against the concrete class. The concrete class has to be a subtype of the type in which the type variable has been declared. This method tries to resolve the given type variable by inspecting the subclasses of the class in which the type variable was declared and as soon as the resolved type is instance of java.lang.Class it stops and returns that class.

Parameters:

concreteClass - The class which is used to resolve the type. The type for the type variable must be bound in this class or a superclass.

typeVariable - The type variable to resolve.

Returns:

The resolved type as class

Throws:

IllegalArgumentException - Is thrown when the concrete class is not a subtype of the class in which the type variable has been declared.

getTypeVariablePosition

public static int getTypeVariablePosition(TypeVariable<?> typeVariable)

Returns the position of the type variable for the class in which it is declared.

Parameters:

typeVariable - The type variable for which the position should be retrieved

Returns:

The position of the type variable within the class in which it is declared.

getTypeVariablePosition

public static int getTypeVariablePosition(GenericDeclaration genericDeclartion,
                                          TypeVariable<?> typeVariable)

Tries to find the position of the given type variable in the type parameters of the given class. This method iterates through the type parameters of the given class and tries to find the given type variable within the type parameters. When the type variable is found, the position is returned, otherwise -1.

Parameters:

genericDeclartion - The generic declartion type in which to look for the type variable

typeVariable - The type variable to look for in the given class type parameters

Returns:

The position of the given type variable within the type parameters of the given class if found, otherwise -1

getInstanceFields

public static Field[] getInstanceFields(Class<?> clazz)

Returns the static field objects that are declared in the given class or any of it's super types. Calling this method is equivalent to a call to getNonMatchingFields(Class, int) with the modifiers Modifier.STATIC.

Parameters:

clazz - The class within to look for the fields with the given modifiers

Returns:

The array of static fields that are within the type hierarchy of the given class

getStaticFields

public static Field[] getStaticFields(Class<?> clazz)

Returns the static field objects that are declared in the given class or any of it's super types. Calling this method is equivalent to a call to getMatchingFields(Class, int) with the modifiers Modifier.STATIC.

Parameters:

clazz - The class within to look for the fields with the given modifiers

Returns:

The array of static fields that are within the type hierarchy of the given class

getMatchingFields

public static Field[] getMatchingFields(Class<?> clazz,
                                        int modifiers)

Returns the field objects that are declared in the given class or any of it's super types that have any of the given modifiers. The type hierarchy is traversed upwards and all declared fields that match the given modifiers are added to the result array. The elements in the array are sorted by their names and declaring classes.

Parameters:

clazz - The class within to look for the fields with the given modifiers

modifiers - The OR-ed together modifiers that a field must match to be included into the result

Returns:

The array of fields that match the modifiers and are within the type hierarchy of the given class

getNonMatchingFields

public static Field[] getNonMatchingFields(Class<?> clazz,
                                           int modifiers)

Returns the field objects that are declared in the given class or any of it's super types that have none of the given modifiers. The type hierarchy is traversed upwards and all declared fields that do not match the given modifiers are added to the result array. The elements in the array are sorted by their names and declaring classes.

Parameters:

clazz - The class within to look for the fields with the given modifiers

modifiers - The OR-ed together modifiers that a field must not match to be included into the result

Returns:

The array of fields that do not match the modifiers and are within the type hierarchy of the given class

getField

public static Field getField(Class<?> clazz,
                             String fieldName)

Returns the field object found for the given field name in the given class. This method traverses through the super classes of the given class and tries to find the field as declared field within these classes. When the object class is reached the traversing stops. If the field can not be found, null is returned.

Parameters:

clazz - The class within to look for the field with the given field name

fieldName - The name of the field to be returned

Returns:

The field object with the given field name if the field can be found, otherwise null

getMethodReturnType

public static Class<?> getMethodReturnType(Class<?> clazz,
                                           String methodName,
                                           Class<?>... parameterTypes)

Returns the return type of a method if it exists within the class. Calling this method is equal to calling getMethod(Class, String, Class[]) with a null check and finally return the type via getReturnType().

Parameters:

clazz - The class within to look for the method with the given method name

methodName - The name of the method to be returned

parameterTypes - The accepting parameter types of the method

Returns:

The return type of the method if it can be found, otherwise null

See Also:

getMethod(Class, String, Class[])

getMethodParameterTypes

public static Class<?>[] getMethodParameterTypes(Class<?> clazz,
                                                 String methodName,
                                                 Class<?>... parameterTypes)

getMethodExceptionTypes

public static Class<?>[] getMethodExceptionTypes(Class<?> clazz,
                                                 String methodName,
                                                 Class<?>... parameterTypes)

getResolvedMethodReturnType

public static Class<?> getResolvedMethodReturnType(Class<?> clazz,
                                                   String methodName,
                                                   Class<?>... parameterTypes)

getResolvedMethodReturnType

public static Class<?> getResolvedMethodReturnType(Class<?> clazz,
                                                   Method m)

getResolvedMethodReturnTypeArguments

public static Class<?>[] getResolvedMethodReturnTypeArguments(Class<?> clazz,
                                                              String methodName,
                                                              Class<?>... parameterTypes)

getResolvedMethodReturnTypeArguments

public static Class<?>[] getResolvedMethodReturnTypeArguments(Class<?> clazz,
                                                              Method m)

getResolvedMethodParameterTypes

public static Class<?>[] getResolvedMethodParameterTypes(Class<?> clazz,
                                                         String methodName,
                                                         Class<?>... parameterTypes)

getResolvedMethodParameterTypes

public static Class<?>[] getResolvedMethodParameterTypes(Class<?> clazz,
                                                         Method m)

getResolvedMethodParameterTypesArguments

public static Class<?>[][] getResolvedMethodParameterTypesArguments(Class<?> clazz,
                                                                    String methodName,
                                                                    Class<?>... parameterTypes)

getResolvedMethodParameterTypesArguments

public static Class<?>[][] getResolvedMethodParameterTypesArguments(Class<?> clazz,
                                                                    Method method)

getResolvedMethodExceptionTypes

public static Class<?>[] getResolvedMethodExceptionTypes(Class<?> clazz,
                                                         String methodName,
                                                         Class<?>... parameterTypes)

getResolvedMethodExceptionTypes

public static Class<?>[] getResolvedMethodExceptionTypes(Class<?> clazz,
                                                         Method m)

getMethodParameters

public static MethodParameter[] getMethodParameters(Class<?> clazz,
                                                    String methodName,
                                                    Class<?>... parameterTypes)

getMethodParameters

public static MethodParameter[] getMethodParameters(Class<?> clazz,
                                                    Method m)

getMethodExceptions

public static MethodException[] getMethodExceptions(Class<?> clazz,
                                                    String methodName,
                                                    Class<?>... parameterTypes)

getMethodExceptions

public static MethodException[] getMethodExceptions(Class<?> clazz,
                                                    Method m)

getMethod

public static Method getMethod(Class<?> clazz,
                               String methodName,
                               Class<?>... parameterTypes)

Returns the method object found for the given method name in the given class. This method traverses through the super classes of the given class and tries to find the method as declared method within these classes. When the object class is reached the traversing stops. If the method can not be found, null is returned.

Parameters:

clazz - The class within to look for the method with the given method name

methodName - The name of the method to be returned

parameterTypes - The accepting parameter types of the method

Returns:

The method object with the given method name if the method can be found, otherwise null

getMethod

public static Method getMethod(Class<?> clazz,
                               Class<? extends Annotation> annotation)

Returns the method object for a method which is annotated with the given annotation of the given class. This method traverses through the super classes of the given class and tries to find the method as declared method within these classes that is annotated with an annotation of the given annotation type. When the object class is reached the traversing stops. If the method can not be found, null is returned. This methods immediatelly returns the first method found that is annotated with an annotation of the given type. To retrieve all methods annotated with the given annotation type see getMethods(java.lang.Class, java.lang.Class)

Parameters:

clazz - The class within to look for the method

annotation - The annotation type a method must be annotated with to be returned

Returns:

The method object for the method annotated with the given annotation type if the method can be found, otherwise null

getMethods

public static List<Method> getMethods(Class<?> clazz,
                                      Class<? extends Annotation> annotation)

Returns the method objects for methods which are annotated with the given annotation of the given class. This method traverses through the super classes of the given class and tries to find methods as declared methods within these classes which are annotated with an annotation of the given annotation type. When the object class is reached the traversing stops. If no methods can be found, an empty list is returned. The order of the methods is random.

Parameters:

clazz - The class within to look for the methods

annotation - The annotation type a method must be annotated with to be included in the list

Returns:

A list of method objects for methods annotated with the given annotation type or an emtpy list

getGetter

public static Method getGetter(Class<?> clazz,
                               String fieldName)

Retrieves the getter method of the given class for the specified field name. The method first tries to find the getFieldName method of the class and if it can not find that method it looks for the isFieldName method. If this method also can not be found, null is returned.

This method uses # getMethodReturnType(Class, String, Class...) to retrieve the getter.

A getter must not have any parameters and must have a return type that is different from void.

Parameters:

clazz - The class within to look for the getter method

fieldName - The field name for which to find the getter method

Returns:

The getter method for the given fieldName if it can be found, otherwise null

isGetter

public static boolean isGetter(Method m)

getSetter

public static Method getSetter(Class<?> clazz,
                               String fieldName)

Retrieves the setter method of the given class for the specified field name. The method traverses through all methods of all types that are in the inheritance hierarchie of the given class and tries to find a setter method with the return type void and exactly one parameter. If that method can not be found, null is returned.

A setter must have void return type and accept exactly one parameter.

Parameters:

clazz - The class within to look for the setter method

fieldName - The field name for which to find the setter method

Returns:

The setter method for the given fieldName if it can be found, otherwise null

isSetter

public static boolean isSetter(Method m)