org.glassfish.jersey.internal.util
Class ReflectionHelper

java.lang.Object
  org.glassfish.jersey.internal.util.ReflectionHelper

public class ReflectionHelper
extends Object

Utility methods for Java reflection.

Author:

Paul Sandoz

Nested Class Summary

static class

ReflectionHelper.DeclaringClassInterfacePair A tuple consisting of a concrete class and a declaring class that declares a generic interface type.

Method Summary

static <T> Class<T>	classForName(String name) Get the Class from the class name.
static <T> Class<T>	classForName(String name, ClassLoader cl) Get the Class from the class name.
static <T> Class<T>	classForNameWithException(String name) Get the Class from the class name.
static <T> Class<T>	classForNameWithException(String name, ClassLoader cl) Get the Class from the class name.
static <T> Class<T>	erasure(Type type) Get the Class representation of the given type.
static Method	findMethodOnClass(Class<?> c, Method m) Find a method on a class given an existing method.
static Collection<Class<? extends Annotation>>	getAnnotationTypes(AnnotatedElement annotatedElement, Class<? extends Annotation> metaAnnotation) Returns collection of all annotation types attached to a given annotated element that have the provided meta annotation attached.
static Type	getArrayComponentType(Type type) Gets the component type of the array.
static Class<?>	getArrayForComponentType(Class<?> c) Get Array class of component type.
static ReflectionHelper.DeclaringClassInterfacePair	getClass(Class<?> concrete, Class<?> iface) Find the declaring class that implements or extends an interface.
static ClassLoader	getContextClassLoader() Get the context class loader.
static Class<?>	getDeclaringClass(AccessibleObject ao) Get the declaring class of an accessible object.
static Method	getFromStringStringMethod(Class<?> c) Get the static fromString(String ) method.
static List<Class<?>>	getGenericTypeArgumentClasses(Type type) Get the list of classes that represent the type arguments of a parameterized input type.
static OsgiRegistry	getOsgiRegistryInstance() Returns an OsgiRegistry instance.
static Class[]	getParameterizedClassArguments(ReflectionHelper.DeclaringClassInterfacePair p) Get the parameterized class arguments for a declaring class that declares a generic interface type.
static Type[]	getParameterizedTypeArguments(ReflectionHelper.DeclaringClassInterfacePair p) Get the parameterized type arguments for a declaring class that declares a generic interface type.
static InputStream	getResourceAsStream(ClassLoader loader, Class<?> originClass, String name) Lookup resource by given name.
static Constructor	getStringConstructor(Class<?> c) Get the constructor that has a single parameter of String.
static Type	getTypeArgument(Type type, int index) Get a type argument at particular index for a parameterized type.
static List<ClassTypePair>	getTypeArgumentAndClass(Type type) Get the list of class-type pairs that represent the type arguments of a parameterized input type.
static Type[]	getTypeArguments(Type type) Get the type arguments for a parameterized type.
static Method	getValueOfStringMethod(Class<?> c) Get the static valueOf(String ) method.
static boolean	isArray(Type type) Checks if the type is an array type.
static boolean	isArrayOfType(Type type, Class<?> componentType) Checks if the type is an array of a given component type.
static boolean	isPrimitive(Type type) Check if the given type is a primitive type.
static boolean	isSubClassOf(Type subType, Type superType) Check if subType is a sub-type of superType.
static String	methodInstanceToString(Object o, Method m) Create a string representation of a method and an instance whose class implements the method.
static String	objectToString(Object o) Create a string representation of an object.
static ClassTypePair	resolveGenericType(Class concreteClass, Class declaringClass, Class rawResolvedType, Type genericResolvedType) Resolve generic type parameter(s) of a raw class and it's generic type based on the class that declares the generic type parameter(s) to be resolved and a concrete implementation of the declaring class.
static ClassTypePair	resolveTypeVariable(Class<?> c, Class<?> dc, TypeVariable tv) Given a type variable resolve the Java class of that variable.
static void	setAccessibleMethod(Method m) Set a method to be accessible.

