ronmamo/reflections
Reflections
Reflections is a Java classpath scanning library and metadata indexer designed to locate classes, methods, and resources at runtime. It functions as a tool for annotation discovery and type hierarchy analysis, allowing the system to identify elements marked with specific annotations or to resolve super-types and subtypes within the Java virtual machine.
The project distinguishes itself through metadata serialization, providing mechanisms to save the scanned index to persistent files or source code. This capability reduces application startup overhead by eliminating the need for repeated, expensive classpath scans.
The library covers broad capability areas including the indexing of class members based on signatures and access modifiers, the discovery of non-bytecode resource files, and the use of functional query composition to filter and transform type system metadata. It also provides configuration utilities to define scan boundaries and inclusion patterns for improved performance.
Features
- Classpath Metadata Indexing - Builds a searchable index of types and members from the Java classpath to avoid repeated expensive scans.
- Index Deserialization - Reconstructs a metadata index of the project classpath by reading a persisted source file from an input stream.
- Class Member Indexing - Scans and extracts signatures of methods, constructors, and fields from compiled Java bytecode.
- Class Member Search - Locates class members based on criteria such as name, parameter types, or access modifiers.
- Subtype Discovery - Locates all classes that extend or implement a specific type, including both direct and transitive descendants.
- Bytecode Analysis - Implements bytecode analysis to extract type signatures and annotations without loading classes into the JVM.
- Classpath Scanning Libraries - Provides a library for indexing and querying Java classes, methods, and resources at runtime.
- Java Classpath Scanning - Searches the Java classpath at runtime to locate classes, resources, and methods based on specific patterns.
- Metadata Serialization - Persists the runtime metadata index to files to eliminate scanning overhead during application startup.
- Annotated Class Discovery - Automatically detects and registers classes marked with specific Java annotations during runtime.
- Runtime Hierarchy Analysis - Provides a utility for discovering subtypes and resolving super-types within the Java virtual machine runtime environment.
- Index Persistence - Provides mechanisms to save in-memory classpath indexes to disk to reduce application initialization time.
- Non-Bytecode Resource Indexing - Indexes non-bytecode files such as properties or configuration files found on the classpath.
- Annotation Indexing - Organizes extracted annotations using class names as keys for optimized retrieval of annotated elements.
- Hierarchy Indexing - Scans the classpath to identify and index all superclasses and interfaces for a given type.
- Hierarchy Querying - Identifies supertypes, superclasses, and interfaces associated with a given class to analyze inheritance structures.
- Classpath Resource Retrieval - Identifies and retrieves specific resource files directly from the project classpath.
- Element Location - Identifies specific methods, constructors, or fields marked with specific Java annotations.
- Type Metadata Query Composition - Provides a mechanism to compose multiple metadata filters and mapping operations for precise type system querying.
- Type Metadata Querying - Retrieves member signatures using detailed filters for return types, parameter types, or parameter annotations.
- Type Metadata Transformations - Applies functional operations like mapping and filtering to transform retrieved runtime type system information.
- Type Hierarchies - Analyzes inheritance structures at runtime to identify all supertypes and subtypes of a given class.
- Transitive Subtype Resolution - Recursively resolves the full hierarchy of superclasses and interfaces to identify all transitive subtypes.
- Classpath Resource Discovery - Locates non-bytecode files and resources on the classpath using regular expression patterns and inclusion filters.
- Introspection and Reflection - Scans and indexes classpath metadata for runtime querying.
