All Classes and Interfaces
Class
Description
Base class for
SslConfiguration extensions for SSL clients.An abstract implementation of
Resource.An interface for classes that bind an
Argument from an HttpRequest driven by
an annotation.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.
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.
A
MutableHttpHeaders implementation that is case-insensitive.Body writer for
CharSequences.Variant of
MessageBodyReader that allows piecewise reading of the input, e.g.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 default
SslConfiguration used for HTTP clients.The default
SslConfiguration.KeyConfiguration.The default
SslConfiguration.KeyStoreConfiguration.The default
SslConfiguration.TrustStoreConfiguration.Configuration for
MediaTypeCodec instances.An exception thrown when an object cannot be decoded.
Represents a completed part of a multipart request.
Represents a completed part of a multipart request.
Exception thrown when the client or server unexpectedly closes the connection.
An annotation to indicate the
MediaTypes consumed by a particular component.Exception thrown when the content length exceeds the allowed amount.
MessageBodyHandlerRegistry implementation that does not need an application context.Utility class to work with context paths and URIs.
Indicates that the role of a class is a controller within an application.
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.
A CookieFactory creates
Cookie instances and should be implemented by a concrete server.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.
This annotation is designed for non-standard http methods, that you
can provide by specifying the required
CustomHttpMethod.method() property.Binds a String body argument.
Default implementation of
Link.Registry of
MediaTypeCodec instances.Stores message body readers and writers.
Default implementation of the
RequestBinderRegistry interface.The default
SslConfiguration configuration used if no other configuration is specified.The default
SslConfiguration.KeyConfiguration.The default
SslConfiguration.KeyStoreConfiguration.The default
SslConfiguration.TrustStoreConfiguration.The binder will try to bind the argument value which wasn't matched by an annotation or a type.
Annotation that can be applied to method to signify the method receives a
HttpMethod.DELETE.Placeholder
MessageBodyWriter implementation that decides which writer to use based on
the dynamic (runtime) type of the body.Annotation that can be applied to method to map it to an error route.
Represents a Server Sent Event.
Represents a part of a
MediaType.MULTIPART_FORM_DATA request.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.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.
The filter runner will start processing the filters in the forward order.
Allows introspecting whether the request is a full http request.
Base interface for different filter types.
"Legacy" filter, i.e.
Wrapper around a filter that signifies the filter should be run asynchronously on the given
executor.
Last item in a filter chain, called when all other filters are done.
Terminal filter that accepts a reactive type.
Resource with indeterminate structure.Annotation that can be applied to method to signify the method receives a
HttpMethod.GET.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.This lets you declare several headers for a client class and have them always included.
Common HTTP attributes.
An HttpClientFilter extends
HttpFilter and allows the passed request to be mutated.HttpClientFilterResolver<T extends io.micronaut.core.annotation.AnnotationMetadataProvider>
Subinterface for filter resolution specific to HTTP client filters.
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.HttpFilterResolver<T extends io.micronaut.core.annotation.AnnotationMetadataProvider>
A contract for resolving filters for a given request.
A resolved filter entry.
Constants for common HTTP headers.
Utility class to work with
HttpHeaders or HTTP Headers.Interface for common HTTP header values.
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.
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.
A factory interface for creating
MutableHttpResponse instances.A contract to provide an http response.
A wrapper around a
HttpResponse.An HttpServerFilter extends
HttpFilter and provides the response as a MutableHttpResponse.HttpServerFilterResolver<T extends io.micronaut.core.annotation.AnnotationMetadataProvider>
Subinterface for filter resolution specific to HTTP server filters.
Represents HTTP status codes.
Exception thrown to return a specific HttpStatus and an error message.
Provide type information for HTTP response.
Utility methods for HTTP handling.
Enum representing different HTTP versions.
A class that can be used to represent JSON errors that complies to Vnd.Error without the content type requirements.
Interface for a hateoas link.
Build for creating
Link instances.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.
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.
Exception thrown during multipart handling.
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.A marker interface for argument binders that are non-blocking.
Annotation that can be applied to method to signify the method receives a
HttpMethod.OPTIONS.Defines a utility class which evaluates if a
HttpRequest should be processed.Implementation of
OutgoingHttpRequestProcessor.Defines regular expressions to match requests.
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.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.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.An annotation to indicate the
MediaTypes produced by a particular component.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.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.
A body handler that is responsible for "raw" writing/reading, i.e.
The reactive execution flow.
A binder that binds from an
HttpRequest.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.
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.
A
CustomScope that creates a new bean for every HTTP request.Represents a REST resource in a hateoas architecture.
Creates beans for
ResourceLoaders to handle static resource requests.Method annotation for a response filter.
Allows defining a condition for this route to match using an expression.
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.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.
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.The default
SslConfiguration used for HTTP servers.The default
SslConfiguration.KeyConfiguration.The default
SslConfiguration.KeyStoreConfiguration.The default
SslConfiguration.TrustStoreConfiguration.Converter registrar for HTTP classes.
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.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.
Sets alternative HttpStatus response code when applied to a method and HttpStatus code is specified.
Represents a part of a
MediaType.MULTIPART_FORM_DATA request.A codec that handles
MediaType.TEXT_PLAIN.Body handler for content type "text/plain".
Annotation that can be applied to method to signify the method receives a
HttpMethod.TRACE.A
TypeArgumentBinder that binds from an HttpRequest.Marker interface for unmatched request argument binder.
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.
Thrown when the URI syntax is correct.
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 type that can be used to represent JSON errors that returns a content type of Vnd.Error.
Body writer for
Writables.