All Classes

Class	Description
AbstractAnnotatedArgumentBinder<A extends java.lang.annotation.Annotation,T,S>	An abstract AnnotatedArgumentBinder implementation.
AbstractBeanConstructor<T>	Abstract implementation of the BeanConstructor interface.
AbstractBeanIntrospection<T>	Abstract implementation of the BeanIntrospection interface.
AbstractBeanIntrospectionReference<T>	Abstract bean introspection reference used by BeanIntrospector to soft load introspections.
AbstractBeanMethod<B,T>	Abstract implementation of the BeanMethod interface.
AbstractBeanProperty<B,P>	Abstract implementation of BeanProperty.
AbstractLocaleResolver<T>	Provides an abstract class which implements LocaleResolver and handles default locale resolution.
AccessorsStyle	Annotate a class (typically a Java Bean) to make it explicit the style of its accessors when not using the standard getter and setters:
AnnotatedArgumentBinder<A extends java.lang.annotation.Annotation,T,S>	An ArgumentBinder whose lookup is driven by an annotation definition.
AnnotatedElement	An annotated element is some point in the code, whether it be a constructor, field, method etc.
AnnotatedTypeInfo	An interface that provides an abstraction for checking for the existence of annotations.
AnnotationClassValue<T>	An annotation class value is a reference to a class in annotation metadata.
AnnotationMetadata	An interface implemented at compile time by Micronaut that allows the inspection of annotation metadata and stereotypes (meta-annotations)
AnnotationMetadataDelegate	An interface that can be implemented by other classes that delegate the resolution of the AnnotationMetadata to the AnnotationMetadataProvider.getAnnotationMetadata() method.
AnnotationMetadataProvider	An interface for a type that provides AnnotationMetadata.
AnnotationMetadataResolver	An interface for types capable of resolving AnnotationMetadata.
AnnotationScanner	Interface for classes that scan for classes with a given annotation.
AnnotationSource	A source of annotations.
AnnotationUtil	Internal utility methods for annotations.
AnnotationValue<A extends java.lang.annotation.Annotation>	A runtime representation of the an annotation and its values.
AnnotationValueBuilder<T extends java.lang.annotation.Annotation>	A build for annotation values.
AnnotationValueProvider<A extends java.lang.annotation.Annotation>	An interface that allows obtaining an underlying annotation value.
AnnotationValueResolver	Interface for types that resolve annotation values.
AntPathMatcher	PathMatcher implementation for Ant-style path patterns.
Argument<T>	Represents an argument to a method or constructor or type.
ArgumentBinder<T,S>	An interface capable of binding the value of an Argument from a source
ArgumentBinder.BindingResult<T>	The result of binding.
ArgumentBinderRegistry<S>	A registry of ArgumentBinder instances.
ArgumentCoercible<T>	An interface for types that can be represented as an Argument.
ArgumentConversionContext<T>	Extended version of the ConversionContext specifically for conversion Argument instances.
ArgumentUtils	Utility methods for checking method argument values.
ArgumentUtils.ArgumentCheck<T>	Allows producing error messages.
ArgumentUtils.Check	Functional interface the check a condition.
ArgumentValue<V>	An Argument with a value.
ArrayUtils	Utility methods for working with arrays.
AttributeHolder	An interface for objects that have attributes.
AutomaticFeatureUtils	Utility methods for implementing Graal's AutomaticFeature.
BeanConstructor<T>	Models a bean constructor.
BeanExceptionHandler<T,E extends java.lang.Throwable>	An exception handler capable of receiving a bean that originated the exception and an exception type.
BeanIntrospection<T>	A BeanIntrospection is the result of compile time computation of a beans properties and annotation metadata.
BeanIntrospectionReference<T>	A reference to a BeanIntrospection that may or may not be present on the classpath.
BeanIntrospectionScanner	An implementation of AnnotationScanner that scans available BeanIntrospection instances through the BeanIntrospector API.
BeanIntrospector	Primary interface for obtaining BeanIntrospection instances that are computed at compilation time.
BeanMap<T>	Simple class that provides a map interface over a bean.
BeanMethod<B,T>	Represents a method on a BeanIntrospection.
BeanProperty<B,T>	Represents a bean property and associated annotation metadata.
BeanPropertyBinder	An interface that provides the ability to bind Maps and Java bean properties
BeanWrapper<T>	Wraps a bean allowing to read and write its properties via a underlying BeanIntrospection.
Bindable	An annotation stereotype for other annotations that indicates a method Argument is bindable.
Blocking	A marker annotation for methods that are blocking.
BoundExecutable<T,R>	A bound Executable is an executable who argument values have been pre-bound to values using a ArgumentBinderRegistry.
ByteBuffer<T>	Interface to allow interfacing with different byte buffer implementations, primarily as an abstraction over Netty.
ByteBufferFactory<T,B>	An allocator for ByteBuffer instances.
ClassPathResourceLoader	Abstraction to load resources from the the classpath.
ClassUtils	Utility methods for loading classes.
ClassUtils.Optimizations	Optimizations for computing missing types.
CollectionUtils	Utility methods for working with Collection types
CommandLine	Represents the parsed command line options.
CommandLine.Builder<T extends CommandLine.Builder>	A build for constructing a command line parser.
ConcurrentLinkedHashMap<K,V>	A hash table supporting full concurrency of retrievals, adjustable expected concurrency for updates, and a maximum capacity to bound the map by.
ConcurrentLinkedHashMap.Builder<K,V>	A builder that creates ConcurrentLinkedHashMap instances.
ConversionContext	A conversion context is a context object supplied to a TypeConverter that allows more accurate conversion.
ConversionError	An interface for reporting conversion errors.
ConversionErrorException	An exception thrown in the case of a ConversionError.
ConversionService<Impl extends ConversionService>	A service for allowing conversion from one type to another.
ConvertibleMultiValues<V>	Specialization of ConvertibleValues where each name has multiple possible values.
ConvertibleMultiValuesMap<V>	An implementation of ConvertibleMultiValues that uses a backing LinkedHashMap.
ConvertibleValues<V>	An interface for classes that represent a map-like structure of values that can be converted.
ConvertibleValuesMap<V>	An implementation of ConvertibleValues backed by a map.
Creator	An annotation applicable to a constructor that provides a hint as to which constructor is the primary constructor.
DefaultArgument<T>	Represents an argument to a constructor or method.
DefaultClassPathResourceLoader	Loads resources from the classpath.
DefaultConversionService	The default conversion service.
DefaultExecutableBinder<S>	Default implementation of the ExecutableBinder interface.
DefaultFileSystemResourceLoader	Loads resources from the file system.
Described	An interface for types that are described by a description.
EntryPoint	EntryPoint is a meta-annotation used on other annotations to indicate that the annotated element is an entry point into the framework from the outside.
EntryWeigher<K,V>	A class that can determine the weight of an entry.
EnvironmentProperties	A mapping from environment variable names to Micronaut property names.
ErrorsContext	Interface for reporting conversion errors.
EvictionListener<K,V>	A listener registered for notification when an entry is evicted.
ExceptionHandler<T extends java.lang.Throwable>	Common interface for types that handle exceptions.
Executable<T,R>	Represents an executable reference.
ExecutableBinder<S>	An ExecutableBinder is capable of taking a target Executable and fulfilling the argument requirements using the provided binding source and ArgumentBinderRegistry
Experimental	Annotates a class or method as being experimental and subject to change or removal.
FileSystemResourceLoader	Abstraction to load resources from the file system.
FixedLocaleResolver<T>	Generic implementation of LocaleResolver for fixed locale resolution.
Format	Annotation used to describe the format in the case where the format needs to be altered for the purposes of conversion.
FormattingTypeConverter<S,T,A extends java.lang.annotation.Annotation>
Generated	A marker annotation for methods that are generated though an annotation processor.
GenericArgument<T>	Captures a generic Argument.
GenericPlaceholder<T>	Extends Argument to allow differentiating the variable name from the argument name in cases where this is required (parameters and fields for example).
GenericTypeUtils	Utility methods for dealing with generic types via reflection.
GraalReflectionConfigurer	Interface that allows dynamic configuration of reflection generated by the GraalTypeElementVisitor.
GraalReflectionConfigurer.ReflectionConfigurationContext	Context object for the configuration.
Headers	Common interface for all headers types.
ImmutableArgumentConversionContext<T>	Immutable variant of ArgumentConversionContext that can be used as a constant in cases where conversion error handling and rejection is not required.
Indexed	An annotation that can be used on types where there may be many implementations of a particular interface.
Indexes	Allows Indexed to be repeatable.
InstantiatedMember	An annotation that can be used on another annotation member that returns a class to indicate that the value of the annotation should be populated as an instance of the specified class.
InstantiationException	Thrown when an error occurs instantiating a instance.
InstantiationUtils	Utility methods for instantiating objects.
Internal	Annotates a class or method regarded as internal and not for public consumption.
Introspected	An annotation that indicates a type should produce a BeanIntrospection at compilation time.
Introspected.AccessKind	The access type for bean properties.
Introspected.IndexedAnnotation	Allow pre-computed indexes for property lookups based on an annotation and a member.
Introspected.Visibility	Visibility policy for bean properties and fields.
IntrospectionException	Thrown when an error occurs introspecting a bean type.
InvocationException	Runtime exception equivalent of InvocationTargetException.
IOExceptionBiFunction<T,U,R>	Utility to use a BiFunction which throws internally a IOException.
IOUtils	Utility methods for I/O operations.
JdkSerializer	A ObjectSerializer that uses JDK serialization.
KotlinUtils	Internal Utility methods for working with Kotlin suspend functions
LocaleResolutionConfiguration	Locale resolution configuration.
LocaleResolver<T>	Responsible for determining the current locale given a context.
MapFormat	Allows configuration how map property values are injected.
MapFormat.MapTransformation	Specifies the type of the map that should be injected.
MapPropertyResolver	A PropertyResolver that resolves values from a backing map.
MethodConvention	Represents the built in conventions for mapping a method name to an HTTP Method and URI.
MultiValuesConverterFactory	A factory for creation of various FormattingTypeConverters to and from ConvertibleMultiValues type.
MultiValuesConverterFactory.AbstractConverterToMultiValues<T>	An abstract class to convert to ConvertibleMultiValues.
MultiValuesConverterFactory.IterableToMultiValuesConverter	A converter from Iterable to ConvertibleMultiValues.
MultiValuesConverterFactory.MapToMultiValuesConverter	A converter from Map to ConvertibleMultiValues.
MultiValuesConverterFactory.MultiValuesToIterableConverter	A converter to convert from ConvertibleMultiValues to an Iterable.
MultiValuesConverterFactory.MultiValuesToMapConverter	A converter to convert from ConvertibleMultiValues to an Map.
MultiValuesConverterFactory.MultiValuesToObjectConverter	A converter to convert from ConvertibleMultiValues to a POJO Object.
MultiValuesConverterFactory.ObjectToMultiValuesConverter	A converter from generic Object to ConvertibleMultiValues.
MutableArgumentValue<V>	A mutable version of the ArgumentValue interface.
MutableAttributeHolder	An interface for types that support mutating attributes.
MutableConvertibleMultiValues<V>
MutableConvertibleMultiValuesMap<V>	Implementation of MutableConvertibleMultiValues that operates against a backing LinkedHashMap.
MutableConvertibleValues<V>	A ConvertibleValues that is mutable.
MutableConvertibleValuesMap<V>	Mutable version of ConvertibleMultiValuesMap.
MutableHeaders	Common interface for all mutable header types.
Named	An interface for components that are named.
NameResolver	An interface for a components that resolve names.
NameUtils	Naming convention utilities.
NonBlocking	A marker annotation for methods that are non-blocking.
NonNull	A common annotation to declare that annotated elements cannot be null.
Nullable	A common annotation to declare that annotated elements can be null under some circumstance.
ObjectSerializer	Interface for implementations capable of serializing objects.
Option	Represents a command line option.
OptionalMultiValues<V>	An OptionalValues that for each key features an Optional List of values.
OptionalValues<V>	A simple type safe abstraction over a map of optional values.
OptionalValuesMap<T>	Default implementation of OptionalValues.
Order	Annotation for objects that are ordered.
Ordered	Interface for objects that are ordered.
OrderUtil	Apply the Ordered interface to lists or arrays.
ParseException	Exception that is thrown in command line parsing fails.
PathMatcher	Interface for components that can match source strings against a specified pattern string.
PropertyConvention	Typical conventions used for property names through the system.
PropertyNotFoundException	Thrown when a property cannot be resolved.
PropertyResolver	A property resolver is capable of resolving properties from an underlying property source.
Readable	Abstraction over File and URL based I/O.
ReadableBytes	Used by ReadableBytesTypeConverter to parse strings in the form 1MB to numbers.
ReadableBytesTypeConverter	Converts String's to readable bytes.
ReferenceCounted
ReflectionConfig	An annotation that models directly the GraalVM reflect-config.json format.
ReflectionConfig.ReflectionConfigList	Wrapper annotation.
ReflectionConfig.ReflectiveFieldConfig	Field configuration.
ReflectionConfig.ReflectiveMethodConfig	Method configuration.
ReflectionUtils	Utility methods for reflection related tasks.
ReflectiveAccess	Descriptive annotation that can be used to declare a field, method, constructor and types for reflective access.
RegexPathMatcher	PathMatcher implementation for regex-style patterns.
ResourceLoader	Basic abstraction over resource loading.
ResourceResolver	Resolves resources from a set of ResourceLoader instances.
ReturnType<T>	Models a return type of an Executable method in Micronaut.
SemanticVersion	Utility class for comparing semantic versions.
SerializationException	A generic exception that occurs during serialization or deserialization.
ServiceDefinition<T>	A service that may or may not be present on the classpath.
SocketUtils	Utility methods for dealing with sockets.
SoftServiceLoader<S>	Variation of ServiceLoader that allows soft loading and conditional loading of META-INF/services classes.
SoftServiceLoader.Optimizations	Static optimizations for service loaders.
SoftServiceLoader.ServiceCollector<S>	Service collector for loading services of the given type.
SoftServiceLoader.StaticDefinition<S>	A ServiceDefinition implementation that uses a MethodHandles.Lookup object to find a public constructor.
SoftServiceLoader.StaticServiceLoader<S>	Service loader that uses SoftServiceLoader.StaticDefinition.
StaticOptimizations	This class is a generic container for pre-computed data which can be injected at initialization time.
StaticOptimizations.Loader<T>	Interface for an optimization which will be injected via service loading.
Streamable	Interface for types that can be written to an OutputStream.
StreamSoftServiceLoader	Deprecated. Use SoftServiceLoader.collectAll(java.util.Collection) instead
StreamUtils	Utility methods for working with streams.
StringConvention	An enum representing different conventions.
StringUtils	Utility methods for Strings.
SupplierUtil	Helper methods for dealing with Supplier.
ThrowingFunction<T,R,E extends java.lang.Throwable>	Represents a function that accepts one argument and produces a result.
ThrowingSupplier<T,E extends java.lang.Throwable>	Represents a supplier of results.
Toggleable	An interface for components or configurations that can be toggled on or off.
TypeArgumentBinder<T,S>	An ArgumentBinder that is resolved based on the argument type.
TypeConvention	Common conventions for types
TypeConverter<S,T>	A type converter for converting from one type to another.
TypeConverterRegistrar	An interface for classes that register type conversions with the ConversionService.
TypeHint	The type hint annotation is a general annotation that can be used on interfaces to provide additional information about types used at runtime.
TypeHint.AccessType	The access type.
TypeInformation<T>	Provides information about a type at runtime.
TypeInformationProvider	Interface that implementors can hook into to control the logic of methods like TypeInformation.isReactive().
TypeVariableResolver	An interface for types that hold and can resolve type variables.
UncheckedIOException	Wraps a IOException in a RuntimeException.
UnsafeBeanProperty<B,T>	Unsafe bean property interface adds read/write methods which don't validate the input/output.
UnsatisfiedArgumentException	An exception thrown when an Argument could not be satisfied by a ExecutableBinder.
UsedByGeneratedCode	A marker annotation indicating that a method is used by generated code and should not be modified or removed otherwise a binary compatibility problem will be introduced.
ValueException	An exception that occurs related to configuration.
ValueResolver<K extends java.lang.CharSequence>	An interface for any type that is able to resolve and convert values.
Version	Annotation used to express the version of a component or method.
VersionUtils	Utility methods for versioning.
Weigher<V>	A class that can determine the weight of a value.
Weighers	A common set of Weigher and EntryWeigher implementations.
Writable	An interface for classes to implement that are capable of writing themselves to a Writer