All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
Class |
Description |
AbstractAnnotationMetadataBuilder<T,A> |
An abstract implementation that builds AnnotationMetadata .
|
AbstractAnnotationMetadataWriter |
Base class for types that also write AnnotationMetadata .
|
AbstractBeanConfiguration |
|
AbstractBeanDefinition<T> |
|
AbstractBeanDefinitionBuilder |
Abstract implementation of the BeanElementBuilder interface that should be implemented by downstream language specific implementations.
|
AbstractBeanDefinitionReference |
An uninitialized and unloaded component definition with basic information available regarding its requirements.
|
AbstractBeanResolutionContext |
|
AbstractBeanResolutionContext.AnnotationSegment |
A segment that represents annotation.
|
AbstractBeanResolutionContext.ConstructorArgumentSegment |
A segment that represents a method argument.
|
AbstractBeanResolutionContext.ConstructorSegment |
A segment that represents a constructor.
|
AbstractBeanResolutionContext.FieldSegment |
A segment that represents a field.
|
AbstractBeanResolutionContext.MethodArgumentSegment |
A segment that represents a method argument.
|
AbstractBeanResolutionContext.MethodSegment |
A segment that represents a method.
|
AbstractClassFileWriter |
Abstract class that writes generated classes to disk and provides convenience methods for building classes.
|
AbstractClassWriterOutputVisitor |
Abstract implementation of the ClassWriterOutputVisitor interface that deals with service descriptors in a
common way across Java and Groovy.
|
AbstractConcurrentCustomScope<A extends java.lang.annotation.Annotation> |
Abstract implementation of the custom scope interface that simplifies defining new scopes using the Map interface.
|
AbstractConstructorInjectionPoint<T> |
Abstract constructor implementation for bean definitions to implement to create constructors at build time.
|
AbstractEnvironmentAnnotationMetadata |
Variation of AnnotationMetadata that is environment specific.
|
AbstractExecutableBeanMethod<B,T> |
|
AbstractExecutableMethod |
|
AbstractExecutableMethodsDefinition<T> |
|
AbstractExecutableMethodsDefinition.MethodReference |
Internal class representing method's metadata.
|
AbstractInitializableBeanDefinition<T> |
|
AbstractInitializableBeanDefinition.AnnotationReference |
The data class containing annotation injection information.
|
AbstractInitializableBeanDefinition.FieldReference |
The data class containing all filed reference information.
|
AbstractInitializableBeanDefinition.MethodOrFieldReference |
The shared data class between method and field reference.
|
AbstractInitializableBeanDefinition.MethodReference |
The data class containing all method reference information.
|
AbstractInitializableBeanDefinitionReference<T> |
An uninitialized and unloaded component definition with basic information available regarding its requirements.
|
AbstractInitializableBeanIntrospection<B> |
Abstract implementation of the BeanIntrospection interface.
|
AbstractInitializableBeanIntrospection.BeanMethodRef<P> |
Bean method compile-time data container.
|
AbstractInitializableBeanIntrospection.BeanPropertyRef<P> |
Bean property compile-time data container.
|
AbstractLocalizedMessageSource<T> |
|
AbstractMessageSource |
Abstract MessageSource implementation that provides basic message interpolation.
|
AbstractParametrizedBeanDefinition<T> |
|
AbstractPropertySourceLoader |
|
AbstractProviderDefinition<T> |
Abstract bean definition for other providers to extend from.
|
ActiveEnvironment |
An environment that is active for the current execution
of the application.
|
AdvisedBeanType<T> |
|
Aliases |
A repeatable annotation that allows defining multiple AliasFor definitions.
|
AliasFor |
Allows specifying an annotation member alias.
|
AnnotatedElementValidator |
Abstract validator for AnnotatedElement that may represent source code level validation routes
executed at compilation time.
|
AnnotationConvertersRegistrar |
Registers annotation converters.
|
AnnotationElement |
Represents an annotation in the AST.
|
AnnotationMapper<T extends java.lang.annotation.Annotation> |
An AnnotationMapper is a type that is capable of mapping a given annotation to one or many annotations at compile time.
|
AnnotationMetadataException |
An exception that occurs constructing AnnotationMetadata .
|
AnnotationMetadataHierarchy |
Used to represent an annotation metadata hierarchy.
|
AnnotationMetadataReference |
A reference to AnnotationMetadata .
|
AnnotationMetadataSupport |
Support method for AnnotationMetadata .
|
AnnotationMetadataWriter |
Responsible for writing class files that are instances of AnnotationMetadata .
|
AnnotationProcessor<A extends java.lang.annotation.Annotation,T> |
An annotation processor is an object that processes the presence if a given annotation.
|
AnnotationRemapper |
Allows remapping of annotations from one annotation set to another at compilation time.
|
AnnotationTransformer<T extends java.lang.annotation.Annotation> |
An AnnotationTransformer transforms an annotation definition into one or many other annotation
definitions discarding the original annotation.
|
Any |
Qualifier that can be used on a bean to indicate it should match any qualifier or on a
injection point to indicate it should match any bean.
|
AnyQualifier<T> |
A qualifier to lookup any type.
|
ApplicationContext |
An application context extends a BeanContext and adds the concepts of configuration, environments and
runtimes.
|
ApplicationContextBuilder |
An interface for building an application context.
|
ApplicationContextConfiguration |
An interface for configuring an application context.
|
ApplicationContextConfigurer |
An application context configurer is responsible
for configuring an application context before the
application/function is started.
|
ApplicationContextLifeCycle<T extends ApplicationContextLifeCycle> |
An interface for classes that manage the ApplicationContext life cycle and shut it down when the class is shutdown.
|
ApplicationContextProvider |
|
ApplicationEvent |
|
ApplicationEventListener<E> |
An interface for receivers of application events.
|
ApplicationEventPublisher<T> |
|
ApplicationEventPublisherFactory<T> |
|
ArgumentBeanType<T> |
|
ArgumentInjectionPoint<B,T> |
An injection point for a method or constructor argument.
|
ArrayableClassElement |
Interface for class elements that can be converted to/from an array type.
|
Banner |
Print a banner programmatically.
|
Bean |
Annotation used to configure a bean.
|
BeanClassWriter |
|
BeanConfiguration |
A BeanConfiguration is a grouping of several BeanDefinition instances.
|
BeanConfigurationWriter |
Writes configuration classes for configuration packages using ASM.
|
BeanConstructorElement |
|
BeanContext |
The core BeanContext abstraction which allows for dependency injection of classes annotated with
Inject .
|
BeanContextConditional |
Interface for other types that are conditional within a context.
|
BeanContextConfiguration |
|
BeanContextEvent |
A BeanContextEvent is an event fired from the BeanContext instance.
|
BeanContextException |
An exception that occurs loading the context.
|
BeanCreatedEvent<T> |
An event fired when a bean is created and fully initialized.
|
BeanCreatedEventListener<T> |
An event listener that is triggered each time a bean is created.
|
BeanCreationContext<T> |
Context object passed to CustomScope instances for creating new beans.
|
BeanCreationException |
A base class for exceptions that occurred during bean creation.
|
BeanDefinition<T> |
Defines a bean definition and its requirements.
|
BeanDefinitionMethodReference<T,R> |
|
BeanDefinitionProcessor<A extends java.lang.annotation.Annotation> |
A bean definition processor is a processor that is called once for each bean annotated with the given annotation type.
|
BeanDefinitionReference<T> |
A bean definition reference provides a reference to a BeanDefinition thus
allowing for soft loading of bean definitions without loading the actual types.
|
BeanDefinitionReferenceWriter |
Writes the bean definition class file to disk.
|
BeanDefinitionRegistry |
Core bean definition registry interface containing methods to find BeanDefinition instances.
|
BeanDefinitionValidator |
Interface to integrate bean validation into the construction of beans within the BeanContext .
|
BeanDefinitionVisitor |
|
BeanDefinitionWriter |
|
BeanDefinitionWriter.MethodVisitData |
Data used when visiting method.
|
BeanDestroyedEvent<T> |
An event fired when a bean has been destroyed and all PreDestroy methods have been invoked.
|
BeanDestroyedEventListener<T> |
An event listener that is triggered after a bean is destroyed.
|
BeanDestructionException |
Exception type for exceptions that happen during bean destruction.
|
BeanElement |
Models a bean that will be produced by Micronaut.
|
BeanElementBuilder |
Interface for defining beans at compilation time from an originating element.
|
BeanElementVisitor<A extends java.lang.annotation.Annotation> |
Allows visiting a bean to perform any validation prior to when bean definitions are written out.
|
BeanElementVisitorContext |
Internal interface for adding associated beans.
|
BeanEvent<T> |
An abstract bean event.
|
BeanFactory<T> |
An interface for classes that are capable of taking the BeanDefinition instance and building a concrete
instance.
|
BeanFieldElement |
Represents a configurable bean field.
|
BeanIdentifier |
An identifier for a Bean that can be used as a key to uniquely identify an
instance.
|
BeanImportHandler |
Interface that allows extension of Bean import handling in other to support
other injection systems beyond JSR-330 in downstream modules.
|
BeanImportVisitor |
|
BeanInitializedEventListener<T> |
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.
|
BeanInitializingEvent<T> |
An event fired when a bean's properties have been populated but initialization hooks (such as
PostConstruct methods) have not yet been triggered.
|
BeanInstantiationException |
Thrown when no such beans exists.
|
BeanLocator |
Core interface for locating and discovering Bean instances.
|
BeanMethodElement |
Represents a configurable bean method.
|
BeanParameterElement |
Represents a configurable bean parameter.
|
BeanPreDestroyEvent<T> |
An event fired when a bean is about to be destroyed but before any PreDestroy methods are invoked..
|
BeanPreDestroyEventListener<T> |
An event listener that is triggered before a bean is destroyed.
|
BeanProvider<T> |
A BeanProvider is a richer replacement for the Provider interface that
provides additional Micronaut specific methods to assist in programmatic bean creation and discovery.
|
BeanProviderDefinition |
|
BeanRegistration<T> |
A bean registration is an association between a BeanDefinition and a created bean, typically a
Singleton .
|
BeanResolutionContext |
Represents the resolution context for a current resolve of a given bean.
|
BeanResolutionContext.Path |
Represents a path taken to resolve a bean definitions dependencies.
|
BeanResolutionContext.Segment<T> |
A segment in a path.
|
BeanType<T> |
A reference to a bean.
|
BootstrapContextCompatible |
An annotation indicating that a bean can be loaded into the Bootstrap Context.
|
BootstrapPropertySourceLocator |
Allows blocking resolving of PropertySource from remote distributed configuration servers.
|
CachedEnvironment |
A "cached environment" is a performance optimization aimed at minimizing
the cost of calling System.getenv() or System.getProperties() .
|
CallableInjectionPoint<T> |
A callable injection point is an injection point that accepts Argument instances.
|
CircularDependencyException |
Represents a circular dependency failure.
|
ClassElement |
Stores data about an element that references a class.
|
ClassGenerationException |
Thrown when an exception occurs during compilation due to a class generation error.
|
ClassOutputWriter |
|
ClassWriterOutputVisitor |
Interface to be consumed by class writers allowing visiting file names and returning appropriate streams.
|
ClosestTypeArgumentQualifier<T> |
A Qualifier that qualifies beans by generic type arguments and only
returns the candidates that most closely match.
|
CommandLinePropertySource |
|
ComputePlatform |
|
Condition |
|
ConditionContext<T extends io.micronaut.core.annotation.AnnotationMetadataProvider> |
|
ConfigurableElement |
Element that supports adding qualifiers.
|
Configuration |
A configuration is a grouping of bean definitions under a package.
|
ConfigurationBuilder |
An annotation applicable to a field or method of a ConfigurationProperties instance that allows to
customize the behaviour of properties that are builders themselves.
|
ConfigurationException |
An exception that occurs during configuration setup.
|
ConfigurationInject |
Allows injecting configuration values into a constructor or method based
on the parameter names.
|
ConfigurationMetadata |
Metadata about a configuration group.
|
ConfigurationMetadataBuilder<T> |
|
ConfigurationMetadataWriter |
|
ConfigurationProperties |
Defines a singleton bean whose property values are resolved from a PropertyResolver .
|
ConfigurationReader |
A meta annotation for use with other annotations to indicate that the annotation reads configuration.
|
ConstantPropertySources |
An optimization class which is used to register property sources
statically.
|
ConstructorElement |
Element for constructors.
|
ConstructorInjectionPoint<T> |
A constructor injection point.
|
Context |
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 .
|
ContextConfigurer |
Annotation used to indicate the annotated class participates in
the application context building phase.
|
ContextConfigurerVisitor |
This visitor is responsible for generating service files for classes
annotated with ContextConfigurer .
|
ContextConverterRegistrar |
A converter registry for converters required by the context.
|
CoreNonNullTransformer |
A transformer that remaps NonNull to javax.annotation.Nonnull .
|
CoreNullableTransformer |
A transformer that remaps Nullable to javax.annotation.Nullable .
|
CreatedBean<T> |
|
CustomScope<A extends java.lang.annotation.Annotation> |
|
CustomScopeRegistry |
|
DefaultAnnotationMetadata |
Default implementation of AnnotationMetadata .
|
DefaultApplicationContext |
|
DefaultApplicationContextBuilder |
|
DefaultBeanContext |
The default context implementations.
|
DefaultBeanResolutionContext |
|
DefaultCustomScopeRegistry |
|
DefaultEnvironment |
The default implementation of the Environment interface.
|
DefaultImplementation |
An annotation to apply to an interface to indicate which implementation
is the default implementation.
|
DefaultPropertyPlaceholderResolver |
|
DefaultPropertyPlaceholderResolver.Segment |
A segment of placeholder resolution.
|
DefaultScope |
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.
|
DelegatingBeanDefinition<T> |
|
DelegatingExecutableMethod<T,R> |
|
DependencyInjectionException |
Represents a runtime failure to perform dependency injection.
|
DirectoryClassWriterOutputVisitor |
|
DisabledBeanException |
An exception that can be thrown to disable a bean programmatically from within a factory bean.
|
DispatchWriter |
Switch based dispatch writer.
|
DispatchWriter.DispatchTarget |
Dispatch target implementation writer.
|
DispatchWriter.FieldGetDispatchTarget |
Field get dispatch target.
|
DispatchWriter.FieldSetDispatchTarget |
Field set dispatch target.
|
DispatchWriter.InterceptableMethodDispatchTarget |
Interceptable method invocation dispatch target.
|
DispatchWriter.MethodDispatchTarget |
Method invocation dispatch target.
|
DisposableBeanDefinition<T> |
A bean definition that provides disposing hooks normally in the form of PreDestroy
annotated methods.
|
EachBean |
This annotation allows driving the production of Bean definitions from presence of other bean definitions.
|
EachProperty |
This annotation allows driving the production of Bean definitions from either configuration or the
presence of another bean definition
|
Element |
Stores data about a compile time element.
|
ElementFactory<E,C extends E,M extends E,F extends E> |
A factory for creating elements.
|
ElementModifier |
An enum of modifier names now tied to the reflection API.
|
ElementQuery<T extends Element> |
An interface for querying the AST for elements.
|
ElementQuery.Result<T extends Element> |
Result interface when building a query.
|
EmptyPropertySource |
|
EntityIntrospectedAnnotationMapper |
An annotation mapper that improves introspection for JPA entities.
|
EntityReflectiveAccessAnnotationMapper |
An annotation mapper that improves reflective access for JPA entities.
|
EnumConstantElement |
Stores data about an element that references a enum constant.
|
EnumElement |
Models an enum type.
|
Environment |
The current application environment.
|
EnvironmentConfigurable |
Interface for components configurable by the environment.
|
EnvironmentPropertySource |
Loads properties from environment variables via System.getenv() .
|
Executable |
Annotation applied to the method or type indicating that a ExecutableMethod should be
produced for this method.
|
ExecutableMethod<T,R> |
An executable method is a compile time produced invocation of a method call.
|
ExecutableMethodProcessor<A extends java.lang.annotation.Annotation> |
|
ExecutableMethodsDefinition<T> |
|
ExecutableMethodsDefinitionWriter |
|
ExecutableMethodWriter |
|
ExecutionHandle<T,R> |
Represents a handle to an executable object.
|
ExecutionHandleLocator |
Interface for components that are able to locate and return ExecutionHandle instances
for beans.
|
Factory |
A factory is a Singleton that produces one or many other bean implementations.
|
Failure |
|
FieldElement |
Stores data about an element that references a field.
|
FieldInjectionPoint<B,T> |
Defines an injection point for a field.
|
FindBugsRemapper |
A remapper that remaps findbugs annotations to javax.annotation which are represented internally.
|
GeneratedFile |
A common interface to allow referencing a generated file in either Groovy or Java.
|
GenericPlaceholderElement |
Represents a generic placeholder in source code.
|
Import |
Allows importing an already compiled set of beans, placing any generating beans relative to the class
where the import annotation is defined.
|
Infrastructure |
Infrastructure scope represents a bean that cannot be overridden or replaced
because it is critical to the functioning of the system.
|
InitializableBeanContext |
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.
|
InitializingBeanDefinition<T> |
A bean definition that is provides initialization hooks normally in the form of methods annotated with
PostConstruct .
|
InjectableElement |
Shared interface for injectable elements.
|
InjectionPoint<T> |
An injection point as a point in a class definition where dependency injection is required.
|
InjectScope |
An annotation that can be declared on a constructor or method parameter that indicates
that the injected bean should be destroyed after injection completes.
|
InterceptedBean |
An internal interface implemented by generated proxy classes.
|
InterceptedBeanProxy<T> |
|
InterceptorBindingQualifier<T> |
Qualifier used to resolve the interceptor binding when injection method interceptors for AOP.
|
IntrospectedTypeElementVisitor |
A TypeElementVisitor that visits classes annotated with Introspected and produces
BeanIntrospectionReference instances at compilation time.
|
JakartaEntityIntrospectedAnnotationMapper |
An annotation mapper that improves introspection for JPA entities.
|
JakartaMappedSuperClassIntrospectionMapper |
Handle mapped super class.
|
JakartaPostConstructTransformer |
Transforms PostConstruct into the javax meta-annotation AnnotationUtil.POST_CONSTRUCT .
|
JakartaPreDestroyTransformer |
Transforms PreDestroy into the javax meta-annotation AnnotationUtil.PRE_DESTROY .
|
JakartaProviderBeanDefinition |
Implementation for Jakarta bean lookups.
|
JakartaRemapper |
Remaps from jakarta.inject to javax.inject.
|
JavaModelUtils |
Utility methods for Java model handling.
|
JavaxProviderBeanDefinition |
Implementation for javax provider bean lookups.
|
JsonConfigurationMetadataWriter |
|
JsonCreatorAnnotationMapper |
Makes every use of Jackson's JsonCreator also represent a Creator .
|
KotlinExecutableMethodUtils |
Internal Utility methods for working with Kotlin suspend functions
|
KotlinNotNullMapper |
An annotation mapper that maps Kotlin's NotNull to a common annotation.
|
KotlinNullableMapper |
An annotation mapper that maps Kotlin's Nullable to a common annotation.
|
KubernetesEnvironmentPropertySource |
A property source specific for the Kubernetes environment.
|
LifeCycle<T extends LifeCycle> |
A life cycle interface providing a start method and extending Closeable which provides a close() method for
termination.
|
LocalizedMessageSource |
Retrieve messages for the resolved locale.
|
MappedSuperClassIntrospectionMapper |
Handle mapped super class.
|
MapPropertySource |
|
MemberElement |
A member element is an element that is contained within a ClassElement .
|
MessageSource |
Interface for resolving messages from some source.
|
MessageSource.MessageContext |
The context to use.
|
MessageSourceUtils |
|
MethodElement |
Stores data about an element that references a method.
|
MethodExecutionHandle<T,R> |
Represents an execution handle that invokes a method.
|
MethodInjectionPoint<B,T> |
Defines an injection point for a method.
|
MethodReference<T,R> |
A reference to a method.
|
MicronautBanner |
Default implementation of Banner that prints the default Micronaut banner.
|
MutableAnnotationMetadata |
|
NamedAnnotationMapper |
A named AnnotationMapper operates against any named annotation, and does not require the
annotation to be on the annotation processor classpath.
|
NamedAnnotationTransformer |
A named AnnotationTransformer operates against any named annotation, and does not require the
annotation to be on the annotation processor classpath.
|
NonBinding |
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.
|
NonUniqueBeanException |
Exception thrown when a bean is not unique and has multiple possible implementations for a given bean type.
|
NoSuchBeanException |
Thrown when no such beans exists.
|
NoSuchMessageException |
Thrown if an error occurs locating a message.
|
OperatingSystem |
Details of the current operating system.
|
OriginatingElements |
Interface for types that provide originating elements.
|
PackageElement |
Models a package in source code.
|
PackageRenameRemapper |
A AnnotationRemapper that simply renames packages retaining the original simple class
names as is.
|
Parallel |
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.
|
Parameter |
Specifies that an argument to a bean constructor is user provided and a
ParametrizedBeanFactory should be generated.
|
ParameterElement |
Represents a parameter to a method or constructor.
|
ParametrizedBeanFactory<T> |
A BeanFactory that requires additional (possibly user supplied) parameters in order construct a bean.
|
ParametrizedProvider<T> |
|
PersistenceContextAnnotationMapper |
Allows using the PersistenceContext annotation in Micronaut.
|
Primary |
A Qualifier that indicates that this bean is the primary bean that should be selected in the case of
multiple possible interface implementations.
|
PrimaryQualifier<T> |
A qualifier to lookup a primary bean.
|
PrimitiveElement |
|
ProcessedTypes |
Deprecated.
|
PropertiesPropertySourceLoader |
Default load that handles Java properties files.
|
Property |
A property that can be contained within a PropertySource or used generally throughout the system.
|
PropertyElement |
A property element represents a JavaBean property on a ClassElement .
|
PropertyExpressionResolver |
The property expression resolver.
|
PropertyMetadata |
Metadata about a property.
|
PropertyPlaceholderResolver |
Interface for implementations that resolve placeholders in configuration and annotations.
|
PropertySource |
An annotation that can be used on either the main class or a test to provide additional hard coded
property values to the Environment .
|
PropertySource |
A PropertySource is a location to resolve property values from.
|
PropertySource.PropertyConvention |
Property convention.
|
PropertySourceLoader |
Loads the given property source for the given environment.
|
PropertySourceLocator |
An interface for beans that are capable of locating a PropertySource instance.
|
PropertySourcePropertyResolver |
A PropertyResolver that resolves from one or many PropertySource instances.
|
PropertySourcePropertyResolver.PropertyCatalog |
The property catalog to use.
|
PropertySourceReader |
Interface for classes that read and process properties sources.
|
Prototype |
Prototype scope is a non-singleton scope that creates a new bean for every injection point.
|
Provided |
Deprecated.
|
ProviderTypeInformationProvider |
Makes TypeInformation.isWrapperType() return true for Providers.
|
ProviderUtils |
Helper methods for dealing with Provider .
|
ProxyBeanDefinition<T> |
|
ProxyingBeanDefinitionVisitor |
|
Qualified<T> |
Internal interface used by generated code to propagate qualifiers.
|
Qualifier<T> |
Used to qualify which bean to select in the case of multiple possible options.
|
Qualifiers |
Factory for Bean qualifiers.
|
Replaces |
Allows a bean to specify that it replaces another bean.
|
Requirements |
For specifying multiple requirements.
|
Requires |
|
Requires.Family |
Used to express an operation system family.
|
Requires.Sdk |
Used to express a required SDK version.
|
RequiresCondition |
An abstract Condition implementation that is based on the presence
of Requires annotation.
|
ResourceBanner |
Prints a banner from a resource.
|
ResourceBundleMessageSource |
A message source backed by a resource bundle.
|
RuntimeBeanDefinition<T> |
Allow the construction for bean definitions programmatically that can be registered
via BeanDefinitionRegistry at runtime.
|
RuntimeBeanDefinition.Builder<B> |
|
Secondary |
Counter part to Primary that allows reducing the priority of a given bean for the purposes of dependency
injection.
|
ShutdownEvent |
An event fired prior to starting shutdown sequence.
|
StartupEvent |
An event fired once startup is complete.
|
StaticMessageSource |
A static mutable message source.
|
StaticOriginatingElements |
Utility class for testing originating element generation.
|
StringSwitchWriter |
String switch writer.
|
SystemPropertiesPropertySource |
Loads properties from system properties.
|
TimedAnnotationMapper |
Maps Micrometer's Timed annotation in order to support AOP.
|
TrueCondition |
|
Type |
Allows restricting injection by type.
|
TypeAnnotationQualifier<T> |
Implementation of Type qualifier.
|
TypeArgumentQualifier<T> |
A Qualifier that qualifies beans by generic type arguments.
|
TypedAnnotationMapper<T extends java.lang.annotation.Annotation> |
|
TypedAnnotationTransformer<T extends java.lang.annotation.Annotation> |
|
TypedElement |
An element that has an underlying type.
|
TypeElementVisitor<C,E> |
Provides a hook into the compilation process to allow user defined functionality to be created at compile time.
|
TypeElementVisitor.VisitorKind |
Implementors of the TypeElementVisitor interface should specify what kind of visitor it is.
|
ValidatedBeanDefinition<T> |
A bean definition that is validated with javax.validation.
|
Value |
Allows configuration injection from the environment on a per property, field, method/constructor parameter
basis.
|
VisitorConfiguration |
|
VisitorContext |
Provides a way for TypeElementVisitor classes to log messages during compilation and fail compilation.
|
VisitorContextUtils |
Internal common helper functions to share among VisitorContext implementations.
|
WildcardElement |
Represents a wildcard, for example List<?> .
|
YamlPropertySourceLoader |
Loads properties from a YML file.
|