Reflections alternatives and similar libraries
Based on the "Introspection" category.
Alternatively, view Reflections alternatives based on common mentions on social networks and blogs.
7.5 1.6 Reflections VS jOORjOOR - 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.
7.0 9.2 Reflections VS ClassGraphAn uber-fast parallelized Java classpath scanner and module scanner.
4.6 6.8 Reflections VS ObjenesisOkay, 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.
Do you think we are missing an alternative of Reflections or a related project?
org.reflections:reflections:0.9.12 - with support for Java 8
Reflections library has over 2.5 million downloads per month from Maven Central, and is being used by thousands of projects and libraries. We're looking for maintainers to assist in reviewing pull requests and managing releases, please reach out.
Java runtime metadata analysis, in the spirit of Scannotations
Reflections scans your classpath, indexes the metadata, allows you to query it on runtime and may save and collect that information for many modules within your project.
Using Reflections you can query your metadata such as:
- get all subtypes of some type
- get all types/members annotated with some annotation
- get all resources matching a regular expression
- get all methods with specific signature including parameters, parameter annotations and return type
Add Reflections to your project. for maven projects just add this dependency:
<dependency> <groupId>org.reflections</groupId> <artifactId>reflections</artifactId> <version>0.9.12</version> </dependency>
A typical use of Reflections would be:
Reflections reflections = new Reflections("my.project"); Set<Class<? extends SomeType>> subTypes = reflections.getSubTypesOf(SomeType.class); Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(SomeAnnotation.class);
Basically, to use Reflections first instantiate it with urls and scanners
//scan urls that contain 'my.package', include inputs starting with 'my.package', use the default scanners Reflections reflections = new Reflections("my.package"); //or using ConfigurationBuilder new Reflections(new ConfigurationBuilder() .setUrls(ClasspathHelper.forPackage("my.project.prefix")) .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner().filterResultsBy(optionalFilter), ...), .filterInputsBy(new FilterBuilder().includePackage("my.project.prefix")) ...);
Then use the convenient query methods: (depending on the scanners configured)
//SubTypesScanner Set<Class<? extends Module>> modules = reflections.getSubTypesOf(com.google.inject.Module.class);
//TypeAnnotationsScanner Set<Class<?>> singletons = reflections.getTypesAnnotatedWith(javax.inject.Singleton.class);
//ResourcesScanner Set<String> properties = reflections.getResources(Pattern.compile(".*\\.properties"));
//MethodAnnotationsScanner Set<Method> resources = reflections.getMethodsAnnotatedWith(javax.ws.rs.Path.class); Set<Constructor> injectables = reflections.getConstructorsAnnotatedWith(javax.inject.Inject.class);
//FieldAnnotationsScanner Set<Field> ids = reflections.getFieldsAnnotatedWith(javax.persistence.Id.class);
//MethodParameterScanner Set<Method> someMethods = reflections.getMethodsMatchParams(long.class, int.class); Set<Method> voidMethods = reflections.getMethodsReturn(void.class); Set<Method> pathParamMethods = reflections.getMethodsWithAnyParamAnnotated(PathParam.class);
//MethodParameterNamesScanner List<String> parameterNames = reflections.getMethodParamNames(Method.class)
//MemberUsageScanner Set<Member> usages = reflections.getMethodUsages(Method.class)
- If no scanners are configured, the default will be used -
- Classloader can also be configured, which will be used for resolving runtime classes from names.
- Reflections expands super types by default. This solves some problems with transitive urls are not scanned.
Checkout the javadoc for more info.
Also, browse the tests directory to see some more examples.
ReflectionsUtils contains some convenient Java reflection helper methods for getting types/constructors/methods/fields/annotations matching some predicates, generally in the form of *getAllXXX(type, withYYY)
import static org.reflections.ReflectionUtils.*; Set<Method> getters = getAllMethods(someClass, withModifier(Modifier.PUBLIC), withPrefix("get"), withParametersCount(0)); //or Set<Method> listMethodsFromCollectionToBoolean = getAllMethods(List.class, withParametersAssignableTo(Collection.class), withReturnType(boolean.class)); Set<Field> fields = getAllFields(SomeClass.class, withAnnotation(annotation), withTypeAssignableTo(type));
See more in the ReflectionUtils javadoc
Integrating into your build lifecycle
Although scanning can be easily done on bootstrap time of your application - and shouldn't take long, it is sometime a good idea to integrate Reflections into your build lifecyle. With simple Maven/Gradle/SBT/whatever configuration you can save all scanned metadata into xml/json files just after compile time. Later on, when your project is bootstrapping you can let Reflections collect all those resources and re-create that metadata for you, making it available at runtime without re-scanning the classpath.
For Maven, see example using gmavenplus in the reflections-maven repository
Other use cases
See the UseCases wiki page
Pull requests are welcomed!!
Apologize for not maintaining this repository continuously! We're looking for maintainers to assist in reviewing pull requests and managing releases, please reach out.
The license is WTFPL, just do what the fuck you want to.
This library is published as an act of giving and generosity, from developers to developers.
Please feel free to use it, and to contribute to the developers community in the same manner. Dāna
*Note that all licence references and agreements mentioned in the Reflections README section above are relevant to that project's source code only.