ReflectionUtils (Helenus Common Utilities 1.0.14 API)

java.lang.Object
- org.helenus.commons.lang3.reflect.ReflectionUtils

```
public class ReflectionUtils
extends Object
```
The ReflectionUtils class provides reflection utilities.

Since:

1.0

Version:

1 - Jan 15, 2015 - paouelle - Creation

Author:

The Helenus Driver Project Authors

Copyright:

2015-2015 The Helenus Driver Project Authors

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static java.util.stream.Stream<Annotation>`	`annotations(Element annotatedElement)` Gets annotations that are present on the element.
`static java.util.stream.Stream<Annotation>`	`annotationsAnnotatedWith(Element annotatedElement, Class<? extends Annotation> annotationClass)` Gets annotations which are themselves annotated with a given type of annotation that are present on the element.
`static <T extends Annotation> java.util.stream.Stream<T>`	`annotationsByType(Element annotatedElement, Class<T> annotationClass)` Gets annotations of a specific type that are associated with the element.
`static Class<?>`	`classFor(DeclaredType type)` Gets a class object corresponding to a given declared type.
`static Class<?>`	`classFor(TypeMirror tm)` Gets a class object corresponding to a given type mirror.
`static Collection<Class<?>>`	`findClasses(String pkg)` Finds all classes defined in a given package using the current classloader.
`static Collection<Class<?>>`	`findClasses(String pkg, ClassLoader cl)` Finds all classes defined in a given package.
`static <A extends Annotation> A`	`findFirstAnnotation(Class<?> clazz, Class<A> annotationClass)` Finds the first annotation from a given class' and interface's hierarchy of the specified annotation.
`static <T> Class<? super T>`	`findFirstClassAnnotatedWith(Class<T> clazz, Class<? extends Annotation> annotationClass)` Finds the first class from a given class' hierarchy that is annotated with the specified annotation.
`static <T> Class<? super T>`	`findFirstClassNotAnnotatedWith(Class<T> clazz, Class<? extends Annotation> annotationClass)` Finds the first class from a given class' hierarchy that is not annotated with the specified annotation.
`static <T> Class<? super T>`	`findLastClassAnnotatedWith(Class<T> clazz, Class<? extends Annotation> annotationClass)` Finds the last class from a given class' hierarchy that is annotated with the specified annotation.
`static Collection<URL>`	`findResources(String pkg)` Finds all resources defined in a given package using the current classloader.
`static Collection<URL>`	`findResources(String pkg, ClassLoader cl)` Finds all resources defined in a given package.
`static <A extends Annotation> Map<Field,A[]>`	`getAllAnnotationsForFieldsAnnotatedWith(Class<?> clazz, Class<A> annotation, boolean up)` Gets all fields of a given type (up the super class hierarchy) annotated with the specified annotation.
`static <T extends Member,A extends Annotation> Map<T,A[]>`	`getAllAnnotationsForMembersAnnotatedWith(Class<T> type, Class<?> clazz, Class<A> annotation, boolean up)` Gets all members of a given type (up the super class hierarchy) annotated with the specified annotation.
`static <A extends Annotation> Map<Method,A[]>`	`getAllAnnotationsForMethodsAnnotatedWith(Class<?> clazz, Class<A> annotation, boolean up)` Gets all methods of a given type (up the super class hierarchy) annotated with the specified annotation.
`static List<Field>`	`getAllDeclaredFields(Class<?> clazz, boolean up)` Gets all declared fields (up the super class hierarchy).
`static <T extends Member> List<T>`	`getAllDeclaredMembers(Class<T> type, Class<?> clazz, boolean up)` Gets all declared members of a given type (up the super class hierarchy).
`static List<Method>`	`getAllDeclaredMethods(Class<?> clazz, boolean up)` Gets all declared methods (up the super class hierarchy).
`static List<Field>`	`getAllFieldsAnnotatedWith(Class<?> clazz, Class<? extends Annotation> annotation, boolean up)` Gets all fields (up the super class hierarchy) annotated with the specified annotation.
`static <T extends Member> List<T>`	`getAllMembersAnnotatedWith(Class<T> type, Class<?> clazz, Class<? extends Annotation> annotation, boolean up)` Gets all members of a given type (up the super class hierarchy) annotated with the specified annotation.
`static List<Method>`	`getAllMethodsAnnotatedWith(Class<?> clazz, Class<? extends Annotation> annotation, boolean up)` Gets all methods (up the super class hierarchy) annotated with the specified annotation.
`static <T extends Annotation> T`	`getAnnotation(Element annotatedElement, Class<T> annotationClass)` Gets the specified element's annotation for the specified type if such an annotation is present, else `null` where classes referenced from the annotation are properly resolved and will not generate a compile-time mirror exception.
`static Annotation[]`	`getAnnotations(Element annotatedElement)` Gets annotations that are present on the element.
`static Annotation[]`	`getAnnotationsAnnotatedWith(Element annotatedElement, Class<? extends Annotation> annotationClass)` Gets annotations which are themselves annotated with a given type of annotation that are present on the element.
`static <K,T extends Annotation> Map<K,T>`	`getAnnotationsByType(Class<K> keyClass, Class<T> annotationClass, AnnotatedElement annotatedElement)` Gets annotations that are associated with the specified element.
`static <T extends Annotation> T[]`	`getAnnotationsByType(Element annotatedElement, Class<T> annotationClass)` Gets annotations of a specific that are associated with the element.
`static <T> List<Class<?>>`	`getClassHierarchy(Class<?> clazz)` Gets the hierarchy of a given class.
`static <T extends Member> T[]`	`getDeclaredMembers(Class<T> type, Class<?> clazz)` Gets the declared members of the given type from the specified class.
`static Class<?>`	`getRawClass(Type t)` Gets the raw class from the provided type.
`static <T> Constructor<T>`	`getSerializationConstructorFromAnnotation(Class<T> clazz, Class<? extends Annotation> annotationClass)` Gets the serialization constructor for the given class based on the given annotation.
`static <T> Constructor<T>`	`getSerializationConstructorFromBaseClass(Class<T> clazz, Class<?> bclass)` Gets the serialization constructor for the given class based on the given base class.
`static boolean`	`isAssignableFrom(Class<?>[] classes, Class<?> clazz)` Checks if the specified class is assignment compatible (i.e.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - findFirstAnnotation
```
public static <A extends Annotation> A findFirstAnnotation(Class<?> clazz,
                                                           Class<A> annotationClass)
