Popularity
8.2
Stable
Activity
2.8
Declining
4,377
190
670

Programming language: Java
License: Do What The F*ck You Want To Public License
Tags: Projects     Introspection    
Latest version: v0.9.12

Reflections alternatives and similar libraries

Based on the "Introspection" category.
Alternatively, view Reflections alternatives based on common mentions on social networks and blogs.

  • jOOR

    jOOR - Fluent Reflection in Java jOOR is a very simple fluent API that gives access to your Java Class structures in a more intuitive way. The JDK's reflection APIs are hard and verbose to use. Other languages have much simpler constructs to access type meta information at runtime. Let us make Java reflection better.
  • ClassGraph

    An uber-fast parallelized Java classpath scanner and module scanner.
  • Sonar helps you commit clean code every time. With over 600 unique rules to find Java bugs, code smells & vulnerabilities, Sonar finds the issues while you focus on the work.
  • ReflectASM

    High performance Java reflection
  • Objenesis

    Okay, it's pretty easy to instantiate objects in Java through standard reflection. However there are many cases where you need to go beyond what reflection provides. For example, if there's no public constructor, you want to bypass the constructor code, or set final fields. There are numerous clever (but fiddly) approaches to getting around this and this library provides a simple way to get at them. You will find the official site here.
  • Mirror

    Mirror was created to bring light to a simple problem, usually named ReflectionUtil, which is on almost all projects that rely on reflection to do advanced tasks.

Do you think we are missing an alternative of Reflections or a related project?

Add another 'Introspection' Library

README

Released org.reflections:reflections:0.10.2

Reflections library has ~4 million downloads per month from Maven Central, and is being used by thousands of projects and libraries.
Thank you for your continuous support! And apologize for the issues. We're looking for community collaborators to assist in reviewing pull requests and issues, please reach out.

Java runtime metadata analysis

Build Status

Reflections scans and indexes your project's classpath metadata, allowing reverse transitive query of the type system on runtime.

Using Reflections you can query for example:

  • Subtypes of a type
  • Types annotated with an annotation
  • Methods with annotation, parameters, return type
  • Resources found in classpath
    And more...

Reflections was written in the spirit of Scannotations library

Usage

Add Reflections dependency to your project:

# Maven
<dependency>
    <groupId>org.reflections</groupId>
    <artifactId>reflections</artifactId>
    <version>0.10.2</version>
</dependency>

# Gradle
implementation 'org.reflections:reflections:0.10.2'

Create Reflections instance and use the query functions:

Reflections reflections = new Reflections("com.my.project");

Set<Class<?>> subTypes =
  reflections.get(SubTypes.of(SomeType.class).asClass());

Set<Class<?>> annotated = 
  reflections.get(SubTypes.of(TypesAnnotated.with(SomeAnnotation.class)).asClass());

Or using previous 0.9.x APIs, for example:

Set<Class<? extends SomeType>> subTypes =
  reflections.getSubTypesOf(SomeType.class);

Set<Class<?>> annotated = 
  reflections.getTypesAnnotatedWith(SomeAnnotation.class);

Note that there are some breaking changes with Reflections 0.10+, along with performance improvements and more functional API, see below.

Scan

Creating Reflections instance requires ConfigurationBuilder, typically configured with packages and Scanners to use:

// typical usage: scan package with the default scanners SubTypes, TypesAnnotated
Reflections reflections = new Reflections(
  new ConfigurationBuilder()
    .forPackage("com.my.project")
    .filterInputsBy(new FilterBuilder().includePackage("com.my.project")));

// or similarly using the convenient constructor
Reflections reflections = new Reflections("com.my.project");

Other examples:

import static org.reflections.scanners.Scanners.*;

// scan package with specific scanners
Reflections reflections = new Reflections(
  new ConfigurationBuilder()
    .forPackage("com.my.project")
    .filterInputsBy(new FilterBuilder().includePackage("com.my.project").excludePackage("com.my.project.exclude"))
    .setScanners(TypesAnnotated, MethodsAnnotated, MethodsReturn));

// scan package with all standard scanners
Reflections reflections = new Reflections("com.my.project", Scanners.values());