Methods inherited from class java.lang.Object

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

Method Detail

getDeclaringClass

public static Class<?> getDeclaringClass(AccessibleObject ao)

Get the declaring class of an accessible object. Supported are Method, Field and Constructor accessible object types.

Parameters:

ao - an accessible object.

Returns:

the declaring class of an accessible object.

Throws:

IllegalArgumentException - in case the type of the accessible object is not supported.

objectToString

public static String objectToString(Object o)

Create a string representation of an object.

Returns a string consisting of the name of the class of which the object is an instance, the at-sign character '@', and the unsigned hexadecimal representation of the hash code of the object. In other words, this method returns a string equal to the value of:

 o.getClass().getName() + '@' + Integer.toHexString(o.hashCode())
 

Parameters:

o - the object.

Returns:

the string representation of the object.

methodInstanceToString

public static String methodInstanceToString(Object o,
                                            Method m)

Create a string representation of a method and an instance whose class implements the method.

Returns a string consisting of the name of the class of which the object is an instance, the at-sign character '@', the unsigned hexadecimal representation of the hash code of the object, the character '.', the name of the method, the character '(', the list of method parameters, and the character ')'. In other words, those method returns a string equal to the value of:

 o.getClass().getName() + '@' + Integer.toHexString(o.hashCode()) +
 '.' + m.getName() + '(' + <parameters> + ')'.
 

Parameters:

o - the object whose class implements m.

m - the method.

Returns:

the string representation of the method and instance.

classForName

public static <T> Class<T> classForName(String name)

Get the Class from the class name.

The context class loader will be utilized if accessible and non-null. Otherwise the defining class loader of this class will be utilized.

Type Parameters:

T - class type.

Parameters:

name - the class name.

Returns:

the Class, otherwise null if the class cannot be found.

classForName

public static <T> Class<T> classForName(String name,
                                        ClassLoader cl)

Get the Class from the class name.

Type Parameters:

T - class type.

Parameters:

name - the class name.

cl - the class loader to use, if null then the defining class loader of this class will be utilized.

Returns:

the Class, otherwise null if the class cannot be found.

classForNameWithException

public static <T> Class<T> classForNameWithException(String name)
                                          throws ClassNotFoundException

Get the Class from the class name.

The context class loader will be utilized if accessible and non-null. Otherwise the defining class loader of this class will be utilized.

Type Parameters:

T - class type.

Parameters:

name - the class name.

Returns:

the Class, otherwise null if the class cannot be found.

Throws:

ClassNotFoundException - if the class cannot be found.

classForNameWithException

public static <T> Class<T> classForNameWithException(String name,
                                                     ClassLoader cl)
                                          throws ClassNotFoundException

Get the Class from the class name.

Type Parameters:

T - class type.

Parameters:

name - the class name.

cl - the class loader to use, if null then the defining class loader of this class will be utilized.

Returns:

the Class, otherwise null if the class cannot be found.

Throws:

ClassNotFoundException - if the class cannot be found.

getContextClassLoader

public static ClassLoader getContextClassLoader()

Get the context class loader.

Returns:

the context class loader, otherwise null security privileges are not set.

setAccessibleMethod

public static void setAccessibleMethod(Method m)

Set a method to be accessible.

Parameters:

m - the method to be set as accessible

getGenericTypeArgumentClasses

public static List<Class<?>> getGenericTypeArgumentClasses(Type type)
                                                    throws IllegalArgumentException

Get the list of classes that represent the type arguments of a parameterized input type.

For any given argument in the returned list, following rules apply:

• If a type argument is a class then the class is returned.
• If the type argument is a generic array type and the generic component type is a class then class of the array is returned.
• If the type argument is a parameterized type and it's raw type is a class then that class is returned.

If the type is not an instance of ParameterizedType an empty list is returned.

Parameters:

type - parameterized type.

Returns:

the list of classed representing the actual type arguments. May be empty, but may never be null.

