Reflections (Reflections 0.10.2 API)

java.lang.Object
- org.reflections.Reflections

All Implemented Interfaces:: NameHelper

public class Reflections
extends Object
implements NameHelper

Reflections one-stop-shop object

Reflections scans and indexes your project's classpath, allowing reverse query of the type system metadata 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...

Create Reflections instance, preferably using ConfigurationBuilder:


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

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

 // another example
 Reflections reflections = new Reflections(
   new ConfigurationBuilder()
     .forPackage("com.my.project")
     .setScanners(Scanners.values())     // all standard scanners
     .filterInputsBy(new FilterBuilder().includePackage("com.my.project").excludePackage("com.my.project.exclude")));

All relevant URLs should be configured.
If required, Reflections will expandSuperTypes(Map, Map) in order to get the transitive closure metadata without scanning large 3rd party urls.

Scanners must be configured in order to be queried, otherwise an empty result is returned.
Default scanners are SubTypes and TypesAnnotated. For all standard scanners use Scanners.values().

Classloader can optionally be used for resolving runtime classes from names.

Query using get(QueryFunction), such as:


 Set<Class<?>> modules = reflections.get(SubTypes.of(Module.class).asClass());
 Set<Class<?>> singletons = reflections.get(TypesAnnotated.with(Singleton.class).asClass());
 Set<String> properties   = reflections.get(Resources.with(".\*\.properties"));
 Set<Method> requests     = reflections.get(MethodsAnnotated.with(RequestMapping.class).as(Method.class));
 Set<Method> voidMethods  = reflections.get(MethodsReturn.with(void.class).as(Method.class));
 Set<Method> someMethods  = reflections.get(MethodsSignature.of(long.class, int.class).as(Method.class));

If not using asClass() or as() query results are strings, such that:

 Set<String> modules    = reflections.get(SubTypes.of(Module.class));
 Set<String> singletons = reflections.get(TypesAnnotated.with(Singleton.class));

Note that previous 0.9.x API is still supported, for example:

 Set<Class<? extends Module>> modules = reflections.getSubTypesOf(Module.class);
 Set<Class<?>> singletons = reflections.getTypesAnnotatedWith(Singleton.class);

Queries can combine Scanners and ReflectionUtils functions, and compose fluent functional methods from QueryFunction.

Scanned metadata can be saved using save(String), and collected using collect(String, java.util.function.Predicate, org.reflections.serializers.Serializer)

For Javadoc, source code, and more information about Reflections Library, see http://github.com/ronmamo/reflections/

Field Summary

Fields
Modifier and Type Field and Description

protected Configuration configuration

static org.slf4j.Logger log

protected Store store
- Fields inherited from interface org.reflections.util.NameHelper
  primitiveDescriptors, primitiveNames, primitiveTypes