Note that:

  • Scanner must be configured in order to be queried, otherwise an empty result is returned
    If not specified, default scanners will be used SubTypes, TypesAnnotated.
    For all standard scanners use Scanners.values(). See more scanners in the source package.
  • All relevant URLs should be configured
    Consider .filterInputsBy() in case too many classes are scanned.
    If required, Reflections will expand super types in order to get the transitive closure metadata without scanning large 3rd party urls.
  • Classloader can optionally be used for resolving runtime classes from names.

Query

Once Reflections was instantiated and scanning was successful, it can be used for querying the indexed metadata.

import static org.reflections.scanners.Scanners.*;

// SubTypes
Set<Class<?>> modules = 
  reflections.get(SubTypes.of(Module.class).asClass());

// TypesAnnotated (*1)
Set<Class<?>> singletons = 
  reflections.get(TypesAnnotated.with(Singleton.class).asClass());

// MethodsAnnotated
Set<Method> resources =
  reflections.get(MethodsAnnotated.with(GetMapping.class).as(Method.class));

// FieldsAnnotated
Set<Field> ids = 
  reflections.get(FieldsAnnotated.with(Id.class).as(Field.class));

// Resources
Set<String> properties = 
  reflections.get(Resources.with(".*\\.properties"));

More scanners:

// MethodsReturn
Set<Method> voidMethods = 
  reflections.get(MethodsReturn.with(void.class).as(Method.class));

// MethodsSignature
Set<Method> someMethods = 
  reflections.get(MethodsSignature.of(long.class, int.class).as(Method.class));

// MethodsParameter
Set<Method> pathParam = 
  reflections.get(MethodsParameter.of(PathParam.class).as(Method.class));

// ConstructorsAnnotated
Set<Constructor> injectables =
  reflections.get(ConstructorsAnnotated.with(Inject.class).as(Constructor.class));

// ConstructorsSignature
Set<Constructor> someConstructors = 
  reflections.get(ConstructorsSignature.of(String.class).as(Constructor.class));

// MethodParameterNamesScanner
List<String> parameterNames =
  reflections.getMemberParameterNames(member);

// MemberUsageScanner
Set<Member> usages =
  reflections.getMemberUsages(member)

See more examples in [ReflectionsQueryTest](src/test/java/org/reflections/ReflectionsQueryTest.java).

Note that previous 0.9.x APIs are still supported

Compare Scanners and previous 0.9.x API (*)

Scanners previous 0.9.x API previous Scanner
get(SubType.of(T)) getSubTypesOf(T) SubTypesScanner
get(SubTypes.of(    TypesAnnotated.with(A))) getTypesAnnotatedWith(A) (1) TypeAnnotationsScanner
get(MethodsAnnotated.with(A)) getMethodsAnnotatedWith(A) MethodAnnotationsScanner
get(ConstructorsAnnotated.with(A)) getConstructorsAnnotatedWith(A) (2) MethodAnnotationsScanner
get(FieldsAnnotated.with(A)) getFieldsAnnotatedWith(A) FieldAnnotationsScanner
get(Resources.with(regex)) getResources(regex) ResourcesScanner
get(MethodsParameter.with(P)) getMethodsWithParameter(P) (3)getMethodsWithAnyParamAnnotated(P) MethodParameterScannerobsolete
get(MethodsSignature.of(P, ...)) getMethodsWithSignature(P, ...) (3)getMethodsMatchParams(P, ...) "
get(MethodsReturn.of(T)) getMethodsReturn(T) (3) "
get(ConstructorsParameter.with(P)) getConstructorsWithParameter(P) (3)getConstructorsWithAnyParamAnnotated(P) "
get(ConstructorsSignature.of(P, ...)) getConstructorsWithSignature(P, ...) (3)getConstructorsMatchParams(P, ...) "

Note: asClass() and as() mappings were omitted

(1): The equivalent of getTypesAnnotatedWith(A) is get(SubTypes.of(TypesAnnotated.with(A))), including SubTypes

(2): MethodsAnnotatedScanner does not include constructor annotation scanning, use instead Scanners.ConstructorsAnnotated

(3): MethodParameterScanner is obsolete, use instead as required:
Scanners.MethodsParameter, Scanners.MethodsSignature, Scanners.MethodsReturn, Scanners.ConstructorsParameter, Scanners.ConstructorsSignature

ReflectionUtils

Apart from scanning classpath metadata using Javassist, Java Reflection convenient methods are available using ReflectionsUtils:

import static org.reflections.ReflectionUtils.*;

Set<Class<?>>    superTypes   = get(SuperTypes.of(T));
Set<Field>       fields       = get(Fields.of(T));
Set<Constructor> constructors = get(Constructors.of(T));
Set<Methods>     methods      = get(Methods.of(T));
Set<URL>         resources    = get(Resources.with(T));

Set<Annotation>  annotations  = get(Annotations.of(T));
Set<Class<? extends Annotation>> annotationTypes = get(AnnotationTypes.of(T));

Previous ReflectionUtils 0.9.x API is still supported though marked for removal, more info in the javadocs.

Query API

Each Scanner and ReflectionUtils function implements QueryBuilder, and supports:

  • get() - function returns direct values
  • with() or of() - function returns all transitive values

For example, Scanners.SubTypes.get(T) return direct subtypes, while Scanners.SubTypes.of(T) return transitive subtypes hierarchy. Same goes for Scanners.TypesAnnotated and ReflectionUtils.SuperTypes etc.

Next, each function implements QueryFunction, and provides fluent functional interface for composing filter(), map(), flatMap(), as() and more, such that:

// filter, as/map
QueryFunction<Store, Method> getters =
  Methods.of(C1.class)
    .filter(withModifier(Modifier.PUBLIC))
    .filter(withPrefix("get").and(withParametersCount(0)))
    .as(Method.class);

// compose Scanners and ReflectionUtils functions 
QueryFunction<Store, Method> methods = 
  SubTypes.of(type).asClass()  // <-- classpath scanned metadata
    .flatMap(Methods::of);     // <-- java reflection api

// function of function
QueryFunction<Store, Class<? extends Annotation>> queryAnnotations = 
  Annotations.of(Methods.of(C4.class))
    .map(Annotation::annotationType);

See more in ReflectionUtilsQueryTest

A more complex example demonstrates getting merged annotations of rest controllers endpoints:

// get all annotations of RequestMapping hierarchy (GetMapping, PostMapping, ...)
Set<Class<?>> metaAnnotations =
  reflections.get(TypesAnnotated.getAllIncluding(RequestMapping.class.getName()).asClass());

QueryFunction<Store, Map<String, Object>> queryAnnotations =
  // get all controller endpoint methods      
  MethodsAnnotated.with(metaAnnotations).as(Method.class)
    .map(method ->
      // get both method's + declaring class's RequestMapping annotations   
      get(Annotations.of(method.getDeclaringClass())
        .add(Annotations.of(method))
        .filter(a -> metaAnnotations.contains(a.annotationType())))
        .stream()
        // merge annotations' member values into a single hash map
        .collect(new AnnotationMergeCollector(method)));

// apply query and map merged hashmap into java annotation proxy
Set<RequestMapping> mergedAnnotations = 
  reflections.get(mergedAnnotation
    .map(map -> ReflectionUtils.toAnnotation(map, metaAnnotation)));

Check the [tests](src/test/java/org/reflections) folder for more examples and API usage

What else?

  • Integrating with build lifecycle
    It is sometime useful to Reflections.save() the scanned metadata into xml/json as part of the build lifecycle for generating resources, and then collect it on bootstrap with Reflections.collect() and avoid scanning. See reflections-maven for example.
  • JavaCodeSerializer - scanned metadata can be persisted into a generated Java source code. Although less common, it can be useful for accessing types and members in a strongly typed manner. (see [example](src/test/java/org/reflections/MyTestModelStore.java))
  • AnnotationMergeCollector - can be used to merge similar annotations. (see [test](src/test/java/org/reflections/ReflectionUtilsQueryTest.java#L216))
  • MemberUsageScanner - experimental scanner allow querying for member usages getMemberUsages() of packages/types/elements in the classpath. Can be used for finding usages between packages, layers, modules, types etc.

Contribute

Pull requests are welcomed!!
Here are some issues labeled with please contribute :heart:
We're looking for community collaborators to assist in reviewing pull requests and issues, please reach out.

Dual licenced with Apache 2 and WTFPL, just do what the fuck you want to.

This library is published as an act of giving and generosity, from developers to developers, to promote knowledge sharing and a--hole free working environments.
Please feel free to use it, and to contribute to the developers' community in the same manner.

PayPal / Patreon

Cheers