```
    Finds the first annotation from a given class' and interface's hierarchy of the specified annotation.
    
    Type Parameters:
    
    A - the type of annotation to search for
    
    Parameters:
    
    clazz - the class from which to search
    
    annotationClass - the annotation to search for
    
    Returns:
    
    the first annotation in clazz's hierarchy or null if none is found
    
    Throws:
    
    NullPointerException - if clazz or annotationClass is null
  - findFirstClassAnnotatedWith
```
public static <T> Class<? super T> findFirstClassAnnotatedWith(Class<T> clazz,
                                                               Class<? extends Annotation> annotationClass)
```
    Finds the first class from a given class' hierarchy that is annotated with the specified annotation.
    
    Type Parameters:
    
    T - the type of the class to start searching from
    
    Parameters:
    
    clazz - the class from which to search
    
    annotationClass - the annotation to search for
    
    Returns:
    
    the first class in clazz's hierarchy annotated with the specified annotation or null if none is found
    
    Throws:
    
    NullPointerException - if clazz or annotationClass is null
  - findFirstClassNotAnnotatedWith
```
public static <T> Class<? super T> findFirstClassNotAnnotatedWith(Class<T> clazz,
                                                                  Class<? extends Annotation> annotationClass)
```
    Finds the first class from a given class' hierarchy that is not annotated with the specified annotation.
    
    Type Parameters:
    
    T - the type of the class to start searching from
    
    Parameters:
    
    clazz - the class from which to search
    
    annotationClass - the annotation to search for
    
    Returns:
    
    the first class in clazz's hierarchy not annotated with the specified annotation or null if none found
    
    Throws:
    
    NullPointerException - if clazz or annotationClass is null
  - findLastClassAnnotatedWith
```
public static <T> Class<? super T> findLastClassAnnotatedWith(Class<T> clazz,
                                                              Class<? extends Annotation> annotationClass)
```
    Finds the last class from a given class' hierarchy that is annotated with the specified annotation.
    
    Type Parameters:
    
    T - the type of the class to start searching from
    
    Parameters:
    
    clazz - the class from which to search
    
    annotationClass - the annotation to search for
    
    Returns:
    
    the last class in clazz's hierarchy annotated with the specified annotation or null if none found
    
    Throws:
    
    NullPointerException - if clazz or annotationClass is null
  - getSerializationConstructorFromBaseClass
```
public static <T> Constructor<T> getSerializationConstructorFromBaseClass(Class<T> clazz,
                                                                          Class<?> bclass)