Fields
Modifier and Type	Field and Description
`protected Configuration`	`configuration`
`static org.slf4j.Logger`	`log`
`protected Store`	`store`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`Reflections()`
	`Reflections(Configuration configuration)` constructs Reflections instance and scan according to the given `Configuration`
	`Reflections(Object... params)` Convenient constructor for Reflections.
	`Reflections(Store store)`
	`Reflections(String prefix, Scanner... scanners)` constructs Reflections instance and scan according to the given package `prefix` and optional `scanners`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static Reflections`	`collect()` collect saved Reflection xml resources and merge it into a Reflections instance
`Reflections`	`collect(File file, Serializer serializer)` deserialize and merge saved Reflections metadata from the given `file` and `serializer`
`Reflections`	`collect(InputStream inputStream, Serializer serializer)` deserialize and merge saved Reflections metadata from the given `inputStream` and `serializer`
`static Reflections`	`collect(String packagePrefix, Predicate<String> resourceNameFilter)` collect saved Reflections metadata from all urls that contains the given `packagePrefix` and matches the given `resourceNameFilter`, and deserialize using the default serializer `XmlSerializer`
`static Reflections`	`collect(String packagePrefix, Predicate<String> resourceNameFilter, Serializer serializer)` collect saved Reflections metadata from all urls that contains the given `packagePrefix` and matches the given `resourceNameFilter`, and deserializes using the given `serializer`
`void`	`expandSuperTypes(Map<String,Set<String>> subTypesStore, Map<String,Set<String>> typesAnnotatedStore)` expand super types after scanning, for super types that were not scanned.
`<T> Set<T>`	`get(QueryFunction<Store,T> query)` apply `QueryFunction` on `Store`
`Set<String>`	`getAll(Scanner scanner)` returns all key and values scanned by the given `scanner`
`Set<String>`	`getAllTypes()` Deprecated.
`Configuration`	`getConfiguration()` returns the `Configuration` object of this instance
`Set<Constructor>`	`getConstructorsAnnotatedWith(Annotation annotation)` get constructors annotated with the given `annotation`, including annotation member values matching
`Set<Constructor>`	`getConstructorsAnnotatedWith(Class<? extends Annotation> annotation)` get constructors annotated with the given `annotation`
`Set<Constructor>`	`getConstructorsWithParameter(AnnotatedElement type)` get constructors with any parameter matching the given `type`, either class or annotation
`Set<Constructor>`	`getConstructorsWithSignature(Class<?>... types)` get constructors with signature matching the given `types`
`Set<Field>`	`getFieldsAnnotatedWith(Annotation annotation)` get fields annotated with the given `annotation`, including annotation member values matching
`Set<Field>`	`getFieldsAnnotatedWith(Class<? extends Annotation> annotation)` get fields annotated with the given `annotation`
`List<String>`	`getMemberParameterNames(Member member)` get parameter names of the given `member`, either method or constructor
`Collection<Member>`	`getMemberUsage(Member member)` get code usages for the given `member`, either field, method or constructor
`Set<Method>`	`getMethodsAnnotatedWith(Annotation annotation)` get methods annotated with the given `annotation`, including annotation member values matching
`Set<Method>`	`getMethodsAnnotatedWith(Class<? extends Annotation> annotation)` get methods annotated with the given `annotation`
`Set<Method>`	`getMethodsReturn(Class<?> type)` get methods with return type matching the given `returnType`
`Set<Method>`	`getMethodsWithParameter(AnnotatedElement type)` get methods with any parameter matching the given `type`, either class or annotation
`Set<Method>`	`getMethodsWithSignature(Class<?>... types)` get methods with signature matching the given `types`
`Set<String>`	`getResources(Pattern pattern)` get resources matching the given `pattern` regex
`Set<String>`	`getResources(String pattern)` get resources matching the given `pattern` regex
`Store`	`getStore()` returns the `Store` object used for storing and querying the metadata
`<T> Set<Class<? extends T>>`	`getSubTypesOf(Class<T> type)` gets all subtypes in hierarchy of a given `type`.
`Set<Class<?>>`	`getTypesAnnotatedWith(Annotation annotation)` get types annotated with the given `annotation`, both classes and annotations, including annotation member values matching
`Set<Class<?>>`	`getTypesAnnotatedWith(Annotation annotation, boolean honorInherited)` get types annotated with the given `annotation`, both classes and annotations, including annotation member values matching
`Set<Class<?>>`	`getTypesAnnotatedWith(Class<? extends Annotation> annotation)` get types annotated with the given `annotation`, both classes and annotations
`Set<Class<?>>`	`getTypesAnnotatedWith(Class<? extends Annotation> annotation, boolean honorInherited)` get types annotated with the given `annotation`, both classes and annotations
`Reflections`	`merge(Reflections reflections)` merges the given `reflections` instance metadata into this instance
`File`	`save(String filename)` serialize metadata to the given `filename`
`File`	`save(String filename, Serializer serializer)` serialize metadata to the given `filename` and `serializer`
`protected Map<String,Map<String,Set<String>>>`	`scan()`

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

Methods inherited from interface org.reflections.util.NameHelper
forClass, forConstructor, forElement, forField, forMember, forMethod, forName, forNames, forNames, toName, toName, toName, toName, toName, toNames, toNames

- Field Detail
  - log
```
public static final org.slf4j.Logger log
```
  - configuration
```
protected final transient Configuration configuration
```
  - store
```
protected final Store store
```
- Constructor Detail
  - Reflections
```
public Reflections(Configuration configuration)
```
    constructs Reflections instance and scan according to the given Configuration
    it is preferred to use ConfigurationBuilder
```
 new Reflections(new ConfigurationBuilder()...)
