All Classes and Interfaces
Class
Description
Deprecated, for removal: This API element is subject to removal in a future version.
An abstract element.
An abstract implementation that builds
AnnotationMetadata.The caching entry.
Base class for types that also write
AnnotationMetadata.An abstract
AnnotatedArgumentBinder implementation.An abstract implementation of the
BeanConfiguration method.Abstract implementation of the
BeanConstructor interface.Abstract constructor implementation for bean definitions to implement to create constructors at build time.
Abstract implementation of the
BeanElementBuilder interface that should be implemented by downstream language specific implementations.Abstract bean introspection reference used by
BeanIntrospector to soft load introspections.Abstract implementation of the
BeanMethod interface.Abstract implementation of
BeanProperty.Default implementation of the
BeanResolutionContext interface.A segment that represents annotation.
A segment that represents a method argument.
A segment that represents a constructor.
A segment that represents a field.
A segment that represents a method argument.
A segment that represents a method.
Abstract class that writes generated classes to disk and provides convenience methods for building classes.
Abstract implementation of the
ClassWriterOutputVisitor interface that deals with service descriptors in a
common way across Java and Groovy.Base class for
SslConfiguration extensions for SSL clients.Base class for the composite customizers for the client and server.
Abstract class representing a cloud computing instance metadata.
Abstract implementation of the custom scope interface that simplifies defining new scopes using the Map interface.
Mutable annotation metadata provider.
Abstract element annotation metadata factory.
An abstract event for events specific to server applications.
Variation of
AnnotationMetadata that is environment specific.Default implementation for evaluated expressions.
Subclass of
AbstractBeanMethod that also implements ExecutableMethod.Abstract base class for generated
ExecutableMethod classes to implement.Abstract base class for
ExecutableMethodsDefinition.Internal class representing method's metadata.
An abstract executor implementation.
A class that executes the configured
LocalFunctionRegistry.FUNCTION_NAME for the given inputs and outputs.Abstract Groovy element.
A base health indicator class to extend from that catches exceptions thrown from the
AbstractHealthIndicator.getHealthInformation() method and updates the HealthResult with the exception information.Abstract class implementation of
HttpClientFactory.Abstract implementation of the
HttpContentProcessor interface that deals with limiting file upload sizes.Default implementation of the
BeanDefinition interface.The data class containing annotation injection information.
The data class containing all filed reference information.
The shared data class between method and field reference.
The data class containing all method reference information.
An uninitialized and unloaded component definition with basic information available regarding its requirements.
Abstract implementation of the
BeanIntrospection interface.Bean method compile-time data container.
Bean property compile-time data container.
An abstract class for other elements to extend from.
Provides an abstract class which implements
LocaleResolver and handles default locale resolution.Abstract class which implements
LocalizedMessageSource and leverages LocaleResolver API.Abstract
MessageSource implementation that provides basic message interpolation.Abstract expression AST node for method calls.
Mutable annotation metadata provider.
Abstract implementation of
HttpRequest for Netty.Abstract implementation that handles WebSocket frames.
An abstract implementation of the
PropertySourceLoader interface.Abstract bean definition for other providers to extend from.
An abstract implementation of
Resource.Base class for
ServerSslBuilder implementations.An Access log instance.
The access log format parser.
Annotate a class (typically a Java Bean) to make it explicit the style of its accessors when not using the standard
getter and setters:
A contract that allows for responding to messages.
An environment that is active for the current execution
of the application.
An
Adapter is advice applicable to a method that will create an entirely new bean definition that delegates to the
annotated method.Internal attributes for the adapter annotation.
Expression node for binary '+' operator.
A marker interface for all
BeanDefinitionReference and BeanDefinition
instances to implement that provides access to the target bean type for an AOP advice bean.The annotation processed used to execute type element visitors.
A repeatable annotation that allows defining multiple
AliasFor definitions.Allows specifying an annotation member alias.
Expression AST node for binary
&& operator.A transformer that remaps androidx.annotation.Nullable to
javax.annotation.Nullable.An
ArgumentBinder whose lookup is driven by an annotation definition.An interface for classes that bind an
Argument to an
MutableHttpRequest driven by an annotation.A binder that binds to a
MutableHttpRequest.An annotated element is some point in the code, whether it be a constructor, field,
method etc.
Abstract validator for
AnnotatedElement that may represent source code level validation routes
executed at compilation time.An
ExecutableMethodProcessor for the Filter annotation.Process methods for
FunctionBean instances.Responsible for building
Route instances for the annotations found in the io.micronaut.http.annotation
package.An interface for classes that bind an
Argument from an HttpRequest driven by
an annotation.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.
Registers annotation converters.
The annotation default values provider.
Represents an annotation in the AST.
A meta annotation used to extend
EvaluatedExpression
context with specified type.An
AnnotationMapper is a type that is capable of mapping a given annotation to one or many annotations at compile time.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 exception that occurs constructing
AnnotationMetadata.Used to represent an annotation metadata hierarchy.
An interface for a type that provides
AnnotationMetadata.A reference to
AnnotationMetadata.An interface for types capable of resolving
AnnotationMetadata.Support method for
AnnotationMetadata.Responsible for writing class files that are instances of
AnnotationMetadata.An implementation of
ClassWriterOutputVisitor for annotation processing.An annotation processor is an object that processes the presence if a given annotation.
Allows remapping of annotations from one annotation set to another at compilation time.
Interface for classes that scan for classes with a given annotation.
A source of annotations.
An
AnnotationTransformer transforms an annotation definition into one or many other annotation
definitions discarding the original annotation.Internal utility methods for annotations.
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.
Qualifier that can be used on a bean to indicate it should match any qualifier or on an
injection point to indicate it should match any bean.
A qualifier to look up any type.
A class that generates AOP proxy classes at compile time.
Common application configuration.
Configuration for instance settings.
An application context extends a
BeanContext and adds the concepts of configuration, environments and
runtimes.An interface for building an application context.
An interface for configuring an application context.
An application context configurer is responsible
for configuring an application context before the
application/function is started.
An interface for classes that manage the
ApplicationContext life cycle and shut it down when the class is shutdown.An interface for classes that provide an
ApplicationContext.An
ApplicationEvent is a user specified event object.An interface for receivers of application events.
Interface for classes that publish events received by
ApplicationEventListener instances.Constructs instances of
ApplicationEventPublisher.Event fired when an
EmbeddedApplication shuts down.Event fired when an
EmbeddedApplication starts up.Thrown when the application fails to start.
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.An injection point for a method or constructor argument.
Utility methods for checking method argument values.
Allows producing error messages.
Functional interface the check a condition.
An
Argument with a value.Annotation stereotype to applied to other annotations to indicate the annotation provides Around advice.
When using
Around.proxyTarget() on a Factory method if the
returned bean features constructor arguments this can lead to undefined behaviour since it is expected
with factory methods that the developer is responsible for constructing the object.Allows intercepting the bean constructor.
Interface for class elements that can be converted to/from an array type.
Utility methods for working with arrays.
Utility class used to perform assertions.
The AST bean properties utils.
Internal holder class for getters and setters.
An annotation that can be applied to any method that returns void or an instance of
CompletionStage to indicate the actual execution should occur
on the given thread pool.Interceptor implementation for the
Async annotation.A
Publisher that uses an ExecutorService to emit a single result.A
TypeElementVisitor that validates methods annotated with @ËšAsync return void or futures.An
AnnotatedClientRequestBinder implementation for RequestAttribute.An interface for objects that have attributes.
A base class for classes that automatically register the server with discovery services.
Print a banner programmatically.
Base class for processing
ServerFilter and
ClientFilter beans.Interface that signals to
FilterRunner that we should wait for the request body to
arrive before running this binder.A class representing basic auth authorization header.
Responsible for binding to a
BasicAuth argument from the authorization
header in the request.Annotation used to configure a bean.
Extended version of
ClassWriterOutputVisitor for types that write beans.A BeanConfiguration is a grouping of several
BeanDefinition instances.Writes configuration classes for configuration packages using ASM.
Models a bean constructor.
Represents the current bean constructor when used through the
BeanElementBuilder API.The core BeanContext abstraction which allows for dependency injection of classes annotated with
Inject.Expression AST node used for to retrieve beans from bean context.
Interface for other types that are conditional within a context.
Interface for components configurable by the bean context.
Configuration for the
BeanContext.A BeanContextEvent is an event fired from the
BeanContext instance.An exception that occurs loading the context.
An event fired when a bean is created and fully initialized.
An event listener that is triggered each time a bean is created.
Context object passed to
CustomScope instances for creating new beans.A base class for exceptions that occurred during bean creation.
Defines a bean definition and its requirements.
Interface for components aware of bean definition associated with them.
Builder that produces multiple Bean definitions represented by
BeanDefinitionVisitor.Bean definition builder factory.
Returns data for a given bean definition to be used for the
BeansEndpoint.Used to respond with bean information used for the
BeansEndpoint.The core annotation processor used to generate bean definitions and power AOP for Micronaut.
An interface for a
ExecutableMethod that is associated with a BeanDefinitionReference.A bean definition processor is a processor that is called once for each bean annotated with the given annotation type.
A bean definition reference provides a reference to a
BeanDefinition thus
allowing for soft loading of bean definitions without loading the actual types.Writes the bean definition class file to disk.
Core bean definition registry interface containing methods to find
BeanDefinition instances.Interface to integrate bean validation into the construction of beans within the
BeanContext.Interface for
BeanDefinitionVisitor implementations such as BeanDefinitionWriter.Responsible for building
BeanDefinition instances at compile time.Data used when visiting method.
An event fired when a bean has been destroyed and all
PreDestroy methods have been invoked.An event listener that is triggered after a bean is destroyed.
Exception type for exceptions that happen during bean destruction.
Models a bean that will be produced by Micronaut.
Interface for defining beans at compilation time from an originating element.
Allows visiting a bean to perform any validation prior to when bean definitions are written out.
Internal interface for adding associated beans.
An abstract bean event.
An exception handler capable of receiving a bean that originated the exception and an exception type.
Represents a configurable bean field.
An identifier for a
Bean that can be used as a key to uniquely identify an
instance.Interface that allows extension of Bean import handling in other to support
other injection systems beyond JSR-330 in downstream modules.
Implementation of
Import.Top level interface for obtaining bean information.
Allows hooking into bean instantiation at the point prior to when
PostConstruct
initialization hooks have been called and in the case of bean BeanProvider instances the
BeanProvider.get() method has not yet been invoked.An event fired when a bean's properties have been populated but initialization hooks (such as
PostConstruct methods) have not yet been triggered.Thrown when no such beans exists.
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 Jackson module that adds reflection-free bean serialization and deserialization for Micronaut.
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.Core interface for locating and discovering
Bean instances.Simple class that provides a map interface over a bean.
Represents a method on a
BeanIntrospection.Represents a configurable bean method.
Represents a configurable bean parameter.
An event fired when a bean is about to be destroyed but before any
PreDestroy methods are invoked..An event listener that is triggered before a bean is destroyed.
Bean properties configuration annotation.
The access type for bean properties.
Visibility policy for bean properties and fields.
Represents a bean property and associated annotation metadata.
An interface that provides the ability to bind Maps and Java bean properties
A BeanProvider is a richer replacement for the
Provider interface that
provides additional Micronaut specific methods to assist in programmatic bean creation and discovery.Implementation for
BeanProvider bean lookups.A bean registration is an association between a
BeanDefinition and a created bean, typically a
Singleton.Represents the resolution context for a current resolve of a given bean.
Represents a path taken to resolve a bean definitions dependencies.
A segment in a path.
Exposes an
Endpoint to provide information about the beans of the application.A reference to a bean.
Wraps a bean allowing to read and write its properties via an underlying
BeanIntrospection.Abstract expression AST node for binary operators.
Allows checking for MediaTypes that should be considered binary.
An annotation stereotype for other annotations that indicates a method
Argument is bindable.A marker annotation for methods that are blocking.
A blocking HTTP client interface that features a subset of the operations provided by
HttpClient and
is designed primarily for testing purposes.An annotation that can be applied to method argument to indicate that the method argument is bound from the HTTP
body.
A binder that binds from a parsed request body.
HTTP Response's body assertions.
The interface for typed BodyAssertion Builders.
BodyAssertion Builder.
Byte Array BodyAssertion Builder.
String BodyAssertion Builder.
Expression AST node for boolean literal.
An annotation indicating that a bean can be loaded into the Bootstrap Context.
Allows blocking resolving of
PropertySource from remote distributed configuration servers.A bound
Executable is an executable who argument values have been pre-bound to
values using a ArgumentBinderRegistry.An
InfoSource that retrieves info from build properties.Base class for a raw
HttpBody with just bytes.Interface for the Netty bytebuf allocator configuration.
Delegates all functionality to the provided buffer.
Interface to allow interfacing with different byte buffer implementations, primarily as an abstraction over Netty.
An allocator for
ByteBuffer instances.Handler for netty
ByteBuf.Builder for BytesSentElement.
A "cached environment" is a performance optimization aimed at minimizing
the cost of calling
System.getenv() or System.getProperties().A callable injection point is an injection point that accepts
Argument instances.A
MutableHttpHeaders implementation that is case-insensitive.The Netty implementation of
SslBuilder that generates an SslContext to create a server handle with
SSL support via user configuration.Creates channel options.
Factory interface for building
ChannelOutboundHandler instances.Interface that allows customizations to the
ChannelPipeline.Deprecated.
Use NettyClientCustomizer or NettyServerCustomizer instead.
Body writer for
CharSequences.The converter that converts
CharSequence to an enum.Variant of
MessageBodyReader that allows piecewise reading of the input, e.g.Variation of
Retryable that implements the Circuit Breaker pattern.An event fired when a Circuit is
CircuitState.CLOSED and has resumed
accepting requests.An event fired when the Circuit is
CircuitState.OPEN and
requests are no longer being accepted.Runtime exception that wraps a non-runtime exception in the case of an error.
State for Circuit breaker phases.
Represents a circular dependency failure.
Stores data about an element that references a class.
Thrown when an exception occurs during compilation due to a class generation error.
A component that accepts a
ClassWriterOutputVisitor and writes classes to it.An optimized classpath scanner that includes the ability to optionally scan JAR files.
Abstraction to load resources from the classpath.
Utility methods for loading classes.
Optimizations for computing missing types.
This class has a method parameter with unresolved class.
Interface to be consumed by class writers allowing visiting file names and returning appropriate streams.
Allows defining declarative HTTP clients and customizing injection for injecting
HttpClient implementations.A binder that binds to a
MutableHttpRequest.An enum describing the type of client authentication.
A contract for providing a context path to a client.
Mark a bean as a filter for the HTTP client.
The client filter resolution context.
A binder that binds to a
MutableHttpRequest.A class that exposes information about the URI to
ClientArgumentRequestBinder instances.A client filter that propagates the request context.
Interface used by the netty HTTP client to construct the SSL context.
The default
SslConfiguration used for HTTP clients.The default
SslConfiguration.KeyConfiguration.The default
SslConfiguration.KeyStoreConfiguration.The default
SslConfiguration.TrustStoreConfiguration.Validates that disallowed types are not used in declarative client methods.
A base configuration class for configuring
Client versioning.Annotation declared on the client to indicate the class handles web socket frames.
Intercepts unimplemented
ClientWebSocket methods.Enumeration of close events.
A
Qualifier that qualifies beans by generic type arguments and only
returns the candidates that most closely match.A
PropertySourceLoader that reads from the environment variable VCAP_APPLICATION
which is used by CloudFoundry.A
PropertySourceLoader that reads from the environment variable VCAP_SERVICES
which is used by CloudFoundry.Configuration for
MediaTypeCodec instances.An exception thrown when an object cannot be decoded.
Utility methods for working with
Collection typesRepresents the parsed command line options.
A build for constructing a command line parser.
A
PropertySource for properties parsed from the command line.Expression AST node for relational operations (>, <,
>=, <=) on
types that implement Comparable interface.Interface that exposes a callback to indicate when an operation has been completed.
The completable future execution flow.
Adapts a
CompletableFuture to a Publisher.Represents a completed part of a multipart request.
Represents a completed part of a multipart request.
A
Subscriber that tracks completion state using a AtomicBoolean.Iterate the cookieDecoders and return the first one that returns cookies.
A composite implementation combining all registered
DiscoveryClient instances.Composite message source that is the primary message source.
This parser is used to split complex expression into multiple
single expressions if necessary and delegate each atomic expression
parsing to separate instance of
SingleEvaluatedEvaluatedExpressionParser,
then combining single expressions parsing results.An interface modelling common Cloud platform compute instance metadata.
Interface for resoling compute instance metadata.
Utility class for
ComputeInstanceMetadataResolver's.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 condition allows conditional loading of a
BeanConfiguration.The ConditionContext passed to a
Condition.Abstract class for common configuration discovery settings.
The format the configuration is stored in.
Element that supports adding qualifiers.
Expression evaluation context that can be configured before evaluation.
The configurable
RouteBuilder.UriNamingStrategy
if property "micronaut.server.context-path" has been set.A configuration is a grouping of bean definitions under a package.
Internal annotation that allows the definition on
ConfigurationProperties
on interfaces.An annotation applicable to a field or method of a
ConfigurationProperties instance that allows to
customize the behaviour of properties that are builders themselves.A Configuration client is responsible for reading configuration for configuration servers.
Implementation of
DefaultVersionProvider which uses configuration.An exception that occurs during configuration setup.
An
InfoSource that retrieves values under the info key from configuration sources.Allows injecting configuration values into a constructor or method based
on the parameter names.
Internal introduction advice used to allow
ConfigurationProperties on interfaces.Metadata about a configuration group.
A builder for producing metadata for the available
ConfigurationProperties.Handles Configuration metadata generation.
An interface for classes that write
ConfigurationProperties metadata.Models a configuration path such as those declared within
ConfigurationProperties and EachProperty declarations.A segment of configuration.
Defines a singleton bean whose property values are resolved from a
PropertyResolver.A meta annotation for use with other annotations to indicate that the annotation reads configuration.
The visitor adds Validated annotation if one of the parameters is a constraint or @Valid.
An util class to calculate configuration paths.
Exception thrown when the client or server unexpectedly closes the connection.
Connection manager for
DefaultHttpClient.Handle for a pooled connection.
ConstantElement LogElement.
An optimization class which is used to register property sources
statically.
Element for constructors.
A constructor injection point.
A
ConstructorInterceptor extends the default Interceptor interface and allows intercepting constructors.Implementation of
InvocationContext for constructor interception.An
InvocationContext for construction invocation.An annotation to indicate the
MediaTypes consumed by a particular component.Exception thrown when the content length exceeds the allowed amount.
Default handle for
ContentLengthExceededException errors.Context scope indicates that the classes life cycle is bound to that of the
BeanContext and it should be initialized and shutdown during startup and shutdown of
the underlying BeanContext.Annotation used to indicate the annotated class participates in
the application context building phase.
This visitor is responsible for generating service files for classes
annotated with
ContextConfigurer.A converter registry for converters required by the context.
Expression AST node used for context element access.
MessageBodyHandlerRegistry implementation that does not need an application context.Expression node used for invocation of method from expression
evaluation context.
Utility class to work with context paths and URIs.
Indicates that the role of a class is a controller within an application.
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.Handles exception of type
ConversionErrorException.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.Serializer for
ConvertibleMultiValues.An interface for classes that represent a map-like structure of values that can be converted.
An implementation of
ConvertibleValues backed by a map.Serializer for
ConvertibleValues.An interface representing a Cookie.
An
AnnotatedArgumentBinder implementation that uses the CookieValue
annotation to trigger binding from an HTTP Cookie.An interface representing the configuration of a Cookie.
Interface to allow cookie decoding.
Builder for CookieElement and CookiesElement.
A CookieFactory creates
Cookie instances and should be implemented by a concrete server.Resolves the Locale from a Cookie within an HTTP Request.
Models the defined
Cookie instances in an application.An annotation that can be applied to method argument to indicate that the method argument is bound from an HTTP
cookie.
Thread-safe map that is optimized for reads.
A transformer that remaps
NonNull to AnnotationUtil.NON_NULL.A transformer that remaps
Nullable to AnnotationUtil.NULLABLE.Coroutines helper.
CORS assertion.
CORS Assertion Builder.
Responsible for handling CORS requests and responses.
Stores configuration for CORS.
Responsible for converting a map of configuration to an instance of
CorsOriginConfiguration.Utility methods for CORS.
Utility class to do CORS related assertions.
Represents a bean that has been created from a
BeanCreationContext.An annotation applicable to a constructor that provides a hint as to which constructor is the primary constructor.
This provides cron support for Java 8 using java-time.
Support CORs configuration via annotation.
Utility classes to work with
CrossOrigin.Strategy interface for retrieving and updating the current
HealthStatus of the application.This annotation is designed for non-standard http methods, that you
can provide by specifying the required
CustomHttpMethod.method() property.MessageBodyHandler that is customizable with JsonFeatures.A type that needs special handling that may include modification of the response.
Represents a custom scope within the
BeanContext.An interface for a registry of
CustomScope instances.Builder for DateTimeElement.
Default implementation of
AnnotationMetadata.Creates a default implementation of the
ApplicationContext interface.Implementation of
ApplicationContextBuilder.Represents an argument to a constructor or method.
The default context implementations.
The default
BeanDefinitionData implementation.The default
BeanDefinitionDataCollector implementation.Default implementation of
BeanResolutionContext.Binds a String body argument.
Creates channel options.
Loads resources from the classpath.
Default configuration when no other is present.
The default
ConfigurationClient implementation.The default
CompositeDiscoveryClient that is activated when caching is disabled.Default implementation of
CookieDecoder that returns the cookies from the request.Default implementation of the
CustomScopeRegistry interface.The default implementation of the
Environment interface.The default error route info implementation.
Configuration interface for event loop configuration.
The default factory for
EventLoopGroup instances.Factory for creating named event loop groups.
Implementation of
ExecutableBeanContextBinder.Default implementation of the
ExecutableBinder interface.Default implementation of the
ExecutorSelector interface that regards methods that return reactive types as non-blocking.Default implementation of
ExtensibleExpressionCompilationContext.Factory for producing expression evaluation context.
Default implementation of
ConfigurableExpressionEvaluationContext.Loads resources from the file system.
Default implementation of the
FunctionDiscoveryClient interface.Default implementation that will exit using
System.exit(int).Default implementation of
HealthAggregator that creates a {status: , description: (optional) , details: }
response.Default implementation of the
HttpClient interface based on Netty.Key used for connection pooling and determining host/port.
Default implementation of
HttpClientAddressResolver.Default implementation of
HttpClientBinderRegistry that searches by
annotation then by type.The default configuration if no explicit configuration is specified for an HTTP client.
The default connection pool configuration.
Resolves filters for http clients.
This class will handle subscribing to a stream of
HttpContent.Default implementation that determines if the body argument (if present) does not expect
decoding of the request body, that the
DefaultHttpContentProcessor should be used,
regardless of the content type of the request.Default implementation of
HttpHostResolver.An annotation to apply to an interface to indicate which implementation
is the default implementation.
Default implementation of the interceptor registry interface.
HttpClient implementation for java.net.http.* HTTP Client.Factory to create java.net.http.* HTTP Clients.
Default implementation of
Link.Abstraction over
LoadBalancer lookup.Default implementation of the
LocalFunctionRegistry interfaceDefault implementation of
LoggersManager.Registry of
MediaTypeCodec instances.Stores message body readers and writers.
The default conversion service.
Default implementation of
NettyEmbeddedServerFactory.Factory for the default implementation of the
HttpClient interface based on Netty.The default
PropertyPlaceholderResolver.A segment of placeholder resolution.
Default implementation of the
RequestBinderRegistry interface.The default
RequestMatcher implementation.A
MethodInterceptor that retries an operation according to the specified
Retryable annotation.Default retry predicate.
A DefaultRouteBuilder implementation for building roots.
Default route data implementation.
A Reactive route data collector.
The default route info implementation.
The default
Router implementation.A meta annotation that can be applied to another annotation to specify a fallback scope of no scope is specified
by the user for a bean.
The default implementation to generate Instance IDs.
The default
SslConfiguration configuration used if no other configuration is specified.The default
SslConfiguration.KeyConfiguration.The default
SslConfiguration.KeyStoreConfiguration.The default
SslConfiguration.TrustStoreConfiguration.The default
StatusRouteInfo implementation.A default streamed HTTP request.
A default streamed HTTP response.
The default exception handler used if non-other is found.
The default thread factory used for creating threads in Micronaut.
Default implementation of
ThreadInfoMapper that returns the
ThreadInfo objects as is.The binder will try to bind the argument value which wasn't matched by an annotation or a type.
The default
UriRouteInfo implementation.Defines a provider of a default Version.
Simple watch service that simply stops the server if any changes occur.
A default WebSocket HTTP response.
ExecutionFlow that can be completed similar to a
CompletableFuture.Delegate class for
ByteBuffer.Delegate for Streamed HTTP Request.
Delegate for Streamed HTTP Response.
An interface for wrapping a
BeanDefinition with another that delegates and potentially decorates the
BeanDefinition instance.An interface for
ExecutableMethod instances that delegate to an underlying ExecutableMethod.Annotation that can be applied to method to signify the method receives a
HttpMethod.DELETE.A method designed to annotate an
Endpoint delete operation.Represents a runtime failure to perform dependency injection.
An interface for types that are described by a description.
Options for controlling the visibility of health details.
Represents
ComputeInstanceMetadata for Digital Ocean.Default configuration for retrieving Digital Ocean metadata for
ComputePlatform.DIGITAL_OCEAN.A enum of Digital Ocean metadata.
Resolves
ComputeInstanceMetadata for Digital Ocean.A
NetworkInterface implementation for Digital Ocean.A
ClassWriterOutputVisitor that writes to a target directory.Data about a disabled bean.
An exception that can be thrown to disable a bean programmatically from within a factory bean.
Main client abstraction used for service discovery.
A health indicator for the discovery client.
Enables the user to enable or disable the health indicator.
A factory class that can be replaced at runtime for creating
LoadBalancer instances that load balance
between available clients provided by the DiscoveryClient.A
LoadBalancer that uses the DiscoveryClient and a
ServiceInstance ID to automatically load balance between discovered clients in a non-blocking manner.Base class for common discovery configuration options.
Base exception for exceptions thrown by the discovery system.
A
HealthIndicator used to display information about the disk
space of the server.Specific configuration properties for the disk space health indicator.
Switch based dispatch writer.
Dispatch target implementation writer.
State carried between different
DispatchWriter.DispatchTargets.Field get dispatch target.
Field set dispatch target.
Interceptable method invocation dispatch target.
Method invocation dispatch target.
A bean definition that provides disposing hooks normally in the form of
PreDestroy
annotated methods.Expression node for binary '/' operator.
Expression AST node for double literal.
An exception thrown when multiple routes match a given URI.
Handles exceptions of type
DuplicateRouteException.Placeholder
MessageBodyWriter implementation that decides which writer to use based on
the dynamic (runtime) type of the body.This annotation allows driving the production of
Bean definitions from presence of other bean definitions.This annotation allows driving the production of
Bean definitions from either configuration or the
presence of another bean definitionBuilder for ElapseTimeElement.
Stores data about a compile time element.
Element's annotation metadata.
Element's annotation metadata factory.
A factory for creating elements.
Expression AST node used for method invocation.
An enum of modifier names now tied to the reflection API.
Mutable annotation metadata provider.
An interface for querying the AST for elements.
Result interface when building a query.
Support for the elvis operator.
An
EmbeddedApplication is a runnable application that starts and manages the ApplicationContext.An EmbeddedServer is a general abstraction to manage the lifecycle of any server implementation within
a running Micronaut application.
Extended version of the
ServiceInstance interface for the EmbeddedServer.ServerUnderTest implementation for EmbeddedServer.ServerUnderTestProvider implemntation which returns an instance of EmbeddedServerUnderTest.Base interface for classes that emit data.
Delegate for Empty HTTP Response.
The empty operator.
An
PropertySource that is empty when instantiated.An exception thrown when the server returned and empty, unreadable response.
The elements query helper.
Defines a management endpoint for a given ID.
An
Endpoint configuration.The default
Endpoint configuration.A condition that checks whether an
Endpoint is enabled.If a bean of type
EndpointSensitivityHandler is present the EndpointsFilter is not loaded.Finds any sensitive endpoints.
Returns 401 for
Endpoint requests which have sensitive true.An annotation mapper that improves introspection for JPA entities.
An annotation mapper that improves reflective access for JPA entities.
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.
Stores data about an element that references a enum constant.
Models an enum type.
The current application environment.
Expression AST node used for retrieving properties from environment at runtime.
Interface for components configurable by the environment.
Endpoint that displays information about the environment and its property sources.A bean interface that allows hiding or masking of parts of the environment and its property sources when they are
displayed in the
EnvironmentEndpoint.This class is passed to an instance of
EnvironmentEndpointFilter (if one is defined) each time the EnvironmentEndpoint
is invoked.A mapping from environment variable names to Micronaut
property names.
Loads properties from environment variables via
System.getenv().Reads properties from JSON stored in the environment variables
SPRING_APPLICATION_JSON or MICRONAUT_APPLICATION_JSON.Checks if epoll is available.
Creates channel options.
Factory for EpollEventLoopGroup.
Expression AST node for binary '==' operator.
Annotation that can be applied to method to map it to an error route.
Contains information about an error that occurred.
A builder for a
ErrorContext.Creates Http responses that represent errors.
Represents a
Route that matches an exception.Represents a
Route that matches an exception.Interface for reporting conversion errors.
Variation of
AnnotationMetadata that is used when evaluated expression
in annotation values need to be resolved at runtime.An EvaluatedAnnotationValue is a
AnnotationValue that contains one or more expressions.Expression included in annotation metadata which can be evaluated at runtime.
Unility methods for used when compiling evaluated expressions.
Set of constants used for evaluated expressions processing.
Interface for evaluated expression parser.
Internal utility class for writing annotation metadata with evaluated expressions.
Wrapper for annotation value, containing evaluated expressions and
class name for generated expression class.
Utility class for working with annotation metadata containing
evaluated expressions.
Writer for compile-time expressions.
Represents a Server Sent Event.
An
Adapter advice annotation that allows listening for events by implementing the ApplicationEventListener interface.Default event loop group configuration interface.
Factory for EventLoopGroup.
Registry of configured event loops.
A listener registered for notification when an entry is evicted.
Common interface for types that handle exceptions.
A generic hook for handling exceptions that occurs during the execution of an HTTP request.
Annotation applied to the method or type indicating that a
ExecutableMethod should be
produced for this method.Represents an executable reference.
Sub-interface of
ExecutableBinder that binds arguments from a BeanContext.An ExecutableBinder is capable of taking a target
Executable and fulfilling the argument
requirements using the provided binding source and ArgumentBinderRegistryAn executable method is a compile time produced invocation of a method call.
A class capable of processing an
ExecutableMethod instances.Collects a set of executable methods
ExecutableMethod.Writes out a
ExecutableMethodsDefinition class.A
TypeElementVisitor that validates primitive types can't have a Nullable annotation.Annotation used to indicate which executor service a particular task should run on.
The execution flow class represents a data flow which state can be represented as a simple imperative flow or an async/reactive.
Represents a handle to an executable object.
Interface for components that are able to locate and return
ExecutionHandle instances
for beans.Constructs
ExecutorService instances based on UserExecutorConfiguration instances.Interface that allows customizing the selection of the
ExecutorService to run an operation on.Annotates a class or method as being experimental and subject to change or removal.
Compilation context is a set of entries which can be referenced in evaluated expression
using the '#' sign followed by entry name.
Factory interface for producing expression evaluation context.
Exception throws when problems with expression compilation occur.
Context that can be used by evaluated expression to obtain objects required
for evaluation process.
Custom type that simplifies registering a new context class.
Exception thrown on expression evaluation failure.
Abstract evaluated expression AST node.
Exception throws when problems with expression parsing occur.
Context class used for compiling expressions.
Metadata for evaluated expression used at compilation time
to generate expression class.
This class was created to pass to the
GroovyAnnotationMetadataBuilder because
the method node the parameter belongs to is not available from the Parameter class
itself.Expression compilation context that can be extended with extra elements.
A factory is a
Singleton that produces one or many other bean implementations.Represents a failure in a
Condition.An exception thrown when an error occurs in the
Fallback system.Stores data about an element that references a field.
Defines an injection point for a field.
Body writer for
Files.Event fired when a file that is being watched changes.
A special type for file handling.
Abstraction to load resources from the file system.
Represents a part of a
MediaType.MULTIPART_FORM_DATA request.Custom condition to only enable file watch if the watch paths exist.
Configuration for the file watch service.
Listener that stops the server if a file changes.
An annotation that can be applied to classes that implement
HttpFilter to
specify the patterns.A non-blocking and thread-safe filter chain.
A filter continuation gives can be declared as a parameter on a
filter method.Allows decorating an existing
Router with filtering capabilities.A variation of
Qualifier that is a simple filter.Stereotype annotation that helps to link together instance of the filter and http client that filter should be applied to.
Different filter order heuristics, derived from annotations or
a
bean method.Dynamic order value (from
Ordered.getOrder()).Fixed order value.
Styles of filter patterns.
A filter route is a route that matches an
HttpFilter.The filter runner will start processing the filters in the forward order.
Visitor that checks validity of
ServerFilter and ClientFilter classes.A remapper that remaps findbugs annotations to internal annotations.
A
LoadBalancer that resolves a fixed URI.Generic implementation of
LocaleResolver for fixed locale resolution.Expression AST node for float literal.
Annotation used to describe the format in the case where the format needs to be altered for the purposes of
conversion.
Decodes
MediaType.MULTIPART_FORM_DATA in a non-blocking manner.Special
HttpBody that "demultiplexes" form data.Allows introspecting whether the request is a full http request.
Wraps a Netty
FullHttpResponse for consumption by the HttpClient.Allows executing functions from the CLI.
An annotation applied to classes that should be exposed as functions.
The
FunctionClient annotation allows applying introduction advise to an interface such that methods
defined by the interface become invokers of remote or local functions configured by the application.Implements advice for the
FunctionClient annotation.Represents a discovered function definition.
Interface for a type that provides function definitions.
An interface for discovery functions, either remote or local.
An exception thrown when an error occurs in the function system.
Allows executing the function configured by
LocalFunctionRegistry.FUNCTION_NAMEA strategy interface for handling exiting from a function when it is executed via the CLI.
A super class that can be used to initialize a function.
Strategy interface for choosing a
FunctionInvoker.An exception thrown when no function can be found.
A marker annotation for methods that are generated though an annotation processor.
A common interface to allow referencing a generated file in either Groovy or Java.
A consumer which may throw an IOException.
Captures a generic
Argument.Represents a generic element that can appear as a type argument.
Base interface for different filter types.
Extends
Argument to allow differentiating the
variable name from the argument name in cases where this is
required (parameters and fields for example).Represents a generic placeholder in source code.
The element annotation metadata for generic placeholder element.
Resource with indeterminate structure.Utility methods for dealing with generic types via reflection.
Utility methods for dealing with generic type signatures.
Annotation that can be applied to method to signify the method receives a
HttpMethod.GET.An
InfoSource that retrieves info from Git properties.Interface that allows dynamic configuration of reflection generated by the GraalTypeElementVisitor.
Context object for the configuration.
Generates the GraalVM reflect.json file at compilation time.
Groovy implementation of
AbstractAnnotationMetadataBuilder.A class element returning data from a
ClassNode.A
ConstructorElement for Groovy.Groovy element annotation metadata factory.
Implementation of
ElementFactory for Groovy.A enum constant element returning data from a
Variable.A field element returning data from a
FieldNode.A method element returning data from a
MethodNode.Groovy's native element.
The class element.
The class element with an owner (Generic type etc.).
The field element.
The method element.
The package element.
The parameter element.
The placeholder element.
A class element returning data from a
PackageNode.Implementation of
ParameterElement for Groovy.The visitor context when visiting Groovy code.
Expression AST node for binary '>=' operator.
Expression AST node for binary '>' operator.
Subscriber that publishes received messages to the handler pipeline.
Creates Hateoas JSON error responses.
Annotation that can be applied to method to signify the method receives a
HttpMethod.HEAD.An annotation that can be applied to method argument to indicate that the method argument is bound from an HTTP header
This also can be used in conjunction with @Headers to list headers on a client class that will always be applied.
An
AnnotatedArgumentBinder implementation that uses the Header
annotation to trigger binding from an HTTP header.An
AnnotatedClientRequestBinder implementation for Header.Builder for Headerlement and HeadersElement.
Common interface for all headers types.
This lets you declare several headers for a client class and have them always included.
A
RequestVersionResolver responsible for extracting version from HttpHeaders.Configuration for version resolution via headers.
Aggregates all registered health indicators into a single response.
Options for
HealthEndpoint selector that aggregates
HealthIndicator according to Liveness
respectively Readiness qualifiers.Exposes an
Endpoint to provide information about the health of the application.Configuration related to handling of the
HealthStatus.Describes an indicator of health of the application.
This class provides a set of common constants to indicate the level of detail to be included in the Health status response.
A continuous health monitor that that updates the
CurrentHealthStatus in a background thread.Used to represent the output of a
HealthIndicator.Helper class to build instances.
A filter that matches the
HealthEndpoint
and returns an appropriate HTTP status code.The status of a health indicator.
Configuration for heart beat.
Custom condition to conditionally enable the heart beat.
Annotation that expresses the requirements for enabling the heart beat.
A heartbeat event is an event fired periodically and configured by
HeartbeatConfiguration.A scheduled task that sends a periodic heartbeat whilst the server is active.
A contract for a publisher that buffers data to allow for
the release of that data if there will not be a subscriber.
Extended version of
InterceptedProxy that allows swapping out the previous instance.Provides an abstract class which implements
LocaleResolver and handles default locale resolution.Logging handler for HTTP access logs.
Common HTTP attributes.
Base type for a representation of an HTTP request body.
A non-blocking HTTP client interface designed around the Micronaut API and Reactive Streams.
Resolves the client IP address from the request.
A registry of
ClientArgumentRequestBinder instances.Configuration for the
HttpClient.Configuration for the HTTP client connnection pool.
Strategy interface for decoding the error from a server respponse.
Parent class for all HTTP client exceptions.
Utility Class to work with
HttpClientException.A factory to create HTTP clients.
An HttpClientFilter extends
HttpFilter and allows the passed request to be mutated.Subinterface for filter resolution specific to HTTP client filters.
Introduction advice that implements the
Client annotation.Interface for managing the construction and lifecycle of instances of
HttpClient clients.An exception that occurs when a response returns an error code equal to or greater than 400.
Determines if a given http message should be compressed.
Deprecated.
Use the
MessageBodyReader API insteadUtility class for transforming a
Note: A more complicated, but possibly faster, implementation of this class is archived in the original PR.
NettyHttpRequest using a HttpContentProcessor
to a Publisher.Note: A more complicated, but possibly faster, implementation of this class is archived in the original PR.
Responsible for determining which
HttpContentProcessor to use to process
the body of the request.Interface that allows plugging into the constructor of the
HttpContent
subscriber.Utility methods for generated HTTP content.
Converter registrar for HTTP classes.
Parent class of all exceptions thrown during HTTP processing.
A interface for classes that can intercept and filter
HttpRequest instances and can
either proceed with the request or return a modified result.A contract for resolving filters for a given request.
A resolved filter entry.
Generic implementation of
LocaleResolver for fixed locale resolution.A
FunctionExecutor that uses a HttpClient to execute a remote function definition.Constants for common HTTP headers.
Adapter from
HttpHeaders into HttpHeaders.Utility class to work with
HttpHeaders or HTTP Headers.Interface for common HTTP header values.
Resolves the host name of the current server.
Configuration for Locale Resolution in a HTTP Request.
Responsible for determining the current locale from a request.
A
RequestScope which uses the current HttpRequest to resolve the locale and hence return the localized messages.Common interface for HTTP messages.
A wrapper around an
HttpMessage.An enum containing the valid HTTP methods.
A meta annotation for HTTP
Controller actions.Represents HTTP query parameters parsed from the
HttpRequest.getUri().Common interface for HTTP request implementations.
Utility class to create
HttpRequest.Builder from a Micronaut HTTP Request.A factory interface for
MutableHttpRequest objects.An event fired when an
HttpRequest is received by the server.An event fired when an
HttpRequest is finalized by the server.A wrapper around a
HttpRequest.Common interface for HTTP response implementations.
Adapter from
HttpResponse to HttpResponse.Utility class to verify assertions given an HTTP Response.
HTTP Response Assertion Builder.
A factory interface for creating
MutableHttpResponse instances.A contract to provide an http response.
A wrapper around a
HttpResponse.A base
ConfigurationProperties for servers.Configuration for CORS.
Configuration for host resolution with the
HttpHostResolver.Configuration for locale resolution used by
HttpLocaleResolver.Configuration for multipart handling.
Exceptions related to the HTTP server.
An HttpServerFilter extends
HttpFilter and provides the response as a MutableHttpResponse.Subinterface for filter resolution specific to HTTP server filters.
Represents HTTP status codes.
Exception thrown to return a specific HttpStatus and an error message.
Handles exception of type
HttpStatusException.Provide type information for HTTP response.
Utility methods for HTTP handling.
Enum representing different HTTP versions.
This class collects information about HTTP client protocol version settings, such as the
HttpVersionSelection.PlaintextMode and the ALPN configuration.The connection mode to use for plaintext (non-TLS) connections.
The default
RouteBuilder.UriNamingStrategy if none is provided by the application.Fully buffered
ByteBody, all operations are eager.Immediate
MultiObjectBody, all operations are eager.HttpBody that contains a single object.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.
Allows importing an already compiled set of beans, placing any generating beans relative to the class
where the import annotation is defined.
An annotation that can be used on types where there may be many implementations of a
particular interface.
Allows
Indexed to be repeatable.Aggregates all registered info sources into a single response.
Exposes an
Endpoint to provide information about the application.Describes an source of info that will be retrieved by the
InfoEndpoint.Infrastructure scope represents a bean that cannot be overridden or replaced
because it is critical to the functioning of the system.
A marker interface for
BeanContext implementations that can be introspected,
that is to say for context which can be created and need to be fully configured,
but not necessarily started yet.A bean definition that is provides initialization hooks normally in the form of methods annotated with
PostConstruct.An type of
BeanDefinition that supports post initialization bean dependencies injection.Shared interface for injectable elements.
An injection point as a point in a class definition where dependency injection is required.
An annotation that can be declared on a constructor or method parameter that indicates
that the injected bean should be destroyed after injection completes.
Extended version of
GroovyClassLoader that can be used to test dependency injection compilation.Utility class for testing Groovy visitors.
Body writer for
InputStreams.Expression AST node for 'instanceof' operator.
An type of
BeanDefinition that can build a new instance.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.
An
Executor that has been instrumented to allow for propagation of thread state
and other instrumentation related tasks.An
ExecutorService that has been instrumented to allow for propagation of thread state
and other instrumentation related tasks.A
ScheduledExecutorService that has been instrumented.An interface implemented by generated proxy classes.
An internal interface implemented by generated proxy classes.
An internal
InterceptedBean that proxies another instance.The intercept method supporting intercepting different reactive invocations.
Possible result types.
The
InterceptedMethod utils class.A
Intercepted that proxies another instance.An Interceptor intercepts the execution of a method allowing cross cutting behaviour to be applied to a
method's execution.
A meta-annotation that can be used on
MethodInterceptor declarations to specify
the InterceptorBinding and make the type a bean.A
TypedAnnotationMapper for the InterceptorBean annotation.An
InterceptorBinding is used as a meta-annotation on Around and Introduction advice to
indicate that AOP advice should be applied to the method and that any annotations that feature this stereotype annotation
should be used to resolve associated interceptors at runtime.Repeatable wrapper for
InterceptorBinding.The remapped for various interceptor annotation stereotypes.
Qualifier used to resolve the interceptor binding when injection method interceptors for AOP.
An internal representation of the
Interceptor chain.Enum representing different interceptors kinds.
Strategy interface for looking up interceptors from the bean context.
Registers the
InterceptorRegistry instance.Interceptor classes implement the Ordered interface
in order to control the order of execution when multiple interceptors are present.Annotates a class or method regarded as internal and not for public consumption.
Logs warnings during compilation if any class extends an internal or
experimental Micronaut API.
Thrown for an unrecoverable server exceptions.
Expression AST node for integer literal.
Marker interface for instances that are implemented automatically via
Introduction advise.Introduction advice allows interfaces and abstract classes to be implemented at compile time by
MethodInterceptor implementations.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.
Map values of
Introspected to BeanProperties, because Introspected module doesn't depend on the inject module.A
TypeElementVisitor that visits classes annotated with Introspected and produces
BeanIntrospectionReference instances at compilation time.Thrown when an error occurs introspecting a bean type.
An InvocationContext passed to one or many
Interceptor instances.Runtime exception equivalent of
InvocationTargetException.Utility to use a
BiFunction which throws internally a IOException.Configures the default I/O thread pool if none is configured by the user.
Checks if io-uring is available.
Factory for IOUringEventLoopGroup.
Utility methods for I/O operations.
Configuration for the Jackson JSON parser.
Converter registrar for Jackson.
Helper class for implementing
JsonMapper.readValue(ByteBuffer, Argument) with optimizations for
netty ByteBufs.A Reactive streams publisher that publishes a
JsonNode once the JSON has been fully consumed.jackson-databind implementation of
JsonMapper.Implementation of
JsonMapperSupplier for Jackson.The pre instantiate callback.
Default exception handler for jackson processing errors.
Annotation that can be applied to types that use Jackson to customize serialization features.
Stores features to later configure an
ObjectMapper.A
MediaTypeCodec for JSON and Jackson.An implementation of the
ObjectSerializer interface for Jackson.A Reactive streams publisher that publishes a
JsonNode once the JSON has been fully consumed.An annotation mapper that improves introspection for JPA entities.
Handle mapped super class.
Allows using the `jakarta.persistence.PersistenceContext` annotation in Micronaut.
Implementation for Jakarta bean lookups.
A
AnnotationMetadata for builder for Java to be used at compile time.A class element returning data from a
TypeElement.Java element annotation metadata factory.
An implementation of
ElementFactory for Java.A method element returning data from a
ExecutableElement.Utility methods for Java model handling.
The Java native element.
The class native element.
The method native element.
The package native element.
The class native element.
The variable native element.
A package element for Java.
Utility for parsing Java code.
The visitor context when visiting Java code.
A transformer that remaps
javax.annotation.Nonnull to AnnotationUtil.NON_NULL.A transformer that remaps
javax.annotation.Nullable to AnnotationUtil.NULLABLE.Allows using the `javax.persistence.PersistenceContext` annotation in Micronaut.
Transforms
javax.annotation.PostConstruct into the javax meta-annotation AnnotationUtil.POST_CONSTRUCT.Transforms
javax.annotation.PreDestroy into the javax meta-annotation AnnotationUtil.PRE_DESTROY.Implementation for javax provider bean lookups.
Remaps from
javax.inject to jakarta.inject.A
HealthIndicator used to display information about the jdbc
status.HttpClient implementation for java.net.http.* HTTP Client.The Javanet implementation of
SslBuilder that generates an SSLContext to create a client that
supports SSL.Marker interface for
HttpClient implementations that use the java.net.http.* HTTP Client.Factory to create java.net.http.* HTTP Clients.
A
ObjectSerializer that uses JDK serialization.A transformer that remaps org.eclipse.jdt.annotation.Nullable to
javax.annotation.Nullable.Public to allow special handling for conversion service.
Exception handler interface that converts json binding exceptions to more specific
ConversionErrorExceptions.Base interface for application-level json configuration.
A
ConfigurationMetadataWriter that writes out metadata in the format defined by
spring-configuration-metadata.json.This class will handle subscribing to a JSON stream and binding once the events are complete in a non-blocking
manner.
Converter registrar for json.
This class takes in JSON data and does simple parsing to detect boundaries between json nodes.
A region that contains a JSON node.
Makes every use of Jackson's JsonCreator also represent a
Creator.A class that can be used to represent JSON errors that complies to Vnd.Error without the content type requirements.
Default exception handler for JSON processing errors.
Base interface for json feature classes that can be scanned from annotations.
Builds the
Subscriber for JSON requests.Common abstraction for mapping json to data structures.
Strategy interface for resolving a
JsonMapper.A
MediaTypeCodec for JSON and Jackson.A
MediaTypeCodec for JSON and Jackson.Body handler for JSON.
Immutable class representing a json node.
Simple facade over a
JsonNode to make it a ConvertibleValues.Deserializer for
JsonNode.Serializer for
JsonNode.Codec for transforming
JsonNode from and to json streams.Public to allow special handling for conversion service.
An implementation of the
ObjectSerializer interface for Jackson.A
PropertySourceLoader that reads application.json files if they exist.A
PropertySourceLoader that reads application.json files if they exist.Configuration for json stream parsing and generation.
A codec for
MediaType.APPLICATION_JSON_STREAM.A codec for
MediaType.APPLICATION_JSON_STREAM.Utility functions for transferring from a
JsonParser to a JsonGenerator.A Reactor subscriber used to handle JSON content.
Exception thrown when there is a syntax error in JSON (e.g.
Jackson @JsonView filter.
A transformer that remaps org.jspecify.annotations.Nullable to
javax.annotation.Nullable.Compiler for kotlin code (for tests).
Allows treating the Kotlin deprecated annotation as the Java one.
Internal Utility methods for working with Kotlin
suspend functionsKotlin's
InterceptedMethod with extra methods to access coroutine's context.An annotation mapper that maps Kotlin's NotNull to a common annotation.
An annotation mapper that maps Kotlin's Nullable to a common annotation.
Represents a Kotlin parameter to a method or constructor.
Internal Utility methods for working with Kotlin
suspend functionsChecks if kqueue is available.
Creates channel options.
Factory for KQueueEventLoopGroup.
A property source specific for the Kubernetes environment.
Lazily parsed
JsonNode.A life cycle interface providing a start method and extending Closeable which provides a close() method for
termination.
Interface for a hateoas link.
Build for creating
Link instances.Qualifier designed to make the
HealthIndicator exposed via
/health/liveness endpoint of HealthEndpoint.Interface to abstract server selection.
Converters from URL to
LoadBalancer interface.A resolver of
LoadBalancer instances that are capable of resolving references to services into a concrete loadbalance.Used to store a reference to an underlying
TypeElementVisitor and
optionally invoke the visit methods on the visitor if it matches the
element being visited by the annotation processor.Binds
Locale arguments in controller methods using
the LocaleResolver.Locale resolution configuration.
Responsible for determining the current locale given a context.
A registry of defined
FunctionBean instances containing within the current running application.Builder for LocalHostElement.
Builder for LocalIpElement.
Retrieve messages for the resolved locale.
Builder for LocalPortElement.
An implementation of
LoggingSystem that works with Log4j.An implementation of
ManagedLoggingSystem that works with logback.An implementation of
LoggingSystem that works with logback.An implementation of
ManagedLoggingSystem that works with logback.Utility methods to configure
LoggerContext.Represents a http request or response element.
Events.
Builder for LogElement.
Represents the configuration of a
ManagedLoggingSystem logger.Exposes an
Endpoint to manage loggers.Used to retrieve and update logger information for the
LoggersEndpoint.Logging converters.
Abstraction for a logging system.
Thrown when something goes wrong on Logging System.
Abstract expression AST node for binary logical operator.
Logging levels supported by a
LoggingSystem
Typically, a logging system may permit the log level to be null, representing
an unspecified log level.Expression AST node for long literal.
Condition that only matches if virtual threads are supported on this platform.
Expression AST node for binary
'<=' operator.Expression AST node for binary
'<' operator.A factory that creates the
WatchService.Replaces the
DefaultWatchThread for Mac OS X to use native file watch.Abstraction for a logging system.
Allows configuration how map property values are injected.
Specifies the type of the map that should be injected.
Handle mapped super class.
An annotation that can be used on abstract methods that define a return type and exactly a single argument.
The conflict strategy specifies the behaviour if a conflict is found.
The mappings.
Handles the mapper annotation.
A
MediaTypeCodec for JsonMapper based implementations.The mapper visitor.
Abstract annotation metadata delegate for cases when annotation
values need to be mapped before being returned.
A
PropertyResolver that resolves values from a backing map.A
PropertySource that uses a map.Expression AST node for regex 'matches' operator.
Abstract expression AST node for binary math operations
on primitive types.
MDC propagation.
Represents a media type.
Represents a codec for a particular media type.
A registry of decoders.
A bean for the default
MediaTypeCodecRegistry used by the server.The media type converters registrar.
Interface for bodies that provide their own media type.
A member element is an element that is contained within a
ClassElement.An exception thrown when a message is being acknowledged or rejected.
An annotation that can be applied to method argument to indicate that the method argument is bound from message body.
Exception that occurs when reading or writing a message body.
A handler combines a reader and a writer.
A registry of
MessageBodyReader and MessageBodyWriter.An interface that allows reading a message body from the client or the server.
An interface that allows writing a message body for the client or the server.
An annotation that can be applied to method argument to indicate that the method argument is bound from a message header.
This lets you declare several headers for a client class and have them always included.
Generic container object for message headers.
Generic stereotype annotation that should be applied to other annotations that indicate to Micronaut,
which classes are message listeners.
An exception thrown when an unrecoverable error occurs with a
MessageListener.Generic stereotype annotation that models a mapping of a message listener onto a target destination, whether that be a queue a topic or whatever.
Generic messaging meta-annotation to indicate a type that is a message producer.
Interface for resolving messages from some source.
The context to use.
Utility class used by
MessageSource to create variables maps.An alternative
EmbeddedApplication that gets activated for messaging applications when
no other application is present.An exception thrown when an unrecoverable error occurs with a messaging client.
General parent exception for all message related exceptions.
An exception thrown when an unrecoverable error occurs with the messaging system.
Represents a route that is backed by a method.
Match a route based on a method.
Represents the built in conventions for mapping a method name to an HTTP Method and URI.
Stores data about an element that references a method.
The element annotation metadata for a method element.
The helper class to implement method element annotations.
Represents an execution handle that invokes a method.
Defines an injection point for a method.
A MethodInterceptor extends the generic
Interceptor and provides an interface more specific to method interception.An internal representation of the
Interceptor chain.Extended version of
InvocationContext for MethodInterceptor instances.A reference to a method.
Main entry point for running a Micronaut application.
Default implementation of
Banner that prints the default Micronaut banner.Micronaut deserializers for jackson.
MicronautHttpData<D extends io.netty.handler.codec.http.multipart.HttpData>
Alternate
HttpData implementation with some limited concurrency support.Factory for
MicronautHttpData instances.Validates all route uri variables are present in the route arguments.
Provides utility method for working with the annotation processor AST.
Expression AST node for binary '/' operator.
Expression node for binary '*' operator.
A body consisting of multiple objects of arbitrary type.
A builder class to generate a list of parts for a multipart request.
Represents the body of a multipart request that emits each
part after it is received in its entirety.
A builder class to add different
Part to MultipartBody.A
Body argument binder for a MultipartBody argument.A factory for Multipart data.
Exception thrown during multipart handling.
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 various of
DefaultAnnotationMetadata that is used only at build time.Mutable annotation metadata.
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.
Extends
HttpHeaders add methods for mutation of headers.An interface for an
HttpMessage that is mutable allowing headers and the message body to be set.Mutable version of
HttpParameters which allows adding new parameters.An extended version of
HttpRequest that allows mutating headers, the body etc.A version of the
HttpResponse interface that is mutable allowing the ability to set headers,
character encoding etc.Mutable propagated context will modify the internal context
Intended for use-cases when the propagated context needs to be mutated and propagated later.
The mutated element annotation metadata for a method element.
An interface for components that are named.
A named
AnnotationMapper operates against any named annotation, and does not require the
annotation to be on the annotation processor classpath.A named
AnnotationTransformer operates against any named annotation, and does not require the
annotation to be on the annotation processor classpath.Client versioning configuration for named configurations nested under
micronaut.http.client.versioning.An interface for a components that resolve names.
Naming convention utilities.
Expression node for unary '-' operator.
Expression AST node for binary '!=' operator.
Netty-specific writer.
A
ByteBufferFactory implementation for Netty.Different netty channel types.
Interface implemented by users to hook into the pipeline setup of the netty HTTP client.
Enum to describe the role of the channel passed to
NettyClientCustomizer.specializeForChannel(Channel, ChannelRole).Interface implemented by the HTTP client registry to register customizers.
Default implementation of
MutableHttpRequest for the HttpClient.Implementation of the
HttpRequestFactory interface for Netty.The Netty implementation of
This class is not final, so you can extend and replace it to implement alternate mechanisms for loading the key and trust stores.
SslBuilder that generates an SslContext to create a client that
supports SSL.This class is not final, so you can extend and replace it to implement alternate mechanisms for loading the key and trust stores.
A delegation of the Netty
Attribute to implement
the CompletedPart contract.A Netty implementation of
CompletedFileUpload.Factory for bytebuf related converters.
Factory for bytebuf related converters that do not need the application context (can be
registered with SPI).
A wrapper around a Netty cookie.
A cookie decoder that extracts cookies from the
NettyClientHttpRequest if it is present.A
CookieFactory for constructing Cookie instances for Netty.Delegates to
Cookie.Extended
EmbeddedServer interface that represents a
Netty-based HTTP server.A factory / strategy interface for creating instances of
NettyEmbeddedServer.Internal interface with services required by the
NettyHttpServer.Allows configuring Netty global properties.
A factory to create Netty HTTP clients.
Delegates to Netty's
HttpHeaders.Implementation of
MutableHttpParameters for Netty.Delegates to the Netty
HttpRequest instance.Common interface for client and server to implement to construct the Netty versions of the request objects.
Common interface for client and server to implement to construct the Netty versions of the response objects.
Implementation of
HttpResponseFactory for Netty.Implements the bootstrap and configuration logic for the Netty implementation of
EmbeddedServer.Allows configuring Netty within
NettyHttpServer.Access logger configuration.
Abstract class for configuring the Netty event loop.
Allows configuration of properties for the
AbstractFileBodyWriter.Configuration for the Cache-Control header.
Http2 settings.
Configuration for the experimental HTTP/3 server.
Sets the manner in which the HTTP server is configured to receive requests.
Netty listener configuration.
Address family enum.
Configuration for Netty parent.
Configuration for Netty worker.
Replacement for
JsonMessageHandler with ChunkedMessageBodyReader support.Netty json stream implementation for MessageBodyHandler.
Delegates to Netty's
FullHttpResponse.A Netty implementation of
PartData.A version of
RequestArgumentBinder that requires NettyHttpRequest.Interface implemented by users to hook into the pipeline setup of the netty HTTP server.
Enum to describe the role of the channel passed to
NettyServerCustomizer.specializeForChannel(Channel, ChannelRole).Interface implemented by the HTTP server to register customizers.
A Netty request binder registry.
Netty implementation of
WebSocketBroadcaster.A handler for
WebSocketFrame instances.Handles WebSocket upgrade requests.
An implementation of the
StreamingFileUpload interface for Netty.Factory for instances of
NettyStreamingFileUpload.The Default thread factory the Netty
NioEventLoopGroup will use within Micronaut to
create threads.Common utilities for netty TLS support.
Handler for WebSocket clients.
Implementation of the
WebSocketSession interface for Netty.Netty-specific writer implementation.
This interface is used to write the different kinds of netty responses.
Represents information about a network interface in the Cloud.
Documents the code change that needs to be done in the next major version.
Factory for NioEventLoopGroup.
An exception thrown when no service is available.
Thrown when a request is made that has no host information.
Excludes a member of an annotation type (such as a qualifier type or interceptor binding type) from consideration when the container compares two annotation instances.
A marker annotation for methods that are non-blocking.
A marker interface for argument binders that are non-blocking.
A common annotation to declare that annotated elements cannot be
null.Exception thrown when a bean is not unique and has multiple possible implementations for a given bean type.
Thrown when no such beans exists.
Thrown if an error occurs locating a message.
Builder for not implemented tokens.
Expression node for unary '!' operator.
A common annotation to declare that annotated elements can be
null under some circumstance.Validates route parameters are nullable or optional for optional
template variables.
Expression AST node for null literal.
Expression AST node for relational operations (>, <,
>=, <=) on
numeric types.Factory bean for creating the Jackson
ObjectMapper.Simple facade over a Jackson
ObjectNode to make it a ConvertibleValues.Interface for implementations capable of serializing objects.
Utility methods for working with objects
Annotation that can be applied to a method that will receive WebSocket close frames.
Expression AST node for array instantiation.
Annotation that can be applied to a method that will receive WebSocket errors.
Annotation that can be applied to a method that will receive WebSocket message frames.
Annotation that can be applied to a method that will receive WebSocket open frames.
Details of the current operating system.
Represents a command line option.
A simple type safe abstraction over a map of optional values.
Default implementation of
OptionalValues.A Jackson Serializer for
OptionalValues.Annotation that can be applied to method to signify the method receives a
HttpMethod.OPTIONS.This Filter intercepts HTTP OPTIONS requests which are not CORS Preflight requests.
Annotation for objects that are ordered.
Interface for objects that are ordered.
Apply the
Ordered interface to lists or arrays.Interface for types that provide originating elements.
Expression node for binary '||' operator.
Defines a utility class which evaluates if a
HttpRequest should be processed.Implementation of
OutgoingHttpRequestProcessor.Defines regular expressions to match requests.
An annotation processor that generates
BeanConfiguration implementations for
each package annotated with Configuration.Models a package in source code.
A
AnnotationRemapper that simply renames packages retaining the original simple class
names as is.A hint annotation that can be added to
Bean definitions or Executable methods to indicate that they can be initialized in
parallel with the application context.Specifies that an argument to a bean constructor is user provided.
Represents a parameter to a method or constructor.
A
RequestVersionResolver responsible for extracting version from HttpParameters.Configuration for version resolution via request parameters.
An type of
BeanDefinition that can build a new instance, construction requires additional (possibly user supplied) parameters in order construct a beanAn extended version of the
Provider interface.Exception that is thrown in command line parsing fails.
Methods to parse Java source files.
An annotation that can be applied to method argument to indicate that the method argument is bound from a specific
part of a "multipart/form-data" request.
Skips binding parts because they should be handled by a multipart processor.
Represents a chunk of data belonging to a part of a multipart request.
Annotation that can be applied to method to signify the method receives a
HttpMethod.PATCH.Interface for components that can match source strings against a specified pattern string.
Used to bind a parameter exclusively from a path variable.
Used for binding a parameter exclusively from a path variable.
A variation of
ArgumentBinder.BindingResult that indicates
that the binding result is pending and the value should be checked later.Netty handler that handles incoming
HttpRequests and forwards them to a
RequestHandler.Expression node for unary '+' operator.
Annotation that can be applied to method to signify the method receives a
HttpMethod.POST.Marker interface for
RequestArgumentBinder to indicate that it should bind after filters are applied.Exception to indicate postponing processing to next round.
Expression AST node for '^' operator.
A
Qualifier that indicates that this bean is the primary bean that should be selected in the case of
multiple possible interface implementations.A qualifier to look up a primary bean.
A
ClassElement of primitive types.The exception can be used to stop the processing and display an error associated to the element.
An annotation to indicate the
MediaTypes produced by a particular component.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.Extends
InfoEndpoint to add a helper method for retrieving a
PropertySource from a properties file.Default load that handles Java properties files.
A property that can be contained within a
PropertySource or used generally throughout the system.Expression AST node used for accessing object property.
Typical conventions used for property names through the system.
A property element represents a JavaBean property on a
ClassElement.The access type for bean properties.
The element annotation metadata for property element.
Represents a query for
PropertyElement definitions.The property expression resolver.
Metadata about a property.
Thrown when a property cannot be resolved.
Interface for implementations that resolve placeholders in configuration and annotations.
A property resolver is capable of resolving properties from an underlying property source.
An annotation that can be used on either the main class or a test to provide additional hard coded
property values to the
Environment.A PropertySource is a location to resolve property values from.
Property convention.
Loads the given property source for the given environment.
An interface for beans that are capable of locating a
PropertySource instance.A
PropertyResolver that resolves from one or many PropertySource instances.The property catalog to use.
Interface for classes that read and process properties sources.
Prototype scope is a non-singleton scope that creates a new bean for every injection point.
Deprecated.
Use the typed member of the
Bean annotation insteadMakes
TypeInformation.isWrapperType() return true for Providers.Helper methods for dealing with
Provider.Marker interface for a
BeanDefinition that is an AOP proxy.Responsible for parsing and returning the information
stored in the standard and de facto standard proxy headers.
Interface that allows proxying of HTTP requests in controllers and filters.
A factory to create Proxy HTTP clients.
Interface for managing the construction and lifecycle of instances of
ProxyHttpClient clients.Extends
BeanDefinitionVisitor and adds access to the proxied type name.Further options for
ProxyHttpClient when handling proxy requests.Builder class.
Deprecated, for removal: This API element is subject to removal in a future version.
No longer used
Deprecated, for removal: This API element is subject to removal in a future version.
No longer used
A subscriber that allows blocking reads from a publisher.
Transform a
PublisherAsBlocking of buffers into a InputStream.Utilities for working with raw
Publisher instances.A publisher for a value.
A publisher that throws an error.
Maps the next result or supplies an empty result.
Marker interface for any micronaut produced publishers.
Static optimizations for the
class.A
HttpRequest that is potentially capable of HTTP2 server push.Annotation that can be applied to method to signify the method receives a
HttpMethod.PUT.Internal interface used by generated code to propagate qualifiers.
An interface for a
BeanType that allows qualifiers.Used to qualify which bean to select in the case of multiple possible options.
The remapped adds a non-binding attribute to any qualifiers that are stereotypes.
Factory for
Bean qualifiers.Indicates that the parameter to a method should be bound from a value in the query string or path of the URI.
A binder for binding arguments annotated with @QueryValue.
Implementation of the Binder for
QueryValue
The details of implementation can be found in the
QueryValueClientArgumentRequestBinder.bind(ArgumentConversionContext, ClientRequestUriContext, Object, MutableHttpRequest) method javadoc.The property expression for random values.
A body handler that is responsible for "raw" writing/reading, i.e.
Allows hooking modifying the resulting publisher prior to returning it from the client.
The reactive execution flow.
Default implementation of
InfoAggregator.Reactive propagation of
PropagatedContext.Implementation of
TypeInformationProvider for reactive streams.Registers converters for Reactive types such as
Publisher.A transformer that remaps io.reactivex.annotations.Nullable to
javax.annotation.Nullable.A transformer that remaps reactor.util.annotation.Nullable to
javax.annotation.Nullable.Reactor propagation of
PropagatedContext.A method designed to annotate an
Endpoint read operation.Used by
ReadableBytesTypeConverter to parse strings in the form 1MB to numbers.Converts String's to readable bytes.
Qualifier designed to make the
HealthIndicator exposed via
/health/readiness endpoint of HealthEndpoint.An exception thrown when a read timeout occurs.
AOP around advice that can be applied to any type or method that requires
Fallback handling.A
MethodInterceptor that will attempt to execute a Fallback
when the target method is in an error state.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.
A custom scope that allows target beans to be refreshed.
Exposes an
Endpoint to refresh application state via a RefreshEvent.An
ApplicationEvent for handling refreshes.A convenience interface that can be implemented if a component needs to listen for
RefreshEvent where the implementation is only interested in a limited set of configuration prefixes.A
MethodInterceptor that will lock the bean preventing it from being destroyed by a
RefreshEvent until the method completes.Implementation of
Refreshable.PathMatcher implementation for regex-style patterns.
Common configuration for
ServiceInstance registration.Exception thrown during
ServiceInstance registration.Abstract expression AST node for relational operations.
Builder for RemoteHostElement.
Builder for RemoteIpElement.
Allows a bean to specify that it replaces another bean.
A binder that binds from an
HttpRequest.A class containing methods to aid in satisfying arguments of a
Route.An annotation that can be applied to method arguments to indicate that the method argument is bound to an HTTP request attribute
This can also be used in conjuction with @RequestAttributes to list attributes on a client class that will always be applied
Note: Request attributes are intended for internal data sharing only, and are not attached to the outbound request.
An
AnnotatedArgumentBinder implementation that uses the RequestAttribute
annotation to trigger binding from an HTTP request attribute.This lets you declare several attributes for a client class and have them always included.
An interface that may be implemented by
RequestScope beans to allow
access to the current request.Used to bind Bindable parameters to a Bean object.
Used to bind Bindable parameters to a Bean object.
Validates RequestBean parameters.
A
ArgumentBinderRegistry where the source of binding is a HttpRequest.An expression evaluation context for use with HTTP annotations and the
condition member.Method annotation for a request filter.
Handler for incoming requests.
This class handles the full route processing lifecycle for a request.
Builder for RequestLineElement.
A locale resolver which resolves the locale via
HttpRequest.getLocale().Route with a request predicate.
Builder for RequestMethodElement.
Builder for RequestProtocolElement.
A
CustomScope that creates a new bean for every HTTP request.Allows defining an HttpRequest based on some property of the server (ie: Port).
Builder for RequestUriElement.
Interface responsible for extracting request version from
HttpRequest.For specifying multiple requirements.
Expresses a requirement for a bean or
Configuration.Used to express an operating system family.
Used to express a required SDK version.
Internal method marks a type, method or a field for validation.
Represents a REST resource in a hateoas architecture.
Prints a banner from a resource.
A message source backed by a resource bundle.
Basic abstraction over resource loading.
Creates beans for
ResourceLoaders to handle static resource requests.Modifies deserialization for
Resource.Resolves resources from a set of
ResourceLoader instances.A resource route is a composite route to a REST endpoint.
Exception raised when the connection is closed during the response.
Builder for ResponseCodeElement.
Method annotation for a response filter.
AOP Advice that can be applied to any method.
An event triggered on each retry.
Generalization of
ApplicationEventListener for RetryEvent.An exception thrown if there is something at miss with the Retry system.
An interface allows to provide custom condition for
Retryable and
CircuitBreaker.An interface that encapsulates the current state of a
Retryable operation.The retry state builder.
Models a return type of
Executable method in Micronaut.Represents a Route definition constructed by a
RouteBuilder.An interface for classes capable of building HTTP routing information.
A URI naming strategy is used to dictate the default name to use when building a URI for a class.
Allows defining a condition for this route to match using an expression.
Returns data for a given route to be used for the
RoutesEndpoint.Used to respond with route information used for the
RoutesEndpoint.A class responsible for executing routes.
Common information shared between route and route match.
A
Route that is executable.A filter responsible for filtering route matches.
Core Router interface that allows discovery of a route given an HTTP method and URI.
Exposes an
Endpoint to display application routes.Routes versioning configuration.
The result of route validation.
Describes a rule to validate a route.
Visits methods annotated with HttpMethodMapping and validates the
parameters are consistent with the URI.
Implementation of
RouteMatchFilter responsible for filtering route matches on Version.An exception that occurs when building routes.
Internal implementation of the
ChannelInboundHandler for Micronaut.Interface for classes that instrument
Runnable instances.Allow the construction for bean definitions programmatically that can be registered
via
BeanDefinitionRegistry at runtime.A builder for constructing
RuntimeBeanDefinition instances.A transformer that remaps io.reactivex.rxjava3.annotations.Nullable to
javax.annotation.Nullable.Asserts that a cookie must not be sent with cross-origin requests, providing some protection against cross-site request forgery attacks (CSRF).
Converts a string to a
SameSite.An annotation for scheduling a re-occurring task.
A default executor service for scheduling adhoc tasks via
ScheduledExecutorService.Simple abstraction over
ScheduledExecutorService.A
ExecutableMethodProcessor for the Scheduled annotation.Repeatable annotation wrapper for
Scheduled.A meta annotation for a scoped proxy.
Counter part to
Primary that allows reducing the priority of a given bean for the purposes of dependency
injection.Annotation that can be applied to arguments that should be included in the endpoint URI.
The Netty implementation of
SslBuilder that generates an SslContext to create a server handler
with SSL support via a generated self-signed certificate.Utility class for comparing semantic versions.
An annotation that can be applied at the method level to indicate that return value of said method should be sent to given destination.
Annotation that can be applied to endpoint methods to control sensitivity at the method level.
A generic exception that occurs during serialization or deserialization.
A contract for providing a context path to a server.
Mark a bean as a filter for the HTTP server.
A non-blocking and thread-safe filter chain.
Represents phases of server filters.
RouteBuilder for ServerFilters.Http request propagation.
The holder for the current
HttpRequest that is bound to instrumented threads.A reactive streams publisher that instruments an existing publisher ensuring execution is
wrapped in a
ServerRequestContext.Event fired when the
EmbeddedServer shuts down.Interface that allows for different builder instances to be able to create
the SSLContext supplied later to the micronaut http server.
The default
SslConfiguration used for HTTP servers.The default
SslConfiguration.KeyConfiguration.The default
SslConfiguration.KeyStoreConfiguration.The default
SslConfiguration.TrustStoreConfiguration.Event fired when the
EmbeddedServer completes startup.An exception thrown on server startup.
Exposes an
Endpoint to stop the server.An API for a Micronaut HTTP Server under test.
Provides a server to test.
Utility class to retrieve a
ServerUnderTestProvider via a Service Loader.Annotation declared on the server to indicate the class handles web socket frames.
A processor that exposes WebSocket URIs via the router.
A service that may or may not be present on the classpath.
Allows defining HTTP client configurations via the
micronaut.http.services setting.The default connection pool configuration.
The default connection pool configuration.
The default
SslConfiguration.KeyConfiguration.The default
SslConfiguration.KeyStoreConfiguration.The default
SslConfiguration.TrustStoreConfiguration.Creates
HttpClient instances for each defined ServiceHttpClientConfiguration.A
HealthIndicator used to display available load balancer URLs.Represents a remote service discovered by the underlying discovery implementation.
A builder for building
ServiceInstance references.Interface for generating IDs for
ServiceInstance.Interface for types that expose a list of
ServiceInstance.The default
LoadBalancer factory for creating LoadBalancer instances from
ServiceInstanceList instances.Strategy interface for classes to contribute to
ServiceInstance metadata
when registering an instance with a discovery service.An event fired when a service has completed starting and is ready to service requests.
A
HealthIndicator that signals when the service is ready to
service requests.An event triggered when a
ServiceInstance has shutdown and will no longer service requests.Converter registrar for HTTP classes.
An event fired prior to starting shutdown sequence.
Simple
Cookie implementation.Simple
CookieFactory implementation.Simple
Cookies implementation.Simple
MutableHttpHeaders implementation.Simple implementation of
MutableHttpParameters.Simple
MutableHttpRequest implementation.Simple
HttpRequestFactory implementation.Simple
HttpResponseFactory implementation.Parser for building AST for single evaluated expression.
Annotation that can be used to describe that an API emits a single result even if the return type is a
Publisher.A
Processor that only allows a single SubscriberA
Publisher that only allows a single Subscriber.A Reactive streams
Processor designed to be used within a single thread and manage
back pressure state.A
Subscriber designed to be used by a single thread that buffers incoming data for the purposes of managing
back pressure.Back pressure state.
An extension of
HttpContentCompressor that skips encoding if the content type is not compressible or if
the content is too small.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.A transformer that remaps edu.umd.cs.findbugs.annotations.Nullable to
javax.annotation.Nullable.A client for streaming Server Sent Event streams.
A factory to create Server Sent Event clients.
Interface for managing the construction and lifecycle of instances of reactive clients.
A class to build a key store and a trust store for use in adding SSL support to a server.
Configuration properties for SSL handling.
Configuration properties for SSL key.
Configuration properties for SSL key store.
Configuration properties for SSL trust store.
An exception thrown while configuring SSL.
An event fired once startup is complete.
A static mutable message source.
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.
Utility class for testing originating element generation.
Stores configuration for the loading of static resources.
Resolves resources from a set of resource loaders.
A factory for creating the default
StaticResourceResolver.A
ServiceInstanceList using a static list of URLs.Sets alternative HttpStatus response code when applied to a method and HttpStatus code is specified.
Represents a
Route that matches a status.Represents a
RouteInfo that matches a status.Interface for types that can be written to an
OutputStream.A special type for streaming an
InputStream representing a file or resource.Combines
HttpMessage and Publisher into one
message.Combines
HttpRequest and StreamedHttpMessage into one
message.Combines
HttpResponse and StreamedHttpMessage into one
message.Body writer for
StreamedFiles.A base function executor for handling input and output as streams
ByteBody implementation that wraps a
StreamedHttpRequest.Represents a part of a
MediaType.MULTIPART_FORM_DATA request.Extended version of the
HttpClient that supports streaming responses.A factory to create Streaming HTTP clients.
Interface for managing the construction and lifecycle of instances of
StreamingHttpClient clients.MultiObjectBody derived from a StreamingByteBody.Utility methods for working with streams.
An enum representing different conventions.
Fixed-size String->int map optimized for very fast read operations.
Expression AST node for string literal.
String switch writer.
Utility methods for Strings.
Expression AST node for binary '-' operator.
Handles list, map and array de-referencing.
Processes the type and its super classes.
Helper methods for dealing with
Supplier.Used as the return value of a route execution to send
File instances to the client.Body writer for
SystemFiles.Loads properties from system properties.
An exception handler interface for task related exceptions.
The names of common task schedulers.
Interface for Scheduling tasks.
Expression AST node for ternary expressions.
Annotation processor for test generation.
Defines a HTTP Server Test Scenario.
Test Scenario Builder.
A codec that handles
MediaType.TEXT_PLAIN.Body handler for content type "text/plain".
A
MediaTypeCodec that will encode Event objects in order to support Server Sent Events.Enables access to 'this' in non-static contexts.
Exposes an
Endpoint to display application threads.Responsible for converting the standard Java ThreadInfo class
into another object for serialization.
A
CustomScope that stores objects in thread local storage.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.Enum the controls the ability to select threads in a Micronaut application.
Represents a function that accepts one argument and produces a result.
Represents a supplier of results.
Registers data time converters.
An interface for components or configurations that can be toggled on or off.
Parsed token with value and type.
Tokenizer for parsing evaluated expressions.
List of supported token types.
Annotation that can be applied to method to signify the method receives a
HttpMethod.TRACE.A
JsonGenerator that returns tokens as a JsonNode.A
Condition that simply returns true.Allows restricting injection by type.
Implementation of
Type qualifier.An
ArgumentBinder that is resolved based on the argument type.A
Qualifier that qualifies beans by generic type arguments.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.A typed
AnnotationMapper operates against a concrete annotation type.A typed
AnnotationTransformer operates against a concrete annotation type.A
ClientArgumentRequestBinder that is resolved based on the argument type.An element that has an underlying type.
Set of constants and utility methods for working with type descriptors
while compiling evaluated expressions.
A
TypeArgumentBinder that binds from an HttpRequest.A subscriber that is aware of the target type.
Provides a hook into the compilation process to allow user defined functionality to be created at compile time.
Implementors of the
TypeElementVisitor interface should specify what kind of visitor it is.The annotation processed used to execute type element visitors.
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.
Expression node for type identifier.
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.
Abstract expression node for unary operators.
An exception thrown when
Introduction advise cannot be implemented.Marker interface for unmatched request argument binder.
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.
A variation of
Executable that exposes invoke method without arguments validation.A variation of
ExecutionHandle that invokes without arguments validation.An exception thrown when an
Argument could not be satisfied
by a ExecutableBinder.Handles exception of type
UnsatisfiedArgumentException.An exception thrown when the an
CookieValue to a Route cannot be satisfied.An exception thrown when the an
PathVariable to a Route cannot be satisfied.An exception thrown when the an
QueryValue to a Route cannot be satisfied.An exception thrown when the an
RequestAttribute to a Route cannot be satisfied.Handles exceptions of type
UnsatisfiedRouteException.Helper class for building URIs and handle encoding correctly.
Meta annotation for the mapped URI whether at the controller or action level.
A URI matcher is capable of matching a URI and producing a
UriMatchInfo.The result of a call to
UriMatcher.match(java.net.URI).Extends
UriTemplate and adds the ability to match a URI to a given template using the
UriMatcher.match(java.net.URI) method.The default
UriMatchInfo implementation.Extended version of
UriTemplate.UriTemplateParser that builds a regular expression to match a path.Represents a variable in a URI template.
A
RouteMatch that matches a URI and HttpMethod.Thrown when the URI syntax is correct.
Handles exception of type
URISyntaxException.A Fast Implementation of URI Template specification.
Represents an expandable path segment.
An URI template parser.
A
UriMatchTemplate that allows specifying types for the URI variables.A typed uri match templated parser.
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.
Allows configuration
ExecutorService instances that are made available as beans.A bean definition that is validated with jakarta.validation.
Allows configuration injection from the environment or bean context on a per property, field,
method/constructor parameter basis.
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.
Configuration to decorate
Router with version matching logic.An
AnnotatedClientRequestBinder implementation for Version.Resolves a version from a given object.
A marker for
RouteMatchFilters related with Versioning.Utility methods for versioning.
Veto the processing of the element.
Allows supplying configuration to the
VisitorContext.Provides a way for
TypeElementVisitor classes to log messages during compilation and fail compilation.The languages that are supported in source code generation.
Internal common helper functions to share among
VisitorContext implementations.A type that can be used to represent JSON errors that returns a content type of Vnd.Error.
The watch event type.
A factory that creates the default watch service.
Wrapper around a WebSocket instance that enables the retrieval of the appropriate methods.
Registry for WebSocket beans.
Defines WebSocket methods to broadcast messages.
Interface that provides a way to connect a client over WebSocket.
Exceptions specific to the WebSocket client.
A factory to create WebSocket clients.
Interface for managing the construction and lifecycle of instances of reactive
WebSocketClient clients.Stereotype meta-annotation declared on both
ServerWebSocket and ClientWebSocket.Parent class for all events emitted by the WebSocket server.
General parent exception for all WebSocket related exceptions.
Combines
HttpResponse and Processor
into one message.Encapsulate functionality to encode WebSocket messages.
An event fired after a WebSocket message has been processed.
Special message class that can be accepted by a
@OnMessage
method to listen to WebSocket pongs.Represents an open WebSocket connection.
Interface used by
ClientWebSocket to gain access to the underlying WebSocketSession.Fired when a
WebSocketSession is closed on the server.Exceptions related to
WebSocketSession interaction.Fired when a
WebSocketSession is opened on the Server.Defines a ChannelGroup repository to handle WebSockets.
Holder object used to bind WebSocket state.
Interface for binders that bind from
WebSocketState.Handles binding WebSocket arguments from
WebSocketState.Creates the inbound handler for websocket upgrade requests.
Enum representing the different WebSocket versions.
A
TypeElementVisitor that validates WebSocket implementations at compile time.A class that can determine the weight of a value.
A common set of
Weigher and EntryWeigher implementations.Represents a wildcard, for example
List<?>.The element annotation metadata for wildcard element.
An interface for classes to implement that are capable of writing themselves to a
WriterBody writer for
Writables.A method designed to annotate an
Endpoint write operation.Loads properties from a YML file.
AbstractArgumentBinder