Interface | Description |
---|---|
AnnotatedElement |
An annotated element is some point in the code, whether it be a constructor, field,
method etc.
|
AnnotatedTypeInfo |
An interface that provides an abstraction for checking for the existence of annotations.
|
AnnotationMetadata |
An interface implemented at compile time by Micronaut that allows the inspection of annotation metadata and
stereotypes (meta-annotations)
|
AnnotationMetadataDelegate |
An interface that can be implemented by other classes that delegate the resolution of the
AnnotationMetadata
to the AnnotationMetadataProvider.getAnnotationMetadata() method. |
AnnotationMetadataProvider |
An interface for a type that provides
AnnotationMetadata . |
AnnotationMetadataResolver |
An interface for types capable of resolving
AnnotationMetadata . |
AnnotationSource |
A source of annotations.
|
AnnotationValueProvider<A extends Annotation> |
An interface that allows obtaining an underlying annotation value.
|
AnnotationValueResolver |
Interface for types that resolve annotation values.
|
Class | Description |
---|---|
AnnotationClassValue<T> |
An annotation class value is a reference to a class in annotation metadata.
|
AnnotationUtil |
Internal utility methods for annotations.
|
AnnotationValue<A extends Annotation> |
A runtime representation of the an annotation and its values.
|
AnnotationValueBuilder<T extends Annotation> |
A build for annotation values.
|
Enum | Description |
---|---|
Introspected.AccessKind |
The access type for bean properties.
|
Introspected.Visibility |
Visibility policy for bean properties and fields.
|
TypeHint.AccessType |
The access type.
|
Annotation Type | Description |
---|---|
AccessorsStyle |
Annotate a class (typically a Java Bean) to make it explicit the style of its accessors when not using the standard
getter and setters:
@AccessorsStyle(readPrefixes = {""}, writePrefixes = {""}) public class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public String name() { return this.name; } public void name(String name) { this.name = name; } public int age() { return this.age; } public void age(int age) { this.age = age; } } |
Blocking |
A marker annotation for methods that are blocking.
|
Creator |
An annotation applicable to a constructor that provides a hint as to which constructor is the primary constructor.
|
EntryPoint |
EntryPoint is a meta-annotation used on other annotations to indicate that the annotated
element is an entry point into the framework from the outside.
|
Experimental |
Annotates a class or method as being experimental and subject to change or removal.
|
Generated |
A marker annotation for methods that are generated though an annotation processor.
|
Indexed |
An annotation that can be used on types where there may be many implementations of a
particular interface.
|
Indexes |
Allows
Indexed to be repeatable. |
InstantiatedMember |
An annotation that can be used on another annotation member that returns a class to indicate that
the value of the annotation should be populated as an instance of the specified class.
|
Internal |
Annotates a class or method regarded as internal and not for public consumption.
|
Introspected |
An annotation that indicates a type should produce a
BeanIntrospection at compilation time. |
Introspected.IndexedAnnotation |
Allow pre-computed indexes for property lookups based on an annotation and a member.
|
NonBlocking |
A marker annotation for methods that are non-blocking.
|
NonNull |
A common annotation to declare that annotated elements cannot be
null . |
Nullable |
A common annotation to declare that annotated elements can be
null under some circumstance. |
Order |
Annotation for objects that are ordered.
|
ReflectionConfig |
An annotation that models directly the GraalVM reflect-config.json format.
|
ReflectionConfig.ReflectionConfigList |
Wrapper annotation.
|
ReflectionConfig.ReflectiveFieldConfig |
Field configuration.
|
ReflectionConfig.ReflectiveMethodConfig |
Method configuration.
|
ReflectiveAccess |
Descriptive annotation that can be used to declare a field, method, constructor and types for reflective access.
|
TypeHint |
The type hint annotation is a general annotation that can be used on interfaces to provide
additional information about types used at runtime.
|
UsedByGeneratedCode |
A marker annotation indicating that a method is used by generated code and should
not be modified or removed otherwise a binary compatibility problem will be introduced.
|