Package org.reflections

Class ReflectionUtils

java.lang.Object

org.reflections.util.ReflectionUtilsPredicates

org.reflections.ReflectionUtils

public abstract class ReflectionUtils
extends ReflectionUtilsPredicates

utils for querying java reflection meta types SuperTypes, Annotations, AnnotationTypes, Methods, Constructors, Fields.

Set<Class<?>> supertypes = get(SuperTypes.of(type))
 Set<Annotation> annotations = get(Annotations.of(type))
 

generally, apply get(QueryFunction) on QueryFunction created by UtilQueryBuilder, and optionally use the functional methods in QueryFunction

get(Methods.of(type)
   .filter(withPublic().and(withPrefix("get")).and(withParameterCount(0)))
   .as(Method.class)
   .map(m -> ...))
 

or (previously), use getAllXXX(type/s, withYYY) methods:

getAllSuperTypes(), getAllFields(), getAllMethods(), getAllConstructors() 
 

some predicates included here:

• ReflectionUtilsPredicates.withPublic()
• ReflectionUtilsPredicates.withParametersCount(int)}
• ReflectionUtilsPredicates.withAnnotation(java.lang.annotation.Annotation)
• ReflectionUtilsPredicates.withParameters(Class[])
• ReflectionUtilsPredicates.withModifier(int)
• ReflectionUtilsPredicates.withReturnType(Class)

 import static org.reflections.ReflectionUtils.*;

 Set<Method> getters =
     get(Methods(classes)
     .filter(withModifier(Modifier.PUBLIC).and(withPrefix("get")).and(withParametersCount(0)));

 get(Annotations.of(method)
   .filter(withAnnotation())
   .map(annotation -> Methods.of(annotation)
     .map(method -> )))))
   .stream()...
 

Field Summary

Fields

Modifier and Type	Field	Description
static UtilQueryBuilder<AnnotatedElement,Annotation>	Annotations	query annotations
static UtilQueryBuilder<AnnotatedElement,Class<? extends Annotation>>	AnnotationTypes	query annotation types
static UtilQueryBuilder<Class<?>,Constructor>	Constructors	query constructors
static UtilQueryBuilder<Class<?>,Field>	Fields	query fields
static UtilQueryBuilder<Class<?>,Class<?>>	Interfaces	query interfaces
static UtilQueryBuilder<Class<?>,Method>	Methods	query methods
static Predicate<Method>	notObjectMethod	predicate to filter out Object methods
static UtilQueryBuilder<Class<?>,Class<?>>	SuperClass	query super class
static UtilQueryBuilder<Class<?>,Class<?>>	SuperTypes	query super classes and interfaces including element

Constructor Summary

Constructors

Constructor	Description
ReflectionUtils()

Method Summary

Modifier and Type	Method	Description
static <T extends AnnotatedElement> UtilQueryBuilder<AnnotatedElement,T>	extendType()
static <C,T> Set<T>	get(QueryFunction<C,T> function)	get type elements <T> by applying QueryFunction
static <T> Set<T>	get(QueryFunction<Store,T> queryFunction, Predicate<? super T>... predicates)	get type elements <T> by applying QueryFunction and predicates
static <T extends AnnotatedElement> Set<Annotation>	getAllAnnotations(T type, Predicate<Annotation>... predicates)	get all annotations of given type, up the super class hierarchy, optionally filtered by predicates
static Set<Constructor>	getAllConstructors(Class<?> type, Predicate<? super Constructor>... predicates)	get all constructors of given type, up the super class hierarchy, optionally filtered by predicates
static Set<Field>	getAllFields(Class<?> type, Predicate<? super Field>... predicates)	get all fields of given type, up the super class hierarchy, optionally filtered by predicates
static Set<Method>	getAllMethods(Class<?> type, Predicate<? super Method>... predicates)	get all methods of given type, up the super class hierarchy, optionally filtered by predicates
static Set<Class<?>>	getAllSuperTypes(Class<?> type, Predicate<? super Class<?>>... predicates)	get all super types of given type, including, optionally filtered by predicates
static <T extends AnnotatedElement> Set<Annotation>	getAnnotations(T type, Predicate<Annotation>... predicates)	get annotations of given type, optionally honorInherited, optionally filtered by predicates
static Set<Constructor>	getConstructors(Class<?> t, Predicate<? super Constructor>... predicates)	get constructors of given type, optionally filtered by predicates
static Set<Field>	getFields(Class<?> type, Predicate<? super Field>... predicates)	get fields of given type, optionally filtered by predicates
static Set<Method>	getMethods(Class<?> t, Predicate<? super Method>... predicates)	get methods of given type, optionally filtered by predicates
static Set<Class<?>>	getSuperTypes(Class<?> type)	get the immediate supertype and interfaces of the given type
static Object	invoke(Method method, Object obj, Object... args)	invoke the given method with args, return either the result or an exception if occurred
static Annotation	toAnnotation(Map<String,Object> map)	create new annotation proxy with member values from the given map
static <T extends Annotation> T	toAnnotation(Map<String,Object> map, Class<T> annotationType)	create new annotation proxy with member values from the given map and member values from the given map
static Map<String,Object>	toMap(Annotation annotation)	map annotation to hash map of member values recursively
static Map<String,Object>	toMap(Annotation annotation, AnnotatedElement element)	map annotation and annotatedElement to hash map of member values

Methods inherited from class org.reflections.util.ReflectionUtilsPredicates