```
    Gets the serialization constructor for the given class based on the given base class. The specified base class is expected to have a default constructor to use for initializing the hierarchy from that point on. The constructor can have any visibility (i.e. public, protected, package private, or private).
    Note: The returned constructor results in having a proper object of the given class instantiated without calling any of the constructors from its class or super classes. The fields of all classes in the hierarchy will not be initialized; thus set using default Java initialization (i.e. null, 0, 0L, false, ...). This is how Java creates new serialized objects before calling the readObject() method of each of the subclasses.
    
    Type Parameters:
    
    T - the class for which to get the serialization constructor
    
    Parameters:
    
    clazz - the class for which to get the serialization constructor
    
    bclass - the base class to start the initialization from in the returned serialization constructor
    
    Returns:
    
    the non-null serialization constructor for the given class
    
    Throws:
    
    NullPointerException - if clazz or bclass is null
    
    IllegalArgumentException - if bclass is not a base class for clazz
    
    SecurityException - if the request is denied
  - getSerializationConstructorFromAnnotation
```
public static <T> Constructor<T> getSerializationConstructorFromAnnotation(Class<T> clazz,
                                                                           Class<? extends Annotation> annotationClass)
```
    Gets the serialization constructor for the given class based on the given annotation. The annotation is used to find the first class in its hierarchy that is not annotated with the annotation and expect a default constructor to use for initializing the hierarchy from that point on. The constructor can have any visibility (i.e. public, protected, package private, or private).
    Note: The returned constructor results in having a proper object of the given class instantiated without calling any of the constructors from its class or super classes. The fields of all classes in the hierarchy will not be initialized; thus set using default Java initialization (i.e. null, 0, 0L, false, ...). This is how Java creates new serialized objects before calling the readObject() method of each of the subclasses.
    
    Type Parameters:
    
    T - the class for which to get the serialization constructor
    
    Parameters:
    
    clazz - the class for which to get the serialization constructor
    
    annotationClass - the annotation to search with
    
    Returns:
    
    the non-null serialization constructor for the given class
    
    Throws:
    
    NullPointerException - if clazz or annotationClass is null
    
    IllegalStateException - if unable to find a default constructor for the first base class not annotated with annotationClass
    
    SecurityException - if the request is denied
  - getDeclaredMembers
```
public static <T extends Member> T[] getDeclaredMembers(Class<T> type,
                                                        Class<?> clazz)
```
    Gets the declared members of the given type from the specified class.
    
    Type Parameters:
    
    T - the type of member
    
    Parameters:
    
    type - the type of members to retrieve
    
    clazz - the class from which to retrieve the members
    
    Returns:
    
    the non-null members of the given type from the specified class
    
    Throws:
    
    NullPointerException - if type or clazz is null
    
    IllegalArgumentException - if type is not Field, Method, or Constructor
  - getAllMembersAnnotatedWith
```
public static <T extends Member> List<T> getAllMembersAnnotatedWith(Class<T> type,
                                                                    Class<?> clazz,
                                                                    Class<? extends Annotation> annotation,
                                                                    boolean up)
```
    Gets all members of a given type (up the super class hierarchy) annotated with the specified annotation.
    
    Type Parameters:
    
    T - the type of members to retrieve (either Field, Method, or Constructor)
    
    Parameters:
    
    type - the type of members to retrieve
    
    clazz - the class from which to find all annotated members
    
    annotation - the annotation for which to find all members
    
    up - true to look up the class hierarchy; false to only look at the specified class level
    
    Returns:
    
    a list in the provided order for all annotated members
    
    Throws:
    
    NullPointerException - if type, clazz or annotation is null
    
    IllegalArgumentException - if type is not Field, Method, or Constructor
  - getAllFieldsAnnotatedWith
```
public static List<Field> getAllFieldsAnnotatedWith(Class<?> clazz,
                                                    Class<? extends Annotation> annotation,
                                                    boolean up)
