# All Classes and Interfaces

Class
Description
AbstractAotProcessor<T>
Abstract base class for filesystem-based ahead-of-time (AOT) processing.
AbstractAotProcessor.Settings
Common settings for AOT processors.
AbstractAotProcessor.Settings.Builder
Fluent builder API for `AbstractAotProcessor.Settings`.
AbstractApplicationContext
Abstract implementation of the `ApplicationContext` interface.
AbstractApplicationEventMulticaster
Abstract implementation of the `ApplicationEventMulticaster` interface, providing the basic listener registration facility.
AbstractAsyncConfiguration
Abstract base `Configuration` class providing common structure for enabling Spring's asynchronous method execution capability.
AbstractBindingResult
Abstract implementation of the `BindingResult` interface and its super-interface `Errors`.
AbstractCacheInvoker
A base component for invoking `Cache` operations and using a configurable `CacheErrorHandler` when an exception occurs.
AbstractCacheManager
Abstract base class implementing the common `CacheManager` methods.
AbstractCacheResolver
A base `CacheResolver` implementation that requires the concrete implementation to provide the collection of cache name(s) based on the invocation context.
AbstractCachingConfiguration
Abstract base `@Configuration` class providing common structure for enabling Spring's annotation-driven cache management capability.
AbstractCachingConfiguration.CachingConfigurerSupplier
AbstractConfigurableMBeanInfoAssembler
Base class for MBeanInfoAssemblers that support configurable JMX notification behavior.
AbstractErrors
Abstract implementation of the `Errors` interface.
AbstractFallbackCacheOperationSource
Abstract implementation of `CacheOperationSource` that caches operations for methods and implements a fallback policy: 1.
AbstractJmxAttribute
Base class for all JMX metadata classes.
AbstractMBeanInfoAssembler
Abstract implementation of the `MBeanInfoAssembler` interface that encapsulates the creation of a `ModelMBeanInfo` instance but delegates the creation of metadata to subclasses.
AbstractMessageSource
Abstract implementation of the `HierarchicalMessageSource` interface, implementing common handling of message variants, making it easy to implement a specific strategy for a concrete MessageSource.
AbstractNumberFormatter
Abstract formatter for Numbers, providing a `AbstractNumberFormatter.getNumberFormat(java.util.Locale)` template method.
AbstractPropertyBindingResult
Abstract base class for `BindingResult` implementations that work with Spring's `PropertyAccessor` mechanism.
AbstractReflectiveMBeanInfoAssembler
Builds on the `AbstractMBeanInfoAssembler` superclass to add a basic algorithm for building metadata based on the reflective metadata of the MBean class.
AbstractRefreshableApplicationContext
Base class for `ApplicationContext` implementations which are supposed to support multiple calls to `AbstractApplicationContext.refresh()`, creating a new internal bean factory instance every time.
AbstractRefreshableConfigApplicationContext
`AbstractRefreshableApplicationContext` subclass that adds common handling of specified config locations.
AbstractResourceBasedMessageSource
Abstract base class for `MessageSource` implementations based on resource bundle conventions, such as `ResourceBundleMessageSource` and `ReloadableResourceBundleMessageSource`.
AbstractValueAdaptingCache
Common base class for `Cache` implementations that need to adapt `null` values (and potentially other such special values) before passing them on to the underlying store.
AbstractXmlApplicationContext
Convenient base class for `ApplicationContext` implementations, drawing configuration from XML documents containing bean definitions understood by an `XmlBeanDefinitionReader`.
AdviceMode
Enumeration used to determine whether JDK proxy-based or AspectJ weaving-based advice should be applied.
AdviceModeImportSelector<A extends Annotation>
Convenient base class for `ImportSelector` implementations that select imports based on an `AdviceMode` value from an annotation (such as the `@Enable*` annotations).
AnnotatedBeanDefinitionReader
Convenient adapter for programmatic registration of bean classes.
AnnotatedElementKey
Represents an `AnnotatedElement` in a particular `Class` and is suitable for use as a cache key.
AnnotationAsyncExecutionInterceptor
Specialization of `AsyncExecutionInterceptor` that delegates method execution to an `Executor` based on the `Async` annotation.
AnnotationBeanNameGenerator
`BeanNameGenerator` implementation for bean classes annotated with the `@Component` annotation or with another annotation that is itself annotated with `@Component` as a meta-annotation.
AnnotationCacheOperationSource
Implementation of the `CacheOperationSource` interface for working with caching metadata in annotation format.
AnnotationCacheOperationSource.CacheOperationProvider
Callback interface providing `CacheOperation` instance(s) based on a given `CacheAnnotationParser`.
AnnotationConfigApplicationContext
Standalone application context, accepting component classes as input — in particular `@Configuration`-annotated classes, but also plain `@Component` types and JSR-330 compliant classes using `jakarta.inject` annotations.
AnnotationConfigBeanDefinitionParser
Parser for the <context:annotation-config/> element.
AnnotationConfigRegistry
Common interface for annotation config application contexts, defining `AnnotationConfigRegistry.register(java.lang.Class<?>...)` and `AnnotationConfigRegistry.scan(java.lang.String...)` methods.
AnnotationConfigUtils
Utility class that allows for convenient registration of common `BeanPostProcessor` and `BeanFactoryPostProcessor` definitions for annotation-based configuration.
AnnotationDrivenBeanDefinitionParser
Parser for the 'annotation-driven' element of the 'task' namespace.
AnnotationFormatterFactory<A extends Annotation>
A factory that creates formatters to format values of fields annotated with a particular `Annotation`.
AnnotationJmxAttributeSource
Implementation of the `JmxAttributeSource` interface that reads annotations and exposes the corresponding attributes.
AnnotationMBeanExporter
Convenient subclass of Spring's standard `MBeanExporter`, activating annotation usage for JMX exposure of Spring beans: `ManagedResource`, `ManagedAttribute`, `ManagedOperation`, etc.
AnnotationScopeMetadataResolver
A `ScopeMetadataResolver` implementation that by default checks for the presence of Spring's `@Scope` annotation on the bean class.
AotApplicationContextInitializer<C extends ConfigurableApplicationContext>
Specialized `ApplicationContextInitializer` used to initialize a `ConfigurableApplicationContext` using artifacts that were generated ahead-of-time.
ApplicationContext
Central interface to provide configuration for an application.
ApplicationContextAotGenerator
Process an `ApplicationContext` and its `BeanFactory` to generate code that represents the state of the bean factory, as well as the necessary hints that can be used at runtime in a constrained environment.
ApplicationContextAware
Interface to be implemented by any object that wishes to be notified of the `ApplicationContext` that it runs in.
ApplicationContextEvent
Base class for events raised for an `ApplicationContext`.
ApplicationContextException
Exception thrown during application context initialization.
ApplicationContextInitializer<C extends ConfigurableApplicationContext>
Callback interface for initializing a Spring `ConfigurableApplicationContext` prior to being refreshed.
ApplicationEvent
Class to be extended by all application events.
ApplicationEventMulticaster
Interface to be implemented by objects that can manage a number of `ApplicationListener` objects and publish events to them.
ApplicationEventPublisher
Interface that encapsulates event publication functionality.
ApplicationEventPublisherAware
Interface to be implemented by any object that wishes to be notified of the ApplicationEventPublisher (typically the ApplicationContext) that it runs in.
ApplicationListener<E extends ApplicationEvent>
Interface to be implemented by application event listeners.
ApplicationListenerMethodAdapter
`GenericApplicationListener` adapter that delegates the processing of an event to an `EventListener` annotated method.
ApplicationObjectSupport
Convenient superclass for application objects that want to be aware of the application context, for example, for custom lookup of collaborating beans or for context-specific resource access.
ApplicationStartupAware
Interface to be implemented by any object that wishes to be notified of the `ApplicationStartup` that it runs with.
AspectJWeavingEnabler
Post-processor that registers AspectJ's `ClassPreProcessorAgentAdapter` with the Spring application context's default `LoadTimeWeaver`.
Async
Annotation that marks a method as a candidate for asynchronous execution.
AsyncAnnotationAdvisor
Advisor that activates asynchronous method execution through the `Async` annotation.
AsyncAnnotationBeanPostProcessor
Bean post-processor that automatically applies asynchronous invocation behavior to any bean that carries the `Async` annotation at class or method-level by adding a corresponding `AsyncAnnotationAdvisor` to the exposed proxy (either an existing AOP proxy or a newly generated proxy that implements all the target's interfaces).
AsyncConfigurationSelector
Selects which implementation of `AbstractAsyncConfiguration` should be used based on the value of `EnableAsync.mode()` on the importing `@Configuration` class.
AsyncConfigurer
Interface to be implemented by @`Configuration` classes annotated with @`EnableAsync` that wish to customize the `Executor` instance used when processing async method invocations or the `AsyncUncaughtExceptionHandler` instance used to process exception thrown from async method with `void` return type.
AsyncConfigurerSupport
Deprecated.
as of 6.0 in favor of implementing `AsyncConfigurer` directly
AsyncResult<V>
Deprecated.
as of 6.0, in favor of `CompletableFuture`
AutodetectCapableMBeanInfoAssembler
Extends the `MBeanInfoAssembler` to add auto-detection logic.
AutoProxyRegistrar
Registers an auto proxy creator against the current `BeanDefinitionRegistry` as appropriate based on an `@Enable*` annotation having `mode` and `proxyTargetClass` attributes set to the correct values.
BasicOperation
The base interface that all cache operations must implement.
Bean
Indicates that a method produces a bean to be managed by the Spring container.
Bean.Bootstrap
Local enumeration for the bootstrap mode.
BeanExpressionContextAccessor
SpEL `PropertyAccessor` that knows how to access the beans and contextual objects of a Spring `BeanExpressionContext`.
BeanFactoryAccessor
SpEL `PropertyAccessor` that knows how to access the beans of a Spring `BeanFactory`.
BeanFactoryCacheOperationSourceAdvisor
Advisor driven by a `CacheOperationSource`, used to include a cache advice bean for methods that are cacheable.
BeanFactoryResolver
SpEL `BeanResolver` that operates against a Spring `BeanFactory`.
BeanPropertyBindingResult
Default implementation of the `Errors` and `BindingResult` interfaces, for the registration and evaluation of binding errors on JavaBean objects.
BeanValidationPostProcessor
Simple `BeanPostProcessor` that checks JSR-303 constraint annotations in Spring-managed beans, throwing an initialization exception in case of constraint violations right before calling the bean's init method (if any).
BindException
Thrown when binding errors are considered fatal.
BindingAwareConcurrentModel
Subclass of `ConcurrentModel` that automatically removes the `BindingResult` object when its corresponding target attribute is replaced through regular `Map` operations.
BindingAwareModelMap
Subclass of `ExtendedModelMap` that automatically removes a `BindingResult` object if the corresponding target attribute gets replaced through regular `Map` operations.
BindingErrorProcessor
Strategy for processing `DataBinder`'s missing field errors, and for translating a `PropertyAccessException` to a `FieldError`.
BindingResult
General interface that represents binding results.
BindingResultUtils
Convenience methods for looking up BindingResults in a model Map.
BshScriptEvaluator
BeanShell-based implementation of Spring's `ScriptEvaluator` strategy interface.
BshScriptFactory
`ScriptFactory` implementation for a BeanShell script.
BshScriptUtils
Utility methods for handling BeanShell-scripted objects.
BshScriptUtils.BshExecutionException
Exception to be thrown on script execution failure.
Cache
Interface that defines common cache operations.
Cache.ValueRetrievalException
Wrapper exception to be thrown from `Cache.get(Object, Callable)` in case of the value loader callback failing with an exception.
Cache.ValueWrapper
A (wrapper) object representing a cache value.
Cacheable
Annotation indicating that the result of invoking a method (or all methods in a class) can be cached.
CacheableOperation
Class describing a cache 'cacheable' operation.
CacheableOperation.Builder
A builder that can be used to create a `CacheableOperation`.
CacheAnnotationParser
Strategy interface for parsing known caching annotation types.
CacheAspectSupport
Base class for caching aspects, such as the `CacheInterceptor` or an AspectJ aspect.
CacheAspectSupport.CacheOperationMetadata
Metadata of a cache operation that does not depend on a particular invocation which makes it a good candidate for caching.
CacheConfig
`@CacheConfig` provides a mechanism for sharing common cache-related settings at the class level.
CachedExpressionEvaluator
Shared utility class used to evaluate and cache SpEL expressions that are defined on an `AnnotatedElement`.
CachedExpressionEvaluator.ExpressionKey
An expression key.
CacheErrorHandler
A strategy for handling cache-related errors.
CacheEvict
Annotation indicating that a method (or all methods on a class) triggers a `cache evict` operation.
CacheEvictOperation
Class describing a cache 'evict' operation.
CacheEvictOperation.Builder
A builder that can be used to create a `CacheEvictOperation`.
CacheInterceptor
AOP Alliance MethodInterceptor for declarative cache management using the common Spring caching infrastructure (`Cache`).
CacheManagementConfigUtils
Configuration constants for internal sharing across subpackages.
CacheManager
Spring's central cache manager SPI.
CacheNamespaceHandler
`NamespaceHandler` allowing for the configuration of declarative cache management using either XML or using annotations.
CacheOperation
Base class for cache operations.
CacheOperation.Builder
Base class for builders that can be used to create a `CacheOperation`.
CacheOperationInvocationContext<O extends BasicOperation>
Representation of the context of the invocation of a cache operation.
CacheOperationInvoker
Abstract the invocation of a cache operation.
CacheOperationInvoker.ThrowableWrapper
Wrap any exception thrown while invoking `CacheOperationInvoker.invoke()`.
CacheOperationSource
Interface used by `CacheInterceptor`.
CacheProxyFactoryBean
Proxy factory bean for simplified declarative caching handling.
CachePut
Annotation indicating that a method (or all methods on a class) triggers a `cache put` operation.
CachePutOperation
Class describing a cache 'put' operation.
CachePutOperation.Builder
A builder that can be used to create a `CachePutOperation`.
CacheResolver
Determine the `Cache` instance(s) to use for an intercepted method invocation.
Caching
Group annotation for multiple cache annotations (of different or the same type).
CachingConfigurationSelector
Selects which implementation of `AbstractCachingConfiguration` should be used based on the value of `EnableCaching.mode()` on the importing `@Configuration` class.
CachingConfigurer
Interface to be implemented by @`Configuration` classes annotated with @`EnableCaching` that wish or need to specify explicitly how caches are resolved and how keys are generated for annotation-driven cache management.
CachingConfigurerSupport
Deprecated.
as of 6.0 in favor of implementing `CachingConfigurer` directly
CandidateComponentsIndex
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.1, in favor of the AOT engine.
CandidateComponentsIndexLoader
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.1, in favor of the AOT engine.
ClassPathBeanDefinitionScanner
A bean definition scanner that detects bean candidates on the classpath, registering corresponding bean definitions with a given registry (`BeanFactory` or `ApplicationContext`).
ClassPathScanningCandidateComponentProvider
A component provider that scans for candidate components starting from a specified base package.
ClassPathXmlApplicationContext
Standalone XML application context, taking the context definition files from the class path, interpreting plain paths as class path resource names that include the package path (for example, "mypackage/myresource.txt").
CommonAnnotationBeanPostProcessor
`BeanPostProcessor` implementation that supports common Java annotations out of the box, in particular the common annotations in the `jakarta.annotation` package.
CommonAnnotationBeanPostProcessor.LookupElement
Class representing generic injection information about an annotated field or setter method, supporting @Resource and related annotations.
Component
Indicates that the annotated class is a component.
ComponentScan
Configures component scanning directives for use with `@Configuration` classes.
ComponentScan.Filter
Declares the type filter to be used as an include filter or exclude filter.
ComponentScanBeanDefinitionParser
Parser for the `<context:component-scan/>` element.
ComponentScans
Container annotation that aggregates several `ComponentScan` annotations.
CompositeCacheManager
Composite `CacheManager` implementation that iterates over a given collection of delegate `CacheManager` instances.
CompositeCacheOperationSource
Composite `CacheOperationSource` implementation that iterates over a given array of `CacheOperationSource` instances.
ConcurrentMapCache
Simple `Cache` implementation based on the core JDK `java.util.concurrent` package.
ConcurrentMapCacheFactoryBean
`FactoryBean` for easy configuration of a `ConcurrentMapCache` when used within a Spring container.
ConcurrentMapCacheManager
`CacheManager` implementation that lazily builds `ConcurrentMapCache` instances for each `ConcurrentMapCacheManager.getCache(java.lang.String)` request.
ConcurrentModel
Implementation of the `Model` interface based on a `ConcurrentHashMap` for use in concurrent scenarios.
ConcurrentTaskExecutor
Adapter that takes a `java.util.concurrent.Executor` and exposes a Spring `TaskExecutor` for it.
ConcurrentTaskExecutor.ManagedTaskBuilder
Delegate that wraps a given Runnable/Callable with a JSR-236 ManagedTask, exposing a long-running hint based on `SchedulingAwareRunnable` and a given identity name.
ConcurrentTaskScheduler
Adapter that takes a `java.util.concurrent.ScheduledExecutorService` and exposes a Spring `TaskScheduler` for it.
Condition
A single condition that must be matched in order for a component to be registered.
Conditional
Indicates that a component is only eligible for registration when all specified conditions match.
ConditionContext
Context information for use by `Condition` implementations.
ConfigurableApplicationContext
SPI interface to be implemented by most if not all application contexts.
Configuration
Indicates that a class declares one or more `@Bean` methods and may be processed by the Spring container to generate bean definitions and service requests for those beans at runtime, for example:
ConfigurationClassPostProcessor
`BeanFactoryPostProcessor` used for bootstrapping processing of `@Configuration` classes.
ConfigurationClassUtils
Utilities for identifying and configuring `Configuration` classes.
ConfigurationCondition
A `Condition` that offers more fine-grained control when used with `@Configuration`.
ConfigurationCondition.ConfigurationPhase
The various configuration phases where the condition could be evaluated.
ConnectorServerFactoryBean
`FactoryBean` that creates a JSR-160 `JMXConnectorServer`, optionally registers it with the `MBeanServer`, and then starts it.
ContextAnnotationAutowireCandidateResolver
Complete implementation of the `AutowireCandidateResolver` strategy interface, providing support for qualifier annotations as well as for lazy resolution driven by the `Lazy` annotation in the `context.annotation` package.
ContextAotProcessor
Filesystem-based ahead-of-time (AOT) processing base implementation.
ContextClosedEvent
Event raised when an `ApplicationContext` gets closed.
ContextLifecycleScheduledTaskRegistrar
`ScheduledTaskRegistrar` subclass which redirects the actual scheduling of tasks to the `ContextLifecycleScheduledTaskRegistrar.afterSingletonsInstantiated()` callback (as of 4.1.2).
ContextNamespaceHandler
`NamespaceHandler` for the '`context`' namespace.
ContextRefreshedEvent
Event raised when an `ApplicationContext` gets initialized or refreshed.
ContextStartedEvent
Event raised when an `ApplicationContext` gets started.
ContextStoppedEvent
Event raised when an `ApplicationContext` gets stopped.
Controller
Indicates that an annotated class is a "Controller" (for example, a web controller).
ConversionServiceFactoryBean
A factory providing convenient access to a ConversionService configured with converters appropriate for most environments.
CronExpression
Representation of a crontab expression that can calculate the next time it matches.
CronTask
`TriggerTask` implementation defining a `Runnable` to be executed according to a standard cron expression.
CronTrigger
`Trigger` implementation for cron expressions.
CurrencyStyleFormatter
A BigDecimal formatter for number values in currency style.
CurrencyUnitFormatter
Formatter for JSR-354 `CurrencyUnit` values, from and to currency code Strings.
CustomizableThreadFactory
Implementation of the `ThreadFactory` interface, allowing for customizing the created threads (name, priority, etc).
CustomValidatorBean
Configurable bean class that exposes a specific JSR-303 Validator through its original interface as well as through the Spring `Validator` interface.
DataBinder
Binder that allows applying property values to a target object via constructor and setter injection, and also supports validation and binding result analysis.
DataBinder.NameResolver
Strategy to determine the name of the value to bind to a method parameter.
DataBinder.ValueResolver
Strategy for `constructor binding` to look up the values to bind to a given constructor parameter.
DateFormatter
A formatter for `Date` types.
DateFormatterRegistrar
Configures basic date formatting for use with Spring, primarily for `DateTimeFormat` declarations.
DateTimeContext
A context that holds user-specific `java.time` (JSR-310) settings such as the user's Chronology (calendar system) and time zone.
DateTimeContextHolder
A holder for a thread-local user `DateTimeContext`.
DateTimeFormat
Declares that a field or method parameter should be formatted as a date or time.
DateTimeFormat.ISO
Common ISO date time format patterns.
DateTimeFormatAnnotationFormatterFactory
Formats fields annotated with the `DateTimeFormat` annotation using a `DateFormatter`.
DateTimeFormatterFactory
Factory that creates a JSR-310 `DateTimeFormatter`.
DateTimeFormatterFactoryBean
`FactoryBean` that creates a JSR-310 `DateTimeFormatter`.
DateTimeFormatterRegistrar
Configures the JSR-310 `java.time` formatting system for use with Spring.
DefaultBindingErrorProcessor
Default `BindingErrorProcessor` implementation.
DefaultContextLoadTimeWeaver
Default `LoadTimeWeaver` bean for use in an application context, decorating an automatically detected internal `LoadTimeWeaver`.
DefaultEventListenerFactory
Default `EventListenerFactory` implementation that supports the regular `EventListener` annotation.
DefaultFormattingConversionService
A specialization of `FormattingConversionService` configured by default with converters and formatters appropriate for most applications.
DefaultLifecycleProcessor
Spring's default implementation of the `LifecycleProcessor` strategy.
DefaultManagedAwareThreadFactory
JNDI-based variant of `CustomizableThreadFactory`, performing a default lookup for JSR-236's "java:comp/DefaultManagedThreadFactory" in a Jakarta EE environment, falling back to the local `CustomizableThreadFactory` setup if not found.
DefaultManagedTaskExecutor
JNDI-based variant of `ConcurrentTaskExecutor`, performing a default lookup for JSR-236's "java:comp/DefaultManagedExecutorService" in a Jakarta EE/8 environment.
DefaultManagedTaskScheduler
JNDI-based variant of `ConcurrentTaskScheduler`, performing a default lookup for JSR-236's "java:comp/DefaultManagedScheduledExecutorService" in a Jakarta EE environment.
DefaultMessageCodesResolver
Default implementation of the `MessageCodesResolver` interface.
DefaultMessageCodesResolver.Format
Common message code formats.
DefaultMessageSourceResolvable
Spring's default implementation of the `MessageSourceResolvable` interface.
DefaultScheduledTaskObservationConvention
Default implementation for `ScheduledTaskObservationConvention`.
DeferredImportSelector
A variation of `ImportSelector` that runs after all `@Configuration` beans have been processed.
DeferredImportSelector.Group
Interface used to group results from different import selectors.
DeferredImportSelector.Group.Entry
An entry that holds the `AnnotationMetadata` of the importing `Configuration` class and the class name to import.
DelayedTask
`Task` implementation defining a `Runnable` with an initial delay.
DelegatingErrorHandlingRunnable
Runnable wrapper that catches any exception or error thrown from its delegate Runnable and allows an `ErrorHandler` to handle it.
DelegatingMessageSource
Empty `MessageSource` that delegates all calls to the parent MessageSource.
DelegatingThemeSource
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
DependsOn
Beans on which the current bean depends.
Description
Adds a textual description to bean definitions derived from `Component` or `Bean`.
DirectFieldBindingResult
Special implementation of the Errors and BindingResult interfaces, supporting registration and evaluation of binding errors on value objects.
DurationFormat
Declares that a field or method parameter should be formatted as a `Duration`, according to the specified `Style` and `Unit`.
DurationFormat.Style
`Duration` format styles.
DurationFormat.Unit
`Duration` format unit, which mirrors a subset of `ChronoUnit` and allows conversion to and from a supported `ChronoUnit` as well as conversion from durations to longs.
DurationFormatAnnotationFormatterFactory
Formats fields annotated with the `DurationFormat` annotation using the selected style for parsing and printing JSR-310 `Duration`.
DurationFormatter
`Formatter` implementation for a JSR-310 `Duration`, following JSR-310's parsing rules for a Duration by default and supporting additional `DurationFormat.Style` styles.
DurationFormatterUtils
Support `Duration` parsing and printing in several styles, as listed in `DurationFormat.Style`.
EmbeddedValueResolutionSupport
Convenient base class for components with a need for embedded value resolution (i.e.
EmbeddedValueResolverAware
Interface to be implemented by any object that wishes to be notified of a `StringValueResolver` for the resolution of embedded definition values.
EnableAspectJAutoProxy
Enables support for handling components marked with AspectJ's `@Aspect` annotation, similar to functionality found in Spring's `<aop:aspectj-autoproxy>` XML element.
EnableAsync
Enables Spring's asynchronous method execution capability, similar to functionality found in Spring's `<task:*>` XML namespace.
EnableCaching
Enables Spring's annotation-driven cache management capability, similar to the support found in Spring's `<cache:*>` XML namespace.
EnableLoadTimeWeaving
Activates a Spring `LoadTimeWeaver` for this application context, available as a bean with the name "loadTimeWeaver", similar to the `<context:load-time-weaver>` element in Spring XML.
EnableLoadTimeWeaving.AspectJWeaving
AspectJ weaving enablement options.
EnableMBeanExport
Enables default exporting of all standard `MBean`s from the Spring context, as well as all `@ManagedResource` annotated beans.
EnableScheduling
Enables Spring's scheduled task execution capability, similar to functionality found in Spring's `<task:*>` XML namespace.
EnvironmentAccessor
Read-only SpEL `PropertyAccessor` that knows how to retrieve properties of a Spring `Environment` instance.
EnvironmentAware
Interface to be implemented by any bean that wishes to be notified of the `Environment` that it runs in.
Errors
Stores and exposes information about data-binding and validation errors for a specific object.
EventListener
Annotation that marks a method as a listener for application events.
EventListenerFactory
Strategy interface for creating `ApplicationListener` for methods annotated with `EventListener`.
EventListenerMethodProcessor
Registers `EventListener` methods as individual `ApplicationListener` instances.
EventPublicationInterceptor
`Interceptor` that publishes an `ApplicationEvent` to all `ApplicationListeners` registered with an `ApplicationEventPublisher` after each successful method invocation.
ExecutorBeanDefinitionParser
Parser for the 'executor' element of the 'task' namespace.
ExecutorConfigurationSupport
Base class for setting up a `ExecutorService` (typically a `ThreadPoolExecutor` or `ScheduledThreadPoolExecutor`).
ExtendedModelMap
Subclass of `ModelMap` that implements the `Model` interface.
Fallback
Indicates that a bean qualifies as a fallback autowire candidate.
FieldError
Encapsulates a field error, that is, a reason for rejecting a specific field value.
FileSystemXmlApplicationContext
Standalone XML application context, taking the context definition files from the file system or from URLs, interpreting plain paths as relative file system locations (for example, "mydir/myfile.txt").
FilterType
Enumeration of the type filters that may be used in conjunction with `@ComponentScan`.
FixedDelayTask
Specialization of `IntervalTask` for fixed-delay semantics.
FixedRateTask
Specialization of `IntervalTask` for fixed-rate semantics.
ForkJoinPoolFactoryBean
A Spring `FactoryBean` that builds and exposes a preconfigured `ForkJoinPool`.
Formatter<T>
Formats objects of type T.
FormatterPropertyEditorAdapter
Adapter that bridges between `Formatter` and `PropertyEditor`.
FormatterRegistrar
Registers `Converters` and `Formatters` with a FormattingConversionService through the `FormatterRegistry` SPI.
FormatterRegistry
A registry of field formatting logic.
FormattingConversionService
A `ConversionService` implementation designed to be configured as a `FormatterRegistry`.
FormattingConversionServiceFactoryBean
A factory providing convenient access to a `FormattingConversionService` configured with converters and formatters for common types such as numbers, dates, and times.
FullyQualifiedAnnotationBeanNameGenerator
An extension of `AnnotationBeanNameGenerator` that uses the fully qualified class name as the default bean name if an explicit bean name is not supplied via a supported type-level annotation such as `@Component` (see `AnnotationBeanNameGenerator` for details on supported annotations).
GenericApplicationContext
Generic ApplicationContext implementation that holds a single internal `DefaultListableBeanFactory` instance and does not assume a specific bean definition format.
GenericApplicationListener
Extended variant of the standard `ApplicationListener` interface, exposing further metadata such as the supported event and source type.
GenericApplicationListenerAdapter
`GenericApplicationListener` adapter that determines supported event types through introspecting the generically declared type of the target listener.
GenericGroovyApplicationContext
An `ApplicationContext` implementation that extends `GenericApplicationContext` and implements `GroovyObject` such that beans can be retrieved with the dot de-reference syntax instead of using `AbstractApplicationContext.getBean(java.lang.String)`.
GenericXmlApplicationContext
Convenient application context with built-in XML support.
GlassFishLoadTimeWeaver
`LoadTimeWeaver` implementation for GlassFish's `org.glassfish.api.deployment.InstrumentableClassLoader InstrumentableClassLoader`.
GroovyObjectCustomizer
Strategy used by `GroovyScriptFactory` to allow the customization of a created `GroovyObject`.
GroovyScriptEvaluator
Groovy-based implementation of Spring's `ScriptEvaluator` strategy interface.
GroovyScriptFactory
`ScriptFactory` implementation for a Groovy script.
HierarchicalMessageSource
Sub-interface of MessageSource to be implemented by objects that can resolve messages hierarchically.
HierarchicalThemeSource
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
IdentityNamingStrategy
An implementation of the `ObjectNamingStrategy` interface that creates a name based on the identity of a given instance.
Import
Indicates one or more component classes to import — typically `@Configuration` classes.
ImportAware
Interface to be implemented by any @`Configuration` class that wishes to be injected with the `AnnotationMetadata` of the @`Configuration` class that imported it.
ImportAwareAotBeanPostProcessor
A `BeanPostProcessor` that honours `ImportAware` callback using a mapping computed at build time.
ImportBeanDefinitionRegistrar
Interface to be implemented by types that register additional bean definitions when processing @`Configuration` classes.
ImportResource
Indicates one or more resources containing bean definitions to import.
ImportRuntimeHints
Indicates that one or more `RuntimeHintsRegistrar` implementations should be processed.
ImportSelector
Interface to be implemented by types that determine which @`Configuration` class(es) should be imported based on a given selection criteria, usually one or more annotation attributes.
Indexed
Indicate that the annotated element represents a stereotype for the index.
InstantFormatter
`Formatter` implementation for a JSR-310 `Instant`, following JSR-310's parsing rules for an Instant (that is, not using a configurable `DateTimeFormatter`): accepting the default `ISO_INSTANT` format as well as `RFC_1123_DATE_TIME` (which is commonly used for HTTP date header values), as of Spring 4.3.
InstrumentationLoadTimeWeaver
`LoadTimeWeaver` relying on VM `Instrumentation`.
InterfaceBasedMBeanInfoAssembler
Subclass of `AbstractReflectiveMBeanInfoAssembler` that allows for the management interface of a bean to be defined using arbitrary interfaces.
IntervalTask
`Task` implementation defining a `Runnable` to be executed at a given millisecond interval which may be treated as fixed-rate or fixed-delay depending on context.
InvalidInvocationException
Thrown when trying to invoke an operation on a proxy that is not exposed by the proxied MBean resource's management interface.
InvalidMetadataException
Thrown by the `JmxAttributeSource` when it encounters incorrect metadata on a managed resource or one of its methods.
InvocationFailureException
Thrown when an invocation on an MBean resource failed with an exception (either a reflection exception or an exception thrown by the target method itself).
JBossLoadTimeWeaver
`LoadTimeWeaver` implementation for JBoss's instrumentable ClassLoader.
JeeNamespaceHandler
`NamespaceHandler` for the '`jee`' namespace.
JmxAttributeSource
Interface used by the `MetadataMBeanInfoAssembler` to read source-level metadata from a managed resource's class.
JmxException
General base exception to be thrown on JMX errors.
JmxMetadataUtils
Utility methods for converting Spring JMX metadata into their plain JMX equivalents.
JmxUtils
Collection of generic utility methods to support Spring JMX.
JndiAccessor
Convenient superclass for JNDI accessors, providing "jndiTemplate" and "jndiEnvironment" bean properties.
JndiCallback<T>
Callback interface to be implemented by classes that need to perform an operation (such as a lookup) in a JNDI context.
JndiLocatorDelegate
`JndiLocatorSupport` subclass with public lookup methods, for convenient use as a delegate.
JndiLocatorSupport
Convenient superclass for classes that can locate any number of JNDI objects.
JndiLookupFailureException
RuntimeException to be thrown in case of JNDI lookup failures, in particular from code that does not declare JNDI's checked `NamingException`: for example, from Spring's `JndiObjectTargetSource`.
JndiObjectFactoryBean
`FactoryBean` that looks up a JNDI object.
JndiObjectLocator
Convenient superclass for JNDI-based service locators, providing configurable lookup of a specific JNDI resource.
JndiObjectTargetSource
AOP `TargetSource` that provides configurable JNDI lookups for `getTarget()` calls.
JndiPropertySource
`PropertySource` implementation that reads properties from an underlying Spring `JndiLocatorDelegate`.
JndiTemplate
Helper class that simplifies JNDI operations.
JndiTemplateEditor
Properties editor for JndiTemplate objects.
Jsr310DateTimeFormatAnnotationFormatterFactory
Formats fields annotated with the `DateTimeFormat` annotation using the JSR-310 `java.time` package in JDK 8.
Jsr330ScopeMetadataResolver
Simple `ScopeMetadataResolver` implementation that follows JSR-330 scoping rules: defaulting to prototype scope unless `Singleton` is present.
Jsr354NumberFormatAnnotationFormatterFactory
Formats `MonetaryAmount` fields annotated with Spring's common `NumberFormat` annotation.
KeyGenerator
Cache key generator.
KeyNamingStrategy
`ObjectNamingStrategy` implementation that builds `ObjectName` instances from the key used in the "beans" map passed to `MBeanExporter`.
LangNamespaceHandler
`NamespaceHandler` that supports the wiring of objects backed by dynamic languages such as Groovy, JRuby and BeanShell.
LangNamespaceUtils
Utilities for use with `LangNamespaceHandler`.
Lazy
Indicates whether a bean is to be lazily initialized.
Lifecycle
A common interface defining methods for start/stop lifecycle control.
LifecycleProcessor
Strategy interface for processing Lifecycle beans within the ApplicationContext.
LoadTimeWeaver
Defines the contract for adding one or more `ClassFileTransformers` to a `ClassLoader`.
LoadTimeWeaverAware
Interface to be implemented by any object that wishes to be notified of the application context's default `LoadTimeWeaver`.
LoadTimeWeaverAwareProcessor
`BeanPostProcessor` implementation that passes the context's default `LoadTimeWeaver` to beans that implement the `LoadTimeWeaverAware` interface.
LoadTimeWeavingConfiguration
`@Configuration` class that registers a `LoadTimeWeaver` bean.
LoadTimeWeavingConfigurer
Interface to be implemented by `@Configuration` classes annotated with `@EnableLoadTimeWeaving` that wish to customize the `LoadTimeWeaver` instance to be used.
LocaleContext
Strategy interface for determining the current Locale.
LocaleContextHolder
Simple holder class that associates a LocaleContext instance with the current thread.
LocaleContextMessageInterpolator
Delegates to a target `MessageInterpolator` implementation but enforces Spring's managed Locale.
LocaleContextThreadLocalAccessor
Adapt `LocaleContextHolder` to the `ThreadLocalAccessor` contract to assist the Micrometer Context Propagation library with `LocaleContext` propagation.
LocalValidatorFactoryBean
This is the central class for `jakarta.validation` (JSR-303) setup in a Spring application context: It bootstraps a `jakarta.validation.ValidationFactory` and exposes it through the Spring `Validator` interface as well as through the JSR-303 `Validator` interface and the `ValidatorFactory` interface itself.
LoggingCacheErrorHandler
A `CacheErrorHandler` implementation that logs error messages.
ManagedAttribute
Method-level annotation that indicates to expose a given bean property as a JMX attribute, corresponding to the `ManagedAttribute`.
ManagedAttribute
Metadata that indicates to expose a given bean property as JMX attribute.
ManagedMetric
Method-level annotation that indicates to expose a given bean property as a JMX attribute, with added descriptor properties to indicate that it is a metric.
ManagedMetric
Metadata that indicates to expose a given bean property as a JMX attribute, with additional descriptor properties that indicate that the attribute is a metric.
ManagedNotification
Type-level annotation that indicates a JMX notification emitted by a bean.
ManagedNotification
Metadata that indicates a JMX notification emitted by a bean.
ManagedNotifications
Type-level annotation used as a container for one or more `@ManagedNotification` declarations.
ManagedOperation
Method-level annotation that indicates to expose a given method as a JMX operation, corresponding to the `ManagedOperation` attribute.
ManagedOperation
Metadata that indicates to expose a given method as JMX operation.
ManagedOperationParameter
Method-level annotation used to provide metadata about operation parameters, corresponding to a `ManagedOperationParameter` attribute.
ManagedOperationParameter
Metadata about JMX operation parameters.
ManagedOperationParameters
Method-level annotation used as a container for one or more `@ManagedOperationParameter` declarations.
ManagedResource
Class-level annotation that indicates to register instances of a class with a JMX server, corresponding to the `ManagedResource` attribute.
ManagedResource
Metadata indicating that instances of an annotated class are to be registered with a JMX server.
MapAccessor
SpEL `PropertyAccessor` that knows how to access the keys of a standard `Map`.
MapBindingResult
Map-based implementation of the BindingResult interface, supporting registration and evaluation of binding errors on Map attributes.
MBeanClientInterceptor
`MethodInterceptor` that routes calls to an MBean running on the supplied `MBeanServerConnection`.
MBeanConnectFailureException
Thrown when an invocation failed because of an I/O problem on the MBeanServerConnection.
MBeanExportConfiguration
`@Configuration` class that registers a `AnnotationMBeanExporter` bean.
MBeanExporter
JMX exporter that allows for exposing any Spring-managed bean to a JMX `MBeanServer`, without the need to define any JMX-specific information in the bean classes.
MBeanExporterListener
A listener that allows application code to be notified when an MBean is registered and unregistered via an `MBeanExporter`.
MBeanExportException
Exception thrown in case of failure when exporting an MBean.
MBeanExportOperations
Interface that defines the set of MBean export operations that are intended to be accessed by application developers during application runtime.
MBeanInfoAssembler
Interface to be implemented by all classes that can create management interface metadata for a managed resource.
MBeanInfoRetrievalException
Thrown if an exception is encountered when trying to retrieve MBean metadata.
MBeanProxyFactoryBean
Creates a proxy to a managed resource running either locally or remotely.
MBeanRegistrationSupport
Provides supporting infrastructure for registering MBeans with an `MBeanServer`.
MBeanServerConnectionFactoryBean
`FactoryBean` that creates a JMX 1.2 `MBeanServerConnection` to a remote `MBeanServer` exposed via a `JMXServerConnector`.
MBeanServerFactoryBean
`FactoryBean` that obtains a `MBeanServer` reference through the standard JMX 1.2 `MBeanServerFactory` API.
MBeanServerNotFoundException
Exception thrown when we cannot locate an instance of an `MBeanServer`, or when more than one instance is found.
MessageCodeFormatter
A strategy interface for formatting message codes.
MessageCodesResolver
Strategy interface for building message codes from validation error codes.
MessageSource
Strategy interface for resolving messages, with support for the parameterization and internationalization of such messages.
MessageSourceAccessor
Helper class for easy access to messages from a MessageSource, providing various overloaded getMessage methods.
MessageSourceAware
Interface to be implemented by any object that wishes to be notified of the `MessageSource` (typically the ApplicationContext) that it runs in.
MessageSourceResolvable
Interface for objects that are suitable for message resolution in a `MessageSource`.
MessageSourceResourceBundle
Helper class that allows for accessing a Spring `MessageSource` as a `ResourceBundle`.
MessageSourceResourceBundleLocator
Implementation of Hibernate Validator 4.3/5.x's `ResourceBundleLocator` interface, exposing a Spring `MessageSource` as localized `MessageSourceResourceBundle`.
MessageSourceSupport
Base class for message source implementations, providing support infrastructure such as `MessageFormat` handling but not implementing concrete methods defined in the `MessageSource`.
MetadataMBeanInfoAssembler
Implementation of the `MBeanInfoAssembler` interface that reads the management interface information from source level metadata.
MetadataNamingStrategy
An implementation of the `ObjectNamingStrategy` interface that reads the `ObjectName` from the source-level metadata.
MethodBasedEvaluationContext
A method-based `EvaluationContext` that provides explicit support for method-based invocations.
MethodExclusionMBeanInfoAssembler
`AbstractReflectiveMBeanInfoAssembler` subclass that allows method names to be explicitly excluded as MBean operations and attributes.
MethodInvokingRunnable
Adapter that implements the `Runnable` interface as a configurable method invocation based on Spring's MethodInvoker.
MethodNameBasedMBeanInfoAssembler
Subclass of `AbstractReflectiveMBeanInfoAssembler` that allows to specify method names to be exposed as MBean operations and attributes.
MethodValidationAdapter
`MethodValidator` that uses a Bean Validation `Validator` for validation, and adapts `ConstraintViolation`s to `MethodValidationResult`.
MethodValidationAdapter.ObjectNameResolver
Strategy to resolve the name of an `@Valid` method parameter to use for its `BindingResult`.
MethodValidationException
Exception that is a `MethodValidationResult`.
MethodValidationInterceptor
An AOP Alliance `MethodInterceptor` implementation that delegates to a JSR-303 provider for performing method-level validation on annotated methods.
MethodValidationPostProcessor
A convenient `BeanPostProcessor` implementation that delegates to a JSR-303 provider for performing method-level validation on annotated methods.
MethodValidationResult
Container for method validation results with validation errors from the underlying library adapted to `MessageSourceResolvable`s and grouped by method parameter as `ParameterValidationResult`.
MethodValidator
Contract to apply method validation and handle the results.
MetricType
Represents how the measurement values of a `ManagedMetric` will change over time.
Model
Interface that defines a holder for model attributes.
ModelMap
Implementation of `Map` for use when building model data for use with UI tools.
ModelMBeanNotificationPublisher
`NotificationPublisher` implementation that uses the infrastructure provided by the `ModelMBean` interface to track `javax.management.NotificationListeners` and send `Notifications` to those listeners.
MonetaryAmountFormatter
Formatter for JSR-354 `MonetaryAmount` values, delegating to `MonetaryAmountFormat.format(javax.money.MonetaryAmount)` and `MonetaryAmountFormat.parse(java.lang.CharSequence)`.
NamedCacheResolver
A `CacheResolver` that forces the resolution to a configurable collection of name(s) against a given `CacheManager`.
NameMatchCacheOperationSource
Simple `CacheOperationSource` implementation that allows attributes to be matched by registered name.
NoOpCache
A no operation `Cache` implementation suitable for disabling caching.
NoOpCacheManager
A basic, no operation `CacheManager` implementation suitable for disabling caching, typically used for backing cache declarations without an actual backing store.
NoOpTaskScheduler
A basic, no operation `TaskScheduler` implementation suitable for disabling scheduling, typically used for test setups.
NoSuchMessageException
Exception thrown when a message can't be resolved.
NotificationListenerBean
Helper class that aggregates a `NotificationListener`, a `NotificationFilter`, and an arbitrary handback object.
NotificationListenerHolder
Helper class that aggregates a `NotificationListener`, a `NotificationFilter`, and an arbitrary handback object, as well as the names of MBeans from which the listener wishes to receive `Notifications`.
NotificationListenerRegistrar
Registrar object that associates a specific `NotificationListener` with one or more MBeans in an `MBeanServer` (typically via a `MBeanServerConnection`).
NotificationPublisher
Simple interface allowing Spring-managed MBeans to publish JMX notifications without being aware of how those notifications are being transmitted to the `MBeanServer`.
NotificationPublisherAware
Interface to be implemented by any Spring-managed resource that is to be registered with an `MBeanServer` and wishes to send JMX `javax.management.Notifications`.
NullValue
Simple serializable class that serves as a `null` replacement for cache stores which otherwise do not support `null` values.
NumberFormat
Declares that a field or method parameter should be formatted as a number.
NumberFormat.Style
Common number format styles.
NumberFormatAnnotationFormatterFactory
Formats fields annotated with the `NumberFormat` annotation.
NumberStyleFormatter
A general-purpose number formatter using NumberFormat's number style.
ObjectError
Encapsulates an object error, that is, a global reason for rejecting an object.
ObjectNameManager
Helper class for the creation of `ObjectName` instances.
ObjectNamingStrategy
Strategy interface that encapsulates the creation of `ObjectName` instances.
OneTimeTask
`Task` implementation defining a `Runnable` with an initial delay.
OptionalValidatorFactoryBean
`LocalValidatorFactoryBean` subclass that simply turns `Validator` calls into no-ops in case of no Bean Validation provider being available.
ParameterErrors
Extension of `ParameterValidationResult` created for Object method parameters or return values with nested errors on their properties.
ParameterValidationResult
Store and expose the results of method validation for a method parameter.
Parser<T>
Parses text strings to produce instances of T.
PayloadApplicationEvent<T>
An `ApplicationEvent` that carries an arbitrary payload.
PercentStyleFormatter
A formatter for number values in percent style.
PeriodicTrigger
A trigger for periodic task execution.
Phased
Interface for objects that may participate in a phased process such as lifecycle management.
Primary
Indicates that a bean should be given preference when multiple candidates are qualified to autowire a single-valued dependency.
Printer<T>
Prints objects of type T for display.
Profile
Indicates that a component is eligible for registration when one or more specified profiles are active.
PropertySource
Annotation providing a convenient and declarative mechanism for adding a `PropertySource` to Spring's `Environment`.
PropertySources
Container annotation that aggregates several `PropertySource` annotations.
PropertySourcesPlaceholderConfigurer
Specialization of `PlaceholderConfigurerSupport` that resolves ${...} placeholders within bean definition property values and `@Value` annotations against the current Spring `Environment` and its set of `PropertySources`.
ProxyAsyncConfiguration
`@Configuration` class that registers the Spring infrastructure beans necessary to enable proxy-based asynchronous method execution.
ProxyCachingConfiguration
`@Configuration` class that registers the Spring infrastructure beans necessary to enable proxy-based annotation-driven cache management.
ReflectiveLoadTimeWeaver
`LoadTimeWeaver` which uses reflection to delegate to an underlying ClassLoader with well-known transformation hooks.
ReflectiveProcessorAotContributionBuilder
Builder for an AOT contribution that detects the presence of `@Reflective` on annotated elements and invoke the underlying `ReflectiveProcessor` implementations.
ReflectiveScan
Scan arbitrary types for use of `Reflective`.
RefreshableScriptTargetSource
Subclass of `BeanFactoryRefreshableTargetSource` that determines whether a refresh is required through the given `ScriptFactory`.
RegistrationPolicy
Indicates registration behavior when attempting to register an MBean that already exists.
ReloadableResourceBundleMessageSource
Spring-specific `MessageSource` implementation that accesses resource bundles using specified basenames, participating in the Spring `ApplicationContext`'s resource loading.
Repository
Indicates that an annotated class is a "Repository", originally defined by Domain-Driven Design (Evans, 2003) as "a mechanism for encapsulating storage, retrieval, and search behavior which emulates a collection of objects".
ResourceBundleMessageSource
`MessageSource` implementation that accesses resource bundles using specified basenames.
ResourceBundleThemeSource
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
ResourceElementResolver
Resolver for the injection of named beans on a field or method element, following the rules of the `Resource` annotation but without any JNDI support.
ResourceLoaderAware
Interface to be implemented by any object that wishes to be notified of the `ResourceLoader` (typically the ApplicationContext) that it runs in.
ResourceOverridingShadowingClassLoader
Subclass of ShadowingClassLoader that overrides attempts to locate certain files.
ResourceScriptSource
`ScriptSource` implementation based on Spring's `Resource` abstraction.
Role
Indicates the 'role' hint for a given bean.
ScannedGenericBeanDefinition
Extension of the `GenericBeanDefinition` class, based on an ASM ClassReader, with support for annotation metadata exposed through the `AnnotatedBeanDefinition` interface.
Scheduled
Annotation that marks a method to be scheduled.
ScheduledAnnotationBeanPostProcessor
Bean post-processor that registers methods annotated with `@Scheduled` to be invoked by a `TaskScheduler` according to the "fixedRate", "fixedDelay", or "cron" expression provided via the annotation.
ScheduledExecutorFactoryBean
`FactoryBean` that sets up a `ScheduledExecutorService` (by default: a `ScheduledThreadPoolExecutor`) and exposes it for bean references.
ScheduledExecutorTask
JavaBean that describes a scheduled executor task, consisting of the `Runnable` and a delay plus period.
ScheduledMethodRunnable
Variant of `MethodInvokingRunnable` meant to be used for processing of no-arg scheduled methods.
ScheduledTask
A representation of a scheduled task at runtime, used as a return value for scheduling methods.
ScheduledTaskHolder
Common interface for exposing locally scheduled tasks.
ScheduledTaskObservationContext
Context that holds information for observation metadata collection during the `execution of scheduled tasks`.
ScheduledTaskObservationConvention
Interface for an `ObservationConvention` for `scheduled task executions`.
ScheduledTaskObservationDocumentation
Documented `KeyValues` for the observations on executions of `scheduled tasks`
ScheduledTaskObservationDocumentation.LowCardinalityKeyNames
ScheduledTaskRegistrar
Helper bean for registering tasks with a `TaskScheduler`, typically using cron expressions.
ScheduledTasksBeanDefinitionParser
Parser for the 'scheduled-tasks' element of the scheduling namespace.
SchedulerBeanDefinitionParser
Parser for the 'scheduler' element of the 'task' namespace.
Schedules
Container annotation that aggregates several `Scheduled` annotations.
SchedulingAwareRunnable
Extension of the `Runnable` interface, adding special callbacks for long-running operations.
SchedulingConfiguration
`@Configuration` class that registers a `ScheduledAnnotationBeanPostProcessor` bean capable of processing Spring's @`Scheduled` annotation.
SchedulingConfigurer
Optional interface to be implemented by `@Configuration` classes annotated with `@EnableScheduling`.
SchedulingException
General exception to be thrown on scheduling failures, such as the scheduler already having shut down.
SchedulingTaskExecutor
A `TaskExecutor` extension exposing scheduling characteristics that are relevant to potential task submitters.
Scope
When used as a type-level annotation in conjunction with `@Component`, `@Scope` indicates the name of a scope to use for instances of the annotated type.
ScopedProxyMode
Enumerates the various scoped-proxy options.
ScopeMetadata
Describes scope characteristics for a Spring-managed bean including the scope name and the scoped-proxy behavior.
ScopeMetadataResolver
Strategy interface for resolving the scope of bean definitions.
ScriptCompilationException
Exception to be thrown on script compilation failure.
ScriptEvaluator
Spring's strategy interface for evaluating a script.
ScriptFactory
Script definition interface, encapsulating the configuration of a specific script as well as a factory method for creating the actual scripted Java `Object`.
ScriptFactoryPostProcessor
`BeanPostProcessor` that handles `ScriptFactory` definitions, replacing each factory with the actual scripted Java object generated by it.
ScriptSource
Interface that defines the source of a script.
SelfNaming
Interface that allows infrastructure components to provide their own `ObjectName`s to the `MBeanExporter`.
Service
Indicates that an annotated class is a "Service", originally defined by Domain-Driven Design (Evans, 2003) as "an operation offered as an interface that stands alone in the model, with no encapsulated state."
ShadowingClassLoader
ClassLoader decorator that shadows an enclosing ClassLoader, applying registered transformers to all affected classes.
SimpleApplicationEventMulticaster
Simple implementation of the `ApplicationEventMulticaster` interface.
SimpleAsyncTaskScheduler
A simple implementation of Spring's `TaskScheduler` interface, using a single scheduler thread and executing every scheduled task in an individual separate thread.
SimpleCacheErrorHandler
A simple `CacheErrorHandler` that does not handle the exception at all, simply throwing it back at the client.
SimpleCacheManager
Simple cache manager working against a given collection of caches.
SimpleCacheResolver
A simple `CacheResolver` that resolves the `Cache` instance(s) based on a configurable `CacheManager` and the name of the cache(s) as provided by `getCacheNames()`.
SimpleErrors
A simple implementation of the `Errors` interface, managing global errors and field errors for a top-level target object.
SimpleInstrumentableClassLoader
Simplistic implementation of an instrumentable `ClassLoader`.
SimpleJndiBeanFactory
Simple JNDI-based implementation of Spring's `BeanFactory` interface.
SimpleKey
A simple key as returned from the `SimpleKeyGenerator`.
SimpleKeyGenerator
Simple key generator.
SimpleLoadTimeWeaver
`LoadTimeWeaver` that builds and exposes a `SimpleInstrumentableClassLoader`.
SimpleLocaleContext
Simple implementation of the `LocaleContext` interface, always returning a specified `Locale`.
SimpleReflectiveMBeanInfoAssembler
Simple subclass of `AbstractReflectiveMBeanInfoAssembler` that always votes yes for method and property inclusion, effectively exposing all public methods and properties as operations and attributes.
SimpleTheme
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
SimpleThreadScope
A simple thread-backed `Scope` implementation.
SimpleThrowawayClassLoader
ClassLoader that can be used to load classes without bringing them into the parent loader.
SimpleTimeZoneAwareLocaleContext
Simple implementation of the `TimeZoneAwareLocaleContext` interface, always returning a specified `Locale` and `TimeZone`.
SimpleTriggerContext
Simple data holder implementation of the `TriggerContext` interface.
SimpleValueWrapper
Straightforward implementation of `Cache.ValueWrapper`, simply holding the value as given at construction and returning it from `SimpleValueWrapper.get()`.
SmartApplicationListener
Extended variant of the standard `ApplicationListener` interface, exposing further metadata such as the supported event and source type.
SmartLifecycle
An extension of the `Lifecycle` interface for those objects that require to be started upon `ApplicationContext` refresh and/or shutdown in a particular order.
SmartValidator
Extended variant of the `Validator` interface, adding support for validation 'hints'.
SourceFilteringListener
`ApplicationListener` decorator that filters events from a specified event source, invoking its delegate listener for matching `ApplicationEvent` objects only.
SpringCacheAnnotationParser
Strategy implementation for parsing Spring's `Caching`, `Cacheable`, `CacheEvict`, and `CachePut` annotations.
SpringConstraintValidatorFactory
JSR-303 `ConstraintValidatorFactory` implementation that delegates to a Spring BeanFactory for creating autowired `ConstraintValidator` instances.
SpringModelMBean
Extension of the `RequiredModelMBean` class that ensures the `thread context ClassLoader` is switched for the managed resource's `ClassLoader` before any invocations occur.
SpringValidatorAdapter
Adapter that takes a JSR-303 `javax.validator.Validator` and exposes it as a Spring `Validator` while also exposing the original JSR-303 Validator interface itself.
StandardBeanExpressionResolver
Standard implementation of the `BeanExpressionResolver` interface, parsing and evaluating Spring EL using Spring's expression module.
StandardScriptEvalException
Exception decorating a `ScriptException` coming out of JSR-223 script evaluation, i.e.
StandardScriptEvaluator
`javax.script` (JSR-223) based implementation of Spring's `ScriptEvaluator` strategy interface.
StandardScriptFactory
`ScriptFactory` implementation based on the JSR-223 script engine abstraction (as included in Java).
StandardScriptUtils
Common operations for dealing with a JSR-223 `ScriptEngine`.
StaticApplicationContext
`ApplicationContext` implementation which supports programmatic registration of beans and messages, rather than reading bean definitions from external configuration sources.
StaticMessageSource
Simple implementation of `MessageSource` which allows messages to be registered programmatically.
StaticScriptSource
Static implementation of the `ScriptSource` interface, encapsulating a given String that contains the script source text.
Task
Holder class defining a `Runnable` to be executed as a task, typically at a scheduled time or interval.
TaskExecutionOutcome
Outcome of a `Task` execution.
TaskExecutionOutcome.Status
Status of the task execution outcome.
TaskExecutorFactoryBean
`FactoryBean` for creating `ThreadPoolTaskExecutor` instances, primarily used behind the XML task namespace.
TaskManagementConfigUtils
Configuration constants for internal sharing across subpackages.
TaskNamespaceHandler
`NamespaceHandler` for the 'task' namespace.
TaskScheduler
Task scheduler interface that abstracts the scheduling of `Runnables` based on different kinds of triggers.
TaskSchedulerRouter
A routing implementation of the `TaskScheduler` interface, delegating to a target scheduler based on an identified qualifier or using a default scheduler otherwise.
TaskUtils
Utility methods for decorating tasks with error handling.
TemporalAccessorParser
`Parser` implementation for a JSR-310 `TemporalAccessor`, using a `DateTimeFormatter` (the contextual one, if available).
TemporalAccessorPrinter
`Printer` implementation for a JSR-310 `TemporalAccessor`, using a `DateTimeFormatter`) (the contextual one, if available).
Theme
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
ThemeSource
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
ThreadPoolExecutorFactoryBean
JavaBean that allows for configuring a `ThreadPoolExecutor` in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a bean reference of its native `ExecutorService` type.
ThreadPoolTaskExecutor
JavaBean that allows for configuring a `ThreadPoolExecutor` in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a Spring `TaskExecutor`.
ThreadPoolTaskScheduler
A standard implementation of Spring's `TaskScheduler` interface, wrapping a native `ScheduledThreadPoolExecutor` and providing all applicable configuration options for it.
TimeZoneAwareLocaleContext
Extension of `LocaleContext`, adding awareness of the current time zone.
TomcatLoadTimeWeaver
`LoadTimeWeaver` implementation for Tomcat's new `org.apache.tomcat.InstrumentableClassLoader`.
Trigger
Common interface for trigger objects that determine the next execution time of a task that they get associated with.
TriggerContext
Context object encapsulating last execution times and last completion time of a given task.
TriggerTask
`Task` implementation defining a `Runnable` to be executed according to a given `Trigger`.
TypeFilterUtils
Collection of utilities for working with `@ComponentScan` type filters.
TypeMismatchNamingException
Exception thrown if a type mismatch is encountered for an object located in a JNDI environment.
UiApplicationContextUtils
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
UnableToRegisterMBeanException
Exception thrown when we are unable to register an MBean, for example because of a naming conflict.
UnableToSendNotificationException
Thrown when a JMX `Notification` is unable to be sent.
Validated
Variant of JSR-303's `Valid`, supporting the specification of validation groups.
ValidationAnnotationUtils
Utility class for handling validation annotations.
ValidationUtils
Utility class offering convenient methods for invoking a `Validator` and for rejecting empty fields.
Validator
A validator for application-specific objects.
WeavingTransformer
ClassFileTransformer-based weaver, allowing for a list of transformers to be applied on a class byte array.