```
  - Reflections
```
public Reflections(Store store)
```
  - Reflections
```
public Reflections(String prefix,
                   Scanner... scanners)
```
    constructs Reflections instance and scan according to the given package prefix and optional scanners
```
 new Reflections("org.reflections")
```
    it is preferred to use ConfigurationBuilder instead, this is actually similar to:
```
 new Reflections(
   new ConfigurationBuilder()
     .forPackage(prefix)
     .setScanners(scanners))
 
```
    uses ClasspathHelper.forPackage(String, ClassLoader...) to resolve urls from given prefix
    optional scanners defaults to Scanners.TypesAnnotated and Scanners.SubTypes
  - Reflections
```
public Reflections(Object... params)
```
    Convenient constructor for Reflections.
    see the javadoc of ConfigurationBuilder.build(Object...) for details.
    it is preferred to use ConfigurationBuilder instead.
  - Reflections
```
protected Reflections()
```
- Method Detail
  - scan
```
protected Map<String,Map<String,Set<String>>> scan()
```
  - collect
```
public static Reflections collect()
```
    collect saved Reflection xml resources and merge it into a Reflections instance
    by default, resources are collected from all urls that contains the package META-INF/reflections and includes files matching the pattern .*-reflections.xml
  - collect
```
public static Reflections collect(String packagePrefix,
                                  Predicate<String> resourceNameFilter)