```
    Gets all fields (up the super class hierarchy) annotated with the specified annotation.
    
    Parameters:
    
    clazz - the class from which to find all annotated fields
    
    annotation - the annotation for which to find all fields
    
    up - true to look up the class hierarchy; false to only look at the specified class level
    
    Returns:
    
    a list in the provided order for all annotated fields
    
    Throws:
    
    NullPointerException - if clazz or annotation is null
  - getAllMethodsAnnotatedWith
```
public static List<Method> getAllMethodsAnnotatedWith(Class<?> clazz,
                                                      Class<? extends Annotation> annotation,
                                                      boolean up)
```
    Gets all methods (up the super class hierarchy) annotated with the specified annotation.
    
    Parameters:
    
    clazz - the class from which to find all annotated methods
    
    annotation - the annotation for which to find all methods
    
    up - true to look up the class hierarchy; false to only look at the specified class level
    
    Returns:
    
    a list in the provided order for all annotated methods
    
    Throws:
    
    NullPointerException - if clazz or annotation is null
  - getAllAnnotationsForMembersAnnotatedWith
```
public static <T extends Member,A extends Annotation> Map<T,A[]> getAllAnnotationsForMembersAnnotatedWith(Class<T> type,
                                                                                                          Class<?> clazz,
                                                                                                          Class<A> annotation,
                                                                                                          boolean up)
```
    Gets all members of a given type (up the super class hierarchy) annotated with the specified annotation.
    
    Type Parameters:
    
    T - the type of members to retrieve (either Field, Method, or Constructor)
    
    A - the type of annotation to search for
    
    Parameters:
    
    type - the type of members to retrieve
    
    clazz - the class from which to find all annotated members
    
    annotation - the annotation for which to find all members
    
    up - true to look up the class hierarchy; false to only look at the specified class level
    
    Returns:
    
    a non-null map in the provided order for all annotated members with their found annotations
    
    Throws:
    
    NullPointerException - if type, clazz or annotation is null
    
    IllegalArgumentException - if type is not Field, Method, or Constructor
  - getAllAnnotationsForFieldsAnnotatedWith
```
public static <A extends Annotation> Map<Field,A[]> getAllAnnotationsForFieldsAnnotatedWith(Class<?> clazz,
                                                                                            Class<A> annotation,
                                                                                            boolean up)
```
    Gets all fields of a given type (up the super class hierarchy) annotated with the specified annotation.
    
    Type Parameters:
    
    A - the type of annotation to search for
    
    Parameters:
    
    clazz - the class from which to find all annotated fields
    
    annotation - the annotation for which to find all fields
    
    up - true to look up the class hierarchy; false to only look at the specified class level
    
    Returns:
    
    a non-null map in the provided order for all annotated fields with their found annotations
    
    Throws:
    
    NullPointerException - if clazz or annotation is null
  - getAllAnnotationsForMethodsAnnotatedWith
```
public static <A extends Annotation> Map<Method,A[]> getAllAnnotationsForMethodsAnnotatedWith(Class<?> clazz,
                                                                                              Class<A> annotation,
                                                                                              boolean up)
```
    Gets all methods of a given type (up the super class hierarchy) annotated with the specified annotation.
    
    Type Parameters:
    
    A - the type of annotation to search for
    
    Parameters:
    
    clazz - the class from which to find all annotated methods
    
    annotation - the annotation for which to find all methods
    
    up - true to look up the class hierarchy; false to only look at the specified class level
    
    Returns:
    
    a non-null map in the provided order for all annotated methods with their found annotations
    
    Throws:
    
    NullPointerException - if clazz or annotation is null
  - getAnnotationsByType
```
public static <K,T extends Annotation> Map<K,T> getAnnotationsByType(Class<K> keyClass,
                                                                     Class<T> annotationClass,
                                                                     AnnotatedElement annotatedElement)
