All Classes and Interfaces
Class
Description
Deprecated, for removal: This API element is subject to removal in a future version.
An abstract
AnnotatedArgumentBinder implementation.Abstract implementation of the
BeanConstructor interface.Abstract bean introspection reference used by
BeanIntrospector to soft load introspections.Abstract implementation of the
BeanMethod interface.Abstract implementation of
BeanProperty.Provides an abstract class which implements
LocaleResolver and handles default locale resolution.Annotate a class (typically a Java Bean) to make it explicit the style of its accessors when not using the standard
getter and setters:
An
ArgumentBinder whose lookup is driven by an annotation definition.An annotated element is some point in the code, whether it be a constructor, field,
method etc.
An interface that provides an abstraction for checking for the existence of annotations.
An annotation class value is a reference to a class in annotation metadata.
The annotation default values provider.
An interface implemented at compile time by Micronaut that allows the inspection of annotation metadata and
stereotypes (meta-annotations)
An interface that can be implemented by other classes that delegate the resolution of the
AnnotationMetadata
to the AnnotationMetadataProvider.getAnnotationMetadata() method.An interface for a type that provides
AnnotationMetadata.An interface for types capable of resolving
AnnotationMetadata.Interface for classes that scan for classes with a given annotation.
A source of annotations.
Internal utility methods for annotations.
A runtime representation of the annotation and its values.
A build for annotation values.
An interface that allows obtaining an underlying annotation value.
Interface for types that resolve annotation values.
PathMatcher implementation for Ant-style path patterns.
Represents an argument to a method or constructor or type.
An interface capable of binding the value of an
Argument from a sourceThe result of binding.
A registry of
ArgumentBinder instances.An interface for types that can be represented as an
Argument.Extended version of the
ConversionContext specifically for conversion Argument instances.Utility methods for checking method argument values.
Allows producing error messages.
Functional interface the check a condition.
An
Argument with a value.Utility methods for working with arrays.
An interface for objects that have attributes.
Models a bean constructor.
An exception handler capable of receiving a bean that originated the exception and an exception type.
Top level interface for obtaining bean information.
A
BeanIntrospection is the result of compile time computation of a beans properties and annotation metadata.A builder style API for creating instances that abstracts whether the instance is a record, bean or created by another builder.
A reference to a
BeanIntrospection that may or may not be present on the classpath.An implementation of
AnnotationScanner that scans available BeanIntrospection
instances through the BeanIntrospector API.Primary interface for obtaining
BeanIntrospection instances that are computed at compilation time.Simple class that provides a map interface over a bean.
Represents a method on a
BeanIntrospection.Represents a bean property and associated annotation metadata.
An interface that provides the ability to bind Maps and Java bean properties
Represents a read write property of a bean.
Wraps a bean allowing to read and write its properties via an underlying
BeanIntrospection.Represents a write property of a bean.
An annotation stereotype for other annotations that indicates a method
Argument is bindable.A marker annotation for methods that are blocking.
A bound
Executable is an executable who argument values have been pre-bound to
values using a ArgumentBinderRegistry.Interface to allow interfacing with different byte buffer implementations, primarily as an abstraction over Netty.
An allocator for
ByteBuffer instances.The converter that converts
CharSequence to an enum.Abstraction to load resources from the classpath.
Utility methods for loading classes.
Optimizations for computing missing types.
Utility methods for working with
Collection typesRepresents the parsed command line options.
A build for constructing a command line parser.
The completable future execution flow.
A hash table supporting full concurrency of retrievals, adjustable expected
concurrency for updates, and a maximum capacity to bound the map by.
A builder that creates
ConcurrentLinkedHashMap instances.A conversion context is a context object supplied to a
TypeConverter that allows more accurate conversion.An interface for reporting conversion errors.
An exception thrown in the case of a
ConversionError.A service for allowing conversion from one type to another.
Interface used when the component requires to set up bean context's
ConversionService.Interface for a component to provide the access to its
ConversionService.Specialization of
ConvertibleValues where each name has multiple possible values.An implementation of
ConvertibleMultiValues that uses a backing LinkedHashMap.An interface for classes that represent a map-like structure of values that can be converted.
An implementation of
ConvertibleValues backed by a map.Thread-safe map that is optimized for reads.
An annotation applicable to a constructor that provides a hint as to which constructor is the primary constructor.
Represents an argument to a constructor or method.
Loads resources from the classpath.
Default implementation of the
ExecutableBinder interface.Loads resources from the file system.
The default conversion service.
ExecutionFlow that can be completed similar to a
CompletableFuture.Delegate class for
ByteBuffer.An interface for types that are described by a description.
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.
A class that can determine the weight of an entry.
A variation of
BeanIntrospection that is representing an enum as a bean.The enum constant.
A mapping from environment variable names to Micronaut
property names.
Interface for reporting conversion errors.
Expression included in annotation metadata which can be evaluated at runtime.
Wrapper for annotation value, containing evaluated expressions and
class name for generated expression class.
A listener registered for notification when an entry is evicted.
Common interface for types that handle exceptions.
Represents an executable reference.
An ExecutableBinder is capable of taking a target
Executable and fulfilling the argument
requirements using the provided binding source and ArgumentBinderRegistryThe execution flow class represents a data flow which state can be represented as a simple imperative flow or an async/reactive.
Annotates a class or method as being experimental and subject to change or removal.
Context that can be used by evaluated expression to obtain objects required
for evaluation process.
Abstraction to load resources from the file system.
Generic implementation of
LocaleResolver for fixed locale resolution.Annotation used to describe the format in the case where the format needs to be altered for the purposes of
conversion.
A marker annotation for methods that are generated though an annotation processor.
Captures a generic
Argument.Extends
Argument to allow differentiating the
variable name from the argument name in cases where this is
required (parameters and fields for example).Utility methods for dealing with generic types via reflection.
Interface that allows dynamic configuration of reflection generated by the GraalTypeElementVisitor.
Context object for the configuration.
Common interface for all headers types.
Immutable variant of
ArgumentConversionContext that can be used as a constant
in cases where conversion error handling and rejection is not required.The imperative execution flow.
An annotation that can be used on types where there may be many implementations of a
particular interface.
Allows
Indexed to be repeatable.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.
Thrown when an error occurs instantiating an instance.
Utility methods for instantiating objects.
Annotates a class or method regarded as internal and not for public consumption.
An annotation that indicates a type should produce a
BeanIntrospection at compilation time.The access type for bean properties.
Allow pre-computed indexes for property lookups based on an annotation and a member.
Configuration for an introspection builder.
Visibility policy for bean properties and fields.
Thrown when an error occurs introspecting a bean type.
Runtime exception equivalent of
InvocationTargetException.Utility to use a
BiFunction which throws internally a IOException.Utility methods for I/O operations.
A
ObjectSerializer that uses JDK serialization.Internal Utility methods for working with Kotlin
suspend functionsLocale resolution configuration.
Responsible for determining the current locale given a context.
Allows configuration how map property values are injected.
Specifies the type of the map that should be injected.
A
PropertyResolver that resolves values from a backing map.Represents the built in conventions for mapping a method name to an HTTP Method and URI.
A factory for creation of various
FormattingTypeConverters to and from ConvertibleMultiValues type.An abstract class to convert to ConvertibleMultiValues.
A converter from
Iterable to ConvertibleMultiValues.A converter from
Map to ConvertibleMultiValues.A converter to convert from
ConvertibleMultiValues to an Iterable.A converter to convert from
ConvertibleMultiValues to an Map.A converter to convert from
ConvertibleMultiValues to a POJO Object.A converter from generic
Object to ConvertibleMultiValues.A mutable version of the
ArgumentValue interface.An interface for types that support mutating attributes.
A version of
ConversionService that supports adding new converters.Implementation of
MutableConvertibleMultiValues that operates against a backing LinkedHashMap.A
ConvertibleValues that is mutable.Mutable version of
ConvertibleMultiValuesMap.Common interface for all mutable header types.
Mutable propagated context will modify the internal context
Intended for use-cases when the propagated context needs to be mutated and propagated later.
An interface for components that are named.
An interface for a components that resolve names.
Naming convention utilities.
Documents the code change that needs to be done in the next major version.
A marker annotation for methods that are non-blocking.
A common annotation to declare that annotated elements cannot be
null.A common annotation to declare that annotated elements can be
null under some circumstance.Interface for implementations capable of serializing objects.
Utility methods for working with objects
Represents a command line option.
A simple type safe abstraction over a map of optional values.
Default implementation of
OptionalValues.Annotation for objects that are ordered.
Interface for objects that are ordered.
Apply the
Ordered interface to lists or arrays.Exception that is thrown in command line parsing fails.
Interface for components that can match source strings against a specified pattern string.
The propagation across different threads using the context which is immutable and can be extended/reduced by different elements.
Context propagation
AutoCloseable to be used in try-resource block.Propagated element of
PropagatedContext.Typical conventions used for property names through the system.
Thrown when a property cannot be resolved.
A property resolver is capable of resolving properties from an underlying property source.
Used by
ReadableBytesTypeConverter to parse strings in the form 1MB to numbers.Converts String's to readable bytes.
An annotation that models directly the GraalVM reflect-config.json format.
Wrapper annotation.
Field configuration.
Method configuration.
Utility methods for reflection related tasks.
Descriptive annotation that can be used to declare a field, method, constructor and types for reflective access.
PathMatcher implementation for regex-style patterns.
Basic abstraction over resource loading.
Resolves resources from a set of
ResourceLoader instances.Models a return type of
Executable method in Micronaut.Utility class for comparing semantic versions.
A generic exception that occurs during serialization or deserialization.
A service that may or may not be present on the classpath.
Utility methods for dealing with sockets.
Variation of
ServiceLoader that allows soft loading and conditional loading of
META-INF/services classes.Static optimizations for service loaders.
Service collector for loading services of the given type.
A
ServiceDefinition implementation that uses a MethodHandles.Lookup object to find a public constructor.Service loader that uses
SoftServiceLoader.StaticDefinition.This class is a generic container for pre-computed data
which can be injected at initialization time.
Interface for an optimization which will be injected via
service loading.
Interface for types that can be written to an
OutputStream.Utility methods for working with streams.
An enum representing different conventions.
Fixed-size String->int map optimized for very fast read operations.
Utility methods for Strings.
Helper methods for dealing with
Supplier.Special version of
PropagatedContextElement that is thread-aware and can update the thread context on the initial propagation entry
and restore it on the propagation exist.Represents a function that accepts one argument and produces a result.
Represents a supplier of results.
An interface for components or configurations that can be toggled on or off.
An
ArgumentBinder that is resolved based on the argument type.Common conventions for types
A type converter for converting from one type to another.
An interface for classes that register type conversions with the
ConversionService.The type hint annotation is a general annotation that can be used on interfaces to provide
additional information about types used at runtime.
The access type.
Provides information about a type at runtime.
Interface that implementors can hook into to control the logic of methods like
TypeInformation.isReactive().An interface for types that hold and can resolve type variables.
A variation of
BeanIntrospection that includes UnsafeBeanInstantiationIntrospection.instantiateUnsafe(Object...) allowing to skip instantiation validation.Unsafe bean property interface adds read/write methods which don't validate the input/output.
Unsafe bean property interface adds read methods which don't validate the input/output.
Unsafe bean property interface adds write methods which don't validate the input/output.
A variation of
Executable that exposes invoke method without arguments validation.An exception thrown when an
Argument could not be satisfied
by a ExecutableBinder.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.
An exception that occurs related to configuration.
An interface for any type that is able to resolve and convert values.
Annotation used to express the version of a component or method.
Utility methods for versioning.
Veto the processing of the element.
A class that can determine the weight of a value.
A common set of
Weigher and EntryWeigher implementations.An interface for classes to implement that are capable of writing themselves to a
Writer
AbstractArgumentBinder