```
    collect saved Reflections metadata from all urls that contains the given packagePrefix and matches the given resourceNameFilter, and deserialize using the default serializer XmlSerializer
```
 Reflections.collect("META-INF/reflections/",
   new FilterBuilder().includePattern(".*-reflections\\.xml")
```
    prefer using a designated directory (for example META-INF/reflections but not just META-INF), so that collect can work much faster
  - collect
```
public static Reflections collect(String packagePrefix,
                                  Predicate<String> resourceNameFilter,
                                  Serializer serializer)
```
    collect saved Reflections metadata from all urls that contains the given packagePrefix and matches the given resourceNameFilter, and deserializes using the given serializer
```
 Reflections reflections = Reflections.collect(
   "META-INF/reflections/",
   new FilterBuilder().includePattern(".*-reflections\\.xml"),
   new XmlSerializer())
```
    prefer using a designated directory (for example META-INF/reflections but not just META-INF), so that collect can work much faster
  - collect
```
public Reflections collect(InputStream inputStream,
                           Serializer serializer)
```
    deserialize and merge saved Reflections metadata from the given inputStream and serializer
    useful if you know the serialized resource location and prefer not to look it up the classpath
  - collect
```
public Reflections collect(File file,
                           Serializer serializer)
```
    deserialize and merge saved Reflections metadata from the given file and serializer
    useful if you know the serialized resource location and prefer not to look it up the classpath
  - merge
```
public Reflections merge(Reflections reflections)
```
    merges the given reflections instance metadata into this instance
  - expandSuperTypes
```
public void expandSuperTypes(Map<String,Set<String>> subTypesStore,
                             Map<String,Set<String>> typesAnnotatedStore)
```
    expand super types after scanning, for super types that were not scanned.
    this is helpful for finding the transitive closure without scanning all 3rd party dependencies.
    for example, for classes A,B,C where A supertype of B, B supertype of C (A -> B -> C):
    - if scanning C resulted in B (B->C in store), but A was not scanned (although A is a supertype of B) - then getSubTypes(A) will not return C
    - if expanding supertypes, B will be expanded with A (A->B in store) - then getSubTypes(A) will return C
  - get
```
public <T> Set<T> get(QueryFunction<Store,T> query)
```
    apply QueryFunction on Store
```
 Set<T> ts = get(query)
```
    use Scanners and ReflectionUtils query functions, such as:
```
 Set<String> annotated = get(Scanners.TypesAnnotated.with(A.class))
 Set<Class<?>> subtypes = get(Scanners.SubTypes.of(B.class).asClass())
 Set<Method> methods = get(ReflectionUtils.Methods.of(B.class))
 
```
  - getSubTypesOf
```
public <T> Set<Class<? extends T>> getSubTypesOf(Class<T> type)
```
    gets all subtypes in hierarchy of a given type.
    similar to get(SubTypes.of(type))
    depends on Scanners.SubTypes configured
  - getTypesAnnotatedWith
```
public Set<Class<?>> getTypesAnnotatedWith(Class<? extends Annotation> annotation)
```
    get types annotated with the given annotation, both classes and annotations
    Inherited is not honored by default, see getTypesAnnotatedWith(Class, boolean).
    similar to get(SubTypes.of(TypesAnnotated.with(annotation)))
    depends on Scanners.TypesAnnotated and Scanners.SubTypes configured
  - getTypesAnnotatedWith
```
public Set<Class<?>> getTypesAnnotatedWith(Class<? extends Annotation> annotation,
                                           boolean honorInherited)
```
    get types annotated with the given annotation, both classes and annotations
    Inherited is honored according to the given honorInherited.
    when honoring @Inherited, meta-annotation should only effect annotated super classes and subtypes
    when not honoring @Inherited, meta annotation effects all subtypes, including annotations interfaces and classes
    Note that this (@Inherited) meta-annotation type has no effect if the annotated type is used for anything other then a class. Also, this meta-annotation causes annotations to be inherited only from superclasses; annotations on implemented interfaces have no effect.
    depends on Scanners.TypesAnnotated and Scanners.SubTypes configured
  - getTypesAnnotatedWith
```
public Set<Class<?>> getTypesAnnotatedWith(Annotation annotation)
```
    get types annotated with the given annotation, both classes and annotations, including annotation member values matching
    Inherited is not honored by default, see getTypesAnnotatedWith(Annotation, boolean).
    depends on Scanners.TypesAnnotated and Scanners.SubTypes configured
  - getTypesAnnotatedWith
```
public Set<Class<?>> getTypesAnnotatedWith(Annotation annotation,
                                           boolean honorInherited)
```
    get types annotated with the given annotation, both classes and annotations, including annotation member values matching
    Inherited is honored according to given honorInherited
    depends on Scanners.TypesAnnotated and Scanners.SubTypes configured
  - getMethodsAnnotatedWith
```
public Set<Method> getMethodsAnnotatedWith(Class<? extends Annotation> annotation)
```
    get methods annotated with the given annotation
    similar to get(MethodsAnnotated.with(annotation))
    depends on Scanners.MethodsAnnotated configured
  - getMethodsAnnotatedWith
```
public Set<Method> getMethodsAnnotatedWith(Annotation annotation)
```
    get methods annotated with the given annotation, including annotation member values matching
    similar to get(MethodsAnnotated.with(annotation))
    depends on Scanners.MethodsAnnotated configured
  - getMethodsWithSignature
```
public Set<Method> getMethodsWithSignature(Class<?>... types)
```
    get methods with signature matching the given types
    similar to get(MethodsSignature.of(types))
    depends on Scanners.MethodsSignature configured
  - getMethodsWithParameter
```
public Set<Method> getMethodsWithParameter(AnnotatedElement type)
```
    get methods with any parameter matching the given type, either class or annotation
    similar to get(MethodsParameter.with(type))
    depends on Scanners.MethodsParameter configured
  - getMethodsReturn
```
public Set<Method> getMethodsReturn(Class<?> type)
```
    get methods with return type matching the given returnType
    similar to get(MethodsReturn.of(type))
    depends on Scanners.MethodsParameter configured
  - getConstructorsAnnotatedWith
```
public Set<Constructor> getConstructorsAnnotatedWith(Class<? extends Annotation> annotation)
```
    get constructors annotated with the given annotation
    similar to get(ConstructorsAnnotated.with(annotation))
    depends on Scanners.ConstructorsAnnotated configured
  - getConstructorsAnnotatedWith
```
public Set<Constructor> getConstructorsAnnotatedWith(Annotation annotation)
```
    get constructors annotated with the given annotation, including annotation member values matching
    similar to get(ConstructorsAnnotated.with(annotation))
    depends on Scanners.ConstructorsAnnotated configured
  - getConstructorsWithSignature
```
public Set<Constructor> getConstructorsWithSignature(Class<?>... types)
```
    get constructors with signature matching the given types
    similar to get(ConstructorsSignature.with(types))
    depends on Scanners.ConstructorsSignature configured
  - getConstructorsWithParameter
```
public Set<Constructor> getConstructorsWithParameter(AnnotatedElement type)
```
    get constructors with any parameter matching the given type, either class or annotation
    similar to get(ConstructorsParameter.with(types))
    depends on Scanners.ConstructorsParameter configured
  - getFieldsAnnotatedWith
```
public Set<Field> getFieldsAnnotatedWith(Class<? extends Annotation> annotation)
```
    get fields annotated with the given annotation
    similar to get(FieldsAnnotated.with(annotation))
    depends on Scanners.FieldsAnnotated configured
  - getFieldsAnnotatedWith
```
public Set<Field> getFieldsAnnotatedWith(Annotation annotation)
```
    get fields annotated with the given annotation, including annotation member values matching
    similar to get(FieldsAnnotated.with(annotation))
    depends on Scanners.FieldsAnnotated configured
  - getResources
```
public Set<String> getResources(String pattern)
```
    get resources matching the given pattern regex
```
 Set<String> xmls = reflections.getResources(".\*\.xml")
```
    similar to get(Resources.with(pattern))
    depends on Scanners.Resources configured
  - getResources
```
public Set<String> getResources(Pattern pattern)
```
    get resources matching the given pattern regex
```
 Set<String> xmls = reflections.getResources(Pattern.compile(".\*\.xml"))
```
    similar to get(Resources.with(pattern))
    depends on Scanners.Resources configured
  - getMemberParameterNames
```
public List<String> getMemberParameterNames(Member member)
```
    get parameter names of the given member, either method or constructor
    depends on MethodParameterNamesScanner configured
  - getMemberUsage
```
public Collection<Member> getMemberUsage(Member member)
```
    get code usages for the given member, either field, method or constructor
    depends on MemberUsageScanner configured
  - getAllTypes
```
@Deprecated
public Set<String> getAllTypes()
```
    Deprecated.
    
    returns all keys and values scanned by Scanners.SubTypes scanner
    using this api is discouraged, it is better to get elements by specific criteria such as SubTypes.of(Class) or TypesAnnotated.with(Class)
    deprecated, use getAll(Scanner) instead
  - getAll
```
public Set<String> getAll(Scanner scanner)
```
    returns all key and values scanned by the given scanner
```
 Set<String> all = reflections.getAll(SubTypes)
```
    using this is discouraged, it is better to get elements by specific criteria such as SubTypes.of(Class) or TypesAnnotated.with(Class)
  - getStore
```
public Store getStore()
```
    returns the Store object used for storing and querying the metadata
    Store is basically Map<String, Map<String, Set<String>>>
  - getConfiguration
```
public Configuration getConfiguration()
```
    returns the Configuration object of this instance
  - save
```
public File save(String filename)
```
    serialize metadata to the given filename
    prefer using a designated directory (for example META-INF/reflections but not just META-INF), so that collect(String, Predicate) can work much faster
  - save
```
public File save(String filename,
                 Serializer serializer)
```
    serialize metadata to the given filename and serializer
    prefer using a designated directory (for example META-INF/reflections but not just META-INF), so that collect(String, Predicate, Serializer) can work much faster

Class Reflections

Field Summary

Fields inherited from interface org.reflections.util.NameHelper

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.reflections.util.NameHelper

Field Detail

log

configuration

store

Constructor Detail

Reflections

Reflections

Reflections

Reflections

Reflections

Method Detail

scan

collect

collect

collect

collect

collect

merge

expandSuperTypes

get

getSubTypesOf

getTypesAnnotatedWith

getTypesAnnotatedWith

getTypesAnnotatedWith

getTypesAnnotatedWith

getMethodsAnnotatedWith

getMethodsAnnotatedWith

getMethodsWithSignature

getMethodsWithParameter

getMethodsReturn

getConstructorsAnnotatedWith

getConstructorsAnnotatedWith

getConstructorsWithSignature

getConstructorsWithParameter

getFieldsAnnotatedWith

getFieldsAnnotatedWith

getResources

getResources

getMemberParameterNames

getMemberUsage

getAllTypes

getAll

getStore

getConfiguration

save

save