```
    Gets annotations that are associated with the specified element. If there are no annotations associated with the element, the return value is an empty map. The difference between this method and AnnotatedElement.getAnnotationsByType(Class) is that this method works on annotation classes that are annotated with the Keyable annotation in order to determine the key of each annotation. For this to work, the annotated class must defined a key element as defined in the Keyable annotation of the same return type as specified in keyClass. If its argument is a repeatable annotation type (JLS 9.6), this method, attempts to find one or more annotations of that type by "looking through" a container annotation. The caller of this method is free to modify the returned map; it will have no effect on the maps returned to other callers.
    This method will look for both the specified annotation and if the annotation is annotated with Repeatable, it will also look for this containing annotation which must have a value() element with an array type of the specified annotation. The resulting array will always start with the annotation itself if found followed by all of those provided by the containing annotation.
    
    Type Parameters:
    
    K - the type of the keys to find
    
    T - the type of the annotation to query for and return if present
    
    Parameters:
    
    keyClass - the class of the keys to find and return
    
    annotationClass - the type of annotations to retrieve
    
    annotatedElement - the element from which to retrieve the annotations
    
    Returns:
    
    a non-null ordered map of annotations associated with the given element properly keyed as defined in each annotation (may be empty if none found)
    
    Throws:
    
    NullPointerException - if annotatedElement, annotationClass or keyClass is null
    
    IllegalArgumentException - if annotationClass is not annotated with Keyable or if the containing annotation doesn't define a value() element returning an array of type annotationClass or if annotationClass doesn't define an element named as specified in its Keyable annotation that returns a value of the same class as keyClass or again if a duplicated keyed annotation is found
  - getAllDeclaredMembers
```
public static <T extends Member> List<T> getAllDeclaredMembers(Class<T> type,
                                                               Class<?> clazz,
                                                               boolean up)
```
    Gets all declared members of a given type (up the super class hierarchy).
    
    Type Parameters:
    
    T - the type of members to retrieve (either Field, Method, or Constructor)
    
    Parameters:
    
    type - the type of members to retrieve
    
    clazz - the class from which to find all declared members
    
    up - true to look up the class hierarchy; false to only look at the specified class level
    
    Returns:
    
    a list in the provided order for all declared members
    
    Throws:
    
    NullPointerException - if type or clazz is null
    
    IllegalArgumentException - if type is not Field, Method, or Constructor
  - getAllDeclaredFields
```
public static List<Field> getAllDeclaredFields(Class<?> clazz,
                                               boolean up)
```
    Gets all declared fields (up the super class hierarchy).
    
    Parameters:
    
    clazz - the class from which to find all declared fields
    
    up - true to look up the class hierarchy; false to only look at the specified class level
    
    Returns:
    
    a list in the provided order for all declared fields
    
    Throws:
    
    NullPointerException - if clazz is null
  - getAllDeclaredMethods
```
public static List<Method> getAllDeclaredMethods(Class<?> clazz,
                                                 boolean up)
```
    Gets all declared methods (up the super class hierarchy).
    
    Parameters:
    
    clazz - the class from which to find all declared methods
    
    up - true to look up the class hierarchy; false to only look at the specified class level
    
    Returns:
    
    a list in the provided order for all declared methods
    
    Throws:
    
    NullPointerException - if clazz is null
  - getRawClass
```
public static Class<?> getRawClass(Type t)
```
    Gets the raw class from the provided type.
    
    Parameters:
    
    t - the type for which to get the raw class
    
    Returns:
    
    the raw class for the given type
  - getClassHierarchy
```
public static <T> List<Class<?>> getClassHierarchy(Class<?> clazz)
```
    Gets the hierarchy of a given class.
    
    Type Parameters:
    
    T - the type of the class to get the hierarchy for
    
    Parameters:
    
    clazz - the class to get the hierarchy for
    
    Returns:
    
    a list of all classes in the given class's hierarchy starting with the specified class
  - findClasses
```
public static Collection<Class<?>> findClasses(String pkg)
```
    Finds all classes defined in a given package using the current classloader.
    
    Parameters:
    
    pkg - the package from which to find all defined classes
    
    Returns:
    
    the non-null collection of all classes defined in the given package
    
    Throws:
    
    NullPointerException - if pkg is null
  - findClasses
```
public static Collection<Class<?>> findClasses(String pkg,
                                               ClassLoader cl)
```
    Finds all classes defined in a given package.
    
    Parameters:
    
    pkg - the package from which to find all defined classes
    
    cl - the classloader to find the classes with
    
    Returns:
    
    the non-null collection of all classes defined in the given package
    
    Throws:
    
    NullPointerException - if pkg or cl is null
  - findResources
```
public static Collection<URL> findResources(String pkg)
```
    Finds all resources defined in a given package using the current classloader.
    
    Parameters:
    
    pkg - the package from which to find all defined resources
    
    Returns:
    
    the non-null collection of all resources defined in the given package
    
    Throws:
    
    NullPointerException - if pkg is null
  - findResources
```
public static Collection<URL> findResources(String pkg,
                                            ClassLoader cl)