isAssignable, withAnnotation, withAnnotation, withAnnotations, withAnnotations, withAnyParameterAnnotation, withAnyParameterAnnotation, withClassModifier, withInterface, withModifier, withName, withParameters, withParametersAssignableFrom, withParametersAssignableTo, withParametersCount, withPattern, withPrefix, withPublic, withReturnType, withReturnTypeAssignableFrom, withStatic, withType, withTypeAssignableTo

Methods inherited from class java.lang.Object

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

Field Detail

notObjectMethod

public static final Predicate<Method> notObjectMethod

predicate to filter out Object methods

SuperClass

public static final UtilQueryBuilder<Class<?>,Class<?>> SuperClass

query super class

get(SuperClass.of(element)) -> Set<Class<?>>

see also SuperTypes, Interfaces

Interfaces

public static final UtilQueryBuilder<Class<?>,Class<?>> Interfaces

query interfaces

get(Interfaces.of(element)) -> Set<Class<?>>

SuperTypes

public static final UtilQueryBuilder<Class<?>,Class<?>> SuperTypes

query super classes and interfaces including element

get(SuperTypes.of(element)) -> Set<Class<?>> 

Annotations

public static final UtilQueryBuilder<AnnotatedElement,Annotation> Annotations

query annotations

get(Annotation.of(element)) -> Set<Annotation> 

AnnotationTypes

public static final UtilQueryBuilder<AnnotatedElement,Class<? extends Annotation>> AnnotationTypes

query annotation types

get(AnnotationTypes.of(element)) -> Set<Class<? extends Annotation>> 

Methods

public static final UtilQueryBuilder<Class<?>,Method> Methods

query methods

get(Methods.of(type)) -> Set<Method>

Constructors

public static final UtilQueryBuilder<Class<?>,Constructor> Constructors

query constructors

get(Constructors.of(type)) -> Set<Constructor> 

Fields

public static final UtilQueryBuilder<Class<?>,Field> Fields

query fields

get(Fields.of(type)) -> Set<Field> 

Constructor Detail

ReflectionUtils

public ReflectionUtils()

Method Detail

get

public static <C,T> Set<T> get(QueryFunction<C,T> function)

get type elements <T> by applying QueryFunction

get(SuperTypes.of(type))

get

public static <T> Set<T> get(QueryFunction<Store,T> queryFunction,
                             Predicate<? super T>... predicates)

get type elements <T> by applying QueryFunction and predicates

extendType

public static <T extends AnnotatedElement> UtilQueryBuilder<AnnotatedElement,T> extendType()

getAllAnnotations

public static <T extends AnnotatedElement> Set<Annotation> getAllAnnotations(T type,
                                                                             Predicate<Annotation>... predicates)

get all annotations of given type, up the super class hierarchy, optionally filtered by predicates

marked for removal, use instead get(Annotations.of())

getAllSuperTypes

public static Set<Class<?>> getAllSuperTypes(Class<?> type,
                                             Predicate<? super Class<?>>... predicates)

get all super types of given type, including, optionally filtered by predicates

getSuperTypes

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

get the immediate supertype and interfaces of the given type

marked for removal, use instead get(SuperTypes.get())

getAllMethods

public static Set<Method> getAllMethods(Class<?> type,
                                        Predicate<? super Method>... predicates)

get all methods of given type, up the super class hierarchy, optionally filtered by predicates

marked for removal, use instead get(Methods.of())

getMethods

public static Set<Method> getMethods(Class<?> t,
                                     Predicate<? super Method>... predicates)

get methods of given type, optionally filtered by predicates

marked for removal, use instead get(Methods.get())

getAllConstructors

public static Set<Constructor> getAllConstructors(Class<?> type,
                                                  Predicate<? super Constructor>... predicates)

get all constructors of given type, up the super class hierarchy, optionally filtered by predicates

marked for removal, use instead get(Constructors.of())

getConstructors

public static Set<Constructor> getConstructors(Class<?> t,
                                               Predicate<? super Constructor>... predicates)

get constructors of given type, optionally filtered by predicates

marked for removal, use instead get(Constructors.get())

getAllFields

public static Set<Field> getAllFields(Class<?> type,
                                      Predicate<? super Field>... predicates)

get all fields of given type, up the super class hierarchy, optionally filtered by predicates

marked for removal, use instead get(Fields.of())

getFields

public static Set<Field> getFields(Class<?> type,
                                   Predicate<? super Field>... predicates)

get fields of given type, optionally filtered by predicates

marked for removal, use instead get(Fields.get())

getAnnotations

public static <T extends AnnotatedElement> Set<Annotation> getAnnotations(T type,
                                                                          Predicate<Annotation>... predicates)

get annotations of given type, optionally honorInherited, optionally filtered by predicates

marked for removal, use instead get(Annotations.get())

toMap

public static Map<String,Object> toMap(Annotation annotation)

map annotation to hash map of member values recursively

Annotations.of(type).map(ReflectionUtils::toMap) 

toMap

public static Map<String,Object> toMap(Annotation annotation,
                                             AnnotatedElement element)

map annotation and annotatedElement to hash map of member values

Annotations.of(type).map(a -> toMap(type, a)) 

toAnnotation

public static Annotation toAnnotation(Map<String,Object> map)

create new annotation proxy with member values from the given map

toAnnotation(Map.of("annotationType", annotationType, "value", ""))

toAnnotation

public static <T extends Annotation> T toAnnotation(Map<String,Object> map,
                                                    Class<T> annotationType)

create new annotation proxy with member values from the given map and member values from the given map

toAnnotation(Map.of("value", ""), annotationType)

invoke

public static Object invoke(Method method,
                            Object obj,
                            Object... args)

invoke the given method with args, return either the result or an exception if occurred