在线时间:8:00-16:00
迪恩网络APP
随时随地掌握行业动态
扫描二维码
关注迪恩网络微信公众号
开源软件名称:ronmamo/reflections开源软件地址:https://github.com/ronmamo/reflections开源编程语言:Java 100.0%开源软件介绍:Released Reflections library has ~4 million downloads per month from Maven Central, and is being used by thousands of projects and libraries. Java runtime metadata analysisReflections 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:
Reflections was written in the spirit of Scannotations library UsageAdd 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. ScanCreating 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:
QueryOnce 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. Note that previous 0.9.x APIs are still supported Compare Scanners and previous 0.9.x API (*)
Note: (1): The equivalent of (2): MethodsAnnotatedScanner does not include constructor annotation scanning, use instead Scanners.ConstructorsAnnotated (3): MethodParameterScanner is obsolete, use instead as required: ReflectionUtilsApart 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 APIEach Scanner and ReflectionUtils function implements QueryBuilder, and supports:
For example, Next, each function implements QueryFunction,
and provides fluent functional interface for composing // 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 folder for more examples and API usage What else?
ContributePull requests are welcomed!! 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. Cheers |
2023-10-27
2022-08-15
2022-08-17
2022-09-23
2022-08-13
请发表评论