Package io.micronaut.reflection

@NullMarked package io.micronaut.reflection

Reflective implementations of the metadata the annotation processors generate at compilation time, for the types they never saw.

The framework describes a type through AnnotationMetadata, Argument, ExecutableMethod, BeanIntrospection and BeanDefinition, all of them generated when the type is compiled. A specification that has to handle any class - Jakarta Validation, Jakarta REST, CDI - meets types that were not compiled with the processors, and has to describe them through java.lang.reflect instead. This package builds the same metadata from reflection, in the shape the processors give it, so that code written against generated metadata works unchanged:

• ReflectionAnnotations - the annotation metadata of an element, with the stereotypes, the repeatable containers and the defaults the processors record;
• ReflectionArguments - the arguments of the parameters, fields and return types, with the type-use annotations of every level;
• ReflectionExecutableMethod and ReflectionBeanConstructor - an executable over a Method or a Constructor, and ReflectionExecutables to resolve one to the best metadata available;
• ReflectionBeanIntrospection - an introspection over a class, and ReflectionBeanIntrospector to serve the generated ones first;
• ReflectionBeanDefinition - a bean definition over a class, registered at runtime, with the injection points and the life cycle of a generated one;
• MethodHierarchy - what each level of a method hierarchy declares.

Every type of this package is Experimental: reading a class back is what the framework is built to avoid, and an application says it wants it by depending on this module and, for the shared introspector, by allowing the types through ReflectionIntrospectionPolicy.

Since:

5.2.0

Class	Description
IntrospectedExecutableMethod<T,R>	An ExecutableMethod over the BeanMethod of a bean introspection, for a specification API that names a method by its Method: the arguments and the metadata are the ones the introspection carries, generated or reflective, and the method itself is the one the caller gave.
MethodHierarchy	What a method hierarchy declares: the method as a caller names it, what its declaring type itself declares, the declarations it overrides or implements, and the three merged into one view.
MethodHierarchy.Declaration	One declaration of a method by one type of a hierarchy.
ReflectionAnnotationCustomizer	The runtime counterpart of the annotation mappers, transformers and remappers of the annotation processors, for the metadata ReflectionAnnotations builds reflectively.
ReflectionAnnotations	Builds AnnotationMetadata and AnnotationValues from the annotations read reflectively from an AnnotatedElement, in the shape the annotation processors give the metadata they generate at compilation time.
ReflectionArguments	Builds Arguments from the types read reflectively from parameters, fields, return types and type hierarchies, in the shape the annotation processors give the arguments they generate: the raw type, the type arguments recursively, the type variables as GenericPlaceholders, and the annotations of the element and of every level of its type as metadata built by ReflectionAnnotations.
ReflectionBeanConstructor<T>	A BeanConstructor over a Constructor, with the arguments and the annotation metadata a generated constructor would have.
ReflectionBeanDefinition<T>	A BeanDefinition over a Class, with the injection points, the executable methods and the life cycle a generated definition would have, to register a type the annotation processors never saw with a bean context at runtime.
ReflectionBeanDefinition.Builder<T>	Builds the definition of a type, reading the class for what the builder does not set.
ReflectionBeanIntrospection<T>	A BeanIntrospection over a Class, with the properties, the constructor and the methods a generated introspection would have.
ReflectionBeanIntrospectionFallback	The BeanIntrospectionFallback describing reflectively the types the shared introspector has no generated introspection for, when ReflectionIntrospectionPolicy allows them.
ReflectionBeanIntrospector	A BeanIntrospector that serves the generated introspections of another introspector first, and a ReflectionBeanIntrospection for a type that has none.
ReflectionExecutableMethod<T,R>	An ExecutableMethod over a Method, with the arguments, the return type and the annotation metadata a generated executable method would have.
ReflectionExecutables	The adapters of a specification API that names an executable by its Method or Constructor: the generated metadata is used when it describes the named executable, and the reflective metadata of this package otherwise - the one reflective step an API defined on java.lang.reflect imposes.
ReflectionIntrospectionConfiguration	Applies the "micronaut.introspection.allow-reflection" property of the application configuration to the ReflectionIntrospectionPolicy when the context starts, and takes it back when the context closes, leaving the patterns of the contexts that are still running.
ReflectionIntrospectionConfiguration.Description	The types matching a set of patterns, and the Introspected members the shared introspector describes them with.
ReflectionIntrospectionConfiguration.Description.Indexed	An annotation the properties carrying it are indexed by.
ReflectionIntrospectionPolicy	The types the shared BeanIntrospector may describe reflectively when it has no generated introspection for them.
ReflectionIntrospectionPolicy.Registration	The patterns one ReflectionIntrospectionPolicy.configure(Collection) call contributed, which closing takes back.
ReflectiveIntrospection<T>	What a reflective introspection knows beyond the BeanIntrospection contract: every constructor of the type, and the members a property is made of, each with the class declaring it and its own metadata.
ReflectiveIntrospection.ReflectivePropertyMember<B>	A member of a property, with the field or method reflection read it from.
SupplementedBeanIntrospection<T>	A generated BeanIntrospection completed by a reflective one: the properties, the constructor and the methods the processor generated are served as generated, and the executables it left out — the methods that are not @Executable, the other constructors — come from reflection.