Throws:

IllegalArgumentException - if any of the generic type arguments is not a class, or a generic array type, or the generic component type of the generic array type is not class, or not a parameterized type with a raw type that is not a class.

getTypeArgumentAndClass

public static List<ClassTypePair> getTypeArgumentAndClass(Type type)
                                                   throws IllegalArgumentException

Get the list of class-type pairs that represent the type arguments of a parameterized input type.

For any given class part of each pair in the returned list, following rules apply:

• If a type argument is a class then the class is returned as raw class.
• If the type argument is a generic array type and the generic component type is a class then class of the array is returned as raw class.
• If the type argument is a parameterized type and it's raw type is a class then that class is returned as raw class.

If the type is not an instance of ParameterizedType an empty list is returned.

Parameters:

type - parameterized type.

Returns:

the list of class-type pairs representing the actual type arguments. May be empty, but may never be null.

Throws:

IllegalArgumentException - if any of the generic type arguments is not a class, or a generic array type, or the generic component type of the generic array type is not class, or not a parameterized type with a raw type that is not a class.

isPrimitive

public static boolean isPrimitive(Type type)

Check if the given type is a primitive type.

Parameters:

type - type to be checked.

getTypeArguments

public static Type[] getTypeArguments(Type type)

Get the type arguments for a parameterized type. In case the type is not a parameterized type, the method returns null.

Parameters:

type - parameterized type.

Returns:

type arguments for a parameterized type, or null in case the input type is not a parameterized type.

getTypeArgument

public static Type getTypeArgument(Type type,
                                   int index)

Get a type argument at particular index for a parameterized type. In case the type is not a parameterized type, the method returns null.

Parameters:

type - parameterized type.

index - type parameter index.

Returns:

type argument for a parameterized type at a given index, or null in case the input type is not a parameterized type.

erasure

public static <T> Class<T> erasure(Type type)

Get the Class representation of the given type. This corresponds to the notion of the erasure in JSR-14.

Parameters:

type - type to provide the erasure for.

Returns:

the given type's erasure.

isSubClassOf

public static boolean isSubClassOf(Type subType,
                                   Type superType)

Check if subType is a sub-type of superType.

Parameters:

subType - sub-type type.

superType - super-type type.

Returns:

true in case the subType is a sub-type of superType, false otherwise.

isArray

public static boolean isArray(Type type)

Checks if the type is an array type.

Parameters:

type - type to check.

Returns:

true in case the type is an array type, false otherwise.

isArrayOfType

public static boolean isArrayOfType(Type type,
                                    Class<?> componentType)

Checks if the type is an array of a given component type.

Parameters:

type - type to check.

componentType - array component type.

Returns:

true in case the type is an array type of a given component type, false otherwise.

getArrayComponentType

public static Type getArrayComponentType(Type type)

Gets the component type of the array.

Parameters:

type - must be an array.

Returns:

array component type.

Throws:

IllegalArgumentException - in case the type is not an array type.

getArrayForComponentType

public static Class<?> getArrayForComponentType(Class<?> c)

Get Array class of component type.

Parameters:

c - the component class of the array

Returns:

the array class.

getValueOfStringMethod

public static Method getValueOfStringMethod(Class<?> c)

Get the static valueOf(String ) method.

Parameters:

c - The class to obtain the method.

Returns:

the method, otherwise null if the method is not present.

getFromStringStringMethod

public static Method getFromStringStringMethod(Class<?> c)

Get the static fromString(String ) method.

Parameters:

c - The class to obtain the method.

Returns:

the method, otherwise null if the method is not present.

getStringConstructor

public static Constructor getStringConstructor(Class<?> c)

Get the constructor that has a single parameter of String.

Parameters:

c - The class to obtain the constructor.

Returns:

the constructor, otherwise null if the constructor is not present.

getAnnotationTypes

public static Collection<Class<? extends Annotation>> getAnnotationTypes(AnnotatedElement annotatedElement,
                                                                         Class<? extends Annotation> metaAnnotation)

