All Classes and Interfaces
Class
Description
An abstract implementation of the
BeanConfiguration method.Abstract constructor implementation for bean definitions to implement to create constructors at build time.
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 implementation of the custom scope interface that simplifies defining new scopes using the Map interface.
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.
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.
Abstract class which implements
LocalizedMessageSource and leverages LocaleResolver API.Abstract
MessageSource implementation that provides basic message interpolation.An abstract implementation of the
PropertySourceLoader interface.Abstract bean definition for other providers to extend from.
An environment that is active for the current execution
of the application.
A marker interface for all
BeanDefinitionReference and BeanDefinition
instances to implement that provides access to the target bean type for an AOP advice bean.A repeatable annotation that allows defining multiple
AliasFor definitions.Allows specifying an annotation member alias.
Abstract validator for
AnnotatedElement that may represent source code level validation routes
executed at compilation time.Registers annotation converters.
A meta annotation used to extend
EvaluatedExpression
context with specified type.An exception that occurs constructing
AnnotationMetadata.Used to represent an annotation metadata hierarchy.
A reference to
AnnotationMetadata.Support method for
AnnotationMetadata.An annotation processor is an object that processes the presence if a given annotation.
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.
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.Represents an
Argument as a BeanType.An injection point for a method or constructor argument.
Print a banner programmatically.
Annotation used to configure a bean.
A BeanConfiguration is a grouping of several
BeanDefinition instances.The core BeanContext abstraction which allows for dependency injection of classes annotated with
Inject.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.
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.Core bean definition registry interface containing methods to find
BeanDefinition instances.Interface to integrate bean validation into the construction of beans within the
BeanContext.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.
An abstract bean event.
An identifier for a
Bean that can be used as a key to uniquely identify an
instance.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.
Core interface for locating and discovering
Bean instances.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.
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.
A reference to a bean.
An annotation indicating that a bean can be loaded into the Bootstrap Context.
Allows blocking resolving of
PropertySource from remote distributed configuration servers.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.Represents a circular dependency failure.
A
Qualifier that qualifies beans by generic type arguments and only
returns the candidates that most closely match.A
PropertySource for properties parsed from the command line.A condition allows conditional loading of a
BeanConfiguration.ConditionContext<T extends io.micronaut.core.annotation.AnnotationMetadataProvider>
The ConditionContext passed to a
Condition.Expression evaluation context that can be configured before evaluation.
A configuration is a grouping of bean definitions under a package.
An annotation applicable to a field or method of a
ConfigurationProperties instance that allows to
customize the behaviour of properties that are builders themselves.An exception that occurs during configuration setup.
Allows injecting configuration values into a constructor or method based
on the parameter names.
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.
An optimization class which is used to register property sources
statically.
A constructor injection point.
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.
A converter registry for converters required by the context.
Represents a bean that has been created from a
BeanCreationContext.Represents a custom scope within the
BeanContext.An interface for a registry of
CustomScope instances.Default implementation of
AnnotationMetadata.Creates a default implementation of the
ApplicationContext interface.Implementation of
ApplicationContextBuilder.The default context implementations.
Default implementation of
BeanResolutionContext.Default implementation of the
CustomScopeRegistry interface.The default implementation of the
Environment interface.Implementation of
ExecutableBeanContextBinder.Default implementation of
ConfigurableExpressionEvaluationContext.An annotation to apply to an interface to indicate which implementation
is the default implementation.
The default
PropertyPlaceholderResolver.A segment of placeholder resolution.
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.
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.Represents a runtime failure to perform dependency injection.
Data about a disabled bean.
An exception that can be thrown to disable a bean programmatically from within a factory bean.
A bean definition that provides disposing hooks normally in the form of
PreDestroy
annotated methods.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 definitionAn
PropertySource that is empty when instantiated.The current application environment.
Interface for components configurable by the environment.
Loads properties from environment variables via
System.getenv().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.Annotation applied to the method or type indicating that a
ExecutableMethod should be
produced for this method.Sub-interface of
ExecutableBinder that binds arguments from a BeanContext.An 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.Represents a handle to an executable object.
Interface for components that are able to locate and return
ExecutionHandle instances
for beans.Exception thrown on expression evaluation failure.
A factory is a
Singleton that produces one or many other bean implementations.Represents a failure in a
Condition.Defines an injection point for a field.
A variation of
Qualifier that is a simple filter.Allows importing an already compiled set of beans, placing any generating beans relative to the class
where the import annotation is defined.
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.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.
An type of
BeanDefinition that can build a new instance.An internal interface implemented by generated proxy classes.
An internal
InterceptedBean that proxies another instance.Qualifier used to resolve the interceptor binding when injection method interceptors for AOP.
Implementation for Jakarta bean lookups.
Implementation for javax provider bean lookups.
Internal Utility methods for working with Kotlin
suspend functionsA property source specific for the Kubernetes environment.
A life cycle interface providing a start method and extending Closeable which provides a close() method for
termination.
Retrieve messages for the resolved locale.
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.
Abstract annotation metadata delegate for cases when annotation
values need to be mapped before being returned.
A
PropertySource that uses a map.Interface for resolving messages from some source.
The context to use.
Utility class used by
MessageSource to create variables maps.Represents an execution handle that invokes a method.
Defines an injection point for a method.
A reference to a method.
Default implementation of
Banner that prints the default Micronaut banner.A mutable various of
DefaultAnnotationMetadata that is used only at build time.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.
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.
Details of the current operating system.
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.
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.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.
Default load that handles Java properties files.
A property that can be contained within a
PropertySource or used generally throughout the system.The property expression resolver.
Interface for implementations that resolve placeholders in configuration and annotations.
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.
Makes
TypeInformation.isWrapperType() return true for Providers.Helper methods for dealing with
Provider.Marker interface for a
BeanDefinition that is an AOP proxy.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.
Factory for
Bean qualifiers.The property expression for random values.
Allows a bean to specify that it replaces another bean.
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.
Prints a banner from a resource.
A message source backed by a resource bundle.
Allow the construction for bean definitions programmatically that can be registered
via
BeanDefinitionRegistry at runtime.A builder for constructing
RuntimeBeanDefinition instances.Counter part to
Primary that allows reducing the priority of a given bean for the purposes of dependency
injection.An event fired prior to starting shutdown sequence.
An event fired once startup is complete.
A static mutable message source.
Loads properties from system properties.
A
Condition that simply returns true.Allows restricting injection by type.
Implementation of
Type qualifier.A
Qualifier that qualifies beans by generic type arguments.A variation of
ExecutionHandle that invokes without arguments validation.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.
Loads properties from a YML file.
Beanannotation instead