All Classes and Interfaces
Class
Description
Abstract base class for filesystem-based ahead-of-time (AOT) processing.
Common settings for AOT processors.
Fluent builder API for
AbstractAotProcessor.Settings.Abstract implementation of the
ApplicationContext
interface.Abstract implementation of the
ApplicationEventMulticaster interface,
providing the basic listener registration facility.Abstract base
Configuration class providing common structure for enabling
Spring's asynchronous method execution capability.Abstract implementation of the
BindingResult interface and
its super-interface Errors.A base component for invoking
Cache operations and using a
configurable CacheErrorHandler when an exception occurs.Abstract base class implementing the common
CacheManager methods.A base
CacheResolver implementation that requires the concrete
implementation to provide the collection of cache name(s) based on the
invocation context.Abstract base
@Configuration class providing common structure
for enabling Spring's annotation-driven cache management capability.Base class for MBeanInfoAssemblers that support configurable
JMX notification behavior.
Abstract implementation of the
Errors interface.Abstract implementation of
CacheOperationSource that caches operations
for methods and implements a fallback policy: 1.Base class for all JMX metadata classes.
Abstract implementation of the
MBeanInfoAssembler interface
that encapsulates the creation of a ModelMBeanInfo instance
but delegates the creation of metadata to subclasses.Abstract implementation of the
HierarchicalMessageSource interface,
implementing common handling of message variants, making it easy
to implement a specific strategy for a concrete MessageSource.Abstract formatter for Numbers,
providing a
AbstractNumberFormatter.getNumberFormat(java.util.Locale) template method.Abstract base class for
BindingResult implementations that work with
Spring's PropertyAccessor mechanism.Builds on the
AbstractMBeanInfoAssembler superclass to
add a basic algorithm for building metadata based on the
reflective metadata of the MBean class.Base class for
ApplicationContext
implementations which are supposed to support multiple calls to AbstractApplicationContext.refresh(),
creating a new internal bean factory instance every time.AbstractRefreshableApplicationContext subclass that adds common handling
of specified config locations.Abstract base class for
MessageSource implementations based on
resource bundle conventions, such as ResourceBundleMessageSource
and ReloadableResourceBundleMessageSource.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.Convenient base class for
ApplicationContext
implementations, drawing configuration from XML documents containing bean definitions
understood by an XmlBeanDefinitionReader.Enumeration used to determine whether JDK proxy-based or
AspectJ weaving-based advice should be applied.
Convenient base class for
ImportSelector implementations that select imports
based on an AdviceMode value from an annotation (such as the @Enable*
annotations).Convenient adapter for programmatic registration of bean classes.
Represent an
AnnotatedElement on a particular Class
and is suitable as a key.Specialization of
AsyncExecutionInterceptor that delegates method execution to
an Executor based on the Async annotation.BeanNameGenerator implementation for bean classes annotated with the
@Component annotation or
with another annotation that is itself annotated with @Component as a
meta-annotation.Implementation of the
CacheOperationSource interface for working with caching metadata in annotation format.Callback interface providing
CacheOperation instance(s) based on
a given CacheAnnotationParser.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.Parser for the <context:annotation-config/> element.
Common interface for annotation config application contexts,
defining
AnnotationConfigRegistry.register(java.lang.Class<?>...) and AnnotationConfigRegistry.scan(java.lang.String...) methods.Utility class that allows for convenient registration of common
BeanPostProcessor and
BeanFactoryPostProcessor
definitions for annotation-based configuration.Parser for the 'annotation-driven' element of the 'task' namespace.
A factory that creates formatters to format values of fields annotated with a particular
Annotation.Implementation of the
JmxAttributeSource interface that
reads annotations and exposes the corresponding attributes.Convenient subclass of Spring's standard
MBeanExporter,
activating annotation usage for JMX exposure of Spring beans:
ManagedResource, ManagedAttribute, ManagedOperation, etc.A
ScopeMetadataResolver implementation that by default checks for
the presence of Spring's @Scope annotation on the bean class.Specialized
ApplicationContextInitializer used to initialize a
ConfigurableApplicationContext using artifacts that were generated
ahead-of-time.Central interface to provide configuration for an application.
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.Interface to be implemented by any object that wishes to be notified
of the
ApplicationContext that it runs in.Base class for events raised for an
ApplicationContext.Exception thrown during application context initialization.
Callback interface for initializing a Spring
ConfigurableApplicationContext
prior to being refreshed.Class to be extended by all application events.
Interface to be implemented by objects that can manage a number of
ApplicationListener objects and publish events to them.Interface that encapsulates event publication functionality.
Interface to be implemented by any object that wishes to be notified
of the ApplicationEventPublisher (typically the ApplicationContext)
that it runs in.
Interface to be implemented by application event listeners.
GenericApplicationListener adapter that delegates the processing of
an event to an EventListener annotated method.Convenient superclass for application objects that want to be aware of
the application context, e.g.
Interface to be implemented by any object that wishes to be notified
of the
ApplicationStartup that it runs with.Post-processor that registers AspectJ's
ClassPreProcessorAgentAdapter
with the Spring application context's default
LoadTimeWeaver.Annotation that marks a method as a candidate for asynchronous execution.
Advisor that activates asynchronous method execution through the
Async
annotation.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).Selects which implementation of
AbstractAsyncConfiguration should
be used based on the value of EnableAsync.mode() on the importing
@Configuration class.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.Deprecated.
Deprecated.
as of 6.0, in favor of
CompletableFutureExtends the
MBeanInfoAssembler to add autodetection logic.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.The base interface that all cache operations must implement.
Indicates that a method produces a bean to be managed by the Spring container.
EL property accessor that knows how to traverse the beans and contextual objects
of a Spring
BeanExpressionContext.EL property accessor that knows how to traverse the beans of a
Spring
BeanFactory.Advisor driven by a
CacheOperationSource, used to include a
cache advice bean for methods that are cacheable.EL bean resolver that operates against a Spring
BeanFactory.Default implementation of the
Errors and BindingResult
interfaces, for the registration and evaluation of binding errors on
JavaBean objects.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).Thrown when binding errors are considered fatal.
Subclass of
ConcurrentModel that automatically removes
the BindingResult object when its corresponding
target attribute is replaced through regular Map operations.Subclass of
ExtendedModelMap that automatically removes
a BindingResult object if the corresponding
target attribute gets replaced through regular Map operations.Strategy for processing
DataBinder's missing field errors,
and for translating a PropertyAccessException to a
FieldError.General interface that represents binding results.
Convenience methods for looking up BindingResults in a model Map.
BeanShell-based implementation of Spring's
ScriptEvaluator strategy interface.ScriptFactory implementation
for a BeanShell script.Utility methods for handling BeanShell-scripted objects.
Exception to be thrown on script execution failure.
Interface that defines common cache operations.
Wrapper exception to be thrown from
Cache.get(Object, Callable)
in case of the value loader callback failing with an exception.A (wrapper) object representing a cache value.
Annotation indicating that the result of invoking a method (or all methods
in a class) can be cached.
Class describing a cache 'cacheable' operation.
A builder that can be used to create a
CacheableOperation.Strategy interface for parsing known caching annotation types.
Base class for caching aspects, such as the
CacheInterceptor or an
AspectJ aspect.Metadata of a cache operation that does not depend on a particular invocation
which makes it a good candidate for caching.
@CacheConfig provides a mechanism for sharing common cache-related
settings at the class level.Shared utility class used to evaluate and cache SpEL expressions that
are defined on
AnnotatedElement.An expression key.
A strategy for handling cache-related errors.
Annotation indicating that a method (or all methods on a class) triggers a
cache evict operation.Class describing a cache 'evict' operation.
A builder that can be used to create a
CacheEvictOperation.AOP Alliance MethodInterceptor for declarative cache
management using the common Spring caching infrastructure
(
Cache).Configuration constants for internal sharing across subpackages.
Spring's central cache manager SPI.
NamespaceHandler allowing for the configuration of declarative
cache management using either XML or using annotations.Base class for cache operations.
Base class for builders that can be used to create a
CacheOperation.Representation of the context of the invocation of a cache operation.
Abstract the invocation of a cache operation.
Wrap any exception thrown while invoking
CacheOperationInvoker.invoke().Interface used by
CacheInterceptor.Proxy factory bean for simplified declarative caching handling.
Annotation indicating that a method (or all methods on a class) triggers a
cache put operation.Class describing a cache 'put' operation.
A builder that can be used to create a
CachePutOperation.Determine the
Cache instance(s) to use for an intercepted method invocation.Group annotation for multiple cache annotations (of different or the same type).
Selects which implementation of
AbstractCachingConfiguration should
be used based on the value of EnableCaching.mode() on the importing
@Configuration class.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.Deprecated.
as of 6.0 in favor of implementing
CachingConfigurer directlyProvide access to the candidates that are defined in
META-INF/spring.components.Candidate components index loading mechanism for internal use within the framework.
A bean definition scanner that detects bean candidates on the classpath,
registering corresponding bean definitions with a given registry (
BeanFactory
or ApplicationContext).A component provider that scans for candidate components starting from a
specified base package.
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 (e.g.
BeanPostProcessor implementation
that supports common Java annotations out of the box, in particular the common
annotations in the jakarta.annotation package.Class representing generic injection information about an annotated field
or setter method, supporting @Resource and related annotations.
Indicates that an annotated class is a "component".
Configures component scanning directives for use with @
Configuration classes.Declares the type filter to be used as an include filter or exclude filter.
Parser for the
<context:component-scan/> element.Container annotation that aggregates several
ComponentScan annotations.Composite
CacheManager implementation that iterates over
a given collection of delegate CacheManager instances.Composite
CacheOperationSource implementation that iterates
over a given array of CacheOperationSource instances.Simple
Cache implementation based on the
core JDK java.util.concurrent package.FactoryBean for easy configuration of a ConcurrentMapCache
when used within a Spring container.CacheManager implementation that lazily builds ConcurrentMapCache
instances for each ConcurrentMapCacheManager.getCache(java.lang.String) request.Implementation of the
Model interface based on a ConcurrentHashMap
for use in concurrent scenarios.Adapter that takes a
java.util.concurrent.Executor and exposes
a Spring TaskExecutor for it.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.Adapter that takes a
java.util.concurrent.ScheduledExecutorService and
exposes a Spring TaskScheduler for it.A single
condition that must be matched in order
for a component to be registered.Indicates that a component is only eligible for registration when all
specified conditions match.
Context information for use by
Condition implementations.SPI interface to be implemented by most if not all application contexts.
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:BeanFactoryPostProcessor used for bootstrapping processing of
@Configuration classes.Utilities for identifying and configuring
Configuration classes.A
Condition that offers more fine-grained control when used with
@Configuration.The various configuration phases where the condition could be evaluated.
FactoryBean that creates a JSR-160 JMXConnectorServer,
optionally registers it with the MBeanServer, and then starts it.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.Filesystem-based ahead-of-time (AOT) processing base implementation.
Event raised when an
ApplicationContext gets closed.ScheduledTaskRegistrar subclass which redirects the actual scheduling
of tasks to the ContextLifecycleScheduledTaskRegistrar.afterSingletonsInstantiated() callback (as of 4.1.2).NamespaceHandler
for the 'context' namespace.Event raised when an
ApplicationContext gets initialized or refreshed.Event raised when an
ApplicationContext gets started.Event raised when an
ApplicationContext gets stopped.Indicates that an annotated class is a "Controller" (e.g.
A factory providing convenient access to a ConversionService configured with
converters appropriate for most environments.
Representation of a
crontab expression
that can calculate the next time it matches.
Deprecated, for removal: This API element is subject to removal in a future version.
as of 5.3, in favor of
CronExpressionTriggerTask implementation defining a Runnable to be executed according
to a standard cron expression.Trigger implementation for cron expressions.A BigDecimal formatter for number values in currency style.
Formatter for JSR-354
CurrencyUnit values,
from and to currency code Strings.Implementation of the
ThreadFactory interface,
allowing for customizing the created threads (name, priority, etc).Configurable bean class that exposes a specific JSR-303 Validator
through its original interface as well as through the Spring
Validator interface.Binder that allows for setting property values on a target object, including
support for validation and binding result analysis.
A formatter for
Date types.Configures basic date formatting for use with Spring, primarily for
DateTimeFormat declarations.A context that holds user-specific
java.time (JSR-310) settings
such as the user's Chronology (calendar system) and time zone.A holder for a thread-local user
DateTimeContext.Declares that a field or method parameter should be formatted as a date or time.
Common ISO date time format patterns.
Formats fields annotated with the
DateTimeFormat annotation using a DateFormatter.Factory that creates a JSR-310
DateTimeFormatter.FactoryBean that creates a JSR-310 DateTimeFormatter.Configures the JSR-310
java.time formatting system for use with Spring.Default
BindingErrorProcessor implementation.Default
LoadTimeWeaver bean for use in an application context,
decorating an automatically detected internal LoadTimeWeaver.Default
EventListenerFactory implementation that supports the
regular EventListener annotation.A specialization of
FormattingConversionService configured by default with
converters and formatters appropriate for most applications.Spring's default implementation of the
LifecycleProcessor strategy.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.JNDI-based variant of
ConcurrentTaskExecutor, performing a default lookup for
JSR-236's "java:comp/DefaultManagedExecutorService" in a Jakarta EE/8 environment.JNDI-based variant of
ConcurrentTaskScheduler, performing a default lookup for
JSR-236's "java:comp/DefaultManagedScheduledExecutorService" in a Jakarta EE environment.Default implementation of the
MessageCodesResolver interface.Common message code formats.
Spring's default implementation of the
MessageSourceResolvable interface.A variation of
ImportSelector that runs after all @Configuration beans
have been processed.Interface used to group results from different import selectors.
An entry that holds the
AnnotationMetadata of the importing
Configuration class and the class name to import.Runnable wrapper that catches any exception or error thrown from its
delegate Runnable and allows an
ErrorHandler to handle it.Empty
MessageSource that delegates all calls to the parent MessageSource.Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
Beans on which the current bean depends.
Special implementation of the Errors and BindingResult interfaces,
supporting registration and evaluation of binding errors on value objects.
Convenient base class for components with a need for embedded value resolution
(i.e.
Interface to be implemented by any object that wishes to be notified of a
StringValueResolver for the resolution of embedded definition values.Enables support for handling components marked with AspectJ's
@Aspect annotation,
similar to functionality found in Spring's <aop:aspectj-autoproxy> XML element.Enables Spring's asynchronous method execution capability, similar to functionality
found in Spring's
<task:*> XML namespace.Enables Spring's annotation-driven cache management capability, similar to the
support found in Spring's
<cache:*> XML namespace.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.AspectJ weaving enablement options.
Enables default exporting of all standard
MBeans from the Spring context, as
well as all @ManagedResource annotated beans.Enables Spring's scheduled task execution capability, similar to
functionality found in Spring's
<task:*> XML namespace.Read-only EL property accessor that knows how to retrieve keys
of a Spring
Environment instance.Interface to be implemented by any bean that wishes to be notified
of the
Environment that it runs in.Stores and exposes information about data-binding and validation errors
for a specific object.
Annotation that marks a method as a listener for application events.
Strategy interface for creating
ApplicationListener for methods
annotated with EventListener.Registers
EventListener methods as individual ApplicationListener instances.Interceptor that publishes an
ApplicationEvent to all ApplicationListeners
registered with an ApplicationEventPublisher after each
successful method invocation.Parser for the 'executor' element of the 'task' namespace.
Base class for setting up a
ExecutorService
(typically a ThreadPoolExecutor or
ScheduledThreadPoolExecutor).Encapsulates a field error, that is, a reason for rejecting a specific
field value.
Standalone XML application context, taking the context definition files
from the file system or from URLs, interpreting plain paths as relative
file system locations (e.g.
Enumeration of the type filters that may be used in conjunction with
@ComponentScan.Specialization of
IntervalTask for fixed-delay semantics.Specialization of
IntervalTask for fixed-rate semantics.A Spring
FactoryBean that builds and exposes a preconfigured ForkJoinPool.Formats objects of type T.
Adapter that bridges between
Formatter and PropertyEditor.Registers
Converters and Formatters with
a FormattingConversionService through the FormatterRegistry SPI.A registry of field formatting logic.
A
ConversionService implementation
designed to be configured as a FormatterRegistry.A factory providing convenient access to a
FormattingConversionService
configured with converters and formatters for common types such as numbers and
datetimes.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).Generic ApplicationContext implementation that holds a single internal
DefaultListableBeanFactory
instance and does not assume a specific bean definition format.Extended variant of the standard
ApplicationListener interface,
exposing further metadata such as the supported event and source type.GenericApplicationListener adapter that determines supported event types
through introspecting the generically declared type of the target listener.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).Convenient application context with built-in XML support.
LoadTimeWeaver implementation for GlassFish's
org.glassfish.api.deployment.InstrumentableClassLoader InstrumentableClassLoader.Strategy used by
GroovyScriptFactory to allow the customization of
a created GroovyObject.Groovy-based implementation of Spring's
ScriptEvaluator strategy interface.ScriptFactory implementation
for a Groovy script.Sub-interface of MessageSource to be implemented by objects that
can resolve messages hierarchically.
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
An implementation of the
ObjectNamingStrategy interface that
creates a name based on the identity of a given instance.Indicates one or more component classes to import — typically
@Configuration classes.Interface to be implemented by any @
Configuration class that wishes
to be injected with the AnnotationMetadata of the @Configuration
class that imported it.A
BeanPostProcessor that honours ImportAware callback using
a mapping computed at build time.Interface to be implemented by types that register additional bean definitions when
processing @
Configuration classes.Indicates one or more resources containing bean definitions to import.
Indicates that one or more
RuntimeHintsRegistrar implementations
should be processed.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.Indicate that the annotated element represents a stereotype for the index.
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.LoadTimeWeaver relying on VM Instrumentation.Subclass of
AbstractReflectiveMBeanInfoAssembler that allows for
the management interface of a bean to be defined using arbitrary interfaces.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.Thrown when trying to invoke an operation on a proxy that is not exposed
by the proxied MBean resource's management interface.
Thrown by the
JmxAttributeSource when it encounters
incorrect metadata on a managed resource or one of its methods.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).
LoadTimeWeaver implementation for JBoss's instrumentable ClassLoader.NamespaceHandler
for the 'jee' namespace.Interface used by the
MetadataMBeanInfoAssembler to
read source-level metadata from a managed resource's class.General base exception to be thrown on JMX errors.
Utility methods for converting Spring JMX metadata into their plain JMX equivalents.
Collection of generic utility methods to support Spring JMX.
Convenient superclass for JNDI accessors, providing "jndiTemplate"
and "jndiEnvironment" bean properties.
Callback interface to be implemented by classes that need to perform an
operation (such as a lookup) in a JNDI context.
JndiLocatorSupport subclass with public lookup methods,
for convenient use as a delegate.Convenient superclass for classes that can locate any number of JNDI objects.
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.FactoryBean that looks up a
JNDI object.Convenient superclass for JNDI-based service locators,
providing configurable lookup of a specific JNDI resource.
AOP
TargetSource that provides
configurable JNDI lookups for getTarget() calls.PropertySource implementation that reads properties from an underlying Spring
JndiLocatorDelegate.Helper class that simplifies JNDI operations.
Properties editor for JndiTemplate objects.
Formats fields annotated with the
DateTimeFormat annotation using the
JSR-310 java.time package in JDK 8.Simple
ScopeMetadataResolver implementation that follows JSR-330 scoping rules:
defaulting to prototype scope unless Singleton is present.Formats
MonetaryAmount fields annotated
with Spring's common NumberFormat annotation.Cache key generator.
ObjectNamingStrategy implementation that builds
ObjectName instances from the key used in the
"beans" map passed to MBeanExporter.NamespaceHandler that supports the wiring of
objects backed by dynamic languages such as Groovy, JRuby and
BeanShell.Utilities for use with
LangNamespaceHandler.Indicates whether a bean is to be lazily initialized.
A common interface defining methods for start/stop lifecycle control.
Strategy interface for processing Lifecycle beans within the ApplicationContext.
Defines the contract for adding one or more
ClassFileTransformers to a ClassLoader.Interface to be implemented by any object that wishes to be notified
of the application context's default
LoadTimeWeaver.BeanPostProcessor
implementation that passes the context's default LoadTimeWeaver
to beans that implement the LoadTimeWeaverAware interface.@Configuration class that registers a LoadTimeWeaver bean.Interface to be implemented by
@Configuration
classes annotated with @EnableLoadTimeWeaving
that wish to customize the LoadTimeWeaver instance to be used.Strategy interface for determining the current Locale.
Simple holder class that associates a LocaleContext instance
with the current thread.
Delegates to a target
MessageInterpolator implementation but enforces Spring's
managed Locale.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.A
CacheErrorHandler implementation that logs error messages.Method-level annotation that indicates to expose a given bean property as a
JMX attribute, corresponding to the
ManagedAttribute.Metadata that indicates to expose a given bean property as JMX attribute.
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.
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.
Type-level annotation that indicates a JMX notification emitted by a bean.
Metadata that indicates a JMX notification emitted by a bean.
Type-level annotation used as a container for one or more
@ManagedNotification declarations.Method-level annotation that indicates to expose a given method as a JMX operation,
corresponding to the
ManagedOperation
attribute.Metadata that indicates to expose a given method as JMX operation.
Method-level annotation used to provide metadata about operation parameters, corresponding
to a
ManagedOperationParameter attribute.Metadata about JMX operation parameters.
Method-level annotation used as a container for one or more
@ManagedOperationParameter declarations.Class-level annotation that indicates to register instances of a class with a JMX server,
corresponding to the
ManagedResource attribute.Metadata indicating that instances of an annotated class
are to be registered with a JMX server.
EL property accessor that knows how to traverse the keys
of a standard
Map.Map-based implementation of the BindingResult interface,
supporting registration and evaluation of binding errors on
Map attributes.
MethodInterceptor that routes calls to an
MBean running on the supplied MBeanServerConnection.Thrown when an invocation failed because of an I/O problem on the
MBeanServerConnection.
@Configuration class that registers a AnnotationMBeanExporter bean.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.A listener that allows application code to be notified when an MBean is
registered and unregistered via an
MBeanExporter.Exception thrown in case of failure when exporting an MBean.
Interface that defines the set of MBean export operations that are intended to be
accessed by application developers during application runtime.
Interface to be implemented by all classes that can
create management interface metadata for a managed resource.
Thrown if an exception is encountered when trying to retrieve
MBean metadata.
Creates a proxy to a managed resource running either locally or remotely.
Provides supporting infrastructure for registering MBeans with an
MBeanServer.FactoryBean that creates a JMX 1.2 MBeanServerConnection
to a remote MBeanServer exposed via a JMXServerConnector.FactoryBean that obtains a MBeanServer reference
through the standard JMX 1.2 MBeanServerFactory
API.Exception thrown when we cannot locate an instance of an
MBeanServer,
or when more than one instance is found.A strategy interface for formatting message codes.
Strategy interface for building message codes from validation error codes.
Strategy interface for resolving messages, with support for the parameterization
and internationalization of such messages.
Helper class for easy access to messages from a MessageSource,
providing various overloaded getMessage methods.
Interface to be implemented by any object that wishes to be notified of the
MessageSource (typically the ApplicationContext) that it runs in.Interface for objects that are suitable for message resolution in a
MessageSource.Helper class that allows for accessing a Spring
MessageSource as a ResourceBundle.Implementation of Hibernate Validator 4.3/5.x's
ResourceBundleLocator interface,
exposing a Spring MessageSource as localized MessageSourceResourceBundle.Base class for message source implementations, providing support infrastructure
such as
MessageFormat handling but not implementing concrete
methods defined in the MessageSource.Implementation of the
MBeanInfoAssembler interface that reads
the management interface information from source level metadata.An implementation of the
ObjectNamingStrategy interface
that reads the ObjectName from the source-level metadata.A method-based
EvaluationContext that
provides explicit support for method-based invocations.AbstractReflectiveMBeanInfoAssembler subclass that allows
method names to be explicitly excluded as MBean operations and attributes.Adapter that implements the
Runnable interface as a configurable
method invocation based on Spring's MethodInvoker.Subclass of
AbstractReflectiveMBeanInfoAssembler that allows
to specify method names to be exposed as MBean operations and attributes.An AOP Alliance
MethodInterceptor implementation that delegates to a
JSR-303 provider for performing method-level validation on annotated methods.A convenient
BeanPostProcessor implementation that delegates to a
JSR-303 provider for performing method-level validation on annotated methods.Represents how the measurement values of a
ManagedMetric will change over time.Interface that defines a holder for model attributes.
Implementation of
Map for use when building model data for use
with UI tools.NotificationPublisher implementation that uses the infrastructure
provided by the ModelMBean interface to track
javax.management.NotificationListeners
and send Notifications to those listeners.Formatter for JSR-354
MonetaryAmount values,
delegating to MonetaryAmountFormat.format(javax.money.MonetaryAmount)
and MonetaryAmountFormat.parse(java.lang.CharSequence).A
CacheResolver that forces the resolution to a configurable
collection of name(s) against a given CacheManager.Simple
CacheOperationSource implementation that allows attributes to be matched
by registered name.A no operation
Cache implementation suitable for disabling caching.A basic, no operation
CacheManager implementation suitable
for disabling caching, typically used for backing cache declarations
without an actual backing store.Exception thrown when a message can't be resolved.
Helper class that aggregates a
NotificationListener,
a NotificationFilter, and an arbitrary handback object.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.Registrar object that associates a specific
NotificationListener
with one or more MBeans in an MBeanServer
(typically via a MBeanServerConnection).Simple interface allowing Spring-managed MBeans to publish JMX notifications
without being aware of how those notifications are being transmitted to the
MBeanServer.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.Simple serializable class that serves as a
null replacement
for cache stores which otherwise do not support null values.Declares that a field or method parameter should be formatted as a number.
Common number format styles.
Formats fields annotated with the
NumberFormat annotation.A general-purpose number formatter using NumberFormat's number style.
Encapsulates an object error, that is, a global reason for rejecting
an object.
Helper class for the creation of
ObjectName instances.Strategy interface that encapsulates the creation of
ObjectName instances.LocalValidatorFactoryBean subclass that simply turns
Validator calls into no-ops
in case of no Bean Validation provider being available.Parses text strings to produce instances of T.
An
ApplicationEvent that carries an arbitrary payload.A formatter for number values in percent style.
A trigger for periodic task execution.
Interface for objects that may participate in a phased
process such as lifecycle management.
Indicates that a bean should be given preference when multiple candidates
are qualified to autowire a single-valued dependency.
Prints objects of type T for display.
Indicates that a component is eligible for registration when one or more
specified profiles are active.
Annotation providing a convenient and declarative mechanism for adding a
PropertySource to Spring's
Environment.Container annotation that aggregates several
PropertySource annotations.Specialization of
PlaceholderConfigurerSupport that resolves ${...} placeholders
within bean definition property values and @Value annotations against the current
Spring Environment and its set of PropertySources.@Configuration class that registers the Spring infrastructure beans necessary
to enable proxy-based asynchronous method execution.@Configuration class that registers the Spring infrastructure beans necessary
to enable proxy-based annotation-driven cache management.LoadTimeWeaver which uses reflection to delegate to an underlying ClassLoader
with well-known transformation hooks.Subclass of
BeanFactoryRefreshableTargetSource that determines whether
a refresh is required through the given ScriptFactory.Indicates registration behavior when attempting to register an MBean that already
exists.
Spring-specific
MessageSource implementation
that accesses resource bundles using specified basenames, participating in the
Spring ApplicationContext's resource loading.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".
MessageSource implementation that
accesses resource bundles using specified basenames.Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
Interface to be implemented by any object that wishes to be notified of the
ResourceLoader (typically the ApplicationContext) that it runs in.Subclass of ShadowingClassLoader that overrides attempts to
locate certain files.
ScriptSource implementation
based on Spring's Resource
abstraction.Indicates the 'role' hint for a given bean.
Extension of the
GenericBeanDefinition
class, based on an ASM ClassReader, with support for annotation metadata exposed
through the AnnotatedBeanDefinition interface.Annotation that marks a method to be scheduled.
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.FactoryBean that sets up
a ScheduledExecutorService
(by default: a ScheduledThreadPoolExecutor)
and exposes it for bean references.JavaBean that describes a scheduled executor task, consisting of the
Runnable and a delay plus period.Variant of
MethodInvokingRunnable meant to be used for processing
of no-arg scheduled methods.A representation of a scheduled task at runtime,
used as a return value for scheduling methods.
Common interface for exposing locally scheduled tasks.
Helper bean for registering tasks with a
TaskScheduler, typically using cron
expressions.Parser for the 'scheduled-tasks' element of the scheduling namespace.
Parser for the 'scheduler' element of the 'task' namespace.
Container annotation that aggregates several
Scheduled annotations.Extension of the
Runnable interface, adding special callbacks
for long-running operations.@Configuration class that registers a ScheduledAnnotationBeanPostProcessor
bean capable of processing Spring's @Scheduled annotation.Optional interface to be implemented by
@Configuration classes annotated
with @EnableScheduling.General exception to be thrown on scheduling failures,
such as the scheduler already having shut down.
A
TaskExecutor extension exposing
scheduling characteristics that are relevant to potential task submitters.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.Enumerates the various scoped-proxy options.
Describes scope characteristics for a Spring-managed bean including the scope
name and the scoped-proxy behavior.
Strategy interface for resolving the scope of bean definitions.
Exception to be thrown on script compilation failure.
Spring's strategy interface for evaluating a script.
Script definition interface, encapsulating the configuration
of a specific script as well as a factory method for
creating the actual scripted Java
Object.BeanPostProcessor that
handles ScriptFactory definitions,
replacing each factory with the actual scripted Java object generated by it.Interface that defines the source of a script.
Interface that allows infrastructure components to provide their own
ObjectNames to the MBeanExporter.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."
ClassLoader decorator that shadows an enclosing ClassLoader,
applying registered transformers to all affected classes.
Simple implementation of the
ApplicationEventMulticaster interface.A simple
CacheErrorHandler that does not handle the
exception at all, simply throwing it back at the client.Simple cache manager working against a given collection of caches.
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().Simplistic implementation of an instrumentable
ClassLoader.Simple JNDI-based implementation of Spring's
BeanFactory interface.A simple key as returned from the
SimpleKeyGenerator.Simple key generator.
LoadTimeWeaver that builds and exposes a
SimpleInstrumentableClassLoader.Simple implementation of the
LocaleContext interface,
always returning a specified Locale.Simple subclass of
AbstractReflectiveMBeanInfoAssembler
that always votes yes for method and property inclusion, effectively exposing
all public methods and properties as operations and attributes.Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
A simple thread-backed
Scope implementation.ClassLoader that can be used to load classes without bringing them
into the parent loader.
Simple implementation of the
TimeZoneAwareLocaleContext interface,
always returning a specified Locale and TimeZone.Simple data holder implementation of the
TriggerContext interface.Straightforward implementation of
Cache.ValueWrapper,
simply holding the value as given at construction and returning it from SimpleValueWrapper.get().Extended variant of the standard
ApplicationListener interface,
exposing further metadata such as the supported event and source type.An extension of the
Lifecycle interface for those objects that require
to be started upon ApplicationContext refresh and/or shutdown in a
particular order.Extended variant of the
Validator interface, adding support for
validation 'hints'.ApplicationListener decorator that filters
events from a specified event source, invoking its delegate listener for
matching ApplicationEvent objects only.Strategy implementation for parsing Spring's
Caching, Cacheable,
CacheEvict, and CachePut annotations.JSR-303
ConstraintValidatorFactory implementation that delegates to a
Spring BeanFactory for creating autowired ConstraintValidator instances.Extension of the
RequiredModelMBean class that ensures the
thread context ClassLoader is switched
for the managed resource's ClassLoader before any invocations occur.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.Standard implementation of the
BeanExpressionResolver
interface, parsing and evaluating Spring EL using Spring's expression module.Exception decorating a
ScriptException coming out of
JSR-223 script evaluation, i.e.javax.script (JSR-223) based implementation of Spring's ScriptEvaluator
strategy interface.ScriptFactory implementation based
on the JSR-223 script engine abstraction (as included in Java).Common operations for dealing with a JSR-223
ScriptEngine.ApplicationContext implementation
which supports programmatic registration of beans and messages,
rather than reading bean definitions from external configuration sources.Simple implementation of
MessageSource
which allows messages to be registered programmatically.Static implementation of the
ScriptSource interface,
encapsulating a given String that contains the script source text.Holder class defining a
Runnable to be executed as a task, typically at a
scheduled time or interval.FactoryBean for creating ThreadPoolTaskExecutor instances,
primarily used behind the XML task namespace.Configuration constants for internal sharing across subpackages.
NamespaceHandler for the 'task' namespace.Task scheduler interface that abstracts the scheduling of
Runnables based on different kinds of triggers.Utility methods for decorating tasks with error handling.
Parser implementation for a JSR-310 TemporalAccessor,
using a DateTimeFormatter (the contextual one, if available).Printer implementation for a JSR-310 TemporalAccessor,
using a DateTimeFormatter) (the contextual one, if available).Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
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.JavaBean that allows for configuring a
ThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity"
properties) and exposing it as a Spring TaskExecutor.A standard implementation of Spring's
TaskScheduler interface, wrapping
a native ScheduledThreadPoolExecutor and providing
all applicable configuration options for it.Extension of
LocaleContext, adding awareness of the current time zone.LoadTimeWeaver implementation
for Tomcat's new org.apache.tomcat.InstrumentableClassLoader.Common interface for trigger objects that determine the next execution time
of a task that they get associated with.
Context object encapsulating last execution times and last completion time
of a given task.
Collection of utilities for working with
@ComponentScan
type filters.Exception thrown if a type mismatch is encountered for an object
located in a JNDI environment.
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
Exception thrown when we are unable to register an MBean,
for example because of a naming conflict.
Thrown when a JMX
Notification is unable to be sent.Variant of JSR-303's
Valid, supporting the
specification of validation groups.Utility class for handling validation annotations.
Utility class offering convenient methods for invoking a
Validator
and for rejecting empty fields.A validator for application-specific objects.
ClassFileTransformer-based weaver, allowing for a list of transformers to be
applied on a class byte array.
AsyncConfigurerdirectly