```
    Finds all resources defined in a given package.
    
    Parameters:
    
    pkg - the package from which to find all defined resources
    
    cl - the classloader to find the resources with
    
    Returns:
    
    the non-null collection of all resources defined in the given package
    
    Throws:
    
    NullPointerException - if pkg or cl is null
  - isAssignableFrom
```
public static final boolean isAssignableFrom(Class<?>[] classes,
                                             Class<?> clazz)
```
    Checks if the specified class is assignment compatible (i.e. is a subclass of) any of the classes provided.
    
    Parameters:
    
    classes - the set of classes to check if clazz is assignment compatible with
    
    clazz - the class to be checking
    
    Returns:
    
    true if clazz is a subclass of at least one of the specified classes
  - classFor
```
public static Class<?> classFor(DeclaredType type)
                         throws ClassNotFoundException
```
    Gets a class object corresponding to a given declared type.
    
    Parameters:
    
    type - the declared type for which to get a class object
    
    Returns:
    
    the corresponding non-null class object
    
    Throws:
    
    ClassNotFoundException - if the class is not found
  - classFor
```
public static Class<?> classFor(TypeMirror tm)
                         throws ClassNotFoundException
```
    Gets a class object corresponding to a given type mirror.
    
    Parameters:
    
    tm - the type mirror for which to get a class object
    
    Returns:
    
    the corresponding non-null class object
    
    Throws:
    
    ClassNotFoundException - if the class is not found
  - annotationsByType
```
public static <T extends Annotation> java.util.stream.Stream<T> annotationsByType(Element annotatedElement,
                                                                                  Class<T> annotationClass)
```
    Gets annotations of a specific type that are associated with the element.
    If there are no annotations associated with this element, the return value is an empty stream.
    
    Type Parameters:
    
    T - the type of the annotation to query for and return if present
    
    Parameters:
    
    annotatedElement - the element to retrieve the annotations from
    
    annotationClass - the type of annotations to retrieve
    
    Returns:
    
    a stream of the element's annotations for the specified annotation type if present on this element, else an empty stream
    
    Throws:
    
    NullPointerException - if the given element or annotation class are null
    
    See Also:
    
    https://blog.retep.org/2009/02/13/getting-class-values-from-annotations-in-an-annotationprocessor/
  - annotationsAnnotatedWith
```
public static java.util.stream.Stream<Annotation> annotationsAnnotatedWith(Element annotatedElement,
                                                                           Class<? extends Annotation> annotationClass)
```
    Gets annotations which are themselves annotated with a given type of annotation that are present on the element.
    If there are no annotations present on the element, the return value is an empty stream.
    For example, one could find all annotations annotated with the @Tag annotation, which in the following examples would return @ThisOne and @ThisOneToo annotations but not @NotThisOne:
```
   @Tag
   public @interface ThisOne {
      String value();
   }

   @Tag
   public @interface ThisOneToo {
      String value();
   }

   public @interface NotThisOne {
      String value();
   }
 
```
    Parameters:
    
    annotatedElement - the element to retrieve the annotations from
    
    annotationClass - the type of annotations to retrieve annotations annotated with
    
    Returns:
    
    a stream of the element's annotations annotated with the specified annotation type if present on this element, else an empty stream
    
    Throws:
    
    NullPointerException - if the given element or annotation class are null
    
    See Also:
    
    https://blog.retep.org/2009/02/13/getting-class-values-from-annotations-in-an-annotationprocessor/
  - annotations
```
public static java.util.stream.Stream<Annotation> annotations(Element annotatedElement)
```
    Gets annotations that are present on the element.
    If there are no annotations present on the element, the return value is an empty stream.
    
    Parameters:
    
    annotatedElement - the element to retrieve the annotations from
    
    Returns:
    
    a stream of annotations present on the element
    
    Throws:
    
    NullPointerException - if the given element is null
    
    See Also:
    
    https://blog.retep.org/2009/02/13/getting-class-values-from-annotations-in-an-annotationprocessor/
  - getAnnotationsAnnotatedWith
```
public static Annotation[] getAnnotationsAnnotatedWith(Element annotatedElement,
                                                       Class<? extends Annotation> annotationClass)
```
    Gets annotations which are themselves annotated with a given type of annotation that are present on the element.
    If there are no annotations present on the element, the return value is an array of length 0.
    For example, one could find all annotations annotated with the @Tag annotation, which in the following examples would return @ThisOne and @ThisOneToo annotations but not @NotThisOne:
```
   @Tag
   public @interface ThisOne {
      String value();
   }

   @Tag
   public @interface ThisOneToo {
      String value();
   }

   public @interface NotThisOne {
      String value();
   }
 