Returns collection of all annotation types attached to a given annotated element that have the provided meta annotation attached.

Parameters:

annotatedElement - annotated element.

metaAnnotation - meta annotation attached to the annotation types we are looking for (if null, annotation types of all attached annotations will be returned).

Returns:

list of annotation types with a given meta annotation

getParameterizedClassArguments

public static Class[] getParameterizedClassArguments(ReflectionHelper.DeclaringClassInterfacePair p)

Get the parameterized class arguments for a declaring class that declares a generic interface type.

Parameters:

p - the declaring class

Returns:

the parameterized class arguments, or null if the generic interface type is not a parameterized type.

getParameterizedTypeArguments

public static Type[] getParameterizedTypeArguments(ReflectionHelper.DeclaringClassInterfacePair p)

Get the parameterized type arguments for a declaring class that declares a generic interface type.

Parameters:

p - the declaring class

Returns:

the parameterized type arguments, or null if the generic interface type is not a parameterized type.

getClass

public static ReflectionHelper.DeclaringClassInterfacePair getClass(Class<?> concrete,
                                                                    Class<?> iface)

Find the declaring class that implements or extends an interface.

Parameters:

concrete - the concrete class than directly or indirectly implements or extends an interface class.

iface - the interface class.

Returns:

the tuple of the declaring class and the generic interface type.

resolveGenericType

public static ClassTypePair resolveGenericType(Class concreteClass,
                                               Class declaringClass,
                                               Class rawResolvedType,
                                               Type genericResolvedType)

Resolve generic type parameter(s) of a raw class and it's generic type based on the class that declares the generic type parameter(s) to be resolved and a concrete implementation of the declaring class.

Parameters:

concreteClass - concrete implementation of the declaring class.

declaringClass - class declaring the generic type parameter(s) to be resolved.

rawResolvedType - raw class of the generic type to be resolved.

genericResolvedType - generic type information of th type to be resolved.

Returns:

a pair of class and the generic type values with the the resolved generic parameter types.

resolveTypeVariable

public static ClassTypePair resolveTypeVariable(Class<?> c,
                                                Class<?> dc,
                                                TypeVariable tv)

Given a type variable resolve the Java class of that variable.

Parameters:

c - the concrete class from which all type variables are resolved.

dc - the declaring class where the type variable was defined.

tv - the type variable.

Returns:

the resolved Java class and type, otherwise null if the type variable could not be resolved.

findMethodOnClass

public static Method findMethodOnClass(Class<?> c,
                                       Method m)

Find a method on a class given an existing method.

If there exists a public method on the class that has the same name and parameters as the existing method then that public method is returned.

Otherwise, if there exists a public method on the class that has the same name and the same number of parameters as the existing method, and each generic parameter type, in order, of the public method is equal to the generic parameter type, in the same order, of the existing method or is an instance of TypeVariable then that public method is returned.

Parameters:

c - the class to search for a public method

m - the method to find

Returns:

the found public method.

getOsgiRegistryInstance

public static OsgiRegistry getOsgiRegistryInstance()

Returns an OsgiRegistry instance.

Returns:

an OsgiRegistry instance or null if the class cannot be instantiated (not in OSGi environment).

getResourceAsStream

public static InputStream getResourceAsStream(ClassLoader loader,
                                              Class<?> originClass,
                                              String name)

Lookup resource by given name. If OSGi runtime is detected and the originClass parameter is not null, an attempt will be made to get the resource input stream via OSGi API from the bundle where originClass is included. Otherwise (non OSGi environment) or if OSGi fails to provide the input stream, the return value will be taken from the provided loader getResourceAsStream method.

Parameters:

loader - class loader where to lookup the resource in non-OSGi environment or if OSGi means fail.

originClass - if not null, and OSGi environment is detected, the resource will be taken from the bundle including the originClass type.

name - filename of the desired resource.

Returns:

an input stream corresponding to the required resource or null if the resource could not be found.