Class ReflectionUtils


public abstract class ReflectionUtils extends ReflectionUtilsPredicates
utils for querying java reflection meta types

see SuperTypes, Annotations, AnnotationTypes, Methods, Constructors and 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:


 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 Details

  • Constructor Details

    • ReflectionUtils

      public ReflectionUtils()
  • Method Details

    • 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