```
    Parameters:
    
    annotatedElement - the element to retrieve the annotations from
    
    annotationClass - the type of annotations to retrieve annotations annotated with
    
    Returns:
    
    an array of the element's annotations annotated with the specified annotation type if present on this element, else an array of length 0
    
    Throws:
    
    NullPointerException - if the given element or annotation class are null
    
    See Also:
    
    https://blog.retep.org/2009/02/13/getting-class-values-from-annotations-in-an-annotationprocessor/
  - getAnnotations
```
public static Annotation[] getAnnotations(Element annotatedElement)
```
    Gets annotations that are present on the element.
    If there are no annotations present on the element, the return value is an array of length 0.
    The caller of this method is free to modify the returned array; it will have no effect on the arrays returned to other callers.
    
    Parameters:
    
    annotatedElement - the element to retrieve the annotations from
    
    Returns:
    
    an array of annotations present on the element, else an array of length 0
    
    Throws:
    
    NullPointerException - if the given element is null
    
    See Also:
    
    https://blog.retep.org/2009/02/13/getting-class-values-from-annotations-in-an-annotationprocessor/
  - getAnnotationsByType
```
public static <T extends Annotation> T[] getAnnotationsByType(Element annotatedElement,
                                                              Class<T> annotationClass)
```
    Gets annotations of a specific that are associated with the element.
    If there are no annotations associated with this element, the return value is an array of length 0.
    The difference between this method and getAnnotation(Element, Class) is that this method detects if its argument is a repeatable annotation type (JLS 9.6), and if so, attempts to find one or more annotations of that type by "looking through" a container annotation.
    The caller of this method is free to modify the returned array; it will have no effect on the arrays returned to other callers.
    
    Type Parameters:
    
    T - the type of the annotation to query for and return if present
    
    Parameters:
    
    annotatedElement - the element to retrieve the annotations from
    
    annotationClass - the type of annotations to retrieve
    
    Returns:
    
    an array of the element's annotations for the specified annotation type if present on this element, else an empty array
    
    Throws:
    
    NullPointerException - if the given element or annotation class are null
    
    See Also:
    
    https://blog.retep.org/2009/02/13/getting-class-values-from-annotations-in-an-annotationprocessor/
  - getAnnotation
```
public static <T extends Annotation> T getAnnotation(Element annotatedElement,
                                                     Class<T> annotationClass)
```
    Gets the specified element's annotation for the specified type if such an annotation is present, else null where classes referenced from the annotation are properly resolved and will not generate a compile-time mirror exception.
    This method is useful when dealing with annotations in a processing environment where Javac does not load classes in the normal manner. In fact it doesn’t at all for classes that are in the source – it’s all contained within a model.
    
    Type Parameters:
    
    T - the type of the annotation to query for and return if present
    
    Parameters:
    
    annotatedElement - the element to retrieve the annotation from
    
    annotationClass - the type of annotation to retrieve
    
    Returns:
    
    the element's annotation for the specified annotation type if present on this element, else null
    
    Throws:
    
    NullPointerException - if the given element or annotation class are null
    
    See Also:
    
    https://blog.retep.org/2009/02/13/getting-class-values-from-annotations-in-an-annotationprocessor/

Class ReflectionUtils

Method Summary

Methods inherited from class java.lang.Object

Method Detail

findFirstAnnotation

findFirstClassAnnotatedWith

findFirstClassNotAnnotatedWith

findLastClassAnnotatedWith

getSerializationConstructorFromBaseClass

getSerializationConstructorFromAnnotation

getDeclaredMembers

getAllMembersAnnotatedWith

getAllFieldsAnnotatedWith

getAllMethodsAnnotatedWith

getAllAnnotationsForMembersAnnotatedWith

getAllAnnotationsForFieldsAnnotatedWith

getAllAnnotationsForMethodsAnnotatedWith

getAnnotationsByType

getAllDeclaredMembers

getAllDeclaredFields

getAllDeclaredMethods

getRawClass

getClassHierarchy

findClasses

findClasses

findResources

findResources

isAssignableFrom

classFor

classFor

annotationsByType

annotationsAnnotatedWith

annotations

getAnnotationsAnnotatedWith

getAnnotations

getAnnotationsByType

getAnnotation