|
|
相关文章推荐
Class
Description
An abstract JMS
MessageListener
adapter providing the necessary
infrastructure to extract the payload of a JMS
Message
.
Base class for
BeanPostProcessor
implementations that apply a
Spring AOP
Advisor
to specific beans.
Generic auto proxy creator that builds AOP proxies for specific beans
based on detected Advisors for each bean.
WebApplicationInitializer
to register a
DispatcherServlet
and use Java-based Spring configuration.
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.
Base class for AOP Alliance
Advice
classes
wrapping an AspectJ aspect or an AspectJ-annotated advice method.
Abstract base class for factories that can create Spring AOP Advisors
given AspectJ classes from classes honoring the AspectJ 5 annotation syntax.
Class modeling an AspectJ annotation, exposing its type enumeration and
pointcut String.
Enum for AspectJ annotation types.
Abstract base
Configuration
class providing common structure for enabling
Spring's asynchronous method execution capability.
Convenient base class for
AsyncHandlerMethodReturnValueHandler
implementations that support only asynchronous (Future-like) return values
and merely serve as adapters of such types to Spring's
ListenableFuture
.
Abstract superclass for Atom Feed views, using the
ROME
package.
BeanPostProcessor
implementation
that wraps each eligible bean with an AOP proxy, delegating to specified interceptors
before invoking the bean itself.
Abstract bean factory superclass that implements default bean creation,
with the full capabilities specified by the
RootBeanDefinition
class.
Base class for concrete, full-fledged
BeanDefinition
classes,
factoring out common properties of
GenericBeanDefinition
,
RootBeanDefinition
, and
ChildBeanDefinition
.
Abstract
BeanDefinitionParser
implementation providing
a number of convenience methods and a
template method
that subclasses must override to provide the actual parsing logic.
Abstract base class for bean definition readers which implement
the
BeanDefinitionReader
interface.
Abstract base class for
BeanFactory
implementations, providing the full capabilities of the
ConfigurableBeanFactory
SPI.
Extension of
AbstractAutoProxyCreator
which implements
BeanFactoryAware
,
adds exposure of the original target class for each proxied bean
(
AutoProxyUtils.ORIGINAL_TARGET_CLASS_ATTRIBUTE
),
and participates in an externally enforced target-class mode for any given bean
(
AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE
).
Base class for
TargetSource
implementations
that are based on a Spring
BeanFactory
,
delegating to Spring-managed bean instances.
Convenient superclass for
TargetSourceCreator
implementations that require creating multiple instances of a prototype bean.
Abstract BeanFactory-based PointcutAdvisor that allows for any Advice
to be configured as reference to an Advice bean in a BeanFactory.
Abstract implementation of the
BindingResult
interface and
its super-interface
Errors
.
Abstract base class for a
MessageHandler
that broker messages to
registered subscribers.
Base class for message broker registration classes.
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.
Convenient base class for
ViewResolver
implementations.
Filter that determines if view should be cached.
Abstract base class to provide common methods for
implementing databinding-aware JSP tags for rendering an HTML '
input
'
element with a '
type
' of '
checkbox
' or '
radio
'.
Abstract class for all code-generating CGLIB utilities.
Type filter that exposes a
ClassMetadata
object
to subclasses, for class testing purposes.
Abstract base for
ClientHttpRequest
that makes sure that headers
and body are not written multiple times.
Base class for
ClientHttpRequest
implementations.
Abstract base class for
ClientHttpRequestFactory
implementations
that decorate another request factory.
Deprecated.
as of 6.0, with no direct replacement; scheduled for removal in 6.2
Base class for SockJS client implementations of
WebSocketSession
.
Abstract base class for
DataFieldMaxValueIncrementer
implementations that use
a column in a custom sequence table.
Base implementation of
ComponentDefinition
that provides a basic implementation of
AbstractComponentDefinition.getDescription()
which delegates to
ComponentDefinition.getName()
.
Base class for MBeanInfoAssemblers that support configurable
JMX notification behavior.
Abstract application context loader that provides a basis for all concrete
implementations of the
ContextLoader
SPI.
Convenient base class for
WebApplicationInitializer
implementations
that register a
ContextLoaderListener
in the servlet context.
Convenient superclass for controller implementations, using the Template Method
design pattern.
A base abstract class to resolve method arguments annotated with
@CookieValue
.
Base tag for all data-binding aware JSP form tags.
Abstract base class for
Decoder
implementations that can decode
a
DataBuffer
directly to the target element type.
Base implementation of
DataFieldMaxValueIncrementer
that delegates
to a single
AbstractDataFieldMaxValueIncrementer.getNextKey()
template method that returns a
long
.
Abstract base class for Spring's
DataSource
implementations, taking care of the padding.
AbstractDecoder
<
T
>
Abstract base class for
Decoder
implementations.
AbstractDelegatingSmartContextLoader
serves as an abstract base class
for implementations of the
SmartContextLoader
SPI that delegate to a
set of
candidate
SmartContextLoaders (i.e., one that supports XML
configuration files or Groovy scripts and one that supports annotated classes)
to determine which context loader is appropriate for a given test class's
configuration.
An extension of
AbstractMessagingTemplate
that adds operations for sending
messages to a resolvable destination name.
Abstract implementation of the
HandlerMapping
interface, detecting URL mappings for handler beans through introspection of all
defined beans in the application context.
Abstract base class for
TestExecutionListener
implementations that
provide support for marking the
ApplicationContext
associated with
a test as
dirty
for both test classes and test methods annotated
with the
@DirtiesContext
annotation.
Base class for
WebApplicationInitializer
implementations that register a
DispatcherServlet
in the servlet context.
Abstract base class for JDBC
DataSource
implementations
that operate on a JDBC
Driver
.
AbstractEncoder
<
T
>
Abstract base class for
Encoder
implementations.
Base class for a return value handler that encodes return values to
Flux<DataBuffer>
through the configured
Encoder
s.
Abstract
FactoryBean
that creates
a local JPA
EntityManagerFactory
instance within
a Spring application context.
Abstract base class for
Environment
implementations.
Abstract implementation of the
Errors
interface.
Cache exception handling method mappings and provide options to look up a method
that should handle an exception.
Abstract superclass for expression pointcuts,
offering location and expression properties.
AbstractFactoryBean
<
T
>
Simple template superclass for
FactoryBean
implementations that
creates a singleton or a prototype object, depending on a flag.
Abstract implementation of
CacheOperation
that caches attributes
for methods and implements a fallback policy: 1.
Abstract implementation of
JCacheOperationSource
that caches attributes
for methods and implements a fallback policy: 1.
Base class for
SQLExceptionTranslator
implementations that allow for
fallback to some other
SQLExceptionTranslator
.
Abstract implementation of
TransactionAttributeSource
that caches
attributes for methods and implements a fallback policy: 1.
AbstractFeedView
<
T
extends com.rometools.rome.feed.WireFeed>
Abstract base class for Atom and RSS Feed views, using the
ROME
package.
Abstract base class for filename suffix based
VersionStrategy
implementations, e.g.
Abstract base class for resources which resolve URLs into File references,
such as
UrlResource
or
ClassPathResource
.
A base class for
FlashMapManager
implementations.
Base class for all JSP form tags.
Abstract, generic extension of
AbstractContextLoader
that loads a
GenericApplicationContext
.
Abstract base class for most
GenericHttpMessageConverter
implementations.
Abstract generic
PointcutAdvisor
that allows for any
Advice
to be configured.
Abstract, generic extension of
AbstractContextLoader
that loads a
GenericWebApplicationContext
.
Abstract base class for
HandlerExceptionResolver
implementations.
Abstract base class for
HandlerMapping
implementations.
Abstract base class for
HandlerMapping
implementations.
Abstract base class for
HandlerAdapter
implementations that support
handlers of type
HandlerMethod
.
Abstract base class for
HandlerExceptionResolver
implementations that support handling exceptions from handlers of type
HandlerMethod
.
Abstract base class for
HandlerMapping
implementations that define
a mapping between a request and a
HandlerMethod
.
Abstract base class for
HandlerMapping
implementations that define
a mapping between a request and a
HandlerMethod
.
A base class for
HandshakeHandler
implementations, independent of the Servlet API.
A base
HeaderMapper
implementation.
Convenient superclass for many html tags that render content using the databinding
features of the
AbstractHtmlElementTag
.
Base class for databinding-aware JSP tags that render HTML element.
Base class for databinding-aware JSP tags that render HTML form input element.
Abstract base class for most
HttpMessageConverter
implementations.
Base class for HTTP transport handlers that receive messages via HTTP POST.
Base class for HTTP transport handlers that push messages to connected clients.
An abstract base class for use with HTTP transport SockJS sessions.
Abstract base class for
DataFieldMaxValueIncrementer
implementations
which are based on identity columns in a sequence-like table.
Base implementation for
BeanDefinitionDecorators
wishing to add an
interceptor
to the resulting bean.
Abstract implementation of the
InterruptibleBatchPreparedStatementSetter
interface, combining the check for available values and setting of those
into a single callback method
AbstractInterruptibleBatchPreparedStatementSetter.setValuesIfAvailable(java.sql.PreparedStatement, int)
.
Abstract base class for Jackson 2.x decoding, leveraging non-blocking parsing.
Base class providing support methods for Jackson 2.x encoding.
Abstract base class for Jackson based and content type independent
HttpMessageConverter
implementations.
Abstract base class for Jackson based and content type independent
AbstractView
implementations.
Abstract base class for
HttpMessageConverters
that use JAXB2.
Abstract JSR-107 specific
@Configuration
class providing common
structure for enabling JSR-107 annotation-driven cache management capability.
Abstract class to provide base functionality for easy stored procedure calls
based on configuration options and database meta-data.
Abstract class to provide base functionality for easy inserts
based on configuration options and database meta-data.
Base
JmsListenerContainerFactory
for Spring's base container implementation.
Base model for a JMS listener endpoint.
Common base class for all containers which need to implement listening
based on a JMS Connection (either shared or freshly obtained for each attempt).
Exception that indicates that the initial setup of this container's
shared JMS Connection failed.
Base class for all JMX metadata classes.
Abstract
JpaVendorAdapter
implementation that defines common properties,
to be translated into vendor-specific JPA properties by concrete subclasses.
Common base class for plain JSON converters, e.g.
Common base class for plain JSON converters, e.g.
Abstract base test class which integrates the
Spring TestContext
Framework
with explicit
ApplicationContext
testing support
in a
JUnit 4
environment.
AbstractKotlinSerializationHttpMessageConverter
<
T
extends kotlinx.serialization.SerialFormat>
Abstract base class for
HttpMessageConverter
implementations that
use Kotlin serialization.
TargetSource
implementation that will
lazily create a user-managed object.
Abstract base class for
Publisher
implementations that bridge between
event-listener read APIs and Reactive Streams.
Abstract base class for listener-based server responses.
Base class for
WebSocketSession
implementations that bridge between
event-listener WebSocket APIs (e.g.
An alternative to
AbstractListenerWriteProcessor
but instead writing
a
Publisher<Publisher<T>>
with flush boundaries enforces after
the completion of each nested Publisher.
Abstract base class for
Processor
implementations that bridge between
event-listener write APIs and Reactive Streams.
Abstract
PreparedStatementCallback
implementation that manages a
LobCreator
.
Abstract base class for
LobHandler
implementations.
Abstract ResultSetExtractor implementation that assumes streaming of LOB data.
Abstract base class for
LocaleContextResolver
implementations.
Abstract base class for
LocaleResolver
implementations.
Base class for
ContentNegotiationStrategy
implementations with the
steps to resolve a request to media types.
A convenient base class for
ResponseBodyAdvice
implementations
that customize the response before JSON serialization with
AbstractJackson2HttpMessageConverter
's concrete subclasses.
Abstract implementation of the
Marshaller
and
Unmarshaller
interface.
Abstract implementation of the
MBeanInfoAssembler
interface
that encapsulates the creation of a
ModelMBeanInfo
instance
but delegates the creation of metadata to subclasses.
Provides essential configuration for handling messages with simple messaging
protocols such as STOMP.
Abstract base class for
MessageChannel
implementations.
Base class for
MessageCondition's
that pre-declares abstract methods
AbstractMessageCondition.getContent()
and
AbstractMessageCondition.getToStringInfix()
in order to provide
implementations of
AbstractMessageCondition.equals(Object)
,
AbstractMessageCondition.hashCode()
, and
AbstractMessageCondition.toString()
.
Abstract base class for
SmartMessageConverter
implementations including
support for common properties and a partial implementation of the conversion methods,
mainly to check if the converter supports the conversion based on the payload class
and MIME type.
A base class for resolving method argument values by reading from the body of
a request with
HttpMessageConverters
.
Extends
AbstractMessageConverterMethodArgumentResolver
with the ability to handle method
return values by writing to the response with
HttpMessageConverters
.
Abstract base implementation of the JCA 1.7
MessageEndpointFactory
interface,
providing transaction management capabilities as well as ClassLoader
exposure for endpoint invocations.
Abstract base class for Spring message listener container implementations.
Abstract base class for argument resolvers that resolve method arguments
by reading the request body with an
HttpMessageReader
.
An extension of
AbstractMessageSendingTemplate
that adds support for
receive style operations as defined by
MessageReceivingOperations
.
Abstract base class for implementations of
MessageSendingOperations
.
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 base class for result handlers that handle return values by writing
to the response with
HttpMessageWriter
.
An extension of
AbstractMessageReceivingTemplate
that adds support for
request-reply style operations as defined by
MessageRequestReplyOperations
.
Abstract base class for HandlerMethod-based message handling.
Abstract base class for reactive HandlerMethod-based message handling.
Abstract implementation of
MockMvcBuilder
with common methods for
configuring filters, default request properties, global expectations and
global result actions.
Base class for monitoring interceptors, such as performance monitors.
Abstract base class to provide common methods for implementing
databinding-aware JSP tags for rendering
multiple
HTML '
input
' elements with a '
type
'
of '
checkbox
' or '
radio
'.
Abstract base implementation of the
MultipartHttpServletRequest
interface.
Abstract base class for resolving method arguments from a named value.
Base class for arguments that resolve to a named request value such as a
request header, path variable, cookie, and others.
Represents the information about a named value, including name, whether
it's required and a default value.
Info about a request value, typically extracted from a method parameter annotation.
Abstract base class to resolve method arguments from a named value, e.g.
Abstract base class to resolve method arguments from a named value, e.g.
Abstract base class for resolving method arguments from a named value.
Represents a named value declaration.
Represents a named value declaration.
Represents the information about a named value, including name, whether it's required and a default value.
An extension of
AbstractNamedValueArgumentResolver
for named value
resolvers that are synchronous and yet non-blocking.
A basic
ConfigurablePropertyAccessor
that provides the necessary
infrastructure for all typical use cases.
A handler for a specific property.
Holder class used to store property tokens.
Convenient base class for
ReactorNettyCodec
implementations that need
to work with NIO
ByteBuffers
.
Abstract formatter for Numbers,
providing a
AbstractNumberFormatter.getNumberFormat(java.util.Locale)
template method.
Abstract superclass for PDF views that operate on an existing
document with an AcroForm.
Abstract superclass for PDF views.
Abstract base class that implements Spring's standard transaction workflow,
serving as basis for concrete platform transaction managers like
JtaTransactionManager
.
Holder for suspended resources.
Abstract base class for
PointcutAdvisor
implementations.
Base class for listener container implementations which are based on polling.
Abstract base class for pooling
TargetSource
implementations which maintain a pool of target instances, acquiring and
releasing a target object from the pool for each method invocation.
Abstract base class for
VersionStrategy
implementations that insert
a prefix into the URL path, e.g.
Abstract implementation of the
PropertyAccessor
interface.
Abstract base class for
BindingResult
implementations that work with
Spring's
PropertyAccessor
mechanism.
Abstract base class for resolving properties against any underlying source.
Base class for dynamic
TargetSource
implementations
that create new prototype bean instances to support a pooling or
new-instance-per-invocation strategy.
Abstract base class that implements Spring's standard reactive transaction workflow,
serving as basis for concrete platform transaction managers.
Holder for suspended resources.
Base class for a
WebApplicationInitializer
that installs a Spring Reactive Web Application on a Servlet container.
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
TargetSource
implementation that
wraps a refreshable target object.
AbstractRefreshableApplicationContext
subclass which implements the
ConfigurableWebApplicationContext
interface for web environments.
Abstract base regular expression pointcut bean.
Abstract support class for RequestAttributes implementations,
offering a request completion mechanism for request-specific destruction
callbacks and for updating accessed session attributes.
Abstract
Scope
implementation that reads from a particular scope
in the current thread-bound
RequestAttributes
object.
A base class for
RequestCondition
types providing implementations of
AbstractRequestCondition.equals(Object)
,
AbstractRequestCondition.hashCode()
, and
AbstractRequestCondition.toString()
.
A base class for
RequestCondition
types providing implementations of
AbstractRequestCondition.equals(Object)
,
AbstractRequestCondition.hashCode()
, and
AbstractRequestCondition.toString()
.
Base class for
RequestExpectationManager
implementations responsible
for storing expectations and actual requests, and checking for unsatisfied
expectations at the end.
Helper class to manage a group of remaining expectations.
Base class for
Filter
s that perform logging operations before and after a request
is processed.
Convenience base class for
Resource
implementations,
pre-implementing typical behavior.
Abstract base class for
MessageSource
implementations based on
resource bundle conventions, such as
ResourceBundleMessageSource
and
ReloadableResourceBundleMessageSource
.
Base
ResourceResolver
providing consistent logging.
Base class for
ResourceResolver
implementations.
Abstract
ConnectionFactory
implementation that routes
AbstractRoutingConnectionFactory.create()
calls to one of various target
factories
based on a lookup key.
Abstract
DataSource
implementation that routes
AbstractRoutingDataSource.getConnection()
calls to one of various target DataSources based on a lookup key.
Abstract superclass for RSS Feed views, using the
ROME
package.
Abstract base class for
DataFieldMaxValueIncrementer
implementations that use
a database sequence.
Common base class for
ServerHttpRequest
implementations.
Base class for
ServerHttpResponse
implementations.
Abstract base class for FactoryBeans operating on the
JDK 1.6
ServiceLoader
facility.
Convenient base class for when there exists a one-to-one mapping
between attribute names on the element that is to be parsed and
the property names on the
Class
being configured.
Base class for those
BeanDefinitionParser
implementations that
need to parse and define just a
single
BeanDefinition
.
Abstract base class to provide common methods for implementing databinding-aware
JSP tags for rendering a
single
HTML '
input
' element with a
'
type
' of '
checkbox
' or '
radio
'.
Convenient superclass for
FactoryBean
types that produce singleton-scoped
proxy objects.
Abstract base class for
Encoder
classes that can only deal with a single value.
A base class for SockJS message codec that provides an implementation of
AbstractSockJsMessageCodec.encode(String[])
.
An abstract base class for
SockJsService
implementations that provides SockJS
path resolution and handling of static SockJS requests (e.g.
An abstract base class for SockJS sessions implementing
SockJsSession
.
Abstract base class for
SqlParameterSource
implementations.
Abstract implementation of the SqlTypeValue interface, for convenient
creation of type values that are supposed to be passed into the
PreparedStatement.setObject
method.
A base class for
RequestUpgradeStrategy
implementations that build
on the standard WebSocket API for Java (JSR-356).
A base class for events for a message received from a WebSocket client and
parsed into a higher-level sub-protocol (e.g.
Abstract base class for
SubscribableChannel
implementations.
Abstract base class for implementations of
SubscriptionRegistry
that
looks up information in messages but delegates to abstract methods for the
actual storage and retrieval.
Adapter base class for template-based view technologies such as FreeMarker,
with the ability to use request and session attributes in their model and
the option to expose helper objects for Spring's FreeMarker macro library.
Abstract base class for template view resolvers, in particular for FreeMarker views.
Abstract implementation of the
TestContextBootstrapper
interface which
provides most of the behavior required by a bootstrapper.
Abstract
ordered
implementation of the
TestExecutionListener
API.
Abstract base test class which integrates the
Spring TestContext Framework
with explicit
ApplicationContext
testing support in a
TestNG
environment.
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
Base
MethodInterceptor
implementation for tracing.
Abstract
transactional
extension of
AbstractJUnit4SpringContextTests
which adds convenience functionality
for JDBC access.
Abstract
transactional
extension of
AbstractTestNGSpringContextTests
which adds convenience functionality
for JDBC access.
Abstract base
@Configuration
class providing common structure for enabling
Spring's annotation-driven transaction management capability.
Abstract base implementation of the
TransactionStatus
interface.
Base class for CacheManager implementations that want to support built-in
awareness of Spring-managed transactions.
Common base class for
TransportHandler
implementations.
Type filter that is aware of traversing over hierarchy.
Base
TypeReference
implementation that ensures consistent behaviour
for
equals()
,
hashCode()
, and
toString()
based on
the
canonical name
.
A base class for
RequestUpgradeStrategy
implementations on top of
JSR-356 based servers which include Tyrus as their WebSocket engine.
Abstract base class for URL-based views.
Abstract base class for URL-based views.
Abstract base class for URL-mapped
HandlerMapping
implementations.
Abstract base class for URL-mapped
HandlerMapping
implementations.
Abstract base class for
Controllers
that return a view name
based on the request URL.
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.
Abstract base class for
VersionStrategy
implementations.
File name-based
VersionPathStrategy
,
A prefix-based
VersionPathStrategy
,
Base class for
View
implementations.
Abstract base class for
View
implementations.
An abstract base class adapting a
WebArgumentResolver
to the
HandlerMethodArgumentResolver
contract.
Abstract base class for
WebSocketClient
implementations.
A convenient base class for
WebSocketHandler
implementation with empty methods.
Base class for
WebSocketHandlerRegistrations
that gathers all the configuration
options but allows subclasses to put together the actual HTTP request mappings.
A message that can be handled or sent on a WebSocket connection.
Convenient base class for
WebSocketSession
implementations that
holds common fields and exposes accessors.
An abstract base class for implementations of
WebSocketSession
.
AbstractWireFeedHttpMessageConverter
<
T
extends com.rometools.rome.feed.WireFeed>
Abstract base class for Atom and RSS Feed message converters, using the
ROME tools
project.
Abstract base class for XHR transport implementations to extend.
Convenient superclass for Excel document views in traditional XLS format.
Convenient superclass for Excel document views in the Office 2007 XLSX format,
using POI's streaming variant.
Convenient superclass for Excel document views in the Office 2007 XLSX format
(as supported by POI-OOXML).
Convenient base class for
ApplicationContext
implementations, drawing configuration from XML documents containing bean definitions
understood by an
XmlBeanDefinitionReader
.
Abstract base class for
HttpMessageConverters
that convert from/to XML.
LocaleContextResolver
implementation that looks for a match between
locales in the
Accept-Language
header and a list of configured
supported locales.
LocaleResolver
implementation that looks for a match between locales
in the
Accept-Language
header and a list of configured supported
locales.
Determine the access control of a
Member
or type signature.
An AccessException is thrown by an accessor if it has an unexpected problem.
ActiveProfiles
is a class-level annotation that is used to declare
which
active bean definition profiles
should be used when loading
an
ApplicationContext
for test classes.
Strategy interface for programmatically resolving which
active bean
definition profiles
should be used when loading an
ApplicationContext
for a test class.
Tag interface for Advice.
ParseState
entry representing an advice element.
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).
Interface to be implemented by classes that hold the configuration
of a factory of AOP proxies.
Base class for AOP proxy configuration managers.
Listener to be registered on
ProxyCreatorSupport
objects
Allows for receiving callbacks on activation and change of advice.
Base interface holding AOP
advice
(action to take at a joinpoint)
and a filter determining the applicability of the advice (such as
a pointcut).
Interface allowing extension to the Spring AOP framework to allow
handling of new Advisors and Advice types.
BeanPostProcessor that registers
AdvisorAdapter
beans in the BeanFactory with
an
AdvisorAdapterRegistry
(by default the
GlobalAdvisorAdapterRegistry
).
Interface for registries of Advisor adapters.
Factory interface for advisor chains.
ComponentDefinition
that bridges the gap between the advisor bean definition configured
by the
<aop:advisor>
tag and the component definition
infrastructure.
ParseState
entry representing an advisor.
Common marker interface for after advice,
such as
AfterReturningAdvice
and
ThrowsAdvice
.
After returning advice is invoked only on normal method return, not if an
exception is thrown.
Interceptor to wrap an
AfterReturningAdvice
.
@EventListener
annotation used to consume an
AfterTestClassEvent
published by the
EventPublishingTestExecutionListener
.
TestContextEvent
published by the
EventPublishingTestExecutionListener
when
TestExecutionListener.afterTestClass(TestContext)
is invoked.
@EventListener
annotation used to consume an
AfterTestExecutionEvent
published by the
EventPublishingTestExecutionListener
.
TestContextEvent
published by the
EventPublishingTestExecutionListener
when
TestExecutionListener.afterTestExecution(TestContext)
is invoked.
@EventListener
annotation used to consume an
AfterTestMethodEvent
published by the
EventPublishingTestExecutionListener
.
TestContextEvent
published by the
EventPublishingTestExecutionListener
when
TestExecutionListener.afterTestMethod(TestContext)
is invoked.
Test annotation which indicates that the annotated
void
method
should be executed
after
a transaction is ended for a test method
configured to run within a transaction via Spring's
@Transactional
annotation.
Representation of an alias that has been registered during the parsing process.
@AliasFor
is an annotation that is used to declare aliases for
annotation attributes.
Common interface for managing aliases.
Extension of
FormHttpMessageConverter
,
adding support for XML and JSON-based parts.
An
IdGenerator
that uses
SecureRandom
for the initial seed and
Random
thereafter, instead of calling
UUID.randomUUID()
every
time as
JdkIdGenerator
does.
Extended
BeanDefinition
interface that exposes
AnnotationMetadata
about its bean class - without requiring the class to be loaded yet.
Convenient adapter for programmatic registration of bean classes.
Represent an
AnnotatedElement
on a particular
Class
and is suitable as a key.
General utility methods for finding annotations, meta-annotations, and
repeatable annotations on
AnnotatedElements
.
WebSocket
connection manager
that connects
to the server via
WebSocketContainer
and handles the session with an
@ClientEndpoint
endpoint.
Extension of the
GenericBeanDefinition
class, adding support for annotation metadata exposed through the
AnnotatedBeanDefinition
interface.
Defines access to the annotations of a specific type (
class
or
method
), in a form that does not necessarily require the
class-loading.
Specialization of
AsyncExecutionInterceptor
that delegates method execution to
an
Executor
based on the
Async
annotation.
LinkedHashMap
subclass representing annotation attribute
key-value
pairs as read by
AnnotationUtils
,
AnnotatedElementUtils
, and Spring's reflection- and ASM-based
AnnotationMetadata
implementations.
AspectJAwareAdvisorAutoProxyCreator
subclass that processes all AspectJ
annotation aspects in the current application context, as well as Spring Advisors.
AnnotationAwareOrderComparator
is an extension of
OrderComparator
that supports Spring's
Ordered
interface as well as the
@Order
and
@Priority
annotations, with an order value provided by an
Ordered
instance overriding a statically defined annotation value (if any).
BeanNameGenerator
implementation for bean classes annotated with the
@Component
annotation or
with another annotation that is itself annotated with
@Component
as a
meta-annotation.
BeanWiringInfoResolver
that
uses the Configurable annotation to identify which classes need autowiring.
Implementation of the
CacheOperationSource
interface for working with caching metadata in annotation format.
Callback interface providing
CacheOperation
instance(s) based on
a given
CacheAnnotationParser
.
Simple ClassFilter that looks for a specific annotation being present on a class.
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.
Concrete implementation of
AbstractGenericContextLoader
that loads
bean definitions from component classes.
Utility methods for
SmartContextLoaders
that deal
with component classes (e.g.,
@Configuration
classes).
Common interface for annotation config application contexts,
defining
AnnotationConfigRegistry.register(java.lang.Class<?>...)
and
AnnotationConfigRegistry.scan(java.lang.String...)
methods.
Thrown by
AnnotationUtils
and
synthesized annotations
if an annotation is improperly configured.
Utility class that allows for convenient registration of common
BeanPostProcessor
and
BeanFactoryPostProcessor
definitions for annotation-based configuration.
WebApplicationContext
implementation which accepts
component classes
as input — in particular
@Configuration
classes, but also plain
@Component
classes as well as JSR-330 compliant classes using
jakarta.inject
annotations.
Concrete implementation of
AbstractGenericWebContextLoader
that loads
bean definitions from annotated classes.
Parser for the 'annotation-driven' element of the 'task' namespace.
A subclass of
AbstractExceptionHandlerMethodResolver
that looks for
MessageExceptionHandler
-annotated methods in a given class.
Callback interface that can be used to filter specific annotation types.
A factory that creates formatters to format values of fields annotated with a particular
Annotation
.
Implementation of the
JCacheOperationSource
interface that reads
the JSR-107
CacheResult
,
CachePut
,
CacheRemove
and
CacheRemoveAll
annotations.
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.
Interface that defines abstract access to the annotations of a specific
class, in a form that does not require that class to be loaded yet.
Simple
MethodMatcher
that looks for
a specific annotation being present on a method (checking both the method on the
invoked interface, if any, and the corresponding method on the target class).
A
ScopeMetadataResolver
implementation that by default checks for
the presence of Spring's
@Scope
annotation on the bean class.
Implementation of the
TransactionAttributeSource
interface for working with transaction metadata in JDK 1.5+ annotation format.
A simple
TypeFilter
which matches classes with a given annotation,
checking inherited annotations as well.
General utility methods for working with annotations, handling meta-annotations,
bridge methods (which the compiler generates for generic declarations) as well
as super methods (for optional
annotation inheritance
).
A visitor to visit a Java annotation.
PathMatcher
implementation for Ant-style path patterns.
Tests whether a string matches against a pattern via a
Pattern
.
The default
Comparator
implementation returned by
AntPathMatcher.getPatternComparator(String)
.
Exception that gets thrown on illegal AOP configuration arguments.
Utility class for handling registration of AOP auto-proxy creators.
Class containing static methods used to obtain information about the current AOP invocation.
Marker interface that indicates a bean that is part of Spring's
AOP infrastructure.
Exception that gets thrown when an AOP invocation failed
because of misconfiguration or unexpected runtime issues.
NamespaceHandler
for the
aop
namespace.
Utility class for handling registration of auto-proxy creators used internally
by the '
aop
' namespace tags.
Delegate interface for a configured AOP proxy, allowing for the creation
of actual proxy objects.
Interface to be implemented by factories that are able to create
AOP proxies based on
AdvisedSupport
configuration objects.
Utility methods for AOP proxy factories.
AopTestUtils
is a collection of AOP-related utility methods for
use in unit and integration testing scenarios.
Utility methods for AOP support code.
Specialized
ApplicationContextInitializer
used to initialize a
ConfigurableApplicationContext
using artifacts that were generated
ahead-of-time.
Strategy interface for loading an
ApplicationContext
for build-time
AOT processing
as well as run-time
AOT execution
for an integration test
managed by the Spring TestContext Framework.
Utility for determining if AOT-processed optimizations must be used rather
than the regular runtime.
AotServices
<
T
>
A collection of AOT services that can be
loaded
from
a
SpringFactoriesLoader
or obtained from a
ListableBeanFactory
.
Loader class used to actually load the services.
Sources from which services were obtained.
Holder for metadata specific to ahead-of-time (AOT) support in the
Spring
TestContext Framework
.
AotTestContextInitializers
provides mappings from test classes to
AOT-optimized context initializers.
AotTestExecutionListener
is an extension of the
TestExecutionListener
SPI that allows a listener to optionally provide ahead-of-time (AOT) support.
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.
Strategy for components that process failures related to application contexts
within the
Spring TestContext Framework
.
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.
ApplicationEvents
encapsulates all
application events
that were fired during the execution of a single test method.
Holder class to expose the application events published during the execution
of a test in the form of a thread-bound
ApplicationEvents
object.
TestExecutionListener
which provides support for
ApplicationEvents
.
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.
@ApplicationScope
is a specialization of
@Scope
for a
component whose lifecycle is bound to the current web application.
Instruments the application startup phase using
steps
.
Interface to be implemented by any object that wishes to be notified
of the
ApplicationStartup
that it runs with.
Allows implementing tag to utilize nested
spring:argument
tags.
Subclass of
MethodInvoker
that tries to convert the given
arguments for the actual target method via a
TypeConverter
.
Simple adapter for
PreparedStatementSetter
that applies a given array of arguments.
Assist with configuration for handler method argument resolvers.
Helps to configure resolvers for Controller method arguments.
The
<argument>
tag is based on the JSTL
fmt:param
tag.
Simple adapter for
PreparedStatementSetter
that applies
given arrays of arguments and JDBC argument types.
ComponentDefinition
that holds an aspect definition, including its nested pointcuts.
ParseState
entry representing an aspect.
Superclass for all AOP infrastructure exceptions.
Interface implemented to provide an instance of an AspectJ aspect.
ParameterNameDiscoverer
implementation that tries to deduce parameter names
for an advice method from the pointcut expression, returning, and throwing clauses.
Thrown in response to an ambiguous binding being detected when
trying to resolve a method's parameter names.
Interface for factories that can create Spring AOP Advisors from classes
annotated with AspectJ annotation syntax.
Spring AOP advice wrapping an AspectJ after advice method.
Spring AOP advice wrapping an AspectJ after-returning advice method.
Spring AOP advice wrapping an AspectJ after-throwing advice method.
Utility methods for dealing with AspectJ advisors.
Spring AOP around advice (MethodInterceptor) that wraps
an AspectJ advice method.
@Configuration
class that registers the Spring infrastructure beans necessary
to enable AspectJ-based asynchronous method execution.
AbstractAdvisorAutoProxyCreator
subclass that exposes AspectJ's invocation context and understands AspectJ's rules
for advice precedence when multiple pieces of advice come from the same aspect.
@Configuration
class that registers the Spring infrastructure beans
necessary to enable AspectJ-based annotation-driven cache management.
Spring
Pointcut
implementation
that uses the AspectJ weaver to evaluate a pointcut expression.
Spring AOP Advisor that can be used for any AspectJ pointcut expression.
@Configuration
class that registers the Spring infrastructure beans necessary
to enable AspectJ-based annotation-driven cache management for standard JSR-107
annotations.
@Configuration
class that registers the Spring infrastructure beans necessary
to enable AspectJ-based annotation-driven transaction management for the JTA 1.2
Transactional
annotation in addition to Spring's own
Transactional
annotation.
Spring AOP advice that wraps an AspectJ before method.
AspectJPointcutAdvisor that adapts an
AbstractAspectJAdvice
to the
PointcutAdvisor
interface.
Interface to be implemented by types that can supply the information
needed to sort advice/advisors by AspectJ's precedence rules.
AspectJ-based proxy factory, allowing for programmatic building
of proxies which include AspectJ aspects (code style as well
annotation style).
Utility methods for working with AspectJ proxies.
@Configuration
class that registers the Spring infrastructure beans necessary
to enable AspectJ-based annotation-driven transaction management for Spring's own
Transactional
annotation.
Type filter that uses AspectJ type pattern for matching.
Implementation of AspectJ's
IMessageHandler
interface that
routes AspectJ weaving messages through the same logging system as the
regular Spring messages.
Post-processor that registers AspectJ's
ClassPreProcessorAgentAdapter
with the Spring application context's default
LoadTimeWeaver
.
Metadata for an AspectJ aspect class, with an additional Spring AOP pointcut
for the per clause.
Assertion utility class that assists in validating arguments.
Test assertions that are independent of any third-party assertion library.
Represents assignment.
A simple filter which matches classes that are assignable to a given type.
Utilities methods for use in the Ast classes.
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.
as of 6.0 in favor of implementing
AsyncConfigurer
directly
Base class for asynchronous method execution aspects, such as
org.springframework.scheduling.annotation.AnnotationAsyncExecutionInterceptor
or
org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect
.
AOP Alliance
MethodInterceptor
that processes method invocations
asynchronously, using a given
AsyncTaskExecutor
.
Extends
HandlerInterceptor
with a callback method invoked after the
start of asynchronous request handling.
An extension of
HandlerMethodReturnValueHandler
for handling async,
Future-like return value types that support success and error callbacks.
A return value handler that supports async types.
Deprecated.
as of 6.0, in favor of
AsyncTaskExecutor.submitCompletable(Runnable)
and
AsyncTaskExecutor.submitCompletable(Callable)
Exception to be thrown when an async request times out.
AsyncResult
<
V
>
Deprecated.
as of 6.0, in favor of
CompletableFuture
Asynchronous subtype of
ServerResponse
that exposes the future
response.
Helps with configuring options for asynchronous request processing.
Extended interface for asynchronous
TaskExecutor
implementations,
offering support for
Callable
.
Handles return values of type
WebAsyncTask
.
A strategy for handling uncaught exceptions thrown from asynchronous methods.
Extends
NativeWebRequest
with methods for asynchronous request processing.
Extends
WebRequestInterceptor
with a callback method invoked during
asynchronous request handling.
Implementation of
HttpMessageConverter
that can read and write Atom feeds.
A non standard class, field, method or Code attribute, as defined in the Java Virtual Machine
Specification (JVMS).
Interface defining a generic contract for attaching and accessing metadata
to/from arbitrary objects.
Support class for
AttributeAccessors
, providing
a base implementation of all methods.
Extends the
MBeanInfoAssembler
to add autodetection logic.
AutoPopulatingList
<
E
>
Simple
List
wrapper class that allows for elements to be
automatically populated as they are requested.
Factory interface for creating elements for an index-based access
data structure such as a
List
.
Exception to be thrown from ElementFactory.
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.
Utilities for auto-proxy aware components.
Enumeration determining autowiring status: that is, whether a bean should
have its dependencies automatically injected by the Spring container using
setter injection.
Qualifier for resolving autowire candidates.
Strategy interface for determining whether a specific bean definition
qualifies as an autowire candidate for a specific dependency.
Extension of the
BeanFactory
interface to be implemented by bean factories that are capable of
autowiring, provided that they want to expose this functionality for
existing bean instances.
Marks a constructor, field, setter method, or config method as to be autowired by
Spring's dependency injection facilities.
BeanPostProcessor
implementation that autowires annotated fields, setter methods, and arbitrary
config methods.
Resolved arguments to be autowired.
Code generator to apply
AutowiredArguments
.
Resolver used to support the autowiring of fields.
Resolver used to support the autowiring of methods.
Simple marker class for an individually autowired property value, to be added
to
BeanDefinition.getPropertyValues()
for a specific bean property.
A marker superinterface indicating that a bean is eligible to be notified by the
Spring container of a particular framework object through a callback-style method.
Provide a
BackOffExecution
that indicates the rate at which
an operation should be retried.
Represent a particular back-off execution.
Exception thrown when SQL specified is invalid.
Exception thrown when SQL specified is invalid.
Deprecated, for removal: This API element is subject to removal in a future version.
as of Spring Framework 6.0.5 in favor of
Base64
; scheduled
for removal in 6.2
ClientHttpRequestInterceptor
to apply a given HTTP Basic Authentication
username/password pair, unless a custom
Authorization
header has
already been set.
The base interface that all cache operations must implement.
Batch update callback interface used by the
JdbcTemplate
class.
SqlUpdate subclass that performs batch update operations.
Indicates that a method produces a bean to be managed by the Spring container.
Callback that allows a bean to be aware of the bean
class loader
; that is, the class loader used by the
present bean factory to load bean classes.
ComponentDefinition based on a standard BeanDefinition, exposing the given bean
definition as well as inner bean definitions and bean references for the given bean.
Convenient base class for bean configurers that can perform Dependency Injection
on objects (however they may be created).
Instantiates a target handler through a Spring
BeanFactory
and also provides
an equivalent destroy method.
Exception thrown when a BeanFactory encounters an error when
attempting to create a bean from a bean definition.
Exception thrown in case of a bean being requested despite
bean creation currently not being allowed (for example, during
the shutdown phase of a bean factory).
Exception thrown in case of a reference to a bean that's currently in creation.
A BeanDefinition describes a bean instance, which has property values,
constructor argument values, and further information supplied by
concrete implementations.
Programmatic means of constructing
BeanDefinitions
using the builder pattern.
Callback for customizing a given bean definition.
Interface used by the
DefaultBeanDefinitionDocumentReader
to handle custom, nested (directly under a
<bean>
) tags.
A simple holder for
BeanDefinition
property defaults.
SPI for parsing an XML document that contains Spring bean definitions.
Holder for a BeanDefinition with name and aliases.
Subclass of
BeanDefinitionStoreException
indicating an invalid override
attempt: typically registering a new definition for the same bean name while
DefaultListableBeanFactory.isAllowBeanDefinitionOverriding()
is
false
.
Interface used by the
DefaultBeanDefinitionDocumentReader
to handle custom,
top-level (directly under
<beans/>
) tags.
Stateful delegate class used to parse XML bean definitions.
Exception thrown when a bean definition reader encounters an error
during the parsing process.
Simple interface for bean definition readers that specifies load methods with
Resource
and
String
location parameters.
Utility methods that are useful for bean definition reader implementations.
Interface for registries that hold bean definitions, for example RootBeanDefinition
and ChildBeanDefinition instances.
Extension to the standard
BeanFactoryPostProcessor
SPI, allowing for
the registration of further bean definitions
before
regular
BeanFactoryPostProcessor detection kicks in.
Exception thrown when a BeanFactory encounters an invalid bean definition:
Exception thrown when the validation of a bean definition failed.
Helper class for use in bean factory implementations,
resolving values contained in bean definition objects
into the actual values applied to the target bean instance.
Visitor class for traversing
BeanDefinition
objects, in particular
the property values and constructor argument values contained in them,
resolving bean metadata values.
ParseState
entry representing a bean definition.
Context object for evaluating an expression within a bean definition.
EL property accessor that knows how to traverse the beans and contextual objects
of a Spring
BeanExpressionContext
.
Exception that indicates an expression evaluation attempt having failed.
Strategy interface for resolving a value by evaluating it as an expression,
if applicable.
The root interface for accessing a Spring bean container.
EL property accessor that knows how to traverse the beans of a
Spring
BeanFactory
.
Helper for retrieving standard Spring Advisors from a BeanFactory,
for use with auto-proxying.
Convenience methods performing bean lookups related to Spring-specific annotations,
for example Spring's
@Qualifier
annotation.
AspectInstanceFactory
implementation
backed by a Spring
BeanFactory
.
Helper for retrieving @AspectJ beans from a BeanFactory and building
Spring Advisors based on them, for use with auto-proxying.
Interface to be implemented by beans that wish to be aware of their
owning
BeanFactory
.
Advisor driven by a
CacheOperationSource
, used to include a
cache advice bean for methods that are cacheable.
ConnectionFactoryLookup
implementation based on a
Spring
BeanFactory
.
DataSourceLookup
implementation based on a Spring
BeanFactory
.
DestinationResolver
implementation based on a Spring
BeanFactory
.
AOT contribution from a
BeanFactoryInitializationAotProcessor
used to
initialize a bean factory.
AOT processor that makes bean factory initialization contributions by
processing
ConfigurableListableBeanFactory
instances.
Interface that can be used to configure the code that will be generated to
perform bean factory initialization.
Advisor driven by a
JCacheOperationSource
, used to include a
cache advice bean for methods that are cacheable.
An implementation of
DestinationResolver
that interprets a destination
name as the bean name of a
MessageChannel
and looks up the bean in
the configured
BeanFactory
.
Factory hook that allows for custom modification of an application context's
bean definitions, adapting the bean property values of the context's underlying
bean factory.
Refreshable TargetSource that fetches fresh target beans from a BeanFactory.
EL bean resolver that operates against a Spring
BeanFactory
.
Advisor driven by a
TransactionAttributeSource
, used to include
a transaction advice bean for methods that are transactional.
Convenience methods operating on bean factories, in particular
on the
ListableBeanFactory
interface.
Strategy interface for creating
BeanInfo
instances for Spring beans.
Exception that a bean implementation is suggested to throw if its own
factory-aware initialization code fails.
Specialized
InstanceSupplier
that provides the factory
Method
used to instantiate the underlying bean instance, if any.
Exception thrown when instantiation of a bean failed.
Exception thrown when a bean instance has been requested for
a bean definition which has been marked as abstract.
Exception thrown when a bean is not a factory, but a user tries to get
at the factory for the given bean name.
A
Map
-based view of a JavaBean.
Holder for a key-value style attribute that is part of a bean definition.
Extension of
AttributeAccessorSupport
,
holding attributes as
BeanMetadataAttribute
objects in order
to keep track of the definition source.
Interface to be implemented by bean metadata elements
that carry a configuration source object.
Auto proxy creator that identifies beans to proxy via a list of names.
Interface to be implemented by beans that want to be aware of their
bean name in a bean factory.
Strategy interface for generating bean names for bean definitions.
Implementation of the
HandlerMapping
interface that maps from URLs to beans with names that start with a slash ("/"),
similar to how Struts maps URLs to action names.
A simple implementation of
ViewResolver
that interprets a view name as a bean name in the current application context,
Thrown when a bean doesn't match the expected type.
Factory hook that allows for custom modification of new bean instances —
for example, checking for marker interfaces or wrapping beans with proxies.
Default implementation of the
Errors
and
BindingResult
interfaces, for the registration and evaluation of binding errors on
JavaBean objects.
RowMapper
implementation that converts a row into a new instance
of the specified mapped target class.
SqlParameterSource
implementation that obtains parameter values
from bean properties of a given JavaBean object.
Interface that exposes a reference to a bean name in an abstract fashion.
Represents a bean reference to a type, for example
@foo
or
@'foo.bar'
.
AOT contribution from a
BeanRegistrationAotProcessor
used to register
a single bean definition.
AOT processor that makes bean registration contributions by processing
RegisteredBean
instances.
Interface that can be used to configure the code that will be generated to
perform registration of a single bean.
Generate the various fragments of code needed to register a bean.
A
BeanRegistrationCodeFragments
decorator implementation.
Filter that can be used to exclude AOT processing of a
RegisteredBean
.
Interface that can be used to configure the code that will be generated to
register beans.
A bean resolver can be registered with the evaluation context and will kick in
for bean references:
@myBeanName
and
&myBeanName
expressions.
EntityResolver
implementation for the Spring beans DTD,
to load the DTD from the Spring class path (or JAR file).
Abstract superclass for all exceptions thrown in the beans package
and subpackages.
Static convenience methods for JavaBeans: for instantiating beans,
checking bean property types, copying bean properties, etc.
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).
Holder for bean wiring metadata information about a particular class.
Strategy interface to be implemented by objects than can resolve bean name
information, given a newly instantiated bean object.
The central interface of Spring's low-level JavaBeans infrastructure.
Default
BeanWrapper
implementation that should be sufficient
for all typical use cases.
Common marker interface for before advice, such as
MethodBeforeAdvice
.
@EventListener
annotation used to consume a
BeforeTestClassEvent
published by the
EventPublishingTestExecutionListener
.
TestContextEvent
published by the
EventPublishingTestExecutionListener
when
TestExecutionListener.beforeTestClass(TestContext)
is invoked.
@EventListener
annotation used to consume a
BeforeTestExecution
published by the
EventPublishingTestExecutionListener
.
TestContextEvent
published by the
EventPublishingTestExecutionListener
when
TestExecutionListener.beforeTestExecution(TestContext)
is invoked.
@EventListener
annotation used to consume a
BeforeTestMethodEvent
published by the
EventPublishingTestExecutionListener
.
TestContextEvent
published by the
EventPublishingTestExecutionListener
when
TestExecutionListener.beforeTestMethod(TestContext)
is invoked.
Test annotation which indicates that the annotated
void
method
should be executed
before
a transaction is started for a test method
configured to run within a transaction via Spring's
@Transactional
annotation.
A binary WebSocket message.
A convenient base class for
WebSocketHandler
implementations
that process binary messages only.
This
<hasBindErrors>
tag provides an
Errors
instance in case of
bind errors.
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.
Context to assist with binding request data onto Objects and provide access
to a shared
Model
with controller-specific attributes.
Strategy for processing
DataBinder
's missing field errors,
and for translating a
PropertyAccessException
to a
FieldError
.
Register the necessary reflection hints so that the specified type can be
bound at runtime.
General interface that represents binding results.
Convenience methods for looking up BindingResults in a model Map.
Base class for value objects representing a value or a
NULL
binding.
A bind marker represents a single bindable parameter within a query.
Bind markers represent placeholders in SQL queries for substitution
for an actual parameter.
This class creates new
BindMarkers
instances to bind
parameter to a specific
Statement
.
Resolves a
BindMarkersFactory
from a
ConnectionFactory
using
BindMarkersFactoryResolver.BindMarkerFactoryProvider
.
SPI to extend Spring's default R2DBC BindMarkersFactory discovery mechanism.
Exception thrown when
BindMarkersFactoryResolver
cannot resolve a
BindMarkersFactory
.
Simple adapter to expose the bind status of a field or object.
Simple adapter to expose the bind status of a field or object.
The
<bind>
tag supports evaluation of binding errors for a certain
bean or bean property.
Target to apply bindings to.
A function that can extract data from a
ReactiveHttpInputMessage
body.
Defines the context used during the extraction.
Static factory methods for
BodyExtractor
implementations.
A combination of functions that can populate a
ReactiveHttpOutputMessage
body.
Defines the context used during the insertion.
Static factory methods for
BodyInserter
implementations.
Extension of
BodyInserter
that allows for adding form data or
multipart form data.
Extension of
BodyInserters.FormInserter
that allows for adding asynchronous parts.
Represents the literal values
TRUE
and
FALSE
.
A
TypedValue
for booleans.
BootstrapContext
encapsulates the context in which the
Spring
TestContext Framework
is bootstrapped.
BootstrapUtils
is a collection of utility methods to assist with
bootstrapping the
Spring TestContext Framework
.
@BootstrapWith
defines class-level metadata that is used to determine
how to bootstrap the
Spring TestContext Framework
.
Helper for resolving synthetic
bridge Methods
to the
Method
being bridged.
Event raised when a broker's availability changes.
BrowserCallback
<
T
>
Callback for browsing the messages in a JMS queue.
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.
Implementation of
HttpMessageConverter
that can read and write
BufferedImages
.
Wrapper for a
ClientHttpRequestFactory
that buffers
all outgoing and incoming streams in memory.
An extension of
StompDecoder
that buffers content remaining in the input ByteBuffer after the parent
class has read all (complete) STOMP frames from it.
The
<button>
tag renders a form field label in an HTML 'button' tag.
Decoder for
byte
arrays.
Encoder for
byte
arrays.
Implementation of
HttpMessageConverter
that can read and write byte arrays.
A
MessageConverter
that supports MIME type "application/octet-stream" with the
payload converted to and from a byte[].
Custom
PropertyEditor
for converting
MultipartFiles
to byte arrays.
Editor for byte arrays.
Resource
implementation for a given byte array.
Decoder for
ByteBuffers
.
Encoder for
ByteBuffers
.
A dynamically extensible vector of bytes.
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.
A
CacheAwareContextLoaderDelegate
is responsible for
loading
and
closing
application
contexts, interacting transparently with a
ContextCache
behind the scenes.
@CacheConfig
provides a mechanism for sharing common cache-related
settings at the class level.
A builder for creating "Cache-Control" HTTP response headers.
Shared utility class used to evaluate and cache SpEL expressions that
are defined on
AnnotatedElement
.
An expression key.
Internal class that caches JavaBeans
PropertyDescriptor
information for a Java class.
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
directly
SingleConnectionFactory
subclass that adds
Session
caching as well as
MessageProducer
and
MessageConsumer
caching.
Extension of the DestinationResolver interface,
exposing methods for clearing the cache.
DestinationResolver
implementation that proxies a target DestinationResolver,
caching its
CachingDestinationResolverProxy.resolveDestination(java.lang.String)
results.
Caching implementation of the
MetadataReaderFactory
interface,
caching a
MetadataReader
instance per Spring
Resource
handle
(i.e.
A
ResourceResolver
that resolves resources from a
Cache
or
otherwise delegates to the resolver chain and caches the result.
A
ResourceResolver
that
resolves resources from a
Cache
or otherwise
delegates to the resolver chain and saves the result in the cache.
A
ResourceTransformer
that checks a
Cache
to see if a
previously transformed resource exists in the cache and returns it if found,
or otherwise delegates to the resolver chain and caches the result.
A
ResourceTransformer
that checks a
Cache
to see if a previously transformed resource
exists in the cache and returns it if found, and otherwise delegates to the resolver
chain and saves the result in the cache.
Spring
Cache
adapter implementation
on top of a Caffeine
Cache
instance.
CacheManager
implementation that lazily builds
CaffeineCache
instances for each
CaffeineCacheManager.getCache(java.lang.String)
request.
Handles return values of type
Callable
.
Intercepts concurrent request handling, where the concurrent result is
obtained by executing a
Callable
on behalf of the application with
an
AsyncTaskExecutor
.
Generic callback interface for code that operates on a CallableStatement.
One of the three central callback interfaces used by the JdbcTemplate class.
Helper class that efficiently creates multiple
CallableStatementCreator
objects with different parameters based on an SQL statement and a single
set of parameter declarations.
All callback interfaces used by
Enhancer
extend this interface.
Map methods of subclasses generated by
Enhancer
to a particular
callback.
Extension of the
PlatformTransactionManager
interface, exposing a method for executing a given callback within a transaction.
Class to manage context meta-data used for the configuration
and execution of a stored procedure call.
Interface specifying the API to be implemented by a class providing call meta-data.
Factory used to create a
CallMetaDataProvider
implementation
based on the type of database being used.
Holder of meta-data for a specific parameter that is used for call processing.
Provide access to the candidates that are defined in
META-INF/spring.components
.
Annotation
Processor
that writes a
CandidateComponentsMetadata
file for spring components.
Candidate components index loading mechanism for internal use within the framework.
Exception thrown on failure to acquire a lock during an update,
for example during a "select for update" statement.
Exception thrown when a transaction can't be created using an
underlying transaction API such as JTA.
Fatal exception thrown when we can't connect to an RDBMS using JDBC.
Exception thrown when the BeanFactory cannot load the specified class
of a given bean.
Thrown by
ScriptUtils
if an SQL script cannot be read.
Thrown by
ScriptUtils
if an SQL script cannot be read.
Deprecated.
as of 6.0.3, in favor of
PessimisticLockingFailureException
/
CannotAcquireLockException
XStream
Converter
that supports all classes, but throws exceptions for
(un)marshalling.
Default object instantiation strategy for use in BeanFactories.
Implementation of the JMS ExceptionListener interface that supports chaining,
allowing the addition of multiple ExceptionListener instances in order.
Implementation of
PersistenceExceptionTranslator
that supports chaining,
allowing the addition of PersistenceExceptionTranslator instances in order.
Interface for interceptors that are able to view and/or modify the
Messages
being sent-to and/or received-from a
MessageChannel
.
A registration class for customizing the configuration for a
MessageChannel
.
ChannelSendOperator
<
T
>
Given a write function that accepts a source
Publisher<T>
to write
with and returns
Publisher<Void>
for the result, this operator helps
to defer the invocation of the write function, until we know if the source
publisher will begin publishing without an error.
Servlet Filter that allows one to specify a character encoding for requests.
Editor for char arrays.
Encode from a
CharSequence
stream to a bytes stream.
Editor for
java.nio.charset.Charset
, translating charset
String representations into Charset objects and back.
The
<checkboxes>
tag renders multiple HTML 'input' tags with type 'checkbox'.
The
<checkbox>
tag renders an HTML 'input' tag with type 'checkbox'.
Bean definition for beans which inherit settings from their parent.
Property editor for an array of
Classes
, to enable
the direct population of a
Class[]
property without having to
use a
String
class name property as bridge.
Property editor for
java.lang.Class
, to enable the direct
population of a
Class
property without recourse to having to use a
String class name property as bridge.
In memory representation of a Java class.
An immutable collection of
ClassFile
instances.
Filter that restricts matching of a pointcut or introduction to
a given set of target classes.
Static utility methods for composing
ClassFilters
.
Utilities for core hint inference on Spring-managed classes,
specifically for proxy types such as interface-based JDK proxies
and CGLIB-generated subclasses which need proxy/reflection hints.
CGLIB GeneratorStrategy variant which exposes the application ClassLoader
as current thread context ClassLoader for the time of class generation.
Interface that defines abstract metadata of a specific class,
in a form that does not require that class to be loaded yet.
Simple default implementation of the
BeanWiringInfoResolver
interface,
looking for a bean with the same name as the fully-qualified class name.
Generate unique class names based on a target
ClassName
and a
feature name.
A bean definition scanner that detects bean candidates on the classpath,
registering corresponding bean definitions with a given registry (
BeanFactory
or
ApplicationContext
).
Resource
implementation for class path resources.
A component provider that provides candidate components from a 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.
A parser to make a
ClassVisitor
visit a ClassFile structure, as defined in the Java
Virtual Machine Specification (JVMS).
ResourceLoader
implementation that interprets plain resource paths
as relative to a given
java.lang.Class
.
Exception thrown when the constant pool of a class produced by a
ClassWriter
is too
large.
Miscellaneous
java.lang.Class
utility methods.
A visitor to visit a Java class.
A
ClassVisitor
that generates a corresponding ClassFile structure, as defined in the Java
Virtual Machine Specification (JVMS).
Deprecated.
as of 6.0.3 since it is not in use within core JDBC/ORM support
Extension of
CodecConfigurer
for HTTP message reader and writer
options relevant on the client side.
CodecConfigurer.DefaultCodecs
extension with extra client-side options.
Abstraction over HTTP clients driving the underlying HTTP client to connect
to the origin server and provide all necessary infrastructure to send a
ClientHttpRequest
and receive a
ClientHttpResponse
.
Documented
KeyValues
for
HTTP client
observations.
Documented
KeyValues
for the
HTTP client
observations.
Represents a client-side HTTP request.
Represents a client-side reactive HTTP request.
Wraps another
ClientHttpRequest
and delegates all methods to it.
Represents the context of a client-side HTTP request execution.
Factory for
ClientHttpRequest
objects.
Callback interface for initializing a
ClientHttpRequest
prior to it
being used.
Intercepts client-side HTTP requests.
Represents a client-side HTTP response.
Represents a client-side reactive HTTP response.
Wraps another
ClientHttpResponse
and delegates all methods to it.
Represents a typed, immutable, client-side HTTP request, as executed by the
ExchangeFunction
.
Defines a builder for a request.
Context that holds information for metadata collection
during the
client HTTP exchanges
observations.
Context that holds information for metadata collection
during the
HTTP client exchange observations
.
Interface for an
ObservationConvention
for
client HTTP exchanges
.
Interface for an
ObservationConvention
related to
HTTP client exchange observations
.
Represents an HTTP response, as returned by
WebClient
and also
ExchangeFunction
.
Defines a builder for a response.
Represents the headers of the HTTP response.
Implementation of the
ClientResponse
interface that can be subclassed
to adapt the request in a
exchange filter function
.
Implementation of the
Headers
interface that can be subclassed
to adapt the headers in a
exchange filter function
.
Extension of
DataBuffer
that allows for buffers that can be used
in a
try
-with-resources statement.
Representation of WebSocket "close" status codes and reasons.
Represents a WebSocket close status code and reason.
Defines a common interface for configuring either client or server HTTP
message readers and writers.
Registry for custom HTTP message readers and writers.
Exposes the values of properties configured through
CodecConfigurer.defaultCodecs()
that are applied to default codecs.
Customize or replace the HTTP message readers and writers registered by
default.
Registry and container for multipart HTTP message writers.
General error that indicates a problem while encoding and decoding to and
from an Object stream.
Manages the class being generated by the compilation process.
Interface used to generate
clinit
static initializer blocks.
Interface used to generate fields.
Factory for collections that is aware of common Java and Spring collection types.
Miscellaneous collection utility methods.
RowMapper
implementation that creates a
java.util.Map
for each row, representing all columns as key-value pairs: one
entry for each column, with the column name as key.
Mapping function
implementation that creates a
java.util.Map
for each row, representing all columns as
key-value pairs: one entry for each column, with the column name as key.
Abstract base class for
PropertySource
implementations backed by command line
arguments.
@Commit
is a test annotation that is used to indicate that a
test-managed transaction
should be
committed
after
the test method has completed.
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.
java.io.Writer
adapter for a Commons Logging
Log
.
TargetSource
implementation that holds
objects in a configurable Apache Commons2 Pool.
Simple request logging filter that writes the request URI
(and optionally the query string) to the Commons Log.
Comparator that adapts Comparables to the Comparator interface.
Convenient entry point with generically typed factory methods
for common Spring
Comparator
variants.
A compilable property accessor is able to generate bytecode that represents
the access operation, facilitating compilation to bytecode of expressions
that use the accessor.
Exception thrown when code cannot compile.
Fully compiled results provided from a
TestCompiler
.
Base superclass for compiled expressions.
Adapter class that can be used to apply AOT
GeneratedFiles
to the
TestCompiler
.
Annotation that registers a JUnit Jupiter extension for test classes or test
methods that need to use a forked classloader with compiled code.
Support for
CompletableFuture
(and as of 4.3.7 also
CompletionStage
)
as a return value type.
Deprecated.
as of 6.0, with no concrete replacement
Indicates that an annotated class is a "component".
Interface that describes the logical view of a set of
BeanDefinitions
and
BeanReferences
as presented in some configuration context.
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.
Convenient class for building up pointcuts.
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.
ComponentDefinition
implementation that holds one or more nested
ComponentDefinition
instances, aggregating them into a named group
of components.
Composite
DatabasePopulator
that delegates to a list of given
DatabasePopulator
implementations, executing all scripts.
Composite
DatabasePopulator
that delegates to a list of given
DatabasePopulator
implementations, executing all scripts.
A generic composite servlet
Filter
that just delegates its behavior
to a chain (list) of user-supplied filters, achieving the functionality of a
FilterChain
, but conveniently using only
Filter
instances.
CompositeIterator
<
E
>
Composite iterator that combines multiple other iterators,
as registered via
CompositeIterator.add(Iterator)
.
Composite
MessageCondition
that delegates to other message conditions.
A
MessageConverter
that delegates to a list of registered converters
to be invoked until one of them returns a non-null result.
Composite
PropertySource
implementation that iterates over a set of
PropertySource
instances.
Implements the
RequestCondition
contract by delegating to multiple
RequestCondition
types and using a logical conjunction (
' && '
) to
ensure all conditions match a given request.
Implements the
RequestCondition
contract by delegating to multiple
RequestCondition
types and using a logical conjunction (
' && '
) to
ensure all conditions match a given request.
Represents a template expression broken into pieces.
Composite
TransactionAttributeSource
implementation that iterates
over a given array of
TransactionAttributeSource
instances.
A
UriComponentsContributor
containing a list of other contributors
to delegate to and also encapsulating a specific
ConversionService
to
use for formatting method argument values as Strings.
Represents a DOT separated expression sequence, such as
property1.property2.methodOne()
.
Exception thrown on various data access concurrency failures.
Interceptor that throttles concurrent access, blocking invocations
if a specified concurrency limit is reached.
Support class for throttling concurrent access to a specific resource.
Deprecated, for removal: This API element is subject to removal in a future version.
ConcurrentExecutorAdapter
is obsolete and will be removed
in Spring Framework 6.1
Simple LRU (Least Recently Used) cache, bounded by a specified cache capacity.
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.
A single map entry.
A reference to an
ConcurrentReferenceHashMap.Entry
contained in the map.
Various reference types supported by this map.
The types of restructuring that can be performed.
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.
Wrap a
WebSocketSession
to guarantee only one thread can send messages at a time.
Enum for options of what to do when the buffer fills up.
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.
Allows a
Converter
,
GenericConverter
or
ConverterFactory
to
conditionally execute based on attributes of the
source
and
target
TypeDescriptor
.
A
GenericConverter
that may conditionally execute based on attributes
of the
source
and
target
TypeDescriptor
.
Contract for
runtime hints
that only apply
if the described condition is met.
Context information for use by
Condition
implementations.
Marks a class as being eligible for Spring-driven configuration.
SPI interface to be implemented by most if not all application contexts.
Configuration interface to be implemented by most bean factories.
Configuration interface to be implemented by most if not all
ConversionService
types.
Configuration interface to be implemented by most if not all
Environment
types.
Configuration interface to be implemented by most listable bean factories.
Spring-configurable
FileTypeMap
implementation that will read
MIME type to file extension mappings from a standard JavaMail MIME type
mapping file, using a standard
MimetypesFileTypeMap
underneath.
Defines common methods for building a
MockMvc
.
Marker interface for domain objects that need DI through aspects.
Special
ObjectInputStream
subclass that resolves class names
against a specific
ClassLoader
.
Interface that encapsulates configuration methods for a PropertyAccessor.
Configuration interface to be implemented by most if not all
PropertyResolver
types.
An extension of
SmartRequestBuilder
that can be configured with
RequestPostProcessors
.
Interface to be implemented by configurable web application contexts.
Convenient
WebBindingInitializer
for declarative configuration
in a Spring application context.
Specialization of
ConfigurableEnvironment
allowing initialization of
servlet-related
PropertySource
objects at the
earliest moment that the
ServletContext
and (optionally)
ServletConfig
become available.
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.
Interface declaring methods that accept callback
Function
to operate within the scope of a
Connection
.
ConnectionCallback
<
T
>
Generic callback interface for code that operates on a JDBC Connection.
Strategy interface for looking up
ConnectionFactory
by name.
Exception to be thrown by a
ConnectionFactoryLookup
implementation,
indicating that the specified
ConnectionFactory
could
not be obtained.
Helper class for managing a JMS
ConnectionFactory
, in particular
for obtaining transactional JMS resources for a given ConnectionFactory.
Helper class that provides static methods for obtaining R2DBC Connections from
a
ConnectionFactory
.
Callback interface for resource creation.
Simple interface to be implemented by handles for a JDBC Connection.
A
StompSession
that implements
TcpConnectionHandler
in order to send and receive messages.
Resource holder wrapping a JDBC
Connection
.
Resource holder wrapping a R2DBC
Connection
.
Raised when the connection for a STOMP session is lost rather than closed.
Base class for a connection manager that automates the process of connecting
to a WebSocket server with the Spring ApplicationContext lifecycle.
ConnectionProperties
serves as a simple data container that allows
essential JDBC connection properties to be configured consistently,
independent of the actual
DataSource
implementation.
Subinterface of
Connection
to be implemented by
Connection proxies.
Annotation to map the initial
ConnectionSetupPayload
and subsequent
metadata pushes onto a handler method.
FactoryBean
that creates a JSR-160
JMXConnectorServer
,
optionally registers it with the
MBeanServer
, and then starts it.
A constant whose value is computed at runtime, with a bootstrap method.
This class can be used to parse other classes containing constant definitions
in public static final members.
Exception thrown when the
Constants
class is asked for
an invalid constant name.
ParseState
entry representing a (possibly indexed)
constructor argument.
Holder for constructor argument values, typically as part of a bean definition.
Holder for a constructor argument value, with an optional type
attribute indicating the target type of the actual constructor argument.
Executors are built by resolvers and can be cached by the infrastructure to repeat an
operation quickly without going back to the resolvers.
Intercepts the construction of a new object.
Description of an invocation to a constructor, given to an
interceptor upon constructor-call.
Represents the invocation of a constructor.
A constructor resolver attempts to locate a constructor and returns a ConstructorExecutor
that can be used to invoke that constructor.
A logical disjunction (' || ') request condition to match a request's
'Content-Type' header to a list of media type expressions.
A logical disjunction (' || ') request condition to match a request's
'Content-Type' header to a list of media type expressions.
HttpServletRequest
wrapper that caches all content read from
the
input stream
and
reader
,
and allows this content to be retrieved via a
byte array
.
HttpServletResponse
wrapper that caches all content written to
the
output stream
and
writer
,
and allows this content to be retrieved via a
byte array
.
Representation of the Content-Disposition type and parameters as defined in RFC 6266.
A mutable builder for
ContentDisposition
.
Implementation of
ViewResolver
that resolves a view based on the request file name
or
Accept
header.
Creates a
ContentNegotiationManager
and configures it with
one or more
ContentNegotiationStrategy
instances.
Central class to determine requested
media types
for a request.
Factory to create a
ContentNegotiationManager
and configure it with
ContentNegotiationStrategy
instances.
A strategy for resolving the requested media types for a request.
Factory for request content
RequestMatcher
's.
Factory for response content assertions.
Resolve the content type for a message.
A
VersionStrategy
that calculates a Hex MD5 hash from the content
of the resource and appends it to the file name, e.g.
A
VersionStrategy
that calculates a Hex MD5 hash from the content
of the resource and appends it to the file name, e.g.
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.
ContextCache
defines the SPI for caching Spring
ApplicationContexts
within the
Spring TestContext Framework
.
Collection of utilities for working with
ContextCaches
.
Web application listener that cleans up remaining disposable attributes
in the ServletContext, i.e.
Event raised when an
ApplicationContext
gets closed.
@ContextConfiguration
defines class-level metadata that is used to determine
how to load and configure an
ApplicationContext
for integration tests.
ContextConfigurationAttributes
encapsulates the context configuration
attributes declared via
@ContextConfiguration
.
Strategy interface for customizing
application contexts
that are created and managed by the
Spring
TestContext Framework
.
Factory for creating
ContextCustomizers
.
HttpServletRequest decorator that makes all Spring beans in a
given WebApplicationContext accessible as request attributes,
through lazy checking once an attribute gets accessed.
@ContextHierarchy
is a class-level annotation that is used to define
a hierarchy of
ApplicationContexts
for integration tests.
ScheduledTaskRegistrar
subclass which redirects the actual scheduling
of tasks to the
ContextLifecycleScheduledTaskRegistrar.afterSingletonsInstantiated()
callback (as of 4.1.2).
Strategy interface for loading an
ApplicationContext
for an integration
test managed by the Spring TestContext Framework.
Performs the actual initialization work for the root application context.
Bootstrap listener to start up and shut down Spring's root
WebApplicationContext
.
Exception thrown when an error occurs while a
SmartContextLoader
attempts to load an
ApplicationContext
.
NamespaceHandler
for the '
context
' namespace.
HttpHandler
delegating requests to one of several
HttpHandler
's
based on simple, prefix-based mappings.
Event raised when an
ApplicationContext
gets initialized or refreshed.
Extended interface for a resource that is loaded from an enclosing
'context', e.g.
Event raised when an
ApplicationContext
gets started.
Event raised when an
ApplicationContext
gets stopped.
WebSocketHandler
decorator that enriches the context of the target handler.
No-op resolver for method arguments of type
Continuation
.
No-op resolver for method arguments of type
Continuation
.
No-op resolver for method arguments of type
Continuation
.
Pointcut and method matcher for use in simple
cflow
-style pointcut.
Indicates that an annotated class is a "Controller" (e.g.
Base Controller interface, representing a component that receives
HttpServletRequest
and
HttpServletResponse
instances just like a
HttpServlet
but is able to
participate in an MVC workflow.
Specialization of
@Component
for classes that declare
@ExceptionHandler
,
@InitBinder
, or
@ModelAttribute
methods to be shared across
multiple
@Controller
classes.
Encapsulates information about an
@ControllerAdvice
Spring-managed bean without necessarily requiring it to be instantiated.
Provides methods to support various naming and other conventions used
throughout the framework.
Base class for exceptions thrown by the conversion system.
Exception to be thrown when an actual type conversion attempt fails.
Exception thrown when no suitable editor or converter can be found for a bean property.
A service interface for type conversion.
Interceptor that places the configured
ConversionService
in request scope
so it's available during request processing.
A factory for common
ConversionService
configurations.
A factory providing convenient access to a ConversionService configured with
converters appropriate for most environments.
A converter converts a source object of type
S
to a target of type
T
.
A factory for "ranged" converters that can convert objects from S to subtypes of R.
Exception to be thrown when a suitable converter could not be found
in a given conversion service.
For registering converters with a type conversion system.
A
Comparator
that converts values before they are compared.
A binary
jakarta.websocket.Encoder
that delegates
to Spring's conversion service.
A binary
jakarta.websocket.Encoder
that delegates
to Spring's conversion service.
A Text
jakarta.websocket.Encoder
that delegates
to Spring's conversion service.
A text
jakarta.websocket.Encoder
that delegates
to Spring's conversion service.
Adapter that exposes a
PropertyEditor
for any given
ConversionService
and specific target type.
Assertions on cookies of the response.
Deprecated.
as of 6.0 in favor of
ResponseCookie
LocaleResolver
implementation that uses a cookie sent back to the user
in case of a custom setting, with a fallback to the configured default locale,
the request's
Accept-Language
header, or the default locale for the server.
Factory for response cookie assertions.
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
Annotation to indicate that a method parameter is bound to an HTTP cookie.
HttpServiceArgumentResolver
for
@CookieValue
annotated arguments.
Resolve method arguments annotated with
@CookieValue
.
Cookie-based
WebSessionIdResolver
.
Utilities for working with Kotlin Coroutines.
BeanDefinitionParser
that parses a
cors
element in order to set the CORS configuration in the various
{AbstractHandlerMapping} beans created by
AnnotationDrivenBeanDefinitionParser
,
ResourcesBeanDefinitionParser
and
ViewControllerBeanDefinitionParser
.
A container for CORS configuration along with methods to check against the
actual origin, HTTP methods, and headers of a given request.
Interface to be implemented by classes (usually HTTP request handlers) that
provides a
CorsConfiguration
instance based on the provided request.
Interface to be implemented by classes (usually HTTP request handlers) that
provides a
CorsConfiguration
instance based on the provided reactive request.
Filter
to handle CORS pre-flight requests and intercept
CORS simple and actual requests with a
CorsProcessor
, and to update
the response, e.g.
A strategy that takes a request and a
CorsConfiguration
and updates
the response.
A strategy to apply CORS validation checks and updates to a
ServerWebExchange
, either rejecting through the response or adding
CORS related headers, based on a pre-selected
CorsConfiguration
.
Assists with the creation of a
CorsConfiguration
instance for a given
URL path pattern.
Assists with the creation of a
CorsConfiguration
instance for a given
URL path pattern.
Assists with the registration of global, URL pattern based
CorsConfiguration
mappings.
Assists with the registration of global, URL pattern based
CorsConfiguration
mappings.
Utility class for CORS request handling based on the
CORS W3C recommendation
.
Utility class for CORS reactive request handling based on the
CORS W3C recommendation
.
WebFilter
that handles CORS preflight requests and intercepts
CORS simple and actual requests thanks to a
CorsProcessor
implementation
(
DefaultCorsProcessor
by default) in order to add the relevant CORS
response headers (like
Access-Control-Allow-Origin
) using the provided
CorsConfigurationSource
(for example an
UrlBasedCorsConfigurationSource
instance.
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
CronExpression
TriggerTask
implementation defining a
Runnable
to be executed according
to a
standard cron expression
.
Trigger
implementation for cron expressions.
A Spring
FactoryBean
for creating a Quartz
CronTrigger
instance, supporting bean-style usage for trigger configuration.
Annotation for permitting cross-origin requests on specific handler classes
and/or handler methods.
A
ResourceTransformer
implementation that modifies links in a CSS
file to match the public URL paths that should be exposed to clients (e.g.
A
ResourceTransformer
implementation that modifies links in a CSS
file to match the public URL paths that should be exposed to clients (e.g.
Abstract base class for
CssLinkResourceTransformer.LinkParser
implementations.
Abstract base class for
CssLinkResourceTransformer.LinkParser
implementations.
Extract content chunks that represent links.
Extract content chunks that represent links.
Editor for
java.util.Currency
, translating currency codes into Currency
objects.
A BigDecimal formatter for number values in currency style.
Formatter for JSR-354
CurrencyUnit
values,
from and to currency code Strings.
A
BeanFactoryPostProcessor
implementation that allows for convenient registration of custom autowire
qualifier types.
Property editor for Boolean/boolean properties.
Property editor for Collections, converting any source Collection
to a given target Collection type.
Property editor for
java.util.Date
,
supporting a custom
java.text.DateFormat
.
BeanFactoryPostProcessor
implementation that allows for convenient
registration of custom
property editors
.
Simple customizable helper class for creating new
Thread
instances.
Implementation of the
ThreadFactory
interface,
allowing for customizing the created threads (name, priority, etc).
MethodInterceptor
implementation that allows for highly customizable
method-level tracing, using placeholders.
Customizes key types for
KeyFactory
when building equals, hashCode, and toString.
Property editor for Maps, converting any source Map
to a given target Map type.
Property editor for any Number subclass such as Short, Integer, Long,
BigInteger, Float, Double, BigDecimal.
Simple
BeanFactoryPostProcessor
implementation that registers
custom
Scope(s)
with the containing
ConfigurableBeanFactory
.
JavaBean for holding custom JDBC error codes translation for a particular
database.
Registry for custom
SQLExceptionTranslator
instances for specific databases.
Registry for custom
SQLExceptionTranslator
instances associated with
specific databases allowing for overriding translation based on values contained in the configuration file
named "sql-error-codes.xml".
Configurable bean class that exposes a specific JSR-303 Validator
through its original interface as well as through the Spring
Validator
interface.
Generic base class for DAOs, defining template methods for DAO initialization.
Root of the hierarchy of data access exceptions discussed in
Expert One-On-One J2EE Design and Development
.
Data access exception thrown when a resource fails completely:
for example, if we can't connect to a database using JDBC.
Miscellaneous utility methods for DAO implementations.
Enumeration for common database platforms.
A non-blocking, reactive client for performing database calls with
Reactive Streams back pressure.
A mutable builder for creating a
DatabaseClient
.
Contract for specifying an SQL call along with options leading to the execution.
A callback interface used by the JdbcUtils class.
Strategy used to populate, initialize, or clean up a database.
Strategy used to populate, initialize, or clean up a database.
Utility methods for executing a
DatabasePopulator
.
Bean that checks if a database has already started up.
Binder that allows for setting property values on a target object, including
support for validation and binding result analysis.
A
MethodResolver
variant for data binding
purposes, using reflection to access instance methods on a given target object.
A
PropertyAccessor
variant for data binding
purposes, using reflection to access properties for reading and possibly writing.
Basic abstraction over byte buffers.
A dedicated iterator type that ensures the lifecycle of iterated
ByteBuffer
elements.
Simple pass-through decoder for
DataBuffers
.
Simple pass-through encoder for
DataBuffers
.
A factory for
DataBuffers
, allowing for allocation and
wrapping of data buffers.
Exception that indicates the cumulative number of bytes consumed from a
stream of
DataBuffer
's exceeded some pre-configured limit.
Utility class for working with
DataBuffers
.
Contract to find delimiter(s) against one or more data buffers that can
be passed one at a time to the
DataBufferUtils.Matcher.match(DataBuffer)
method.
Provides a convenient implementation of the
DataBuffer
interface
that can be overridden to adapt the delegate.
DataClassRowMapper
<
T
>
RowMapper
implementation that converts a row into a new instance
of the specified mapped target class.
Interface that defines contract of incrementing any data store field's
maximum value.
Exception thrown when an attempt to insert or update data
results in violation of an integrity constraint.
Exception thrown if certain expected data could not be retrieved, e.g.
A data size, such as '12MB'.
DataSourceFactory
encapsulates the creation of a particular
DataSource
implementation such as a non-pooling
SimpleDriverDataSource
or a HikariCP pool setup in the shape of a
HikariDataSource
.
Strategy interface for looking up DataSources by name.
Exception to be thrown by a DataSourceLookup implementation,
indicating that the specified DataSource could not be obtained.
PlatformTransactionManager
implementation
for a single JDBC
DataSource
.
Helper class that provides static methods for obtaining JDBC
Connection
s
from a
DataSource
.
A standard set of
DataSize
units.
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.
DB2 specific implementation for the
CallMetaDataProvider
interface.
DataFieldMaxValueIncrementer
that retrieves the next value
of a given sequence on DB2 LUW (for Linux, Unix and Windows).
DataFieldMaxValueIncrementer
that retrieves the next value
of a given sequence on DB2 for the mainframe (z/OS, DB2/390, DB2/400).
Deprecated.
as of 6.0.3, in favor of
PessimisticLockingFailureException
/
CannotAcquireLockException
AOP Alliance
MethodInterceptor
that can be introduced in a chain
to display verbose information about intercepted invocations to the logger.
Introduction advisor delegating to the given object.
Strategy for decoding a
DataBuffer
input stream into an output stream
of elements of type
<T>
.
HttpMessageReader
that wraps and delegates to a
Decoder
.
Indicates an issue with decoding the input stream with a focus on content
related issues such as a parse failure.
Base class for decorating ClassLoaders such as
OverridingClassLoader
and
ShadowingClassLoader
,
providing common handling of excluded packages and classes.
Base class for JSF NavigationHandler implementations that want
to be capable of decorating an original NavigationHandler.
Interface to be implemented by decorating proxies, in particular Spring AOP
proxies but potentially also custom proxies with decorator semantics.
Default implementation of the
ActiveProfilesResolver
strategy that
resolves
active bean definition profiles
based solely on profiles
configured declaratively via
ActiveProfiles.profiles()
or
ActiveProfiles.value()
.
Default implementation of the
AdvisorAdapterRegistry
interface.
BeanPostProcessor
implementation that creates AOP proxies based on all
candidate
Advisor
s in the current
BeanFactory
.
A simple but definitive way of working out an advice chain for a Method,
given an
Advised
object.
Default
AopProxyFactory
implementation, creating either a CGLIB proxy
or a JDK dynamic proxy.
Default implementation of the
BeanDefinitionDocumentReader
interface that
reads bean definitions according to the "spring-beans" DTD and XSD format
(Spring's default XML bean definition format).
Concrete BeanFactory-based PointcutAdvisor that allows for any Advice
to be configured as reference to an Advice bean in the BeanFactory,
as well as the Pointcut to be configured through a bean property.
Default implementation of the
BeanNameGenerator
interface, delegating to
BeanDefinitionReaderUtils.generateBeanName(BeanDefinition, BeanDefinitionRegistry)
.
Default
BindingErrorProcessor
implementation.
Default implementation of the
BootstrapContext
interface.
Default implementation of the
CacheAwareContextLoaderDelegate
interface.
Default implementation of
ClientCodecConfigurer
.
Default implementation for a
ClientRequestObservationConvention
,
extracting information from the
ClientRequestObservationContext
.
Default implementation for a
ClientRequestObservationConvention
,
extracting information from the
ClientRequestObservationContext
.
A default
ContentTypeResolver
that checks the
MessageHeaders.CONTENT_TYPE
header or falls back to a default value.
Default implementation of the
ContextCache
API.
Default
LoadTimeWeaver
bean for use in an application context,
decorating an automatically detected internal
LoadTimeWeaver
.
A specialization of
GenericConversionService
configured by default
with converters appropriate for most environments.
The default implementation of
CorsProcessor
, as defined by the
CORS W3C recommendation
.
The default implementation of
CorsProcessor
,
as defined by the
CORS W3C recommendation
.
Create a
WebRequestDataBinder
instance and initialize it with a
WebBindingInitializer
.
Default implementation of the
DataBuffer
interface that uses a
ByteBuffer
internally.
Default implementation of the
DataBufferFactory
interface.
A default
Deserializer
implementation that reads an input stream
using Java serialization.
Spring's default
DocumentLoader
implementation.
Default
EventListenerFactory
implementation that supports the
regular
EventListener
annotation.
A specialization of
FormattingConversionService
configured by default with
converters and formatters appropriate for most applications.
Default
GenerationContext
implementation.
The default implementation of the
HandlerExceptionResolver
interface, resolving standard Spring MVC exceptions and translating them to corresponding
HTTP status codes.
A default
HandshakeHandler
implementation,
extending
AbstractHandshakeHandler
with Servlet-specific initialization support.
Simple
IntroductionAdvisor
implementation
that by default applies to any class.
The default
JCacheOperationSource
implementation delegating
default operations to configurable services with sensible defaults
when not present.
A
JmsListenerContainerFactory
implementation to build a
JCA-based
JmsMessageEndpointManager
.
Default implementation of the
JmsActivationSpecFactory
interface.
A
JmsListenerContainerFactory
implementation to build a regular
DefaultMessageListenerContainer
.
Default implementation of the
JpaDialect
interface.
Default implementation of the
LifecycleProcessor
strategy.
Spring's default implementation of the
ConfigurableListableBeanFactory
and
BeanDefinitionRegistry
interfaces: a full-fledged bean factory
based on bean definition metadata, extensible through post-processors.
Default implementation of the
LobHandler
interface.
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.
The default
MessageHandlerMethodFactory
implementation creating an
InvocableHandlerMethod
with the necessary
HandlerMethodArgumentResolver
instances to detect and process
most of the use cases defined by
MessageMapping
.
Message listener container variant that uses plain JMS client APIs, specifically
a loop of
MessageConsumer.receive()
calls that also allow for
transactional reception of messages (registering them with XA transactions).
Spring's default implementation of the
MessageSourceResolvable
interface.
Default
MetadataExtractor
implementation that relies on
Decoder
s to deserialize the content of metadata entries.
Default
MethodReference
implementation based on a
MethodSpec
.
A concrete implementation of
AbstractMockMvcBuilder
that provides
the
WebApplicationContext
supplied to it as a constructor argument.
Default implementation of the
MultipartHttpServletRequest
interface.
Default implementation of the
NamespaceHandlerResolver
interface.
The default policy used by
AbstractClassGenerator
.
Default implementation of the
ParameterNameDiscoverer
strategy interface,
delegating to the Java 8 standard reflection mechanism, with a deprecated fallback
to
LocalVariableTableParameterNameDiscoverer
.
Default implementation of the
PersistenceUnitManager
interface.
Convenient Pointcut-driven Advisor implementation.
Default implementation of the
PropertiesPersister
interface.
The default implementation for
PropertySourceFactory
,
wrapping every resource in a
ResourcePropertySource
.
Default implementation of
RequestExpectation
that simply delegates
to the request matchers and the response creator it contains.
Helper class that keeps track of actual vs expected request count.
RequestToViewNameTranslator
that simply transforms the URI of
the incoming request into a view name.
Default implementation of the
ResourceLoader
interface.
ClassPathResource that explicitly expresses a context-relative path
through implementing the ContextResource interface.
A
ResponseCreator
with builder-style methods for adding response details.
Spring's default implementation of the
ResponseErrorHandler
interface.
Default implementation of the
ScopedObject
interface.
Marker interface for a defaults definition,
extending BeanMetadataElement to inherit source exposure.
A
Serializer
implementation that writes an object to an output stream
using Java serialization.
Default implementation of
ServerCodecConfigurer
.
Default
ServerRequestObservationConvention
.
Default
ServerRequestObservationConvention
.
Default implementation of
ServerWebExchange
.
Configures a request handler for serving static resources by forwarding
the request to the Servlet container's "default" Servlet.
An
HttpRequestHandler
for serving static files using the Servlet container's "default" Servlet.
Default implementation of the
SessionAttributeStore
interface,
storing the attributes in the WebRequest session (i.e.
A default implementation of
SimpUserRegistry
that relies on
AbstractSubProtocolEvent
application context events to keep
track of connected users and their subscriptions.
Generic registry for shared bean instances, implementing the
SingletonBeanRegistry
.
A default implementation of
SockJsFrameFormat
that relies
on
String.format(String, Object...)
..
A default implementation of
SockJsService
with all default
TransportHandler
implementations pre-registered.
Default implementation of
ConnectionHandlingStompSession
.
Implementation of
SubscriptionRegistry
that stores subscriptions
in memory and uses a
PathMatcher
for matching destinations.
Default implementation of the
TestContext
interface.
Default implementation of the
TestContextBootstrapper
SPI.
Spring's default
toString()
styler.
Spring's common transaction attribute implementation.
Default implementation of the
TransactionDefinition
interface,
offering bean-style configuration and sensible default values
(PROPAGATION_REQUIRED, ISOLATION_DEFAULT, TIMEOUT_DEFAULT, readOnly=false).
Default implementation of the
TransactionStatus
interface, used by
AbstractPlatformTransactionManager
.
UriBuilderFactory
that relies on
UriComponentsBuilder
for
the actual building of the URI.
Enum to represent multiple URI encoding strategies.
A default implementation of
UserDestinationResolver
that relies
on a
SimpUserRegistry
to find active sessions for a user.
Converts objects to String form, generally for debugging purposes,
using Spring's
toString
styling conventions.
Default implementation of
WebFilterChain
.
Default implementation of
WebSessionManager
delegating to a
WebSessionIdResolver
for session id resolution and to a
WebSessionStore
.
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.
DeferredResult
<
T
>
DeferredResult
provides an alternative to using a
Callable
for
asynchronous request processing.
Handles a DeferredResult value when set.
Intercepts concurrent request handling, where the concurrent result is
obtained by waiting for a
DeferredResult
to be set from a thread
chosen by the application (e.g.
Convenient implementation of the
IntroductionInterceptor
interface.
ConnectionFactory
implementation that delegates all calls
to a given target
ConnectionFactory
, adapting specific
create(Queue/Topic)Connection
calls to the target ConnectionFactory
if necessary (e.g.
R2DBC
ConnectionFactory
implementation that delegates
all calls to a given target
ConnectionFactory
.
JDBC
DataSource
implementation that delegates all calls
to a given target
DataSource
.
EntityResolver
implementation that delegates to a
BeansDtdResolver
and a
PluggableSchemaResolver
for DTDs and XML schemas, respectively.
Runnable wrapper that catches any exception or error thrown from its
delegate Runnable and allows an
ErrorHandler
to handle it.
Proxy for a standard Servlet Filter, delegating to a Spring-managed bean that
implements the Filter interface.
Convenient implementation of the
IntroductionInterceptor
interface.
Empty
MessageSource
that delegates all calls to the parent MessageSource.
JSF NavigationHandler implementation that delegates to a NavigationHandler
bean obtained from the Spring root WebApplicationContext.
JSF PhaseListener implementation that delegates to one or more Spring-managed
PhaseListener beans coming from the Spring root WebApplicationContext.
Implementation of
ServerHttpResponse
that delegates all calls to a
given target
ServerHttpResponse
.
Delegating implementation of
ServletInputStream
.
Delegating implementation of
ServletOutputStream
.
DelegatingSmartContextLoader
is a concrete implementation of
AbstractDelegatingSmartContextLoader
that delegates to a
GenericXmlContextLoader
(or a
GenericGroovyXmlContextLoader
if Groovy
is present in the classpath) and an
AnnotationConfigContextLoader
.
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
TransactionAttribute
implementation that delegates all calls to a given target
TransactionAttribute
instance.
TransactionDefinition
implementation that delegates all calls to a given target
TransactionDefinition
instance.
Implementation of
WebConnection
that allows delegating to various
WebConnection
implementations.
The delegate web connection.
A subclass of
WebFluxConfigurationSupport
that detects and delegates
to all beans of type
WebFluxConfigurer
allowing them to customize the
configuration provided by
WebFluxConfigurationSupport
.
A subclass of
WebMvcConfigurationSupport
that detects and delegates
to all beans of type
WebMvcConfigurer
allowing them to customize the
configuration provided by
WebMvcConfigurationSupport
.
A variation of
WebSocketConfigurationSupport
that detects implementations of
WebSocketConfigurer
in Spring configuration and invokes them in order to
configure WebSocket request handling.
A
WebSocketMessageBrokerConfigurationSupport
extension that detects
beans of type
WebSocketMessageBrokerConfigurer
and delegates to all
of them allowing callback style customization of the configuration provided
in
WebSocketMessageBrokerConfigurationSupport
.
Shortcut for
@HttpExchange
for HTTP DELETE requests.
Annotation for mapping HTTP
DELETE
requests onto specific handler
methods.
Descriptor for a specific dependency that is about to be injected.
TestExecutionListener
which provides support for dependency
injection and initialization of test instances.
Beans on which the current bean depends.
Bean factory post processor that logs a warning for
@Deprecated
beans.
Derby specific implementation for the
CallMetaDataProvider
interface.
DataFieldMaxValueIncrementer
that increments the maximum value of a given Derby table
with the equivalent of an auto-increment column.
The Derby specific implementation of
TableMetaDataProvider
.
Simple
Resource
implementation that holds a resource description
but does not point to an actually readable resource.
Deserializer
<
T
>
A strategy interface for converting from data in an InputStream to an Object.
A
Converter
that delegates to a
Deserializer
to convert data in a byte array to an object.
MessageCondition
to match the destination header of a Message
against one or more patterns through a
RouteMatcher
.
Thrown by a DestinationResolver when it cannot resolve a destination name.
Thrown by a
DestinationResolver
when it cannot resolve a destination.
Strategy interface for resolving JMS destinations.
DestinationResolver
<
D
>
Strategy for resolving a String destination name to an actual destination
of type
<D>
.
Extends
MessageReceivingOperations
and adds operations for receiving messages
from a destination specified as a (resolvable) String name.
Extends
MessageRequestReplyOperations
and adds operations for sending and
receiving messages to and from a destination specified as a (resolvable) String name.
Extends
MessageSendingOperations
and adds operations for sending messages
to a destination specified as a (resolvable) String name.
A
Principal
can also implement this contract when
getName()
isn't globally unique
and therefore not suited for use with "user" destinations.
Annotation that indicates a method parameter should be bound to a template variable
in a destination template string.
RSocketServiceArgumentResolver
for a
@DestinationVariable
annotated argument.
Resolve for
@DestinationVariable
method parameters.
Resolve for
@DestinationVariable
method parameters.
Subinterface of
BeanPostProcessor
that adds a before-destruction callback.
Adapter that implements the Servlet HttpSessionBindingListener interface,
wrapping a session destruction callback.
Miscellaneous methods for calculating digests.
ConfigurablePropertyAccessor
implementation that directly accesses
instance fields.
Special implementation of the Errors and BindingResult interfaces,
supporting registration and evaluation of binding errors on value objects.
Test annotation which indicates that the
ApplicationContext
associated with a test is
dirty
and should therefore be closed
and removed from the context cache.
Defines
modes
which determine how
@DirtiesContext
is
interpreted when used to annotate a test class.
Defines
modes
which determine how the context cache is cleared
when
@DirtiesContext
is used in a test whose context is
configured as part of a hierarchy via
@ContextHierarchy
.
Defines
modes
which determine how
@DirtiesContext
is
interpreted when used to annotate a test method.
TestExecutionListener
which provides support for marking the
ApplicationContext
associated with a test as
dirty
for
both test classes and test methods annotated with the
@DirtiesContext
annotation.
TestExecutionListener
which provides support for marking the
ApplicationContext
associated with a test as
dirty
for
both test classes and test methods annotated with the
@DirtiesContext
annotation.
@DisabledIf
is used to signal that the annotated test class or test
method is
disabled
and should not be executed if the supplied
DisabledIf.expression()
evaluates to
true
.
DisabledIfCondition
is an
ExecutionCondition
that supports the
@DisabledIf
annotation when using the
Spring
TestContext Framework
in conjunction with JUnit 5's
Jupiter
programming model.
Dispatching
Enhancer
callback.
Central dispatcher for HTTP request handlers/controllers.
Central dispatcher for HTTP request handlers/controllers, e.g.
Strategy interface for customizing
DispatcherServlet
instances that are
managed by
MockMvc
.
ServletWebRequest
subclass that is aware of
DispatcherServlet
's
request context, such as the Locale determined by the configured
LocaleResolver
.
Contract to map a
Throwable
to a
HandlerResult
.
Interface to be implemented by beans that want to release resources on destruction.
Subinterface of
SqlTypeValue
that adds a cleanup callback,
to be invoked after the value has been set and the corresponding
statement has been executed.
Simple JavaBean that holds the defaults specified at the
<beans>
level in a standard Spring XML bean definition document:
default-lazy-init
,
default-autowire
, etc.
Strategy interface for loading an XML
Document
.
Convenience methods for working with the DOM API,
in particular for working with DOM Nodes and DOM Elements.
Simple implementation of the standard JDBC
DataSource
interface,
configuring the plain old JDBC
DriverManager
via bean properties, and
returning a new
Connection
from every
getConnection
call.
Exception thrown when an attempt to insert or update data
results in violation of a primary key or unique constraint.
ClassLoader
used to expose dynamically generated content.
Simple
DestinationResolver
implementation resolving destination names
as dynamic destinations.
Abstract base class for dynamically generated files.
Assertion methods for
DynamicFile
instances.
Subinterface of AOP Alliance Advice that allows additional interfaces
to be implemented by an Advice, and available via a proxy using that
interceptor.
Convenient abstract superclass for dynamic method matchers,
which do care about arguments at runtime.
Convenient superclass when we want to force subclasses to
implement MethodMatcher interface, but subclasses
will want to be pointcuts.
Registry used with
@DynamicPropertySource
methods so that they can add properties to the
Environment
that have
dynamically resolved values.
Method-level annotation for integration tests that need to add properties with
dynamic values to the
Environment
's set of
PropertySources
.
JpaDialect
implementation for Eclipse
Persistence Services (EclipseLink).
JpaVendorAdapter
implementation for Eclipse
Persistence Services (EclipseLink).
Interface to be implemented by JSP tags that expose a
PropertyEditor for a property that they are currently bound to.
Strategy implementation for parsing EJB3's
TransactionAttribute
annotation.
Represents the elvis operator
?:
.
EmbeddedDatabase
serves as a handle to an embedded database instance.
A builder that provides a convenient API for constructing an embedded database.
EmbeddedDatabaseConfigurer
encapsulates the configuration required to
create, connect to, and shut down a specific type of embedded database such as
HSQL, H2, or Derby.
Factory for creating an
EmbeddedDatabase
instance.
A subclass of
EmbeddedDatabaseFactory
that implements
FactoryBean
for registration as a Spring bean.
A supported embedded database type.
Convenient base class for components with a need for embedded value resolution
(i.e.
StringValueResolver
adapter for resolving placeholders and
expressions against a
ConfigurableBeanFactory
.
Interface to be implemented by any object that wishes to be notified of a
StringValueResolver
for the resolution of embedded definition values.
Empty implementation of the
ReaderEventListener
interface,
providing no-op implementations of all callback methods.
Data access exception thrown when a result was expected to have at least
one row (or element) but zero rows (or elements) were actually returned.
A simple empty implementation of the
SqlParameterSource
interface.
Canonical
TargetSource
when there is no target
(or just the target class known), and behavior is supplied
by interfaces and advisors only.
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.
@EnabledIf
is used to signal that the annotated test class or test
method is
enabled
and should be executed if the supplied
EnabledIf.expression()
evaluates to
true
.
EnabledIfCondition
is an
ExecutionCondition
that supports the
@EnabledIf
annotation when using the
Spring
TestContext Framework
in conjunction with JUnit 5's
Jupiter
programming model.
@EnabledIfRuntimeHintsAgent
signals that the annotated test class or test method
is only enabled if the
RuntimeHintsAgent
is loaded on the current JVM.
Enable JMS listener annotated endpoints that are created under the cover
by a
JmsListenerContainerFactory
.
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
MBean
s 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.
Signals the current application context to apply dependency injection to
non-managed classes that are instantiated outside the Spring bean factory
(typically classes annotated with the
@Configurable
annotation).
Enables Spring's annotation-driven transaction management capability, similar to
the support found in Spring's
<tx:*>
XML namespace.
Adding this annotation to an
@Configuration
class imports the Spring
WebFlux configuration from
WebFluxConfigurationSupport
that enables
use of annotated controllers and functional endpoints.
Adding this annotation to an
@Configuration
class imports the Spring MVC
configuration from
WebMvcConfigurationSupport
, e.g.:
Add this annotation to an
@Configuration
class to configure
processing WebSocket requests.
Add this annotation to an
@Configuration
class to enable broker-backed
messaging over WebSocket using a higher-level messaging sub-protocol.
Holder that combines a
Resource
descriptor with a specific encoding
or
Charset
to be used for reading from the resource.
Resolver that delegates to the chain, and if a resource is found, it then
attempts to find an encoded (e.g.
Resolver that delegates to the chain, and if a resource is found, it then
attempts to find an encoded (e.g.
Strategy to encode a stream of Objects of type
<T>
into an output
stream of bytes.
HttpMessageWriter
that wraps and delegates to an
Encoder
.
Indicates an issue with encoding the input Object stream with a focus on
not being able to encode Objects.
WebSocket
connection manager
that connects
to the server via
WebSocketContainer
and handles the session with an
Endpoint
.
Generates dynamic subclasses to enable method interception.
ExchangeResult
sub-class that exposes the response body fully
extracted to a representation of type
<T>
.
Base class for any class that needs to access a JPA
EntityManagerFactory
,
usually in order to obtain a JPA
EntityManager
.
Metadata interface for a Spring-managed JPA
EntityManagerFactory
.
Helper class featuring methods for JPA EntityManager handling,
allowing for reuse of EntityManager instances within transactions.
Resource holder wrapping a JPA
EntityManager
.
Subinterface of
EntityManager
to be implemented by
EntityManager proxies.
EntityResponse
<
T
>
Entity-specific subtype of
ServerResponse
that exposes entity data.
EntityResponse
<
T
>
Entity-specific subtype of
ServerResponse
that exposes entity data.
Defines a builder for
EntityResponse
.
Defines a builder for
EntityResponse
.
A
PropertySource
implementation capable of interrogating its
underlying source object to enumerate all possible property name/value
pairs.
Interface representing the environment in which the current application is running.
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.
Interface indicating a component that contains and exposes an
Environment
reference.
A strategy for handling errors.
A
GenericMessage
with a
Throwable
payload.
Representation of a complete RFC 7807 error response including status,
headers, and an RFC 7807 formatted
ProblemDetail
body.
Builder for an
ErrorResponse
.
RuntimeException
that implements
ErrorResponse
to expose
an HTTP status, response headers, and a body formatted as an RFC 7807
ProblemDetail
.
Stores and exposes information about data-binding and validation
errors for a specific object.
Resolves
Errors
method arguments.
Resolve
Errors
or
BindingResult
method arguments.
The
<errors>
tag renders field errors in an HTML 'span' tag.
The
<escapeBody>
tag is used to escape its enclosed body content,
applying HTML escaping and/or JavaScript escaping.
Errors wrapper that adds automatic HTML escaping to the wrapped instance,
for convenient usage in HTML views.
The
<eval>
tag evaluates a Spring expression (SpEL) and either prints
the result or assigns it to a variable.
Expressions are executed in an evaluation context.
Represent an exception that occurs during expression evaluation.
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.
TestExecutionListener
that publishes test execution events to the
ApplicationContext
for the currently executing test.
A TransportHandler for sending messages via Server-Sent Events:
https://dev.w3.org/html5/eventsource/
.
ExceptionCollector
is a test utility for executing code blocks,
collecting exceptions, and generating a single
AssertionError
containing any exceptions encountered as
suppressed exceptions
.
Executable
is a functional interface that can be used to implement
any generic block of code that potentially throws a
Throwable
.
Comparator capable of sorting exceptions based on their depth from the thrown exception type.
Annotation for handling exceptions in specific handler classes and/or
handler methods.
An
AbstractHandlerMethodExceptionResolver
that resolves exceptions
through
@ExceptionHandler
methods.
Discovers
@ExceptionHandler
methods in a given class,
including all of its superclasses, and helps to resolve a given
Exception
to the exception types supported by a given
Method
.
WebHandler decorator that invokes one or more
WebExceptionHandlers
after the delegate
WebHandler
.
An
InstanceFilter
implementation that handles exception types.
An exception handling
WebSocketHandlerDecorator
.
Represents a function that filters an
exchange function
.
Static factory methods providing access to built-in implementations of
ExchangeFilterFunction
for basic authentication, error handling, etc.
Deprecated.
as of Spring 5.1 in favor of using
HttpHeaders.setBasicAuth(String, String)
while building the request.
Represents a function that exchanges a
request
for a (delayed)
ClientResponse
.
Static factory methods to create an
ExchangeFunction
.
Container for request and response details for exchanges performed through
WebTestClient
.
Provides strategies for use in an
ExchangeFunction
.
A mutable builder for an
ExchangeStrategies
.
A hint that describes the need for reflection on a
Method
or
Constructor
.
Builder for
ExecutableHint
.
Represent the need of reflection for a given
Executable
.
ResponseCreator
that obtains the response by executing the request
through a
ClientHttpRequestFactory
.
Parser for the 'executor' element of the 'task' namespace.
An extension of
ChannelInterceptor
with callbacks to intercept the
asynchronous sending of a
Message
to
a specific subscriber through an
Executor
.
Base class for setting up a
ExecutorService
(typically a
ThreadPoolExecutor
or
ScheduledThreadPoolExecutor
).
Adapter that takes a Spring
TaskExecutor
and exposes a full
java.util.concurrent.ExecutorService
for it.
A
SubscribableChannel
that sends messages to each of its subscribers.
A simple type representing a range for an expected count.
Implementation of
BackOff
that increases the back off period for each
retry attempt.
Convenient methods for creating advisors that may be used when autoproxying beans
created with the Spring IoC container, binding the bean name to the current
invocation.
Interceptor that exposes the current
MethodInvocation
as a thread-local object.
An expression capable of evaluating itself against context objects.
Superclass for exceptions that can occur whilst processing expressions.
This exception wraps (as cause) a checked exception thrown by some method that SpEL
invokes.
Parses expression strings into compiled expressions that can be evaluated.
Interface to be implemented by pointcuts that use String expressions.
ExpressionState is for maintaining per-expression-evaluation state: any changes to
it are not seen by other expressions, but it gives a place to hold local variables and
for component expressions in a compound expression to communicate state.
Common utility functions that may be used by any Expression Language provider.
Resolves method arguments annotated with
@Value
.
Resolves method arguments annotated with
@Value
.
Extension of
StandardBeanInfoFactory
that supports "non-standard"
JavaBeans setter methods through introspection by Spring's
(package-visible)
ExtendedBeanInfo
implementation.
Delegate for creating a variety of
EntityManager
proxies that follow the JPA spec's semantics for "extended" EntityManagers.
Subclass of
ServletRequestDataBinder
that adds URI template variables
to the values used for data binding.
Implementation of
ResponseErrorHandler
that uses
HttpMessageConverters
to convert HTTP error responses to
RestClientExceptions
.
Convenience methods to retrieve Spring's root
WebApplicationContext
for a given JSF
FacesContext
.
RequestAttributes
adapter for a JSF
FacesContext
.
WebRequest
adapter for a JSF
FacesContext
.
All enhanced instances returned by the
Enhancer
class implement this interface.
FactoryBean
<
T
>
Interface to be implemented by objects used within a
BeanFactory
which
are themselves factories for individual objects.
Exception to be thrown from a FactoryBean's
getObject()
method
if the bean is not fully initialized yet, for example because it is involved
in a circular reference.
Support base class for singleton registries which need to handle
FactoryBean
instances,
integrated with
DefaultSingletonBeanRegistry
's singleton management.
Simple
ProblemReporter
implementation that exhibits fail-fast
behavior when errors are encountered.
Deprecated.
as of 6.0, in favor of
CompletableFuture.whenComplete(BiConsumer)
A speedy alternative to
ByteArrayOutputStream
.
Thrown on an unrecoverable problem encountered in the
beans packages or sub-packages, e.g.
Union type for fetching results.
Encapsulates a field error, that is, a reason for rejecting a specific
field value.
A hint that describes the need for reflection on a
Field
.
FactoryBean
which retrieves a static or non-static field value.
Customizes key types for
KeyFactory
right in constructor.
A visitor to visit a Java field.
Simple utility methods for file and stream copying.
Editor for
java.io.File
, to directly populate a File property
from a Spring resource location.
A
NativeConfigurationWriter
implementation that writes the
configuration to disk.
Specialization of
Part
that represents an uploaded file received in
a multipart request.
Represents an event triggered for a file upload.
Register the necessary resource hints for loading files from the classpath.
GeneratedFiles
implementation that stores generated files using a
FileSystem
.
ResourceLoader
implementation that resolves plain paths as
file system resources rather than as class path resources
(the latter is
DefaultResourceLoader
's default strategy).
Utility methods for working with the file system.
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.
Subclass of
UrlResource
which assumes file resolution, to the degree
of implementing the
WritableResource
interface for it.
Enumeration of the type filters that may be used in conjunction with
@ComponentScan
.
A simple
BackOff
implementation that provides a fixed interval
between two attempts and a maximum number of retries.
A
ContentNegotiationStrategy
that returns a fixed content type.
Resolver that always resolves to a fixed list of media types.
Specialization of
IntervalTask
for fixed-delay semantics.
A simple strategy for making reconnect attempts at a fixed interval.
LocaleContextResolver
implementation that always returns a fixed locale
and optionally time zone.
LocaleResolver
implementation
that always returns a fixed default locale and optionally time zone.
Specialization of
IntervalTask
for fixed-rate semantics.
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
Enhancer
callback that simply returns the value to return
from the proxied method.
A
VersionStrategy
that relies on a fixed version applied as a request
path prefix, e.g.
A
VersionStrategy
that relies on a fixed version applied as a request
path prefix, e.g.
Factory for "output" flash attribute assertions.
A FlashMap provides a way for one request to store attributes intended for
use in another.
A strategy interface for retrieving and saving FlashMap instances.
ApplicationStartup
implementation for the Java Flight Recorder.
Expression language AST node that represents a float literal.
FluxExchangeResult
<
T
>
ExchangeResult
variant with the response body decoded as
Flux<T>
but not yet consumed.
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.
Filter
that parses form data for HTTP PUT, PATCH, and DELETE requests
and exposes it as Servlet request parameters.
Specialization of
Part
for a form field.
Implementation of
HttpMessageConverter
to read and write 'normal' HTML
forms and also to write (but not read) multipart data (e.g.
Implementation of an
HttpMessageReader
to read HTML form data, i.e.
HttpMessageWriter
for writing a
MultiValueMap<String, String>
as HTML form data, i.e.
Represents an event triggered for a form field.
The
<form>
tag renders an HTML 'form' tag and exposes a binding path to
inner tags for binding.
Extract values from "Forwarded" and "X-Forwarded-*" headers, wrap the request
and response, and make they reflect the client-originated protocol and
address in the following methods:
getServerName()
getServerPort()
getScheme()
isSecure()
sendRedirect(String)
.
Extract values from "Forwarded" and "X-Forwarded-*" headers to override
the request URI (i.e.
Base servlet for Spring's web framework.
Interface to be implemented by objects that configure and manage a
FreeMarker Configuration object in a web environment.
Interface to be implemented by objects that configure and manage a
FreeMarker Configuration object in a web environment.
Factory that configures a FreeMarker Configuration.
Factory bean that creates a FreeMarker Configuration and provides it as
bean reference.
Configures FreeMarker for web usage via the "configLocation" and/or
"freemarkerSettings" and/or "templateLoaderPath" properties.
JavaBean to configure FreeMarker for web usage, via the "configLocation"
and/or "freemarkerSettings" and/or "templateLoaderPath" properties.
Parse the
<mvc:freemarker-configurer>
MVC namespace element and
register
FreeMarkerConfigurer
bean.
Utility class for working with FreeMarker.
A
View
implementation that uses the FreeMarker template engine.
View using the FreeMarker template engine.
A
ViewResolver
for resolving
FreeMarkerView
instances, i.e.
Convenience subclass of
UrlBasedViewResolver
that supports
FreeMarkerView
(i.e.
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).
A function reference is of the form "#someFunction(a,b,c)".
Deprecated.
as of 6.0, with no concrete replacement
Convenience utilities for working with
Future
and implementations.
A single generated class.
A managed collection of generated classes.
Interface that can be used to add
source
,
resource
, or
class
files generated
during ahead-of-time processing.
The various kinds of generated files that are supported.
The standard implementation of the
KeyHolder
interface, to be used for
holding auto-generated keys (as potentially returned by JDBC insert statements).
A generated method.
A managed collection of generated methods.
A
TypeReference
for a generated type.
Central interface used for code generation.
The
GeneratorStrategy
is responsible for taking a
ClassGenerator
and producing a byte array containing the
data for the generated
Class
.
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.
GenericBeanDefinition is a one-stop shop for declarative bean definition purposes.
A generic implementation of the
CallMetaDataProvider
interface.
Base
ConversionService
implementation suitable for use in most environments.
Generic converter interface for converting between two or more types.
Holder for a source-to-target class pair.
Simple base implementation of
Filter
which treats
its config parameters (
init-param
entries within the
filter
tag in
web.xml
) as bean properties.
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)
.
Concrete implementation of
AbstractGenericContextLoader
that reads
bean definitions from Groovy scripts
and
XML configuration files.
Concrete implementation of
AbstractGenericWebContextLoader
that loads
bean definitions from Groovy scripts
and
XML configuration files.
A specialization of
HttpMessageConverter
that can convert an HTTP request
into a target object of a specified generic type and a source object of a specified
generic type into an HTTP response.
Subinterface of
Marshaller
that has support for generics.
GenericMessage
<
T
>
An implementation of
Message
with a generic payload.
An extension of the
SimpleMessageConverter
that uses a
ConversionService
to convert the payload of the message
to the requested type.
Generic implementation of the JCA 1.7
MessageEndpointFactory
interface,
providing transaction management capabilities for any kind of message
listener object (e.g.
Internal exception thrown when a ResourceException has been encountered
during the endpoint invocation.
Generic bean that manages JCA 1.7 message endpoints within a Spring
application context, activating and deactivating the endpoint as part
of the application context's lifecycle.
A messaging template that resolves destinations names to
MessageChannel
's
to send and receive messages from.
Default implementation of the
ReactiveTransaction
interface,
used by
AbstractReactiveTransactionManager
.
GenericSqlQuery
<
T
>
Concrete implementation making it possible to define the RDBMS stored procedures
in an application context without writing a custom Java implementation class.
A generic implementation of the
TableMetaDataProvider
interface
which should provide enough features for all supported databases.
Basic
AutowireCandidateResolver
that performs a full generic type
match with the candidate's type if the dependency is declared as a generic type
(e.g.
Helper class for resolving generic types against type variables.
Subinterface of
Unmarshaller
that has support for generics.
Subclass of
GenericApplicationContext
, suitable for web environments.
Convenient application context with built-in XML support.
Concrete implementation of
AbstractGenericContextLoader
that reads
bean definitions from XML resources.
Concrete implementation of
AbstractGenericWebContextLoader
that loads
bean definitions from XML resources.
Shortcut for
@HttpExchange
for HTTP GET requests.
Annotation for mapping HTTP
GET
requests onto specific handler
methods.
LoadTimeWeaver
implementation for GlassFish's
org.glassfish.api.deployment.InstrumentableClassLoader InstrumentableClassLoader
.
A WebSocket
RequestUpgradeStrategy
for Oracle's GlassFish 4.1 and higher.
Singleton to publish a shared DefaultAdvisorAdapterRegistry instance.
A Groovy-based reader for Spring bean definitions: like a Groovy builder,
but more of a DSL for Spring configuration.
Interface to be implemented by objects that configure and manage a Groovy
MarkupTemplateEngine
for automatic lookup in a web environment.
An extension of Groovy's
TemplateConfiguration
and
an implementation of Spring MVC's
GroovyMarkupConfig
for creating
a
MarkupTemplateEngine
for use in a web application.
Parse the
<mvc:groovy-configurer>
MVC namespace element and register a
GroovyConfigurer
bean.
An
AbstractTemplateView
subclass based on Groovy XML/XHTML markup templates.
Convenience subclass of
AbstractTemplateViewResolver
that supports
GroovyMarkupView
(i.e.
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.
WebApplicationContext
implementation which takes
its configuration from Groovy bean definition scripts and/or XML files, as understood by
a
GroovyBeanDefinitionReader
.
A simple utility class for obtaining a Google Gson 2.x
GsonBuilder
which Base64-encodes
byte[]
properties when reading and writing JSON.
A
FactoryBean
for creating a Google Gson 2.x
Gson
instance.
Implementation of
HttpMessageConverter
that can read and write JSON using the
Google Gson
library.
Implementation of
MessageConverter
that can read and write JSON
using
Google Gson
.
DataFieldMaxValueIncrementer
that retrieves the next value
of a given H2 sequence.
SAP HANA specific implementation for the
CallMetaDataProvider
interface.
DataFieldMaxValueIncrementer
that retrieves the next value
of a given SAP HANA sequence.
A reference to a field or a method.
Contract to abstract the details of invoking a handler of a given type.
MVC framework SPI, allowing parameterization of the core MVC workflow.
Interface to be implemented by objects that can resolve exceptions thrown during
handler mapping or execution, in the typical case to error views.
A
HandlerExceptionResolver
that delegates to a list of other
HandlerExceptionResolvers
.
Handler execution chain, consisting of handler object and any handler interceptors.
Represents a function that filters a
handler function
.
Represents a function that filters a
handler function
.
Represents a function that handles a
request
.
Represents a function that handles a
request
.
HandlerAdapter
implementation that supports
HandlerFunctions
.
HandlerAdapter
implementation that supports
HandlerFunction
s.
Workflow interface that allows for customized handler execution chains.
Interface to be implemented by objects that define a mapping between
requests and handler objects.
Interface to be implemented by objects that define a mapping between
requests and handler objects.
Helper class to get information from the
HandlerMapping
that would
serve a specific request.
Strategy interface for resolving method parameters into argument values
in the context of a given
Message
.
Strategy interface for resolving method parameters into argument values
in the context of a given
Message
.
Strategy interface for resolving method parameters into argument values in
the context of a given request.
Strategy to resolve the argument value for a method parameter in the context
of the current HTTP request.
Resolves method parameters by delegating to a list of registered
HandlerMethodArgumentResolvers
.
Resolves method parameters by delegating to a list of registered
HandlerMethodArgumentResolvers
.
Resolves method parameters by delegating to a list of registered
HandlerMethodArgumentResolvers
.
Base class for
HandlerMethodArgumentResolver
implementations with access to a
ReactiveAdapterRegistry
and methods to check for method parameter support.
A strategy for assigning a name to a handler method's mapping.
Strategy interface to handle the value returned from the invocation of a
method handling a
Message
.
Handle the return value from the invocation of an annotated
Message
handling method.
Strategy interface to handle the value returned from the invocation of a
handler method.
A HandlerMethodReturnValueHandler that wraps and delegates to others.
A HandlerMethodReturnValueHandler that wraps and delegates to others.
Handles method return values by delegating to a list of registered
HandlerMethodReturnValueHandlers
.
Represent the result of the invocation of a handler or a handler method.
Process the
HandlerResult
, usually returned by a
HandlerAdapter
.
Base class for
HandlerResultHandler
with support for content negotiation and access to a
ReactiveAdapter
registry.
Factory for assertions on the selected handler or handler method.
Defines the strategies to be used for processing
HandlerFunctions
.
A mutable builder for a
HandlerStrategies
.
A
Predicate
to match request handling component types if
any
of the following selectors match:
Base packages -- for selecting handlers by their package.
A
HandlerTypePredicate
builder.
Thrown when handshake processing failed to complete due to an internal, unrecoverable
error.
Contract for processing a WebSocket handshake request.
Simple container of information related to the handshake request that started
the
WebSocketSession
session.
Interceptor for WebSocket handshake requests.
A helper class that assists with invoking a list of handshake interceptors.
WebSocketService
implementation that handles a WebSocket HTTP
handshake request by delegating to a
RequestUpgradeStrategy
which
is either auto-detected (no-arg constructor) from the classpath but can
also be explicitly configured.
Annotation which indicates that a method parameter should be bound to a message header.
Assertions on headers of the response.
A
ContentNegotiationStrategy
that checks the 'Accept' request header.
Resolver that looks at the 'Accept' header of the request.
HeaderMapper
<
T
>
Generic strategy interface for mapping
MessageHeaders
to and from other
types of objects.
Resolver for
@Header
arguments.
Resolver for
@Header
arguments.
Factory for response header assertions.
Annotation which indicates that a method parameter should be bound to the headers of a
message.
Argument resolver for headers.
Argument resolver for headers.
A logical conjunction (
' && '
) request condition that matches a request against
a set of header expressions with syntax defined in
RequestMapping.headers()
.
A logical conjunction (
' && '
) request condition that matches a request against
a set of header expressions with syntax defined in
RequestMapping.headers()
.
Request and response header-based
WebSessionIdResolver
.
Exception that represents a transaction failure caused by a heuristic
decision on the side of the transaction coordinator.
HibernateCallback
<
T
>
Callback interface for Hibernate code.
Convenient superclass for Hibernate-based data access objects.
PersistenceExceptionTranslator
capable of translating
HibernateException
instances to Spring's
DataAccessException
hierarchy.
Hibernate-specific subclass of UncategorizedDataAccessException,
for JDBC exceptions that Hibernate wrapped.
JpaDialect
implementation for Hibernate.
JpaVendorAdapter
implementation for Hibernate.
Hibernate-specific subclass of ObjectRetrievalFailureException.
Interface that specifies a common set of Hibernate operations as well as
a general
HibernateOperations.execute(org.springframework.orm.hibernate5.HibernateCallback<T>)
method for Session-based lambda expressions.
Hibernate-specific subclass of ObjectOptimisticLockingFailureException.
Hibernate-specific subclass of InvalidDataAccessResourceUsageException,
thrown on invalid HQL query syntax.
Hibernate-specific subclass of UncategorizedDataAccessException,
for Hibernate system errors that do not match any concrete
org.springframework.dao
exceptions.
Helper class that simplifies Hibernate data access code.
PlatformTransactionManager
implementation for a single Hibernate
SessionFactory
.
Filter
that converts posted method parameters into HTTP methods,
retrievable via
HttpServletRequest.getMethod()
.
Reactive
WebFilter
that converts posted method parameters into HTTP methods,
retrievable via
HttpRequest.getMethod()
.
The
<hidden>
tag renders an HTML 'input' tag with type 'hidden' using
the bound value.
Sub-interface implemented by bean factories that can be part
of a hierarchy.
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
Constants and convenience methods for working with hints.
Main types of
RuntimeHints
.
A
WebRequestMatcher
that allows matching on the host and optionally
the port of
WebRequest#getUrl()
.
TargetSource
implementation that
caches a local target object, but allows the target to be swapped
while the application is running.
DataFieldMaxValueIncrementer
that increments the maximum value of a given HSQL table
with the equivalent of an auto-increment column.
DataFieldMaxValueIncrementer
that retrieves the next value
of a given HSQL sequence.
The HSQL specific implementation of
TableMetaDataProvider
.
The
<htmlEscape>
tag sets default HTML escape value for the current
page.
Superclass for tags that output content that might get HTML-escaped.
An HTTP
TransportHandler
that uses a famous browser
document.domain
technique.
Utility class for HTML escaping.
Base class for
RestTemplate
and other HTTP accessing gateway helpers, defining common properties
such as the
ClientHttpRequestFactory
to operate on.
Contract to abstract the underlying HTTP client and decouple it from the
HTTP service proxy
.
Exception thrown when an HTTP 4xx is received.
HttpClientErrorException
for status HTTP 400 Bad Request.
HttpClientErrorException
for status HTTP 409 Conflict.
HttpClientErrorException
for status HTTP 403 Forbidden.
HttpClientErrorException
for status HTTP 410 Gone.
HttpClientErrorException
for status HTTP 405 Method Not Allowed.
HttpClientErrorException
for status HTTP 406 Not Acceptable.
HttpClientErrorException
for status HTTP 404 Not Found.
HttpClientErrorException
for status HTTP 429 Too Many Requests.
HttpClientErrorException
for status HTTP 401 Unauthorized.
HttpClientErrorException
for status HTTP 422 Unprocessable Entity.
HttpClientErrorException
for status HTTP 415 Unsupported Media Type.
ClientHttpConnector
implementation for the Apache HttpComponents HttpClient 5.x.
ClientHttpRequestFactory
implementation that
uses
Apache HttpComponents
HttpClient
to create requests.
Represents an HTTP cookie as a name-value pair consistent with the content of
the "Cookie" request header.
HttpEntity
<
T
>
Represents an HTTP request or response entity, consisting of headers and body.
Resolves method arguments of type
HttpEntity
or
RequestEntity
by reading the body of the request through a compatible
HttpMessageReader
.
Resolves
HttpEntity
and
RequestEntity
method argument values,
as well as return values of type
HttpEntity
,
ResponseEntity
,
ErrorResponse
and
ProblemDetail
.
Annotation to declare a method on an HTTP service interface as an HTTP
endpoint.
Lowest level contract for reactive HTTP request handling that serves as a
common denominator across different runtimes.
Connector that handles requests by invoking an
HttpHandler
rather
than making actual requests to a network socket.
Indicates that an error occurred after the server response was completed,
via
ReactiveHttpOutputMessage.writeWith(org.reactivestreams.Publisher<? extends org.springframework.core.io.buffer.DataBuffer>)
or
ReactiveHttpOutputMessage.setComplete()
,
and can no longer be changed.
Contract for applying a decorator to an
HttpHandler
.
A data structure representing HTTP request or response headers, mapping String header names
to a list of String values, also offering accessors for common application-level data types.
Handles
HttpHeaders
return values.
ServerHttpResponse
decorator for HTTP HEAD requests.
Holds the shared logger named "org.springframework.web.HttpLogging" for HTTP
related logging when "org.springframework.http" is not enabled but
"org.springframework.web" is.
Abstract base for exceptions related to media types.
Exception thrown when the request handler cannot generate a response that is
acceptable by the client.
Exception thrown when a client POSTs, PUTs, or PATCHes content of a type
not supported by request handler.
Represents the base interface for HTTP request and response messages.
Thrown by
HttpMessageConverter
implementations when a conversion attempt fails.
Strategy interface for converting from and to HTTP requests and responses.
Response extractor that uses the given
entity converters
to convert the response into a type
T
.
HttpMessageDecoder
<
T
>
Extension of
Decoder
exposing extra methods relevant in the context
of HTTP request or response body decoding.
HttpMessageEncoder
<
T
>
Extension of
Encoder
exposing extra methods relevant in the context
of HTTP request or response body encoding.
Thrown by
HttpMessageConverter
implementations when the
HttpMessageConverter.read(java.lang.Class<? extends T>, org.springframework.http.HttpInputMessage)
method fails.
Thrown by
HttpMessageConverter
implementations when the
HttpMessageConverter.write(T, org.springframework.http.MediaType, org.springframework.http.HttpOutputMessage)
method fails.
HttpMessageReader
<
T
>
Strategy for reading from a
ReactiveHttpInputMessage
and decoding
the stream of bytes to Objects of type
<T>
.
HttpMessageWriter
<
T
>
Strategy for encoding a stream of objects of type
<T>
and writing
the encoded stream of bytes to an
ReactiveHttpOutputMessage
.
View
that writes model attribute(s) with an
HttpMessageWriter
.
Represents an HTTP request method.
HttpServiceArgumentResolver
that resolves the target
request's HTTP method from an
HttpMethod
argument.
Represents an HTTP (byte) range for use with the HTTP
"Range"
header.
Plain handler interface for components that process HTTP requests,
analogous to a Servlet.
Adapter to use the plain
HttpRequestHandler
interface with the generic
DispatcherServlet
.
Simple HttpServlet that delegates to an
HttpRequestHandler
bean defined
in Spring's root web application context.
Exception thrown when a request handler does not support a
specific request method.
Container for HTTP request values extracted from an
@HttpExchange
-annotated
method and argument values passed to it.
Builder for
HttpRequestValues
.
Provides a convenient implementation of the
HttpRequest
interface
that can be overridden to adapt the request.
Extended interface for a
Resource
to be written to an
HTTP response.
Extended interface for a
Resource
to be written to an
HTTP response.
Exception thrown when an HTTP 5xx is received.
HttpServerErrorException
for HTTP status 502 Bad Gateway.
HttpServerErrorException
for status HTTP 504 Gateway Timeout.
HttpServerErrorException
for status HTTP 500 Internal Server Error.
HttpServerErrorException
for status HTTP 501 Not Implemented.
HttpServerErrorException
for status HTTP 503 Service Unavailable.
Resolve an argument from an
@HttpExchange
-annotated method
to one or more HTTP request values.
Factory to create a client proxy from an HTTP service interface with
@HttpExchange
methods.
Builder to create an
HttpServiceProxyFactory
.
Simple extension of
HttpServlet
which treats
its config parameters (
init-param
entries within the
servlet
tag in
web.xml
) as bean properties.
An interceptor to copy information from the HTTP session to the "handshake
attributes" map to be made available via
WebSocketSession.getAttributes()
.
Servlet HttpSessionListener that automatically exposes the session mutex
when an HttpSession gets created.
Exception thrown when an HTTP request handler requires a pre-existing session.
Enumeration of HTTP status codes.
Enumeration of HTTP status series.
Represents an HTTP response status code.
Abstract base class for exceptions based on an
HttpStatusCode
.
Default adapter of
WebHandler
to the
HttpHandler
contract.
An 'identifier'
SpelNode
.
An implementation of the
ObjectNamingStrategy
interface that
creates a name based on the identity of a given instance.
Contract for generating universally unique identifiers (
UUIDs
).
A
MessageHeaderInitializer
to customize the strategy for ID and TIMESTAMP message header generation.
Test annotation for use with JUnit 4 to indicate whether a test is enabled or
disabled for a specific testing profile.
Runtime exception mirroring the JMS IllegalStateException.
Exception thrown when the existence or non-existence of a transaction
amounts to an illegal state according to the transaction propagation
behavior that applies.
A simpler interceptor that calls
MessageHeaderAccessor.setImmutable()
on the headers of messages passed through the preSend method.
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.
Representation of an import that has been processed during the parsing process.
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.
Data access exception thrown when a result set did not have the correct column count,
for example when expecting a single column but getting 0 or more than 1 columns.
Data access exception thrown when a result was not of the expected size,
for example when expecting a single row but getting 0 or more than 1 rows.
Data access exception thrown when something unintended appears to have
happened with an update, but the transaction hasn't already been rolled back.
Indicate that the annotated element represents a stereotype for the index.
An Indexer can index into some proceeding structure to access a particular piece of it.
A component that can execute the SockJS "Info" request that needs to be
performed before the SockJS session starts in order to check server endpoint
capabilities such as whether the endpoint permits use of WebSocket.
Auto-proxy creator that considers infrastructure Advisor beans only,
ignoring any application-defined Advisors.
Interface to be implemented by transparent resource proxies that need to be
considered as equal to the underlying resource, for example for consistent
lookup key comparisons.
Annotation that identifies methods that initialize the
WebDataBinder
which
will be used for populating command and form object arguments
of annotated handler methods.
Adds initialization to a WebDataBinder via
@InitBinder
methods.
BeanPostProcessor
implementation
that invokes annotated init and destroy methods.
Interface to be implemented by beans that need to react once all their properties
have been set by a
BeanFactory
: e.g.
Internal class for managing injection metadata.
A single injected element.
A simple descriptor for an injection point, pointing to a method/constructor
parameter or a field.
Represent a list in an expression, e.g.
Represent a map in an expression, e.g.
GeneratedFiles
implementation that keeps generated files in-memory.
Simple Map-based storage for
WebSession
instances.
Editor for
org.xml.sax.InputSource
, converting from a
Spring resource location String to a SAX InputSource object.
One-way PropertyEditor which can convert from a text String to a
java.io.InputStream
, interpreting the given String as a
Spring resource location (e.g.
Resource
implementation for a given
InputStream
.
Simple interface for objects that are sources for an
InputStream
.
The
<input>
tag renders an HTML 'input' tag with type 'text' using
the bound value.
InstanceComparator
<
T
>
Compares objects based on an arbitrary class order.
InstanceFilter
<
T
>
A simple instance filter that checks if a given instance match based on
a collection of includes and excludes element.
InstanceSupplier
<
T
>
Specialized
Supplier
that can be set on a
BeanDefinition
when details about the
registered bean
are needed to
supply the instance.
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.
Subinterface of
BeanPostProcessor
that adds a before-instantiation callback,
and a callback after instantiation but before explicit properties are set or
autowiring occurs.
Interface to be implemented by Spring AOP Advisors wrapping AspectJ
aspects that may have a lazy initialization strategy.
Interface responsible for creating instances corresponding to a root bean definition.
LoadTimeWeaver
relying on VM
Instrumentation
.
Java agent that saves the
Instrumentation
interface from the JVM
for later use.
Deprecated.
This class should only be used by the runtime-hints agent when instrumenting bytecode
and is not considered public API.
A
MessageChannel
that
maintains a list
ChannelInterceptors
and allows interception of message sending.
ClientHttpRequestFactory
wrapper with support for
ClientHttpRequestInterceptors
.
Base class for
RestTemplate
and other HTTP accessing gateway helpers, adding interceptor-related
properties to
HttpAccessor
's common properties.
This interface represents a generic interceptor.
Assists with the creation of a
MappedInterceptor
.
Helps with configuring a list of mapped interceptors.
Subclass of
AbstractReflectiveMBeanInfoAssembler
that allows for
the management interface of a bean to be defined using arbitrary interfaces.
Generates new interfaces at runtime.
Wraps a real parse exception.
Wrapper for a JSP or other resource within the same web application.
Convenient subclass of
UrlBasedViewResolver
that supports
InternalResourceView
(i.e.
Editor for
java.mail.internet.InternetAddress
,
to directly populate an InternetAddress property.
Extension of the
BatchPreparedStatementSetter
interface,
adding a batch exhaustion check.
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.
Expression language AST node that represents an integer literal.
Superinterface for advisors that perform one or more AOP
introductions
.
A specialized type of
MethodMatcher
that takes into account introductions
when matching methods.
Interface supplying the information necessary to describe an introduction.
Support for implementations of
IntroductionInfo
.
Subinterface of AOP Alliance MethodInterceptor that allows additional interfaces
to be implemented by the interceptor, and available via a proxy using that
interceptor.
Listener that flushes the JDK's
JavaBeans Introspector
cache on web app shutdown.
Runtime exception mirroring the JMS InvalidClientIDException.
Exception thrown on incorrect usage of the API, such as failing to
"compile" a query object that needed compilation before execution.
Root for exceptions thrown when we use a data access resource incorrectly.
Runtime exception mirroring the JMS InvalidDestinationException.
Thrown when trying to invoke an operation on a proxy that is not exposed
by the proxied MBean resource's management interface.
Exception that gets thrown when an invalid isolation level is specified,
Exception thrown from
MediaType.parseMediaType(String)
in case of
encountering an invalid media type specification String.
Thrown by the
JmxAttributeSource
when it encounters
incorrect metadata on a managed resource or one of its methods.
Exception thrown from
MimeTypeUtils.parseMimeType(String)
in case of
encountering an invalid content type specification String.
Exception thrown when referring to an invalid bean property.
Exception thrown when a ResultSet has been accessed in an invalid fashion.
Runtime exception mirroring the JMS InvalidSelectorException.
Exception that gets thrown when an invalid timeout is specified,
that is, the specified timeout valid is out of range or the
transaction manager implementation doesn't support timeouts.
Extension of
HandlerMethod
that invokes the underlying method with
argument values resolved from the current HTTP request through a list of
HandlerMethodArgumentResolver
.
Extension of
HandlerMethod
that invokes the underlying method with
argument values resolved from the current HTTP request through a list of
HandlerMethodArgumentResolver
.
Extension of
HandlerMethod
that invokes the underlying method with
argument values resolved from the current HTTP request through a list of
HandlerMethodArgumentResolver
.
Extension of
HandlerMethod
that invokes the underlying method with
argument values resolved from the current HTTP request through a list of
HandlerMethodArgumentResolver
.
This interface represents an invocation in the program.
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).
InvocationHandler
replacement (unavailable under JDK 1.2).
Enumeration that represents transaction isolation levels for use with the
@Transactional
annotation, corresponding to the
TransactionDefinition
interface.
An adapter for a target
DataSource
, applying the current
Spring transaction's isolation level (and potentially specified user credentials)
to every
getConnection
call.
DataSource that routes to one of various target DataSources based on the
current transaction isolation level.
Decode bytes into CBOR and convert to Object's with Jackson.
Encode from an
Object
to bytes of CBOR objects using Jackson.
Base class providing support methods for Jackson 2.x encoding and decoding.
Decode a byte stream into JSON and convert to Object's with Jackson 2.x,
leveraging non-blocking parsing.
Encode from an
Object
stream to a byte stream of JSON objects using Jackson 2.x.
A builder used to create
ObjectMapper
instances with a fluent API.
A
FactoryBean
for creating a Jackson 2.x
ObjectMapper
(default) or
XmlMapper
(
createXmlMapper
property set to true) with setters
to enable or disable Jackson features from within XML configuration.
Decode a byte stream into Smile and convert to Object's with Jackson 2.x,
leveraging non-blocking parsing.
Encode from an
Object
stream to a byte stream of Smile objects using Jackson 2.x.
A Jackson 2.x codec for encoding and decoding SockJS messages.
Extended
MailSender
interface for JavaMail,
supporting MIME messages both as direct arguments and through preparation
callbacks.
Production implementation of the
JavaMailSender
interface,
supporting both JavaMail
MimeMessages
and Spring
SimpleMailMessages
.
Utility class for JavaScript escaping.
A hint that describes the need for Java serialization at runtime.
Builder for
JavaSerializationHint
.
An
HttpMessageConverter
that can read XML collections using JAXB2.
Implementation of the
GenericMarshaller
interface for JAXB 2.2.
Implementation of
HttpMessageConverter
that can read and write XML using JAXB2.
Decode from a bytes stream containing XML elements to a stream of
Object
s (POJOs).
Encode from single value to a byte stream containing XML elements.
LoadTimeWeaver
implementation for JBoss's instrumentable ClassLoader.
Base class for JSR-107 caching aspects, such as the
JCacheInterceptor
or an AspectJ aspect.
Cache
implementation on top of a
javax.cache.Cache
instance.
CacheManager
implementation
backed by a JCache
javax.cache.CacheManager
.
Extension of
CachingConfigurer
for the JSR-107 implementation.
Deprecated.
as of 6.0 in favor of implementing
JCacheConfigurer
directly
AOP Alliance MethodInterceptor for declarative cache
management using JSR-107 caching annotations.
FactoryBean
for a JCache
javax.cache.CacheManager
,
obtaining a pre-defined
CacheManager
by name through the standard
JCache
javax.cache.Caching
class.
Model the base of JSR-107 cache operation through an interface contract.
Interface used by
JCacheInterceptor
.
Deprecated, for removal: This API element is subject to removal in a future version.
since 6.0.10, as it is not used by the framework anymore
Default implementation of the
SqlXmlHandler
interface.
Base class for
JdbcTemplate
and
other JDBC-accessing DAO helpers, defining common properties such as
DataSource and exception translator.
Deprecated.
as of 5.3, in favor of Spring's common bean definition formats
and/or custom reader implementations
Convenient superclass for JDBC-based data access objects.
NamespaceHandler
for JDBC configuration namespace.
Interface specifying a basic set of JDBC operations.
This is the central class in the JDBC core package.
It simplifies the use of JDBC and helps to avoid common errors.
JdbcTestUtils
is a collection of JDBC related utility functions
intended to simplify standard database testing scenarios.
JdbcAccessor
-aligned subclass of the plain
DataSourceTransactionManager
,
adding common JDBC exception translation for the commit and rollback step.
Convenient base class for JDBC-aware transaction objects.
Exception thrown when a JDBC update affects an unexpected number of rows.
Generic utility methods for working with JDBC.
ClientHttpConnector
for the Java
HttpClient
.
Factory to manage JDK HttpClient resources such as a shared
Executor
within the lifecycle of a Spring
ApplicationContext
.
An
IdGenerator
that calls
UUID.randomUUID()
.
A hint that describes the need for a JDK interface-based
Proxy
.
Builder for
JdkProxyHint
.
Regular expression pointcut based on the
java.util.regex
package.
NamespaceHandler
for the '
jee
' namespace.
ClientHttpConnector
for the Jetty Reactive Streams HttpClient.
ServletHttpHandlerAdapter
extension that uses Jetty APIs for writing
to the response with
ByteBuffer
.
A WebSocket
RequestUpgradeStrategy
for Jetty 11.
A
RequestUpgradeStrategy
for Jetty 11.
Factory to manage Jetty resources, i.e.
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.0.3, in favor of
StandardWebSocketClient
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.0.3, in favor of
StandardWebSocketClient
Jetty
@WebSocket
handler that delegates events to a
reactive
WebSocketHandler
and its session.
Adapts
WebSocketHandler
to the Jetty 9 WebSocket API.
Spring
WebSocketSession
implementation that adapts to a Jetty
WebSocket
Session
.
A
WebSocketSession
for use with the Jetty 9.4 WebSocket API.
An XHR transport based on Jetty's
HttpClient
.
Base class for
JmsTemplate
and other
JMS-accessing gateway helpers, defining common properties such as the
JMS
ConnectionFactory
to operate on.
Common configuration object for activating a JMS message endpoint.
Strategy interface for creating JCA 1.5 ActivationSpec objects
based on a configured
JmsActivationSpecConfig
object.
@Configuration
class that registers a
JmsListenerAnnotationBeanPostProcessor
bean capable of processing Spring's
@JmsListener
annotation.
Base class for
JmsTemplate
and other
JMS-accessing gateway helpers, adding destination-related properties to
JmsAccessor's
common properties.
Base class for exception thrown by the framework whenever it
encounters a problem related to JMS.
Convenient superclass for application classes that need JMS access.
Pre-defined names and prefixes to be used for setting and/or retrieving
JMS attributes from/to generic message headers.
Annotation that marks a method to be the target of a JMS message listener on the
specified
JmsListener.destination()
.
Bean post-processor that registers methods annotated with
JmsListener
to be invoked by a JMS message listener container created under the cover
by a
JmsListenerContainerFactory
according to the attributes of the annotation.
Optional interface to be implemented by a Spring managed bean willing
to customize how JMS listener endpoints are configured.
Configuration constants for internal sharing across subpackages.
Factory of
MessageListenerContainer
based on a
JmsListenerEndpoint
definition.
Model for a JMS listener endpoint.
Helper bean for registering
JmsListenerEndpoint
with a
JmsListenerEndpointRegistry
.
Creates the necessary
MessageListenerContainer
instances for the
registered
endpoints
.
Container annotation that aggregates several
JmsListener
annotations.
JMS-specific implementation of the JCA 1.7
MessageEndpointFactory
interface,
providing transaction management capabilities for a JMS listener object
(e.g.
Internal exception thrown when a ResourceException has been encountered
during the endpoint invocation.
Extension of the generic JCA 1.5
GenericMessageEndpointManager
,
adding JMS-specific support for ActivationSpec configuration.
A
MessageHeaderAccessor
implementation giving access to JMS-specific headers.
A specialization of
MessageSendingOperations
,
MessageReceivingOperations
and
MessageRequestReplyOperations
for JMS related operations that allow to specify
a destination name rather than the actual
Destination
.
An implementation of
JmsMessageOperations
.
A
NamespaceHandler
for the JMS namespace.
Specifies a basic set of JMS operations.
Resource holder wrapping a JMS
Connection
and a JMS
Session
.
JmsResponse
<
T
>
Return type of any JMS listener method used to indicate the actual response
destination alongside the response itself.
Runtime exception mirroring the JMS JMSSecurityException.
Helper class that simplifies synchronous JMS access code.
PlatformTransactionManager
implementation
for a single JMS
ConnectionFactory
.
Generic utility methods for working with JMS.
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.
JndiCallback
<
T
>
Callback interface to be implemented by classes that need to perform an
operation (such as a lookup) in a JNDI context.
JNDI-based
DataSourceLookup
implementation.
DestinationResolver
implementation which interprets destination names
as JNDI locations (with a configurable fallback strategy).
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.
A Spring
FactoryBean
for creating a Quartz
JobDetail
instance, supporting bean-style usage for JobDetail configuration.
Unchecked exception that wraps an exception thrown from a target method.
This interface represents a generic runtime joinpoint (in the AOP
terminology).
CommandLinePropertySource
implementation backed by a JOpt
OptionSet
.
SPI strategy that encapsulates certain functionality that standard JPA 3.0 does
not offer, such as access to the underlying JDBC Connection.
JPA-specific subclass of ObjectRetrievalFailureException.
JPA-specific subclass of ObjectOptimisticLockingFailureException.
JPA-specific subclass of UncategorizedDataAccessException,
for JPA system errors that do not match any concrete
org.springframework.dao
exceptions.
PlatformTransactionManager
implementation
for a single JPA
EntityManagerFactory
.
SPI interface that allows to plug in vendor-specific behavior
into Spring's EntityManagerFactory creators.
Implementation of
HttpMessageConverter
that can read and write JSON using the
JSON Binding API
.
Implementation of
MessageConverter
that can read and write JSON
using the
JSON Binding API
.
A helper class for assertions on JSON content.
JsonPath
assertions.
A helper class for applying assertions via JSON path expressions.
Factory for assertions on the request content using
JsonPath
expressions.
Factory for assertions on the response content using
JsonPath
expressions.
A
RequestBodyAdvice
implementation that adds support for Jackson's
@JsonView
annotation declared on a Spring MVC
@HttpEntity
or
@RequestBody
method parameter.
A
ResponseBodyAdvice
implementation that adds support for Jackson's
@JsonView
annotation declared on a Spring MVC
@RequestMapping
or
@ExceptionHandler
method.
JSP-aware (and JSTL-aware) subclass of RequestContext, allowing for
population of the context from a
jakarta.servlet.jsp.PageContext
.
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.
Helper class for preparing JSTL views,
in particular for exposing a JSTL localization context.
Specialization of
InternalResourceView
for JSTL pages,
Adapter for a JTA Synchronization, invoking the
afterCommit
/
afterCompletion
callbacks of Spring
TransactionSynchronization
objects callbacks after the outer JTA transaction has completed.
Strategy implementation for parsing JTA 1.2's
Transactional
annotation.
PlatformTransactionManager
implementation
for JTA, delegating to a backend JTA provider.
Parser for the <tx:jta-transaction-manager/> XML configuration element.
Deprecated.
as of 6.0, in favor of a straight
JtaTransactionManager
definition
JTA transaction object, representing a
UserTransaction
.
Generates classes to handle multi-valued keys, for use in things such as Maps and Sets.
Marker interface for customizers of
KeyFactory
Cache key generator.
Interface for retrieving keys, typically used for auto-generated keys
as potentially returned by JDBC insert statements.
ObjectNamingStrategy
implementation that builds
ObjectName
instances from the key used in the
"beans" map passed to
MBeanExporter
.
A common delegate for detecting Kotlin's presence and for identifying Kotlin types.
ParameterNameDiscoverer
implementation which uses Kotlin's reflection facilities
for introspecting parameter names.
KotlinSerializationBinaryDecoder
<
T
extends kotlinx.serialization.BinaryFormat>
Abstract base class for
Decoder
implementations that defer to Kotlin
binary serializers.
KotlinSerializationBinaryEncoder
<
T
extends kotlinx.serialization.BinaryFormat>
Abstract base class for
Encoder
implementations that defer to Kotlin
binary serializers.
KotlinSerializationBinaryHttpMessageConverter
<
T
extends kotlinx.serialization.BinaryFormat>
Abstract base class for
HttpMessageConverter
implementations that
defer to Kotlin binary serializers.
Decode a byte stream into CBOR and convert to Objects with
kotlinx.serialization
.
Encode from an
Object
stream to a byte stream of CBOR objects using
kotlinx.serialization
.
Implementation of
HttpMessageConverter
that can read and write CBOR using
kotlinx.serialization
.
Decode a byte stream into JSON and convert to Object's with
kotlinx.serialization
.
Encode from an
Object
stream to a byte stream of JSON objects using
kotlinx.serialization
.
Implementation of
HttpMessageConverter
that can read and write JSON using
kotlinx.serialization
.
Implementation of
MessageConverter
that can read and write JSON
using
kotlinx.serialization
.
Decode a byte stream into a protocol Buffer and convert to Objects with
kotlinx.serialization
.
Decode a byte stream into a Protocol Buffer and convert to Objects with
kotlinx.serialization
.
Implementation of
HttpMessageConverter
that can read and write Protocol Buffers using
kotlinx.serialization
.
KotlinSerializationStringDecoder
<
T
extends kotlinx.serialization.StringFormat>
Abstract base class for
Decoder
implementations that defer to Kotlin
string serializers.
KotlinSerializationStringEncoder
<
T
extends kotlinx.serialization.StringFormat>
Abstract base class for
Encoder
implementations that defer to Kotlin
string serializers.
KotlinSerializationStringHttpMessageConverter
<
T
extends kotlinx.serialization.StringFormat>
Abstract base class for
HttpMessageConverter
implementations that
defer to Kotlin string serializers.
KotlinSerializationSupport
<
T
extends kotlinx.serialization.SerialFormat>
Base class providing support methods for encoding and decoding with Kotlin
serialization.
A position in the bytecode of a method.
The
<label>
tag renders a form field label in an HTML 'label' tag.
NamespaceHandler
that supports the wiring of
objects backed by dynamic languages such as Groovy, JRuby and
BeanShell.
Utilities for use with
LangNamespaceHandler
.
Deprecated.
as of 5.3.9 in favor of using the
checkNotModified
methods
in
WebRequest
, or from an
annotated controller method, returning a
ResponseEntity
with an "ETag" and/or
"Last-Modified" headers set.
Indicates whether a bean is to be lazily initialized.
Proxy for a target DataSource, fetching actual JDBC Connections lazily,
TargetSource
that lazily accesses a
singleton bean from a
BeanFactory
.
TargetSourceCreator
that enforces a
LazyInitTargetSource
for
each bean that is defined as "lazy-init".
Lazy-loading
Enhancer
callback.
Decorator to cause a
MetadataAwareAspectInstanceFactory
to instantiate only once.
A common interface defining methods for start/stop lifecycle control.
Strategy interface for processing Lifecycle beans within the ApplicationContext.
Custom
List
to collect data buffers with and enforce a
limit on the total number of bytes buffered.
LinkedHashMap
variant that stores String keys in a case-insensitive
manner, for example for key-based access in a results table.
Simple implementation of
MultiValueMap
that wraps a
LinkedHashMap
,
storing multiple values in an
ArrayList
.
Extension of the
BeanFactory
interface to be implemented by bean factories
that can enumerate all their bean instances, rather than attempting bean lookup
by name one by one as requested by clients.
ListenableFuture
<
T
>
Deprecated.
as of 6.0, in favor of
CompletableFuture
Deprecated.
as of 6.0, in favor of
CompletableFuture
Deprecated.
as of 6.0, in favor of
CompletableFuture.whenComplete(BiConsumer)
Deprecated.
as of 6.0, with no concrete replacement
Deprecated.
as of 6.0, in favor of
CompletableFutureReturnValueHandler
Deprecated.
as of 6.0, with no concrete replacement
Exception to be thrown when the execution of a listener method failed.
Simple factory for shared List instances.
Common superclass for nodes representing literals (boolean, string, number, etc).
A very simple hardcoded implementation of the Expression interface that represents a
string literal.
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.
Interface that abstracts potentially database-specific creation of large binary
fields and large text fields.
Abstraction for handling large binary fields and large text fields in
specific databases, no matter if represented as simple types or Large OBjects.
Exception to be thrown when a LOB could not be retrieved.
FactoryBean
that creates
a local JCA connection factory in "non-managed" mode (as defined by the
Java Connector Architecture specification).
FactoryBean
that creates a JPA
EntityManagerFactory
according to JPA's standard
container
bootstrap contract.
Subclass of Quartz's
JobStoreCMT
class that delegates to a Spring-managed
DataSource
instead of using a Quartz-managed JDBC connection pool.
Interceptor that allows for changing the current locale on every request,
via a configurable request parameter (default parameter name: "locale").
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.
Interface for web-based locale context resolution strategies that allows
for both locale context resolution via the request and locale context modification
via the HTTP exchange.
Extension of
LocaleResolver
that adds support for a rich locale context
(potentially including locale and time zone information).
Editor for
java.util.Locale
, to directly populate a Locale property.
FactoryBean
that creates a JPA
EntityManagerFactory
according to JPA's standard
standalone
bootstrap contract.
Interface for web-based locale resolution strategies that allows for
both locale resolution via the request and locale modification via
request and response.
Helper class for loading a localized resource,
specified through name, extension and current locale.
FactoryBean
that creates a Hibernate
SessionFactory
.
A Spring-provided extension of the standard Hibernate
Configuration
class,
adding
SpringSessionContext
as a default and providing convenient ways
to specify a JDBC
DataSource
and an application class loader.
Quartz
ThreadPool
adapter that delegates to a Spring-managed
Executor
instance, specified on
SchedulerFactoryBean
.
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
MethodVisitor
that renumbers local variables in their order of
appearance.
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.0.1, in favor of
StandardReflectionParameterNameDiscoverer
(with the "-parameters" compiler flag)
Class that models an arbitrary location in a
resource
.
A simple logging interface abstracting logging APIs.
A convenient accessor for Commons Logging, providing not only
CharSequence
based log methods but also
Supplier
based variants for use with Java 8 lambda expressions.
Factory for common
Log
delegates with Spring's logging conventions.
A minimal incarnation of Apache Commons Logging's
LogFactory
API,
providing just the common
Log
lookup methods.
Deprecated.
since it is only meant to be used in the above-mentioned fallback scenario
Utility methods for formatting and logging messages.
A
CacheErrorHandler
implementation that logs error messages.
Base class for
Encoder
,
Decoder
,
HttpMessageReader
, or
HttpMessageWriter
that uses a logger and shows potentially sensitive
request data.
A
WebSocketHandlerDecorator
that adds logging to WebSocket lifecycle events.
A simple log message type for use with Commons Logging, allowing for convenient
lazy resolution of a given
Supplier
instance (typically bound to a lambda
expression) or a printf-style format string (
String.format(java.lang.String, java.lang.Object...)
) in its
LogMessage.toString()
.
Expression language AST node that represents a long integer literal.
An annotation that indicates 'lookup' methods, to be overridden by the container
to redirect them back to the
BeanFactory
for a
getBean
call.
Represents an override of a method that looks up an object in the same IoC context,
either by bean name or by bean type (based on the declared method return type).
Exception thrown on failed authentication.
Base class for all mail exceptions.
This is a common interface for mail messages, allowing a user to set key
values required in assembling a mail message, without needing to know if
the underlying message is a simple text message or a more sophisticated
MIME message.
Exception thrown if illegal message properties are encountered.
Exception to be thrown by user code if a mail cannot be prepared properly,
for example when a FreeMarker template cannot be rendered for the mail text.
This interface defines a strategy for sending simple mails.
Exception thrown when a mail sending error is encountered.
Tag collection class used to hold managed array elements, which may
include runtime bean references (to be resolved into bean objects).
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.
ManagedList
<
E
>
Tag collection class used to hold managed List elements, which may
include runtime bean references (to be resolved into bean objects).
Tag collection class used to hold managed Map values, which may
include runtime bean references (to be resolved into bean objects).
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.
Tag class which represents a Spring-managed
Properties
instance
that supports merging of parent/child definitions.
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.
ManagedSet
<
E
>
Tag collection class used to hold managed Set values, which may
include runtime bean references (to be resolved into bean objects).
Adapter for a managed JTA Transaction handle, taking a JTA
TransactionManager
reference and creating
a JTA
Transaction
handle for it.
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.
Simple
ConnectionFactoryLookup
implementation that relies
on a map for doing lookups.
Simple
DataSourceLookup
implementation that relies on a map for doing lookups.
Simple factory for shared Map instances.
Wraps a
HandlerInterceptor
and uses URL patterns to determine whether
it applies to a given request.
Meta annotation that indicates a web mapping annotation.
Implementation of
HttpMessageConverter
that can read and write the
CBOR
data format using
the dedicated Jackson 2.x extension
.
Implementation of
HttpMessageConverter
that can read and
write JSON using
Jackson 2.x's
ObjectMapper
.
Spring MVC
View
that renders JSON content by serializing the model for the current request
using
Jackson 2's
ObjectMapper
.
Message converter that uses Jackson 2.x to convert messages to and from JSON.
A Jackson 2 based
MessageConverter
implementation.
Implementation of
HttpMessageConverter
that can read and write Smile data format ("binary JSON") using
the dedicated Jackson 2.x extension.
Implementation of
HttpMessageConverter
that can read and write XML using
Jackson 2.x extension component for reading and writing XML encoded data
.
Spring MVC
View
that renders XML content by serializing the model for the current request
using
Jackson 2's
XmlMapper
.
HttpInputMessage
that can eventually stores a Jackson view that will be used
to deserialize the message.
A simple holder for the POJO to serialize via
MappingJackson2HttpMessageConverter
along with further
serialization instructions to be passed in to the converter.
An implementation of
MediaTypeFileExtensionResolver
that maintains
lookups between file extensions and MediaTypes in both directions.
MappingSqlQuery
<
T
>
Reusable query in which concrete subclasses must implement the abstract
mapRow(ResultSet, int) method to convert each row of the JDBC ResultSet
into an object.
Reusable RDBMS query in which concrete subclasses must implement
the abstract mapRow(ResultSet, int) method to map each row of
the JDBC ResultSet into an object.
PropertySource
that reads keys and values from a
Map
object.
SqlParameterSource
implementation that holds a given Map of parameters.
DataFieldMaxValueIncrementer
that retrieves the next value of a given
MariaDB sequence.
Defines the contract for Object XML Mapping Marshallers.
Base class for exception thrown when a marshalling or unmarshalling error occurs.
Exception thrown on marshalling failure.
Implementation of
HttpMessageConverter
that can read and write XML using Spring's
Marshaller
and
Unmarshaller
abstractions.
Implementation of
MessageConverter
that can read and write XML using Spring's
Marshaller
and
Unmarshaller
abstractions.
Source
implementation that uses a
Marshaller
.Can be constructed with a
Marshaller
and an object to be marshalled.
Spring-MVC
View
that allows for response context to be rendered as the result
of marshalling by a
Marshaller
.
Additional interface that a
HandlerMapping
can implement to expose
a request matching API aligned with its internal request matching
configuration and implementation.
Very simple implementation of TransactionAttributeSource which will always return
the same TransactionAttribute for all methods fed to it.
Annotation which indicates that a method parameter should be bound to a
name-value pair within a path segment.
Resolves arguments of type
Map
annotated with
@MatrixVariable
where the annotation does not specify a name.
Resolves arguments of type
Map
annotated with
@MatrixVariable
where the annotation does not specify a name.
Resolves arguments annotated with
@MatrixVariable
.
Resolves arguments annotated with
@MatrixVariable
.
MultipartException subclass thrown when an upload exceeds the
maximum upload size allowed.
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
Exception thrown when we cannot locate an instance of an
MBeanServer
,
or when more than one instance is found.
A subclass of
MimeType
that adds support for quality parameters
as defined in the HTTP specification.
A contract for media type expressions (e.g.
A contract for media type expressions (e.g.
Strategy to resolve a
MediaType
to a list of file extensions —
for example, to resolve "application/json" to "json".
Predefined
Member
categories.
Base hint that describes the need for reflection on a
Member
.
Interface representing an object whose value set can be merged with
that of a parent object.
A single merged annotation returned from a
MergedAnnotations
collection.
Adaptations that can be applied to attribute values when creating
Maps
or
AnnotationAttributes
.
Collector
implementations that provide various reduction operations for
MergedAnnotation
instances.
Predicate implementations that provide various test operations for
MergedAnnotations
.
Provides access to a collection of merged annotations, usually obtained
from a source such as a
Class
or
Method
.
Fluent API for configuring the search algorithm used in the
MergedAnnotations
model and performing a search.
Search strategies supported by
MergedAnnotations.search(SearchStrategy)
as well as
MergedAnnotations.from(AnnotatedElement, SearchStrategy)
and variants of that method.
Strategy interface used to select between two
MergedAnnotation
instances.
MergedAnnotationSelector
implementations that provide various options
for
MergedAnnotation
instances.
Post-processor callback interface for
merged
bean definitions at runtime.
MergedContextConfiguration
encapsulates the
merged
context
configuration declared on a test class and all of its superclasses and
enclosing classes via
@ContextConfiguration
,
@ActiveProfiles
, and
@TestPropertySource
.
A generic message representation with headers and body.
A registry for configuring message broker options.
MessageBuilder
<
T
>
Defines methods for sending messages.
A strategy interface for formatting message codes.
Strategy interface for building message codes from validation error codes.
MessageCondition
<
T
>
Contract for mapping conditions to messages.
Thrown by
MessageConverter
implementations when the conversion
of an object to/from a
Message
fails.
An exception raised by
MessageConverter
implementations.
Strategy interface that specifies a converter between Java objects and JMS messages.
A converter to turn the payload of a
Message
from serialized form to a typed
Object and vice versa.
Creates a JMS message given a
Session
.
Exception that indicates an error occurred during message delivery.
Runtime exception mirroring the JMS MessageEOFException.
Annotation for handling exceptions thrown from message-handling methods within a
specific handler class.
Runtime exception mirroring the JMS MessageFormatException.
Simple contract for handling a
Message
.
A factory for
InvocableHandlerMethod
that is suitable to process
an incoming
Message
Exception that indicates an error occurred during message handling.
Extension of the
Runnable
interface with methods to obtain the
MessageHandler
and
Message
to be handled.
Wrapper around
MessageHeaders
that provides extra features such as
strongly typed accessors for specific headers, the ability to leave headers
in a
Message
mutable, and the option to suppress automatic generation
of
id
and
timestamp
headers.
Callback interface for initializing a
MessageHeaderAccessor
.
The headers for a
Message
.
Message listener adapter that delegates the handling of messages to target
listener methods via reflection, with flexible message type conversion.
Internal abstraction used by the framework representing a message
listener container.
Annotation for mapping a
Message
onto a message-handling method by
matching the declared
patterns
to a destination extracted
from the message.
Extension of
AbstractMethodMessageHandler
for reactive, non-blocking
handling of messages via
@MessageMapping
methods.
ReflectiveProcessor
implementation for types annotated
with
@MessageMapping
,
@SubscribeMapping
and
@MessageExceptionHandler
.
HandlerMethodArgumentResolver
for
Message
method arguments.
Runtime exception mirroring the JMS MessageNotReadableException.
Runtime exception mirroring the JMS MessageNotWriteableException.
To be used with JmsTemplate's send method that converts an object to a message.
A contract for processing a
Message
after it has been created, either
returning a modified (effectively new) message or returning the same.
Operations for receiving messages from a destination.
Operations for sending messages to and receiving the reply from a destination.
Operations for sending messages to a destination.
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
.
The
<message>
tag looks up a message in the scope of this page.
Constants that indicate a target message type to convert to: a
TextMessage
, a
BytesMessage
,
a
MapMessage
or an
ObjectMessage
.
Represents a Spring-managed bean with cross-cutting functionality to be
applied to one or more Spring beans with annotation-based message
handling methods.
The base exception for any failures related to messaging.
Convert a
Message
from the messaging abstraction to and from a
Message
using an underlying
MessageConverter
for the payload and a
JmsHeaderMapper
to map the JMS headers to and from standard message headers.
A
MessageListener
adapter that invokes a configurable
InvocableHandlerMethod
.
Exception indicating that something went wrong during JDBC meta-data lookup.
RSocketServiceArgumentResolver
for metadata entries.
Subinterface of
AspectInstanceFactory
that returns
AspectMetadata
associated with AspectJ-annotated classes.
Strategy to extract a map of value(s) from
Payload
metadata, which
could be composite metadata with multiple entries.
Stores registrations of extractors for metadata entries.
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.
Simple facade for accessing class metadata,
as read by an ASM
ClassReader
.
Factory interface for
MetadataReader
instances.
A ConversionNotSupportedException raised while resolving a method argument.
Exception to be thrown when a method argument fails validation perhaps as a
result of
@Valid
style validation, or perhaps because it is required.
Exception to be thrown when validation on an argument annotated with
@Valid
fails.
Common exception resulting from the invocation of
HandlerMethodArgumentResolver
.
Exception that indicates that a method argument has not the expected type.
A TypeMismatchException raised while resolving a controller method argument.
A method-based
EvaluationContext
that
provides explicit support for method-based invocations.
Advice invoked before a method is invoked.
Interceptor to wrap a
MethodBeforeAdvice
.
A common key class for a method against a specific target class,
including
MethodClassKey.toString()
representation and
Comparable
support (as suggested for custom
HashMap
keys as of Java 8).
DOCUMENTATION FROM APACHE AVALON DELEGATE CLASS
AbstractReflectiveMBeanInfoAssembler
subclass that allows
method names to be explicitly excluded as MBean operations and attributes.
MethodExecutors are built by the resolvers and can be cached by the infrastructure to
repeat an operation quickly without going back to the resolvers.
MethodFilter instances allow SpEL users to fine tune the behaviour of the method
resolution process.
Intercepts calls on an interface on its way to the target.
General-purpose
Enhancer
callback which provides for "around advice".
Defines the algorithm for searching for metadata-associated methods exhaustively
including interfaces and parent classes while also dealing with parameterized methods
as well as common scenarios encountered with interface and class-based proxies.
A callback interface for metadata lookup on a given method.
Description of an invocation to a method, given to an interceptor
upon method-call.
Thrown when a bean property getter or setter method throws an exception,
analogous to an InvocationTargetException.
An implementation of the AspectJ
ProceedingJoinPoint
interface
wrapping an AOP Alliance
MethodInvocation
.
Helper class that allows for specifying a method to invoke in a declarative
fashion, be it static or non-static.
Simple method invoker bean: just invoking a target method, not expecting a result
to expose to the container (in contrast to
MethodInvokingFactoryBean
).
FactoryBean
which returns a value which is the result of a static or instance
method invocation.
FactoryBean
that exposes a
JobDetail
object which delegates job execution to a
specified (static or non-static) method.
Quartz Job implementation that invokes a specified method.
Extension of the MethodInvokingJob, implementing the StatefulJob interface.
Adapter that implements the
Runnable
interface as a configurable
method invocation based on Spring's MethodInvoker.
A
JmsListenerEndpoint
providing the method to invoke to process
an incoming message for this endpoint.
FactoryBean
implementation that locates a
Method
on a specified bean.
Simple
TransactionAttributeSource
implementation that
allows attributes to be stored per method in a
Map
.
Part of a
Pointcut
: Checks whether the target method is eligible for advice.
Static utility methods for composing
MethodMatchers
.
Interface that defines abstract access to the annotations of a specific
method, in a form that does not require that method's class to be loaded yet.
Subclass of
AbstractReflectiveMBeanInfoAssembler
that allows
to specify method names to be exposed as MBean operations and attributes.
Exception for errors that fit response status 405 (method not allowed).
Object representing the override of a method on a managed object by the IoC
container.
Set of method overrides, determining which, if any, methods on a
managed object the Spring IoC container will override at runtime.
Helper class that encapsulates the specification of a method parameter, i.e.
Classes generated by
Enhancer
pass this object to the
registered
MethodInterceptor
objects when an intercepted method is invoked.
Reference to a Java method, identified by its owner class and the method name.
A reference to a method with convenient code generation for
referencing, or invoking it.
Expression language AST node that represents a method reference.
Strategy for generating code for arguments based on their type.
Interface to be implemented by classes that can reimplement any method on an
IoC-managed object: the
Method Injection
form of Dependency Injection.
A method resolver attempts to locate a method and returns a command executor that can be
used to invoke that method.
Exception thrown when the Code attribute of a method produced by a
ClassWriter
is too
large.
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.
A visitor to visit a Java method.
Represents how the measurement values of a
ManagedMetric
will change over time.
Represents a container for MIME attachments
Concrete implementations might adapt a SOAPMessage or an email message.
Implementation of the MailMessage interface for a JavaMail MIME message,
to let message population code interact with a simple message or a MIME
message through a common interface.
Subinterface of
Marshaller
that can use MIME attachments to optimize
storage of binary data.
Helper class for populating a
MimeMessage
.
Callback interface for the preparation of JavaMail MIME messages.
Represents a MIME Type, as originally defined in RFC 2046 and subsequently
used in other Internet protocols including HTTP.
Deprecated, for removal: This API element is subject to removal in a future version.
As of 6.0, with no direct replacement
Miscellaneous
MimeType
utility methods.
Subinterface of
Unmarshaller
that can use MIME attachments
to optimize storage of binary data.
ServletRequestBindingException
subclass that indicates that a matrix
variable expected in the method parameters of an
@RequestMapping
method is not present among the matrix variables extracted from the URL.
ServletRequestBindingException
subclass that indicates that a path
variable expected in the method parameters of an
@RequestMapping
method is not present among the URI variables extracted from the URL.
ServletRequestBindingException
subclass that indicates
that a request cookie expected in the method parameters of an
@RequestMapping
method is not present.
ServletRequestBindingException
subclass that indicates
that a request header expected in the method parameters of an
@RequestMapping
method is not present.
Base class for
ServletRequestBindingException
exceptions that could
not bind because the request value is required but is either missing or
otherwise resolves to
null
after conversion.
ServerWebInputException
subclass that indicates a missing request
value such as a request header, cookie value, query parameter, etc.
Exception thrown when required properties are not found.
ServletRequestBindingException
subclass that indicates a missing parameter.
Signals the part of a "multipart/form-data" request, identified by name
could not be found.
MessagingException
thrown when a session is missing.
Mixin
allows
multiple objects to be combined into a single larger object.
Mock implementation of the
AsyncContext
interface.
Mock implementation of the
BodyContent
class.
Mock implementation of
ClientHttpRequest
.
Mock implementation of
ClientHttpRequest
.
Mock implementation of
ClientHttpResponse
.
Mock implementation of
ClientHttpResponse
.
Extension of
Cookie
with extra attributes, as defined in
RFC 6265
.
Simple
ConfigurableEnvironment
implementation exposing
MockEnvironment.setProperty(String, String)
and
MockEnvironment.withProperty(String, String)
methods for testing purposes.
Mock implementation of the
FilterChain
interface.
Mock implementation of the
FilterConfig
interface.
Mock implementation of
HttpInputMessage
.
Mock implementation of
HttpOutputMessage
.
Mock implementation of
HttpServletMapping
.
Mock implementation of the
HttpServletRequest
interface.
Default builder for
MockHttpServletRequest
required as input to
perform requests in
MockMvc
.
Mock implementation of the
HttpServletResponse
interface.
Mock implementation of the
HttpSession
interface.
Mock implementation of the
JspWriter
class.
Mock implementation of the
MultipartFile
interface.
Mock implementation of the
MultipartHttpServletRequest
interface.
Default builder for
MockMultipartHttpServletRequest
.
Main entry point for server-side Spring MVC test support.
Builds a
MockMvc
instance.
The main class to import in order to access all available
MockMvcBuilders
.
Base class for MockMvc builder implementations, providing the capability to
create a
MockMvc
instance.
A
ClientHttpRequestFactory
for requests executed via
MockMvc
.
Contract for customizing a
ConfigurableMockMvcBuilder
in some
specific way, e.g.
An empty method implementation of
MockMvcConfigurer
.
MockMvcHtmlUnitDriverBuilder
simplifies the building of an
HtmlUnitDriver
that delegates to
MockMvc
and optionally
delegates to an actual connection for specific requests.
Connector that handles requests by invoking a
MockMvc
rather than
making actual requests over HTTP.
Static factory methods for
RequestBuilders
.
Static factory methods for
ResultHandler
-based result actions.
Static factory methods for
ResultMatcher
-based result actions.
MockMvcWebClientBuilder
simplifies the creation of an HtmlUnit
WebClient
that delegates to a
MockMvc
instance.
Support class that simplifies the creation of a
WebConnection
that
uses
MockMvc
and optionally delegates to a real
WebConnection
for specific requests.
The main class for testing Spring MVC applications via
WebTestClient
with
MockMvc
for server request handling.
Specification for configuring
MockMvc
to test one or more
controllers directly, and a simple facade around
StandaloneMockMvcBuilder
.
Base specification for configuring
MockMvc
, and a simple facade
around
ConfigurableMockMvcBuilder
.
Mock implementation of the
PageContext
interface.
Mock implementation of
jakarta.servlet.http.Part
.
Simple
PropertySource
implementation for use in testing.
Mock implementation of the
RequestDispatcher
interface.
Static factory methods for
RequestMatcher
classes.
Static factory methods to obtain a
ResponseCreator
with a fixed
response.
Main entry point for client-side REST testing
.
Builder to create a
MockRestServiceServer
.
Simple
ClientHttpResponse
extension that also exposes a result object
from the underlying mock server exchange for further assertions on the state
of the server response after the request is performed.
Contract that frameworks or applications can use to pre-package a set of
customizations to a
WebTestClient.MockServerSpec
and expose that
as a shortcut.
Mock extension of
AbstractServerHttpRequest
for use in tests without
an actual server.
Request builder exposing properties not related to the body.
A builder that adds a body to the request.
Mock extension of
AbstractServerHttpResponse
for use in tests without
an actual server.
Mock implementation of
ServerRequest
.
Builder for
MockServerRequest
.
Extension of
DefaultServerWebExchange
for use in tests, along with
MockServerHttpRequest
and
MockServerHttpResponse
.
Builder for a
MockServerWebExchange
.
Mock implementation of the
ServletConfig
interface.
Mock implementation of the
ServletContext
interface.
Mock implementation of the
SessionCookieConfig
interface.
Simple mock
SpringFactoriesLoader
implementation that can be used for testing
purposes.
Implementation of
WebSession
that delegates to a session instance
obtained via
InMemoryWebSessionStore
.
Interface that defines a holder for model attributes.
Holder for both Model and View in the web MVC framework.
A collection of assertions intended to simplify testing scenarios dealing
with Spring Web MVC
ModelAndView
objects.
Records model and view related decisions made by
HandlerMethodArgumentResolvers
and
HandlerMethodReturnValueHandlers
during the course of invocation of
a controller method.
Exception to be thrown on error conditions that should forward
to a specific view with a specific model.
Handles return values of type
ModelAndView
copying view and model
information to the
ModelAndViewContainer
.
SPI for resolving custom return values from a specific handler method.
This return value handler is intended to be ordered after all others as it
attempts to handle _any_ return value type (i.e.
Annotation that binds a method parameter or method return value
to a named model attribute, exposed to a web view.
Resolve
@ModelAttribute
annotated method arguments.
Resolve
@ModelAttribute
annotated method arguments and handle
return values from
@ModelAttribute
annotated methods.
Assist with initialization of the
Model
before controller method
invocation and with updates to it after the invocation.
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.
Factory for assertions on the model.
A visitor to visit a Java module.
Formatter for JSR-354
MonetaryAmount
values,
delegating to
MonetaryAmountFormat.format(javax.money.MonetaryAmount)
and
MonetaryAmountFormat.parse(java.lang.CharSequence)
.
Deprecated.
as of 6.0, in favor of
Mono.toFuture()
Prepare the body of a multipart request, resulting in a
MultiValueMap<String, HttpEntity>
.
Builder that allows for further customization of part headers.
Exception thrown when multipart resolution fails.
A representation of an uploaded file received in a multipart request.
Servlet Filter that resolves multipart requests via a
MultipartResolver
.
HttpMessageReader
for reading
"multipart/form-data"
requests
into a
MultiValueMap<String, Part>
.
HttpMessageWriter
for writing a
MultiValueMap<String, ?>
as multipart form data, i.e.
Provides additional methods for dealing with multipart content within a
servlet request, allowing to access uploaded files.
This interface defines the multipart request access operations that are exposed
for actual multipart requests.
A common delegate for
HandlerMethodArgumentResolver
implementations
which need to resolve
MultipartFile
and
Part
arguments.
A strategy interface for multipart file upload resolution in accordance
with
RFC 1867
.
Support class for multipart HTTP message writers.
SimpUserRegistry
that looks up users in a "local" user registry as
well as a set of "remote" user registries.
Extension of the
Map
interface that stores multiple values.
Adapts a given
Map
to the
MultiValueMap
contract.
Spring's base implementation of the JPA
PersistenceUnitInfo
interface,
used to bootstrap an
EntityManagerFactory
in a container.
The default implementation of the
PropertySources
interface.
The default implementation of the
PropertyValues
interface.
Mutable implementation of the
SortDefinition
interface.
NamespaceHandler
for Spring MVC configuration namespace.
Convenience methods for use in MVC namespace BeanDefinitionParsers.
Provides access to the result of an executed request.
Creates instances of
UriComponentsBuilder
by pointing to
@RequestMapping
methods on Spring MVC controllers.
Builder class to create URLs for method arguments.
Method invocation information.
DataFieldMaxValueIncrementer
that increments the maximum value of a given MySQL table
with the equivalent of an auto-increment column.
Counterpart of
BeanNameAware
.
NamedBeanHolder
<
T
>
A simple holder for a given bean name plus bean instance.
A
CacheResolver
that forces the resolution to a configurable
collection of name(s) against a given
CacheManager
.
InheritableThreadLocal
subclass that exposes a specified name
as
NamedInheritableThreadLocal.toString()
result (allowing for introspection).
Extension of JdbcDaoSupport that exposes a NamedParameterJdbcTemplate as well.
Interface specifying a basic set of JDBC operations allowing the use
of named parameters rather than the traditional '?' placeholders.
Template class with a basic set of JDBC operations, allowing the use
of named parameters rather than traditional '?' placeholders.
Helper methods for named parameter parsing.
NamedThreadLocal
<
T
>
ThreadLocal
subclass that exposes a specified name
as
NamedThreadLocal.toString()
result (allowing for introspection).
Simple
CacheOperationSource
implementation that allows attributes to be matched
by registered name.
Pointcut bean for simple method name matches, as an alternative to regexp patterns.
Convenient class for name-match method pointcuts that hold an Advice,
making them an Advisor.
Simple
TransactionAttributeSource
implementation that
allows attributes to be matched by registered name.
Base interface used by the
DefaultBeanDefinitionDocumentReader
for handling custom namespaces in a Spring XML configuration file.
Used by the
DefaultBeanDefinitionDocumentReader
to
locate a
NamespaceHandler
implementation for a particular namespace URI.
Support class for implementing custom
NamespaceHandlers
.
NameValueExpression
<
T
>
A contract for
"name!=value"
style expression used to specify request
parameters and request header conditions in
@RequestMapping
.
NameValueExpression
<
T
>
A contract for
"name!=value"
style expression used to specify request
parameters and request header conditions in
@RequestMapping
.
Customize the generated class name for
AbstractClassGenerator
-based utilities.
Write
RuntimeHints
as GraalVM native configuration.
A common delegate for detecting a GraalVM native image environment.
Native image context as defined in GraalVM's
ImageInfo
.
MessageHeaderAccessor
subclass that supports storage and access of
headers from an external source such as a message broker.
Extension of the
WebRequest
interface, exposing the
native request and response objects in a generic fashion.
A
WebSocketSession
that exposes the underlying, native WebSocketSession
through a getter.
Handy class for wrapping checked
Exceptions
with a root cause.
Helper class for implementing exception classes which are capable of
holding nested exceptions.
The
<nestedPath>
tag supports and assists with nested beans or
bean properties in the model.
Handy class for wrapping runtime
Exceptions
with a root cause.
Deprecated.
as of 6.0, in favor of standard
ServletException
nesting
@NestedTestConfiguration
is a type-level annotation that is used to
configure how Spring test configuration annotations are processed within
enclosing class hierarchies (i.e., for
inner
test classes).
Enumeration of
modes
that dictate how test configuration from
enclosing classes is processed for inner test classes.
Exception thrown when attempting to work with a nested transaction
but nested transactions are not supported by the underlying backend.
Decoder for
Buffers
.
Encoder for
Buffers
.
Implementation of the
DataBuffer
interface that wraps a Netty 5
Buffer
.
Implementation of the
DataBufferFactory
interface based on a
Netty 5
BufferAllocator
.
Base class for Netty-based
WebSocketSession
adapters that provides
convenience methods to convert Netty
WebSocketFrames
to and from
WebSocketMessages
.
Decoder for
ByteBufs
.
Encoder for
ByteBufs
.
Implementation of the
DataBuffer
interface that wraps a Netty 4
ByteBuf
.
Implementation of the
DataBufferFactory
interface based on a
Netty 4
ByteBufAllocator
.
Base class for Netty-based
WebSocketSession
adapters that provides
convenience methods to convert Netty
WebSocketFrames
to and from
WebSocketMessages
.
By default, when the DispatcherServlet can't find a handler for a request it
sends a 404 response.
A common Spring annotation to declare that annotated elements cannot be
null
.
A common Spring annotation to declare that parameters and return values
are to be considered as non-nullable by default for a given package.
A common Spring annotation to declare that fields are to be considered as
non-nullable by default for a given package.
Root of the hierarchy of data access exceptions that are considered non-transient -
where a retry of the same operation would fail unless the cause of the Exception
is corrected.
Data access exception thrown when a resource fails completely and the failure is permanent.
Methods using this
Enhancer
callback will delegate directly to the
default (super) implementation in the base class.
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.
Trivial implementation of
Log
that throws away all messages.
Tag subclass of
RollbackRuleAttribute
that has the opposite behavior
to the
RollbackRuleAttribute
superclass.
Exception thrown when a
BeanFactory
is asked for a bean instance for which it
cannot find a definition.
Exception thrown when a message can't be resolved.
Exception for errors that fit response status 406 (not acceptable).
Extension of AopConfigException thrown when trying to perform
an advisor generation operation on a class that is not an
AspectJ annotation-style aspect.
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
.
Exception thrown when an operation is attempted that
relies on an existing transaction (such as setting
rollback status) and there is no existing transaction.
Exception thrown on an attempt to get the value of a property
that isn't readable, because there's no getter method.
Exception thrown on an attempt to set the value of a property that
is not writable (typically because there is no setter method).
Exception thrown when a
BeanFactory
is asked for a bean instance for which
multiple matching candidates have been found when only one matching bean was expected.
A common Spring annotation to declare that annotated elements can be
null
under
some circumstance.
Expression language AST node that represents null.
NullSafeComparator
<
T
>
A Comparator that will safely compare nulls to be lower or higher than
other objects.
Simple implementation of
SourceExtractor
that returns
null
as the source metadata.
Simple serializable class that serves as a
null
replacement
for cache stores which otherwise do not support
null
values.
Exception thrown when navigation of a valid nested property
path encounters a NullPointerException.
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.
Miscellaneous utility methods for number conversion and parsing.
Encapsulates an object error, that is, a global reason for rejecting
an object.
ObjectFactory
<
T
>
Defines a factory which can return an Object instance
(possibly shared or independent) when invoked.
A
FactoryBean
implementation that
returns a value which is an
ObjectFactory
that in turn returns a bean sourced from a
BeanFactory
.
Helper class for the creation of
ObjectName
instances.
Strategy interface that encapsulates the creation of
ObjectName
instances.
Exception thrown on an optimistic locking violation for a mapped object.
ObjectProvider
<
T
>
A variant of
ObjectFactory
designed specifically for injection points,
allowing for programmatic optionality and lenient not-unique handling.
Exception thrown if a mapped object could not be retrieved via its identifier.
An
HttpMessageConverter
that uses
StringHttpMessageConverter
for reading and writing content and a
ConversionService
for converting
the String content to and from the target object type.
Miscellaneous object utility methods.
ClientHttpRequestFactory
implementation that uses
OkHttp
3.x to create requests.
Filter base class that aims to guarantee a single execution per request
dispatch, on any servlet container.
Represents the boolean AND operation.
The JVM opcodes, access flags and array type codes.
Decrement operator.
Implements division operator.
Servlet Filter that binds a JPA EntityManager to the thread for the
entire processing of the request.
Spring web request interceptor that binds a JPA EntityManager to the
thread for the entire processing of the request.
Simple AOP Alliance
MethodInterceptor
implementation that binds a new
Hibernate
Session
for each method invocation, if none bound before.
Servlet Filter that binds a Hibernate Session to the thread for the entire
processing of the request.
Spring web request interceptor that binds a Hibernate
Session
to the
thread for the entire processing of the request.
Implements the equality operator.
Supported operations that an
OperatorOverloader
can implement for any pair of
operands.
Common supertype for operators that operate on either one or two operands.
A descriptor comparison encapsulates the result of comparing descriptor
for two operands and describes at what level they are compatible.
Represents the between operator.
The operator 'instanceof' checks if an object is of the class specified in the
right-hand operand, in the same way that
instanceof
does in Java.
Implements the matches operator.
Represents a NOT operation.
By default the mathematical operators
Operation
support simple types
like numbers.
The power operator.
Implements greater-than-or-equal operator.
Implements the greater-than operator.
Increment operator.
Implements the less-than-or-equal operator.
Implements the less-than operator.
The minus operator supports:
subtraction of numbers
subtraction of an int from a string of one character
(effectively decreasing that character), so 'd'-3='a'
Implements the modulus operator.
Implements the
multiply
operator.
Implements the not-equal operator.
Represents the boolean OR operation.
The plus operator will:
add numbers
concatenate strings
Exception thrown on an optimistic locking violation.
LocalValidatorFactoryBean
subclass that simply turns
Validator
calls into no-ops
in case of no Bean Validation provider being available.
The
<options>
tag renders a list of HTML 'option' tags.
The
<option>
tag renders a single HTML 'option'.
Oracle-specific implementation for the
CallMetaDataProvider
interface.
DataFieldMaxValueIncrementer
that retrieves the next value
of a given Oracle sequence.
Oracle-specific implementation of the
TableMetaDataProvider
.
@Order
defines the sort order for an annotated component.
Comparator
implementation for
Ordered
objects, sorting
by order value ascending, respectively by priority descending.
Strategy interface to provide an order source for a given object.
Ordered
is an interface that can be implemented by objects that
should be
orderable
, for example in a
Collection
.
Decorator for an
ExecutorSubscribableChannel
that ensures messages
are processed in the order they were published to the channel.
General utility for determining the order of an object based on its type declaration.
An interceptor to check request
Origin
header value against a
collection of allowed origins.
Internal helper for exposing dummy OutputStreams to embedded databases
such as Derby, preventing the creation of a log file.
ClassLoader
that does
not
always delegate to the parent loader
as normal class loaders do.
NamespaceHandler
for the '
oxm
' namespace.
PagedListHolder
<
E
>
PagedListHolder is a simple state holder for handling lists of objects,
separating them into pages.
For the efficient sorting of multiple arrays in parallel.
Bean used to pass name-value pair parameters from a
ParamTag
to a
ParamAware
tag.
Allows implementing tag to utilize nested
spring:param
tags.
Deprecated.
since 6.0, use
io.r2dbc.spi.Parameter
instead.
Strategy that resolves the requested content type from a query parameter.
Resolver that checks a query parameter and uses it to look up a matching
MediaType.
Interface to be implemented by objects that can close resources
allocated by parameters like
SqlLobValue
objects.
Trivial controller that always returns a pre-configured view and optionally
sets the response status code.
Parameterized callback interface used by the
JdbcTemplate
class for
batch updates.
The purpose of this class is to enable capturing and passing a generic
Type
.
Implement this interface when parameters need to be customized based
on the connection.
Interface to discover parameter names for methods and constructors.
Public delegate for resolving autowirable parameters on externally managed
constructors and methods.
A logical conjunction (
' && '
) request condition that matches a request against
a set parameter expressions with syntax defined in
RequestMapping.params()
.
A logical conjunction (
' && '
) request condition that matches a request against
a set parameter expressions with syntax defined in
RequestMapping.params()
.
The
<param>
tag collects name-value parameters and passes them to a
ParamAware
ancestor in the tag hierarchy.
Holds information about a parsed SQL statement.
Represent an exception that occurs during expression parsing.
Parses text strings to produce instances of T.
Context that gets passed along a bean definition parsing process,
encapsulating all relevant configuration as well as state.
Input provided to an expression parser that can influence an expression
parsing/compilation routine.
Simple
ArrayDeque
-based structure for tracking the logical position during
a parsing process.
Marker interface for entries into the
ParseState
.
Representation for a part in a "multipart/form-data" request.
Represents an event for a "multipart/form-data" request.
HttpMessageWriter
for writing
PartEvent
objects.
HttpMessageWriter
for writing with
Part
.
Implementation of the
FilterConfig
interface which
simply passes the call through to a given Filter/FilterChain combination
(indicating the next Filter in the chain along with the FilterChain that it is
supposed to work on) or to a given Servlet (indicating the end of the chain).
Simple
SourceExtractor
implementation that just passes
the candidate source metadata object through for attachment.
The
<password>
tag renders an HTML 'input' tag with type 'password'
using the bound value.
Shortcut for
@HttpExchange
for HTTP PATCH requests.
Annotation for mapping HTTP
PATCH
requests onto specific handler
methods.
Structured representation of a URI path parsed via
PathContainer.parsePath(String)
into a sequence of
PathContainer.Separator
and
PathContainer.PathSegment
elements.
A path element, either separator or path segment.
Options to customize parsing based on the type of input path.
Path segment element.
Path separator element.
Editor for
java.nio.file.Path
, to directly populate a Path
property instead of using a String property as bridge.
Deprecated.
as of 5.2.4.
Assist with configuring
HandlerMapping
's with path matching options.
Configure path matching options.
Strategy interface for
String
-based path matching.
A
ResourcePatternResolver
implementation that is able to resolve a
specified resource location path into one or more matching Resources.
Representation of a parsed path pattern.
Holder for URI variables and path parameters (matrix variables) extracted
based on the pattern for a given matched path.
Holder for the result of a match on the start of a pattern.
Parser for URI path patterns producing
PathPattern
instances that can
then be matched to requests.
RouteMatcher
built on
PathPatternParser
that uses
PathContainer
and
PathPattern
as parsed representations of
routes and patterns.
A logical disjunction (' || ') request condition that matches a request
against a set of URL path patterns.
Resource
implementation for
Path
handles,
performing all operations and transformations via the
Path
API.
A simple
ResourceResolver
that tries to find a resource under the given
locations matching to the request path.
A simple
ResourceResolver
that tries to find a resource under the given
locations matching to the request path.
Annotation which indicates that a method parameter should be bound to a URI template
variable.
HttpServiceArgumentResolver
for
@PathVariable
annotated arguments.
Resolver for
Map
method arguments annotated with
@PathVariable
where the annotation does not specify a
path variable name.
Resolves
Map
method arguments annotated with
@PathVariable
where the annotation does not specify a
path variable name.
Resolves method arguments annotated with @
PathVariable
.
Resolves method arguments annotated with an @
PathVariable
.
Editor for
java.util.regex.Pattern
, to directly populate a Pattern property.
Utility methods for simple pattern matching, in particular for
Spring's typical "xxx*", "*xxx" and "*xxx*" pattern styles.
Exception that is thrown when there is a problem with the pattern being parsed.
The messages that can be included in a
PatternParseException
when there is a parse failure.
A logical disjunction (' || ') request condition that matches a request
against a set of URL path patterns.
A logical disjunction (' || ') request condition that matches a request
against a set of URL path patterns.
Annotation that binds a method parameter to the payload of a message.
An
ApplicationEvent
that carries an arbitrary payload.
RSocketServiceArgumentResolver
for
@Payload
annotated arguments.
A resolver to extract and decode the payload of a message using a
Decoder
, where the payload is expected to be a
Publisher
of
DataBuffer
.
A resolver to extract and convert the payload of a message using a
MessageConverter
.
Static utility methods to create
Payload
from
DataBuffer
s
and vice versa.
A formatter for number values in percent style.
A
WebSocketHandler
that initializes and destroys a
WebSocketHandler
instance for each WebSocket connection and delegates all other methods to it.
Simple AOP Alliance
MethodInterceptor
for performance monitoring.
A trigger for periodic task execution.
Exception thrown when the underlying resource denied a permission
to access a specific element, such as a specific database table.
BeanPostProcessor that processes
PersistenceUnit
and
PersistenceContext
annotations, for injection of
the corresponding JPA resources
EntityManagerFactory
and
EntityManager
.
Spring AOP exception translation aspect for use at Repository or DAO layer level.
AOP Alliance MethodInterceptor that provides persistence exception translation
based on a given PersistenceExceptionTranslator.
Bean post-processor that automatically applies persistence exception translation to any
bean marked with Spring's @
Repository
annotation, adding a corresponding
PersistenceExceptionTranslationAdvisor
to
the exposed proxy (either an existing AOP proxy or a newly generated proxy that
implements all of the target's interfaces).
Interface implemented by Spring integrations with data access technologies
that throw runtime exceptions, such as JPA and Hibernate.
Provide the list of managed persistent types that an entity manager should
consider.
Scanner of
PersistenceManagedTypes
.
Interface that defines an abstraction for finding and managing
JPA PersistenceUnitInfos.
Callback interface for post-processing a JPA PersistenceUnitInfo.
Exception thrown on a pessimistic locking violation.
Interface for objects that may participate in a phased
process such as lifecycle management.
A WebSocket ping message.
Abstract base class for property resource configurers that resolve placeholders
in bean definition property values.
This is the central interface in Spring's imperative transaction infrastructure.
EntityResolver
implementation that attempts to resolve schema URLs into
local
classpath resources
using a set of mappings files.
Core Spring pointcut abstraction.
Superinterface for all Advisors that are driven by a pointcut.
ComponentDefinition
implementation that holds a pointcut definition.
ParseState
entry representing a pointcut.
Pointcut constants for matching getters and setters,
and static methods useful for manipulating and evaluating pointcuts.
A
MessageChannel
from which messages may be actively received through polling.
A SockJS session for use with polling HTTP transports.
A WebSocket pong message.
Extension of
DataBuffer
that allows for buffers that share
a memory pool.
Config interface for a pooling target source.
Shortcut for
@HttpExchange
for HTTP POST requests.
Postgres-specific implementation for the
CallMetaDataProvider
interface.
DataFieldMaxValueIncrementer
that retrieves the next value
of a given PostgreSQL sequence.
The PostgreSQL specific implementation of
TableMetaDataProvider
.
Annotation for mapping HTTP
POST
requests onto specific handler
methods.
Deprecated.
Strategy interface for retrieving
profile values
for a given
testing environment.
as of 5.2, along with
PropertyPlaceholderConfigurer
Handler for CORS pre-flight requests.
WebFilter that handles pre-flight requests through a
PreFlightRequestHandler
and bypasses the rest of the chain.
PreparedOperation
<
T
>
Extension to
QueryOperation
for a prepared SQL query
Supplier
with bound parameters.
Generic callback interface for code that operates on a PreparedStatement.
One of the two central callback interfaces used by the JdbcTemplate class.
Helper class that efficiently creates multiple
PreparedStatementCreator
objects with different parameters based on an SQL statement and a single
set of parameter declarations.
General callback interface used by the
JdbcTemplate
class.
@EventListener
annotation used to consume a
PrepareTestInstanceEvent
published by the
EventPublishingTestExecutionListener
.
TestContextEvent
published by the
EventPublishingTestExecutionListener
when
TestExecutionListener.prepareTestInstance(TestContext)
is invoked.
Indicates that a bean should be given preference when multiple candidates
are qualified to autowire a single-valued dependency.
Resolver for arguments of type
Principal
, including
Optional<Principal>
.
Resolves method argument value of type
Principal
.
Resolves an argument of type
Principal
, similar to
ServletRequestMethodArgumentResolver
but irrespective of whether the
argument is annotated or not.
Prints objects of type T for display.
Result handler that prints
MvcResult
details to a given output
stream — for example:
System.out
,
System.err
, a
custom
java.io.PrintWriter
, etc.
A contract for how to actually write result information.
ParameterNameDiscoverer
implementation that tries several discoverer
delegates in succession.
Extension of the
Ordered
interface, expressing a
priority
ordering:
PriorityOrdered
objects are always applied before
plain
Ordered
objects regardless of their order values.
Represents a problem with a bean definition configuration.
Representation for an RFC 7807 problem detail.
An interface to associate Jackson annotations with
ProblemDetail
to avoid a hard dependency on
the Jackson library.
Provides the same declarations as
ProblemDetailJacksonMixin
and some
additional ones to support XML serialization when
jackson-dataformat-xml
is on the classpath.
SPI interface allowing tools and other external processes to handle errors
and warnings reported during bean definition parsing.
ProducerCallback
<
T
>
Callback for sending a message to a JMS destination.
A logical disjunction (' || ') request condition to match a request's 'Accept' header
to a list of media type expressions.
A logical disjunction (' || ') request condition to match a request's 'Accept' header
to a list of media type expressions.
Indicates that a component is eligible for registration when one or more
specified profiles
are active.
Profile predicate that may be
accepted
by an
Environment
.
ProfileValueChecker
is a custom JUnit
Statement
that checks
whether a test class or test method is enabled in the current environment
via Spring's
@IfProfileValue
annotation.
ProfileValueSourceConfiguration
is a class-level annotation for use
with JUnit 4 which is used to specify what type of
ProfileValueSource
to use when retrieving
profile values
configured via
@IfProfileValue
.
General utility methods for working with
profile values
.
Represents projection, where a given operation is performed on all elements in some
input sequence, returning a new sequence of the same size.
Enumeration that represents transaction propagation behaviors for use
with the
Transactional
annotation, corresponding to the
TransactionDefinition
interface.
Deprecated.
as of 5.3, in favor of Spring's common bean definition formats
and/or custom reader implementations
Custom
PropertyEditor
for
Properties
objects.
Allows for making a properties file from a classpath location available
as Properties instance in a bean factory.
Base class for JavaBean-style components that need to load properties
from one or more resources.
Convenient utility methods for loading of
java.util.Properties
,
performing standard handling of input streams.
Strategy interface for persisting
java.util.Properties
,
allowing for pluggable parsing strategies.
PropertySource
implementation that extracts properties from a
Properties
object.
A description of a JavaBeans Property that allows us to avoid a dependency on
java.beans.PropertyDescriptor
.
Superclass for exceptions related to a property access,
such as type mismatch or invocation target exception.
Common interface for classes that can access named properties
(such as bean properties of an object or fields in an object).
A property accessor is able to read from (and possibly write to) an object's properties.
Simple factory facade for obtaining
PropertyAccessor
instances,
in particular for
BeanWrapper
instances.
Utility methods for classes that perform bean property access
according to the
PropertyAccessor
interface.
Combined exception, composed of individual PropertyAccessException instances.
PropertyComparator
<
T
>
PropertyComparator performs a comparison of two beans,
evaluating the specified bean property via a BeanWrapper.
Interface for strategies that register custom
property editors
with a
property editor registry
.
Encapsulates methods for registering JavaBeans
PropertyEditors
.
Base implementation of the
PropertyEditorRegistry
interface.
ParseState
entry representing a JavaBean property.
Helper class for calculating property matches, according to a configurable
distance.
Represents a simple property or field reference.
Property resource configurer that overrides bean property values in an application
context definition.
FactoryBean
that evaluates a property path on a given target object.
Deprecated.
as of 5.2; use
org.springframework.context.support.PropertySourcesPlaceholderConfigurer
instead which is more flexible through taking advantage of the
Environment
and
PropertySource
mechanisms.
Utility class for working with Strings that have placeholder values in them.
Strategy interface used to resolve replacement values for placeholders contained in Strings.
Strategy for providing named properties — for example, for looking up
key-value pairs in a generic fashion.
Interface for resolving properties against any underlying source.
Allows for configuration of individual bean property values from a property resource,
Annotation providing a convenient and declarative mechanism for adding a
PropertySource
to Spring's
Environment
.
PropertySource
<
T
>
Abstract base class representing a source of name/value property pairs.
PropertySource
to be used as a placeholder in cases where an actual
property source cannot be eagerly initialized at application context
creation time.
Describe a
PropertySource
.
Strategy interface for creating resource-based
PropertySource
wrappers.
Contribute
property sources
to the
Environment
.
Container annotation that aggregates several
PropertySource
annotations.
Holder containing one or more
PropertySource
objects.
Specialization of
PlaceholderConfigurerSupport
that resolves ${...} placeholders
within bean definition property values and
@Value
annotations against the current
Spring
Environment
and its set of
PropertySources
.
PropertyResolver
implementation that resolves property values against
an underlying set of
PropertySources
.
Object to hold information and value for an individual bean property.
Holder containing one or more
PropertyValue
objects,
typically comprising one update for a specific target bean.
Editor
for a
PropertyValues
object.
Base class providing support methods for Protobuf encoding and decoding.
An
HttpMessageConverter
that reads and writes
com.google.protobuf.Messages
using
Google Protocol Buffers
.
HttpMessageWriter
that can write a protobuf
Message
and adds
X-Protobuf-Schema
,
X-Protobuf-Message
headers and a
delimited=true
parameter is added to the content type if a flux is serialized.
Subclass of
ProtobufHttpMessageConverter
which enforces the use of Protobuf 3 and
its official library
"com.google.protobuf:protobuf-java-util"
for JSON processing.
Subclass of
ProtobufMessageConverter
for use with the official
"com.google.protobuf:protobuf-java-util"
library for JSON support.
An
MessageConverter
that reads and writes
com.google.protobuf.Messages
using
Google Protocol Buffers
.
A resolution strategy for protocol-specific resource handles.
AspectInstanceFactory
backed by a
BeanFactory
-provided prototype, enforcing prototype semantics.
TargetSource
implementation that
creates a new instance of the target bean for each request,
destroying each instance on release (after each request).
A
FactoryBean
implementation that
returns a value which is a JSR-330
Provider
that in turn
returns a bean sourced from a
BeanFactory
.
This class is meant to be used as replacement for
java.lang.reflect.Proxy
under JDK 1.2.
@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.
Convenience superclass for configuration used in creating proxies,
to ensure that all proxy creators have consistent properties.
Holder for the current proxy creation context, as exposed by auto-proxy creators
such as
AbstractAdvisorAutoProxyCreator
.
Base class for proxy factories.
Factory for AOP proxies for programmatic use, rather than via declarative
setup in a bean factory.
FactoryBean
implementation that builds an
AOP proxy based on beans in a Spring
BeanFactory
.
FactoryBean
that creates a
java.net.Proxy
.
Gather the need for using proxies at runtime.
Generator of
ProxyHints
predicates, testing whether the given hints
match the expected behavior for proxies.
@Configuration
class that registers the Spring infrastructure beans necessary
to enable proxy-based annotation-driven JSR-107 cache management.
Extension of the AOP Alliance
MethodInvocation
interface, allowing access to the proxy that the method invocation was made through.
Base class with common functionality for proxy processors, in particular
ClassLoader management and the
ProxyProcessorSupport.evaluateProxyInterfaces(java.lang.Class<?>, org.springframework.aop.framework.ProxyFactory)
algorithm.
Dispatching
Enhancer
callback.
@Configuration
class that registers the Spring infrastructure beans
necessary to enable proxy-based annotation-driven transaction management.
Shortcut for
@HttpExchange
for HTTP PUT requests.
Annotation for mapping HTTP
PUT
requests onto specific handler
methods.
Gather the Quality-of-Service settings that can be used when sending a message.
Represents a dot separated sequence of strings that indicate a package qualified type
reference.
This annotation may be used on a field or parameter as a qualifier for
candidate beans when autowiring.
AutowireCandidateResolver
implementation that matches bean definition qualifiers
against
qualifier annotations
on the field or parameter to be autowired.
ParseState
entry representing an autowire candidate qualifier.
Simple implementation of the Quartz Job interface, applying the
passed-in JobDataMap and also the SchedulerContext as bean property
values.
Interface declaring a query operation that can be represented
with a query string.
Exception to be thrown on a query timeout.
Convenient TargetSourceCreator using bean name prefixes to create one of three
well-known TargetSource types:
: CommonsPool2TargetSource
% ThreadLocalTargetSource
! PrototypeTargetSource
ReactiveTransactionManager
implementation
for a single R2DBC
ConnectionFactory
.
The
<radiobuttons>
tag renders multiple HTML 'input' tags with type 'radio'.
The
<radiobutton>
tag renders an HTML 'input' tag with type 'radio'.
Marker for AOP proxy interfaces (in particular: introduction interfaces)
that explicitly intend to return the raw target object (which would normally
get replaced with the proxy object when returned from a method invocation).
An "RDBMS operation" is a multithreaded, reusable object representing a query,
update, or stored procedure call.
Adapter for a Reactive Streams
Publisher
to and from an async/reactive
type such as
CompletableFuture
, RxJava
Observable
, and others.
A registry of adapters to adapt Reactive Streams
Publisher
to/from
various async/reactive types such as
CompletableFuture
, RxJava
Flowable
, and others.
BlockHoundIntegration
for spring-core classes.
A "reactive" HTTP input message that exposes the input as
Publisher
.
A "reactive" HTTP output message that accepts output as a
Publisher
.
Reactive contract for handling a
Message
.
TransactionSynchronization
implementation that manages a
resource object bound through
TransactionSynchronizationManager
.
Support for single-value reactive types (like
Mono
or
Single
)
as a return value type.
Representation of an ongoing reactive transaction.
This is the central interface in Spring's reactive transaction infrastructure.
Describes the semantics of a reactive type including boolean checks for
ReactiveTypeDescriptor.isMultiValue()
,
ReactiveTypeDescriptor.isNoValue()
, and
ReactiveTypeDescriptor.supportsEmpty()
.
Reactor-Netty implementation of
ClientHttpConnector
.
Adapt
HttpHandler
to the Reactor Netty channel handling function.
Reactor Netty 2 (Netty 5) implementation of
ClientHttpConnector
.
Adapt
HttpHandler
to the Reactor Netty 5 channel handling function.
A WebSocket
RequestUpgradeStrategy
for Reactor Netty for Netty 5.
Factory to manage Reactor Netty resources, i.e.
Reactor Netty based implementation of
TcpOperations
.
Reactor Netty based implementation of
TcpConnection
.
WebSocketClient
implementation for use with Reactor Netty for Netty 5.
WebSocketSession
implementation for use with the Reactor Netty's (Netty 5)
NettyInbound
and
NettyOutbound
.
Simple container for
NettyInbound
and
NettyOutbound
.
ReactorNettyCodec
<
P
>
Simple holder for a decoding
Function
and an encoding
BiConsumer
to use with Reactor Netty.
A WebSocket
RequestUpgradeStrategy
for Reactor Netty.
Reactor Netty based implementation of
TcpOperations
.
Reactor Netty based implementation of
TcpConnection
.
A STOMP over TCP client, configurable with either
ReactorNettyTcpClient
or
ReactorNetty2TcpClient
.
WebSocketClient
implementation for use with Reactor Netty.
Simple container for
NettyInbound
and
NettyOutbound
.
Factory to manage Reactor Netty resources, i.e.
Context that gets passed along a bean definition reading process,
encapsulating all relevant configuration as well as state.
One-way PropertyEditor which can convert from a text String to a
java.io.Reader
, interpreting the given String as a Spring
resource location (e.g.
Interface that receives callbacks for component, alias and import
registrations during a bean definition reading process.
Expression language AST node that represents a real literal.
A contract to determine the frequency of reconnect attempts after connection failure.
@RecordApplicationEvents
is a class-level annotation that is used to
instruct the
Spring TestContext Framework
to record all
application events
that are published in the
ApplicationContext
during the execution of a single test.
A visitor to visit a record component.
Record of an invocation of a method relevant to
RuntimeHints
.
Builder for
RecordedInvocation
.
Listener for
invocations recorded
by the
RuntimeHintsAgent
.
Publishes invocations on method relevant to
RuntimeHints
,
as they are recorded by the
RuntimeHintsAgent
.
Data access exception thrown when a previously failed operation might be able
to succeed if the application performs some recovery steps and retries the entire
transaction or in the case of a distributed transaction, the transaction branch.
A specialization of the
Model
interface that controllers can use to
select attributes for a redirect scenario.
Resolves method arguments of type
RedirectAttributes
.
View that redirects to an absolute or context relative URL.
View that redirects to an absolute, context relative, or current request
relative URL.
Assist with the registration of a single redirect view controller.
Utility methods used by the reflection resolver code to discover the appropriate
methods/constructors and fields that should be used in expressions.
Gather the need for reflection at runtime.
Generator of
ReflectionHints
predicates, testing whether the given hints
match the expected behavior for reflection.
ReflectionTestUtils
is a collection of reflection-based utility
methods for use in unit and integration testing scenarios.
Simple utility class for working with the reflection API and handling
reflection exceptions.
Callback interface invoked on each field in the hierarchy.
Callback optionally used to filter fields to be operated on by a field callback.
Action to take on each method.
Callback optionally used to filter methods to be operated on by a method callback.
Indicate that the annotated element requires reflection.
Factory that can create Spring AOP Advisors given AspectJ classes from
classes honoring AspectJ's annotation syntax, using reflection to invoke the
corresponding advice methods.
Synthetic advisor that instantiates the aspect.
A simple ConstructorExecutor implementation that runs a constructor using reflective
invocation.
A constructor resolver that uses reflection to locate the constructor that should be invoked.
LoadTimeWeaver
which uses reflection to delegate to an underlying ClassLoader
with well-known transformation hooks.
MethodExecutor
that works via reflection.
Spring's implementation of the AOP Alliance
MethodInvocation
interface,
implementing the extended
ProxyMethodInvocation
interface.
Reflection-based
MethodResolver
used by default in
StandardEvaluationContext
unless explicit method resolvers have been specified.
Process an
AnnotatedElement
and register the necessary reflection
hints for it.
A powerful
PropertyAccessor
that uses reflection to access properties
for reading and possibly also for writing on a target instance.
An optimized form of a PropertyAccessor that will use reflection but only knows
how to access a particular property on a particular class.
Process
@Reflective
annotated elements.
Interface to be implemented by dynamic target objects,
which support reloading and optionally polling for updates.
Subclass of
BeanFactoryRefreshableTargetSource
that determines whether
a refresh is required through the given
ScriptFactory
.
A simple filter for matching a fully-qualified class name with a regex
Pattern
.
Convenient class for regexp method pointcuts that hold an Advice,
making them an
Advisor
.
A
RegisteredBean
represents a bean that has been registered with a
BeanFactory
, but has not necessarily been instantiated.
Indicates that the classes specified in the annotation attributes require some
reflection hints for binding or reflection-based serialization purposes.
A
ReflectiveProcessor
implementation that registers reflection hints
for data binding purpose (class, constructors, fields, properties, record
components, including types transitively used on properties and record components).
Indicates registration behavior when attempting to register an MBean that already
exists.
Overrides
HttpServletResponse.sendRedirect(String)
and handles it by
setting the HTTP status and "Location" headers, which keeps the Servlet
container from re-writing relative redirect URLs into absolute ones.
Spring-specific
MessageSource
implementation
that accesses resource bundles using specified basenames, participating in the
Spring
ApplicationContext
's resource loading.
Public API for HTML rendering.
Defines a builder for
Rendering
.
Extends
Rendering.Builder
with extra options for redirect scenarios.
Context passed to
ScriptTemplateView
render function in order to make
the application context, the locale, the template loader and the url available on
scripting side.
Context passed to
ScriptTemplateView
render function in order to make
the application context, the locale, the template loader and the url available on
scripting side.
Rendering-specific subtype of
ServerResponse
that exposes model and template data.
Rendering-specific subtype of
ServerResponse
that exposes model and template data.
Defines a builder for
RenderingResponse
.
Defines a builder for
RenderingResponse
.
Test annotation for use with JUnit 4 to indicate that a test method should be
invoked repeatedly.
Strategy used to determine annotations that act as containers for other
annotations.
Extension of
MethodOverride
that represents an arbitrary
override of a method by the IoC container.
Exception to be thrown when the reply of a message failed to be sent.
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".
Annotation to bind a method parameter to a request attribute.
HttpServiceArgumentResolver
for
@RequestAttribute
annotated arguments.
Resolves method arguments annotated with an @
RequestAttribute
.
Resolves method arguments annotated with an @
RequestAttribute
.
Abstraction for accessing attribute objects associated with a request.
Annotation indicating a method parameter should be bound to the body of the web request.
Allows customizing the request before its body is read and converted into an
Object and also allows for processing of the resulting Object before it is
passed into a controller method as an
@RequestBody
or an
HttpEntity
method argument.
A convenient starting point for implementing
RequestBodyAdvice
with default method implementations.
HttpServiceArgumentResolver
for
@RequestBody
annotated arguments.
Resolves method arguments annotated with
@RequestBody
by reading the
body of the request through a compatible
HttpMessageReader
.
Builds a
MockHttpServletRequest
.
Callback interface for code that operates on a
ClientHttpRequest
.
RequestCondition
<
T
>
Contract for request mapping conditions.
RequestCondition
<
T
>
Contract for request mapping conditions.
A holder for a
RequestCondition
useful when the type of the request
condition is not known ahead of time, e.g.
A holder for a
RequestCondition
useful when the type of the request
condition is not known ahead of time, e.g.
Context holder for request-specific state, like the
MessageSource
to
use, current locale, binding errors, etc.
Context holder for request-specific state, like current web application context, current locale,
current theme, and potential binding errors.
Superclass for all tags that require a
RequestContext
.
Servlet Filter that exposes the request to the current thread,
through both
LocaleContextHolder
and
RequestContextHolder
.
Holder class to expose the web request in the form of a thread-bound
RequestAttributes
object.
Servlet listener that exposes the request to the current thread,
through both
LocaleContextHolder
and
RequestContextHolder
.
Utility class for easy access to request-specific state which has been
set by the
DispatcherServlet
.
A contract for inspecting and potentially modifying request data values such
as URL query parameters or form field values before they are rendered by a
view or before a redirect.
A contract for inspecting and potentially modifying request data values such
as URL query parameters or form field values before they are rendered by a
view or before a redirect.
Strategy to resolve the requested media types for a
ServerWebExchange
.
Builder for a composite
RequestedContentTypeResolver
that delegates
to other resolvers each implementing a different strategy to determine the
requested content type -- e.g.
Helper to create and configure
ParameterContentTypeResolver
.
RequestEntity
<
T
>
Extension of
HttpEntity
that also exposes the HTTP method and the
target URL.
Defines a builder that adds a body to the response entity.
Defines a builder that adds headers to the request entity.
RequestEntity initialized with a URI template and variables instead of a
URI
.
An extension of
ResponseActions
that also implements
RequestMatcher
and
ResponseCreator
Encapsulates the behavior required to implement
MockRestServiceServer
including its public API (create expectations + verify/reset) along with an
extra method for verifying actual requests.
Event raised when a request is handled within an ApplicationContext.
Annotation which indicates that a method parameter should be bound to a web request header.
HttpServiceArgumentResolver
for
@RequestHeader
annotated arguments.
Resolves
Map
method arguments annotated with
@RequestHeader
.
Resolves
Map
method arguments annotated with
@RequestHeader
.
Resolves method arguments annotated with
@RequestHeader
except for
Map
arguments.
Resolves method arguments annotated with
@RequestHeader
except for
Map
arguments.
Annotation for mapping web requests onto methods in request-handling classes
with flexible method signatures.
Supports the invocation of
@RequestMapping
handler methods.
An extension of
RequestMappingInfoHandlerMapping
that creates
RequestMappingInfo
instances from class-level and method-level
@RequestMapping
annotations.
Creates
RequestMappingInfo
instances from type and method-level
@RequestMapping
annotations in
@Controller
classes.
Request mapping information.
Request mapping information.
Defines a builder for creating a RequestMappingInfo.
Defines a builder for creating a RequestMappingInfo.
Container for configuration options used for request mapping purposes.
Container for configuration options used for request mapping purposes.
Abstract base class for classes for which
RequestMappingInfo
defines
the mapping between a request and a handler method.
Abstract base class for classes for which
RequestMappingInfo
defines
the mapping between a request and a handler method.
A
HandlerMethodMappingNamingStrategy
for
RequestMappingInfo
-based handler
method mappings.
A contract for matching requests to expectations.
Container for the result from request pattern matching via
MatchableHandlerMapping
with a method to further extract
URI template variables from the pattern.
Enumeration of HTTP request methods.
A logical disjunction (' || ') request condition that matches a request
against a set of
RequestMethods
.
A logical disjunction (' || ') request condition that matches a request
against a set of
RequestMethods
.
Annotation which indicates that a method parameter should be bound to a web
request parameter.
HttpServiceArgumentResolver
for
@RequestParam
annotated arguments.
Resolves
Map
method arguments annotated with an @
RequestParam
where the annotation does not specify a request parameter name.
Resolver for
Map
method arguments annotated with
@RequestParam
where the annotation does not specify a
request parameter name.
Resolves method arguments annotated with @
RequestParam
, arguments of
type
MultipartFile
in conjunction with Spring's
MultipartResolver
abstraction, and arguments of type
jakarta.servlet.http.Part
in conjunction
with Servlet multipart requests.
Resolver for method arguments annotated with @
RequestParam
from URI
query string parameters.
Annotation that can be used to associate the part of a "multipart/form-data" request
with a method argument.
HttpServiceArgumentResolver
for
@RequestPart
annotated arguments.
Resolver for
@RequestPart
arguments where the named part is decoded
much like an
@RequestBody
argument but based on the content of an
individual part instead.
Resolves the following method arguments:
Annotated with @
RequestPart
Of type
MultipartFile
in conjunction with Spring's
MultipartResolver
abstraction
Of type
jakarta.servlet.http.Part
in conjunction with Servlet multipart requests
ServerHttpRequest
implementation that accesses one part of a multipart
request.
Specialization of
PathContainer
that subdivides the path into a
RequestPath.contextPath()
and the remaining
RequestPath.pathWithinApplication()
.
Extension point for applications or 3rd party libraries that wish to further
initialize a
MockHttpServletRequest
instance after it has been built
by
MockHttpServletRequestBuilder
or its subclass
MockMultipartHttpServletRequestBuilder
.
Represents a function that evaluates on a given
ServerRequest
.
Represents a function that evaluates on a given
ServerRequest
.
Implementations of
RequestPredicate
that implement various useful
request matching operations, such as matching based on path, HTTP method, etc.
Implementations of
RequestPredicate
that implement various useful
request matching operations, such as matching based on path, HTTP method, etc.
Receives notifications from the logical structure of request predicates.
Receives notifications from the logical structure of request predicates.
Resolves method arguments annotated with
@RequestBody
and handles return
values from methods annotated with
@ResponseBody
by reading and writing
to the body of the request or response with an
HttpMessageConverter
.
Factory for assertions on the request.
@RequestScope
is a specialization of
@Scope
for a
component whose lifecycle is bound to the current web request.
Request-backed
Scope
implementation.
Strategy interface for translating an incoming
HttpServletRequest
into a
logical view name when no view name is explicitly supplied.
A strategy for upgrading an HTTP request to a WebSocket session depending
on the underlying network runtime.
A server-specific strategy for performing the actual upgrade to a WebSocket exchange.
An extension of
ByteArrayOutputStream
that:
has public
ResizableByteArrayOutputStream.grow(int)
and
ResizableByteArrayOutputStream.resize(int)
methods
to get more control over the size of the internal buffer
has a higher initial capacity (256) by default
Encapsulates a Java
Type
, providing access to
supertypes
,
interfaces
, and
generic parameters
along with the ability to ultimately
resolve
to a
Class
.
Any object can implement this interface to provide its actual
ResolvableType
.
Interface for a resource descriptor that abstracts from the actual
type of underlying resource, such as a file or class path resource.
Exception thrown when an I/O error occurs.
FactoryBean
that bootstraps
the specified JCA 1.7
ResourceAdapter
,
starting it with a local
BootstrapContext
and exposing it for bean references.
Runtime exception mirroring the JMS ResourceAllocationException.
Editor for
Resource
arrays, to
automatically convert
String
location patterns
(e.g.
PropertyEditor
implementation for standard JDK
ResourceBundles
.
A hint that describes the need to access a
ResourceBundle
.
Builder for
ResourceBundleHint
.
MessageSource
implementation that
accesses resource bundles using specified basenames.
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
Deprecated.
as of 5.3, in favor of Spring's common view resolver variants
and/or custom resolver implementations
Assists with the registration of resource resolvers and transformers.
Assists with the registration of resource resolvers and transformers.
Populates, initializes, or cleans up a database using SQL scripts defined in
external resources.
Populates, initializes, or cleans up a database using SQL
scripts defined in external resources.
Decoder for
Resources
.
Editor
for
Resource
descriptors, to automatically convert
String
locations
PropertyEditorRegistrar implementation that populates a given
PropertyEditorRegistry
(typically a
BeanWrapper
used for bean
creation within an
ApplicationContext
)
with resource editors.
Encoder for
Resources
.
EntityResolver
implementation that tries to resolve entity references
through a
ResourceLoader
(usually,
relative to the resource base of an
ApplicationContext
), if applicable.
DynamicFile
that holds resource file content and provides
ResourceFileAssert
support.
Assertion methods for
ResourceFile
instances.
An immutable collection of
ResourceFile
instances.
Assist with creating and configuring a static resources handler.
Encapsulates information required to create a resource handler.
Stores registrations of resource handlers for serving static resources such
as images, css files and others through Spring WebFlux including setting cache
headers optimized for efficient loading in a web browser.
Stores registrations of resource handlers for serving static resources such
as images, css files and others through Spring MVC including setting cache
headers optimized for efficient loading in a web browser.
Gather the need for resources available at runtime.
Generator of
ResourceHints
predicates, testing whether the given hints
match the expected behavior for resources.
Generic interface to be implemented by resource holders.
Convenient base class for resource holders.
TransactionSynchronization
implementation that manages a
ResourceHolder
bound through
TransactionSynchronizationManager
.
Implementation of
HttpMessageConverter
that can read/write
Resources
and supports byte range requests.
HttpMessageReader
that wraps and delegates to a
ResourceDecoder
that extracts the filename from the
"Content-Disposition"
header, if
available, and passes it as the
ResourceDecoder.FILENAME_HINT
.
HttpMessageWriter
that can write a
Resource
.
HttpRequestHandler
that serves static resources in an optimized way
according to the guidelines of Page Speed, YSlow, etc.
Strategy interface for loading resources (e.g., class path or file system
resources).
Interface to be implemented by any object that wishes to be notified of the
ResourceLoader
(typically the ApplicationContext) that it runs in.
Wrapper that adapts from the Quartz
ClassLoadHelper
interface
onto Spring's
ResourceLoader
interface.
Subclass of ShadowingClassLoader that overrides attempts to
locate certain files.
A hint that describes resources that should be made available at runtime.
A collection of
ResourcePatternHint
describing whether resources should
be made available at runtime using a matching algorithm based on include/exclude
patterns.
Builder for
ResourcePatternHints
.
Strategy interface for resolving a location pattern (for example,
an Ant-style path pattern) into
Resource
objects.
Utility class for determining whether a given URL is a resource
location that can be loaded via a
ResourcePatternResolver
.
Subclass of
PropertiesPropertySource
that loads a
Properties
object
from a given
Resource
or resource location such as
"classpath:/com/myco/foo.properties"
or
"file:/path/to/file.xml"
.
Region of a
Resource
implementation, materialized by a
position
within the
Resource
and a byte
count
for the length of that region.
Encoder for
ResourceRegions
.
Implementation of
HttpMessageConverter
that can write a single
ResourceRegion
or Collections of
ResourceRegions
.
A strategy for resolving a request to a server-side resource.
A strategy for resolving a request to a server-side resource.
A contract for invoking a chain of
ResourceResolvers
where each resolver
is given a reference to the chain allowing it to delegate when necessary.
A contract for invoking a chain of
ResourceResolvers
where each resolver
is given a reference to the chain allowing it to delegate when necessary.
ScriptSource
implementation
based on Spring's
Resource
abstraction.
Extended variant of
TransactionDefinition
, indicating a resource transaction
and in particular whether the transactional resource is ready for local optimizations.
Extension of the
PlatformTransactionManager
interface, indicating a native resource transaction manager, operating on a single
target resource.
An abstraction for transforming the content of a resource.
An abstraction for transforming the content of a resource.
A contract for invoking a chain of
ResourceTransformers
where each resolver
is given a reference to the chain allowing it to delegate when necessary.
A contract for invoking a chain of
ResourceTransformers
where each resolver
is given a reference to the chain allowing it to delegate when necessary.
A base class for a
ResourceTransformer
with an optional helper method
for resolving public links within a transformed resource.
A base class for a
ResourceTransformer
with an optional helper method
for resolving public links within a transformed resource.
A filter that wraps the
HttpServletResponse
and overrides its
encodeURL
method in order to
translate internal resource request URLs into public URL paths for external use.
A central component to use to obtain the public URL path that clients should
use to access a static resource.
A central component to use to obtain the public URL path that clients should
use to access a static resource.
An interceptor that exposes the
ResourceUrlProvider
instance it
is configured with as a request attribute.
Utility methods for resolving resource locations to files in the
file system.
HttpRequestHandler
that serves static resources in an optimized way
according to the guidelines of Page Speed, YSlow, etc.
A contract for setting up request expectations and defining a response.
Annotation that indicates a method return value should be bound to the web
response body.
ResponseBodyAdvice
<
T
>
Allows customizing the response after the execution of an
@ResponseBody
or a
ResponseEntity
controller method but before the body is written
with an
HttpMessageConverter
.
A controller method return value type for asynchronous request processing
where one or more objects are written to the response.
A simple holder of data to be written along with a MediaType hint for
selecting a message converter to write with.
Handler for return values of type
ResponseBodyEmitter
and subclasses
such as
SseEmitter
including the same types wrapped with
ResponseEntity
.
HandlerResultHandler
that handles return values from methods annotated
with
@ResponseBody
writing to the body of the request or response with
an
HttpMessageWriter
.
An
HttpCookie
subclass with the additional attributes allowed in
the "Set-Cookie" response header.
A builder for a server-defined HttpCookie with attributes.
A contract for creating a
ClientHttpResponse
.
ResponseEntity
<
T
>
Extension of
HttpEntity
that adds an
HttpStatusCode
status code.
Defines a builder that adds a body to the response entity.
Defines a builder that adds headers to the response entity.
A class with an
@ExceptionHandler
method that handles all Spring
WebFlux raised exceptions by returning a
ResponseEntity
with
RFC 7807 formatted error details in the body.
A class with an
@ExceptionHandler
method that handles all Spring MVC
raised exceptions by returning a
ResponseEntity
with RFC 7807
formatted error details in the body.
Handles return values of type
HttpEntity
,
ResponseEntity
,
HttpHeaders
,
ErrorResponse
, and
ProblemDetail
.
Strategy interface used by the
RestTemplate
to determine
whether a particular response has an error or not.
ResponseExtractor
<
T
>
Generic callback interface used by
RestTemplate
's retrieval methods.
Marks a method or exception class with the status
ResponseStatus.code()
and
ResponseStatus.reason()
that should be returned.
Subclass of
ErrorResponseException
that accepts a "reason", and by
default maps that to the
"detail"
of the
ProblemDetail
.
Handle
ResponseStatusException
by setting the response status.
A
HandlerExceptionResolver
that uses the
@ResponseStatus
annotation to map exceptions to HTTP status codes.
Base class for exceptions thrown by
RestTemplate
in case a request
fails because of a server error response, as determined via
ResponseErrorHandler.hasError(ClientHttpResponse)
, failure to decode
the response, or a low level I/O error.
Common base class for exceptions that contain actual HTTP response data.
A convenience annotation that is itself annotated with
@Controller
and
@ResponseBody
.
A convenience annotation that is itself annotated with
@ControllerAdvice
and
@ResponseBody
.
Convenient superclass for application classes that need REST access.
Interface specifying a basic set of RESTful operations.
Synchronous client to perform HTTP requests, exposing a simple, template
method API over underlying HTTP client libraries such as the JDK
HttpURLConnection
, Apache HttpComponents, and others.
An
XhrTransport
implementation that uses a
RestTemplate
.
Allows applying actions, such as expectations, on the result of an executed
request.
A
ResultHandler
performs a generic action on the result of an
executed request — for example, printing debug information.
A
ResultMatcher
matches the result of an executed request against
some expectation.
ResultSetExtractor
<
T
>
Callback interface used by
JdbcTemplate
's query methods.
Common base class for ResultSet-supporting SqlParameters like
SqlOutParameter
and
SqlReturnResultSet
.
The default implementation of Spring's
SqlRowSet
interface, wrapping a
ResultSet
, catching any
SQLExceptions
and
translating them to a corresponding Spring
InvalidResultSetAccessException
.
The default implementation of Spring's
SqlRowSetMetaData
interface, wrapping a
ResultSetMetaData
instance, catching any
SQLExceptions
and translating them to a corresponding Spring
InvalidResultSetAccessException
.
Assist with configuration for handler method return value handlers.
Indicates the 'role' hint for a given bean.
@Rollback
is a test annotation that is used to indicate whether
a
test-managed transaction
should be
rolled back
after
the test method has completed.
Rule determining whether a given exception should cause a rollback.
A root bean definition represents the
merged bean definition at runtime
that backs a specific bean in a Spring BeanFactory.
Simple ClassFilter implementation that passes classes (and optionally subclasses).
Contract for matching routes to patterns.
A parsed representation of a route.
Represents a function that routes to a
handler function
.
Represents a function that routes to a
handler function
.
HandlerMapping
implementation that supports
RouterFunctions
.
HandlerMapping
implementation that supports
RouterFunctions
.
Central entry point to Spring's functional web framework.
Exposes routing functionality, such as to
create
a
RouterFunction
using a discoverable builder-style API, to
create
a
RouterFunction
given a
RequestPredicate
and
HandlerFunction
, and to do further
subrouting
on an existing routing
function.
Central entry point to Spring's functional web framework.
Exposes routing functionality, such as to
create
a
RouterFunction
using a discoverable builder-style API, to
create
a
RouterFunction
given a
RequestPredicate
and
HandlerFunction
, and to do further
subrouting
on an existing routing
function.
Represents a discoverable builder for router functions.
Represents a discoverable builder for router functions.
Receives notifications from the logical structure of router functions.
Receives notifications from the logical structure of router functions.
An interface used by
JdbcTemplate
and
NamedParameterJdbcTemplate
for processing rows of a
ResultSet
on a per-row basis.
Implementation of RowCallbackHandler.
An interface used by
JdbcTemplate
for mapping rows of a
ResultSet
on a per-row basis.
Adapter implementation of the ResultSetExtractor interface that delegates
to a RowMapper which is supposed to create an object for each row.
RowsFetchSpec
<
T
>
Contract for fetching tabular results.
Strategy to apply configuration to an
RSocketConnector
.
Annotation to declare a method on an RSocket service interface as an RSocket
endpoint.
A condition to assist with mapping onto handler methods based on the RSocket
frame type.
Extension of
MessageMappingMessageHandler
for handling RSocket
requests with
@ConnectMapping
and
@MessageMapping
methods.
Extension of
AbstractEncoderMethodReturnValueHandler
that
handles
encoded content by wrapping data buffers
as RSocket payloads and by passing those through the
RSocketPayloadReturnValueHandler.RESPONSE_HEADER
header.
A thin wrapper around a sending
RSocket
with a fluent API accepting
and returning higher level Objects for input and for output, along with
methods to prepare routing and other metadata.
Builder to create a requester by connecting to a server.
Spec for providing additional composite metadata entries.
Spec to declare the input for an RSocket request.
Spec to declare the expected output for an RSocket request.
Resolves arguments of type
RSocket
that can be used for making
requests to the remote peer.
Container for RSocket request values extracted from an
@RSocketExchange
-annotated
method and argument values passed to it.
Builder for
RSocketRequestValues
.
Resolve an argument from an
@RSocketExchange
-annotated
method to one or more RSocket request values.
Factory for creating a client proxy given an RSocket service interface with
@RSocketExchange
methods.
Builder to create an
RSocketServiceProxyFactory
.
Access to strategies for use by RSocket requester and responder components.
The builder options for creating
RSocketStrategies
.
Implementation of
HttpMessageConverter
that can read and write RSS feeds.
TransactionAttribute implementation that works out whether a given exception
should cause transaction rollback by applying a number of rollback rules,
both positive and negative.
RunAfterTestClassCallbacks
is a custom JUnit
Statement
which allows
the
Spring TestContext Framework
to be plugged into the JUnit execution chain
by calling
afterTestClass()
on the supplied
TestContextManager
.
RunAfterTestExecutionCallbacks
is a custom JUnit
Statement
which allows the
Spring TestContext Framework
to be plugged into the
JUnit 4 execution chain by calling
afterTestExecution()
on the supplied
TestContextManager
.
RunAfterTestMethodCallbacks
is a custom JUnit
Statement
which allows
the
Spring TestContext Framework
to be plugged into the JUnit execution chain
by calling
afterTestMethod()
on the supplied
TestContextManager
.
RunBeforeTestClassCallbacks
is a custom JUnit
Statement
which allows
the
Spring TestContext Framework
to be plugged into the JUnit execution chain
by calling
beforeTestClass()
on the
supplied
TestContextManager
.
RunBeforeTestExecutionCallbacks
is a custom JUnit
Statement
which allows the
Spring TestContext Framework
to be plugged into the
JUnit 4 execution chain by calling
beforeTestExecution()
on the supplied
TestContextManager
.
RunBeforeTestMethodCallbacks
is a custom JUnit
Statement
which allows
the
Spring TestContext Framework
to be plugged into the JUnit execution chain
by calling
beforeTestMethod()
on the supplied
TestContextManager
.
RunPrepareTestInstanceCallbacks
is a custom JUnit
Statement
which
allows the
Spring TestContext Framework
to be plugged into the JUnit
execution chain by calling
prepareTestInstance()
on the supplied
TestContextManager
.
Immutable placeholder class used for a property value object when it's a
reference to another bean name in the factory, to be resolved at runtime.
Immutable placeholder class used for a property value object when it's
a reference to another bean in the factory, to be resolved at runtime.
Gather hints that can be used to optimize the application runtime.
Java Agent that records method invocations related to
RuntimeHints
metadata.
A wrapper for
RecordedInvocation
that is the starting point for
RuntimeHints
AssertJ assertions.
AssertJ
assertions
that can be applied to
RuntimeHintsInvocations
.
Static generator of predicates that test whether the given
RuntimeHints
instance matches the expected behavior for reflection, resource, serialization,
or proxy generation.
Invocations relevant to
RuntimeHints
recorded during the execution of a block
of code instrumented by the
RuntimeHintsAgent
.
Contract for registering
RuntimeHints
based on the
ClassLoader
of the deployment unit.
Interface that specifies an API to programmatically manage transaction
savepoints in a generic fashion.
Convenient utility methods for dealing with SAX.
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.
Common base class for accessing a Quartz Scheduler, i.e.
Spring bean-style class for accessing a Quartz Scheduler, i.e.
Parser for the 'scheduler' element of the 'task' namespace.
Callback interface to be implemented by Spring-managed
Quartz artifacts that need access to the SchedulerContext
(without having natural access to it).
FactoryBean
that creates and configures a Quartz
Scheduler
,
manages its lifecycle as part of the Spring application context, and exposes the
Scheduler as bean reference for dependency injection.
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.
Strategy interface used by a
ConfigurableBeanFactory
,
representing a target scope to hold bean instances in.
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.
An AOP introduction interface for scoped objects.
Convenient proxy factory bean for scoped objects.
Enumerates the various scoped-proxy options.
Utility class for creating a scoped proxy.
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.
A subclass of
BeanCreationException
which indicates that the target scope
is not active, e.g.
Exception to be thrown on script compilation failure.
Spring's strategy interface for evaluating a script.
Root of the hierarchy of data access exceptions that are related to processing
of SQL scripts.
Root of the hierarchy of data access exceptions that are related to processing
of SQL scripts.
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.
Thrown by
ScriptUtils
if an SQL script cannot be properly parsed.
Thrown by
ScriptUtils
if an SQL script cannot be properly parsed.
Interface that defines the source of a script.
Thrown by
ScriptUtils
if a statement in an SQL script failed when
executing it against the target database.
Thrown by
ScriptUtils
if a statement in an SQL script failed when
executing it against the target database.
Interface to be implemented by objects that configure and manage a
JSR-223
ScriptEngine
for automatic lookup in a web environment.
Interface to be implemented by objects that configure and manage a
JSR-223
ScriptEngine
for automatic lookup in a web environment.
An implementation of the Spring WebFlux
ScriptTemplateConfig
for
creating a
ScriptEngine
for use in a web application.
An implementation of Spring MVC's
ScriptTemplateConfig
for creating
a
ScriptEngine
for use in a web application.
Parse the
<mvc:script-template-configurer>
MVC namespace element and
register a
ScriptTemplateConfigurer
bean.
An
AbstractUrlBasedView
subclass designed to run any template library
based on a JSR-223 script engine.
An
AbstractUrlBasedView
subclass designed to run any template library
based on a JSR-223 script engine.
Convenience subclass of
UrlBasedViewResolver
that supports
ScriptTemplateView
and custom subclasses of it.
Convenience subclass of
UrlBasedViewResolver
that supports
ScriptTemplateView
and custom subclasses of it.
Generic utility methods for working with SQL scripts in conjunction with JDBC.
Generic utility methods for working with SQL scripts in conjunction with R2DBC.
Represents selection over a map or collection.
The
<select>
tag renders an HTML 'select' element.
Interface that allows infrastructure components to provide their own
ObjectName
s to the
MBeanExporter
.
Annotation that indicates a method's return value should be converted to
a
Message
if necessary and sent to the specified destination.
A
HandlerMethodReturnValueHandler
for sending to destinations specified in a
SendTo
or
SendToUser
method-level annotations.
Indicates the return value of a message-handling method should be sent as a
Message
to the specified destination(s)
further prepended with
"/user/{username}"
where the user name
is extracted from the headers of the input message being handled.
A convenient delegate with pre-arranged configuration state for common
serialization needs.
Wrapper for the native IOException (or similar) when a
Serializer
or
Deserializer
failed.
Gather the need for Java serialization at runtime.
Generator of
SerializationHints
predicates, testing whether the
given hints match the expected behavior for serialization.
Static utilities for serialization and deserialization using
Java Object Serialization
.
Serializer
<
T
>
A strategy interface for streaming an object to an OutputStream.
A
Converter
that delegates to a
Serializer
to convert an object to a byte array.
Extension of
CodecConfigurer
for HTTP message reader and writer
options relevant on the server side.
CodecConfigurer.DefaultCodecs
extension with extra server-side options.
Detects beans of type
ServerEndpointConfig
and registers
with the standard Jakarta WebSocket runtime.
An implementation of
ServerEndpointConfig
for use in
Spring-based applications.
Exception for an
HttpStatus.INTERNAL_SERVER_ERROR
that exposes extra
information about a controller method that failed, or a controller method
argument that could not be resolved.
A control that can put the processing of an HTTP request in asynchronous mode during
which the response remains open until explicitly closed.
Documented
KeyValues
for the HTTP server observations
for Servlet-based web applications.
Documented
KeyValues
for the HTTP server observations
for reactive web applications.
WebFilter
that creates
observations
for HTTP exchanges.
Filter
that creates
observations
for HTTP exchanges.
Represents a reactive server-side HTTP request.
Represents a server-side HTTP request.
Builder for mutating an existing
ServerHttpRequest
.
Wraps another
ServerHttpRequest
and delegates all methods to it.
Represents a reactive server-side HTTP response.
Represents a server-side HTTP response.
Wraps another
ServerHttpResponse
and delegates all methods to it.
Represents a server-side HTTP request, as handled by a
HandlerFunction
.
Represents a server-side HTTP request, as handled by a
HandlerFunction
.
Defines a builder for a request.
Defines a builder for a request.
Represents the headers of the HTTP request.
Represents the headers of the HTTP request.
Context that holds information for metadata collection regarding
Servlet HTTP requests
observations.
Context that holds information for metadata collection regarding
reactive HTTP requests
observations.
Interface for an
ObservationConvention
for
Servlet HTTP requests
.
Interface for an
ObservationConvention
for
reactive HTTP requests
.
Implementation of the
ServerRequest
interface that can be subclassed
to adapt the request in a
handler filter function
.
Implementation of the
Headers
interface that can be subclassed
to adapt the headers in a
handler filter function
.
Represents a typed server-side HTTP response, as returned
by a
handler function
or
filter function
.
Represents a typed server-side HTTP response, as returned
by a
handler function
or
filter function
.
Defines a builder that adds a body to the response.
Defines a builder that adds a body to the response.
Defines the context used during the
ServerResponse.writeTo(ServerWebExchange, Context)
.
Defines the context used during the
ServerResponse.writeTo(HttpServletRequest, HttpServletResponse, Context)
.
Defines a builder that adds headers to the response.
Defines a builder that adds headers to the response.
Defines a builder for a body that sends server-sent events.
HandlerResultHandler
implementation that supports
ServerResponses
.
ServerSentEvent
<
T
>
Representation for a Server-Sent Event for use with Spring's reactive Web support.
A mutable builder for a
SseEvent
.
Reader that supports a stream of
ServerSentEvents
and also plain
Objects
which is the same as an
ServerSentEvent
with data only.
HttpMessageWriter
for
"text/event-stream"
responses.
Contract for an HTTP request-response interaction.
Builder for mutating an existing
ServerWebExchange
.
Inserts an attribute in the Reactor
Context
that makes the current
ServerWebExchange
available under the attribute name
ServerWebExchangeContextFilter.EXCHANGE_CONTEXT_ATTRIBUTE
.
A convenient base class for classes that need to wrap another
ServerWebExchange
.
Resolves ServerWebExchange-related method argument values of the following types:
ServerWebExchange
ServerHttpRequest
ServerHttpResponse
HttpMethod
Locale
TimeZone
ZoneId
UriBuilder
or
UriComponentsBuilder
-- for building URL's
relative to the current request
Exception for errors that fit response status 400 (bad request) for use in
Spring Web applications.
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."
FactoryBean
that exposes the
'primary' service for the configured service class, obtained through
the JDK 1.6
ServiceLoader
facility.
FactoryBean
that exposes
all
services for the configured service class, represented as a List of service objects,
obtained through the JDK 1.6
ServiceLoader
facility.
FactoryBean
that exposes the
JDK 1.6
ServiceLoader
for the configured service class.
A
FactoryBean
implementation that takes an interface which must have one or more
methods with the signatures
MyType xxx()
or
MyType xxx(MyIdType id)
(typically,
MyService getService()
or
MyService getService(String id)
)
and creates a dynamic proxy which implements that interface, delegating to an
underlying
BeanFactory
.
Interface to be implemented by any object that wishes to be notified of the
ServletConfig
(typically determined by the
WebApplicationContext
)
that it runs in.
PropertySource
that reads init parameters from a
ServletConfig
object.
Exporter that takes Spring-defined objects and exposes them as
ServletContext attributes.
FactoryBean
that fetches a specific, existing ServletContext attribute.
Interface to be implemented by any object that wishes to be notified of the
ServletContext
(typically determined by the
WebApplicationContext
)
that it runs in.
BeanPostProcessor
implementation that passes the ServletContext to beans that implement
the
ServletContextAware
interface.
FactoryBean
that retrieves a specific ServletContext init parameter
(that is, a "context-param" defined in
web.xml
).
PropertySource
that reads init parameters from a
ServletContext
object.
Helper class for resolving placeholders in texts.
Simple request logging filter that writes the request URI
(and optionally the query string) to the ServletContext log.
Resource
implementation for
ServletContext
resources, interpreting
relative paths within the web application root directory.
ResourceLoader implementation that resolves paths as ServletContext
resources, for use outside a WebApplicationContext (for example,
in an HttpServletBean or GenericFilterBean subclass).
ServletContext-aware subclass of
PathMatchingResourcePatternResolver
,
able to find matching resources below the web application root directory
via
ServletContext.getResourcePaths(java.lang.String)
.
Scope
wrapper for a ServletContext, i.e.
An
AbstractCookieValueMethodArgumentResolver
that resolves cookie values from an
HttpServletRequest
.
Spring Controller implementation that forwards to a named servlet,
Adapt
HttpHandler
to an
HttpServlet
using Servlet Async support
and Servlet non-blocking I/O.
Extends
InvocableHandlerMethod
with the ability to handle return
values through a registered
HandlerMethodReturnValueHandler
and
also supports setting the response status based on a method-level
@ResponseStatus
annotation.
A Servlet-specific
ModelAttributeMethodProcessor
that applies data
binding through a WebDataBinder of type
ServletRequestDataBinder
.
Deprecated.
as of 5.2.4.
Servlet-based implementation of the
RequestAttributes
interface.
Fatal binding exception, thrown when we want to
treat binding exceptions as unrecoverable.
Special
DataBinder
to perform data binding
from servlet request parameters to JavaBeans, including support for multipart files.
Creates a
ServletRequestDataBinder
.
Servlet-specific subclass of RequestHandledEvent,
adding servlet-specific context information.
Resolves servlet backed request-related method arguments.
PropertyValues implementation created from parameters in a ServletRequest.
Filter
that
parses and
caches
a
RequestPath
that can then
be accessed via
ServletRequestPathUtils.getParsedRequestPath(jakarta.servlet.ServletRequest)
.
Utility class to assist with preparation and access to the lookup path for
request mapping purposes.
Parameter extraction methods, for an approach distinct from data binding,
in which parameters of specific types are required.
Resolves servlet backed response-related method arguments.
A
FactoryBean
for configuring
ServerContainer
.
A
ServerHttpAsyncRequestControl
to use on Servlet containers.
ServerHttpRequest
implementation that is based on a
HttpServletRequest
.
ServerHttpResponse
implementation that is based on a
HttpServletResponse
.
TestExecutionListener
which provides mock Servlet API support to
WebApplicationContexts
loaded by the
Spring
TestContext Framework
.
UriComponentsBuilder with additional static factory methods to create links
based on the current HttpServletRequest.
A Servlet-specific
AbstractWebArgumentResolverAdapter
that creates a
NativeWebRequest
from
ServletRequestAttributes
.
WebRequest
adapter for an
HttpServletRequest
.
A helper class for configuring
WebSocketHandler
request handling
including SockJS fallback options.
WebSocketHandlerRegistry
with Spring MVC handler mappings for the
handshake requests.
Spring Controller implementation that wraps a servlet instance which it manages
internally.
Annotation to bind a method parameter to a session attribute.
Resolves method arguments annotated with an @
SessionAttribute
.
Resolves method arguments annotated with an @
SessionAttribute
.
Annotation that indicates the session attributes that a specific handler uses.
Manages controller-specific session attributes declared via
@SessionAttributes
.
Strategy interface for storing model attributes in a backend session.
Variant of the standard JMS
MessageListener
interface,
offering not only the received Message but also the underlying
JMS Session object.
SessionCallback
<
T
>
Callback for executing any number of operations on a provided
Session
.
A connected event represents the server response to a client's connect request.
Event raised when a new WebSocket client using a Simple Messaging Protocol
(e.g.
Event raised when the session of a WebSocket client using a Simple Messaging
Protocol (e.g.
Helper class featuring methods for Hibernate Session handling.
Store and retrieve
FlashMap
instances to and from the HTTP session.
Resource holder wrapping a Hibernate
Session
(plus an optional
Transaction
).
Raised when a WebSocket session has exceeded limits it has been configured
for, e.g.
LocaleResolver
implementation that
uses a locale attribute in the user's session in case of a custom setting,
with a fallback to the configured default locale, the request's
Accept-Language
header, or the default locale for the server.
Subinterface of
Session
to be implemented by
Session proxies.
@SessionScope
is a specialization of
@Scope
for a
component whose lifecycle is bound to the current web session.
Session-backed
Scope
implementation.
Simple interface that can be injected into handler methods, allowing them to
signal that their session processing is complete.
Resolves a
SessionStatus
argument by obtaining it from
the
ModelAndViewContainer
.
Resolver for a
SessionStatus
argument obtaining it from the
BindingContext
.
Event raised when a new WebSocket client using a Simple Messaging Protocol
(e.g.
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
Event raised when a new WebSocket client using a Simple Messaging Protocol
(e.g.
Simple factory for shared Set instances.
Deprecated.
as of 6.0, in favor of
CompletableFuture
ClassLoader decorator that shadows an enclosing ClassLoader,
applying registered transformers to all affected classes.
Filter
that generates an
ETag
value based on the
content on the response.
FactoryBean
that exposes a shared JPA
EntityManager
reference for a given EntityManagerFactory.
Delegate for creating a shareable JPA
EntityManager
reference for a given
EntityManagerFactory
.
MockMvcConfigurer
that stores and re-uses the HTTP session across
multiple requests performed through the same
MockMvc
instance.
A representation of a method signature, containing the method name,
return type, and parameter types.
A handler for messages delegating to
@MessageMapping
and
@SubscribeMapping
annotated methods.
A wrapper class for access to attributes associated with a SiMP session
(e.g.
Holder class to expose SiMP attributes associated with a session (e.g.
Simple implementation of the
AliasRegistry
interface.
Simple implementation of the
ApplicationEventMulticaster
interface.
Implementation of
AspectInstanceFactory
that creates a new instance
of the specified aspect class for every
SimpleAspectInstanceFactory.getAspectInstance()
call.
TaskExecutor
implementation that fires up a new Thread for each task,
executing it asynchronously.
A default
AsyncUncaughtExceptionHandler
that simply logs the exception.
AutowireCandidateResolver
implementation to use when no annotation
support is available.
Simple implementation of the
BeanDefinitionRegistry
interface.
Implementation of
AspectInstanceFactory
that locates the aspect from the
BeanFactory
using a configured bean name.
Simple
TargetSource
implementation,
freshly obtaining the specified target bean from its containing
Spring
BeanFactory
.
Simple implementation of the JCA 1.7
BootstrapContext
interface, used for bootstrapping a JCA ResourceAdapter in a local environment.
A "simple" message broker that recognizes the message types defined in
SimpMessageType
, keeps track of subscriptions with the help of a
SubscriptionRegistry
, and sends messages to subscribers.
Registration class for configuring a
SimpleBrokerMessageHandler
.
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()
.
ClientHttpRequestFactory
implementation that uses standard JDK facilities.
CommandLinePropertySource
implementation backed by a simple String array.
Simple implementation of the
ConnectionHandle
interface,
containing a given JDBC Connection.
Simple
NamespaceHandler
implementation that maps custom
attributes directly through to bean properties.
Adapter to use the plain
Controller
workflow interface with
the generic
DispatcherServlet
.
Simple implementation of the standard JDBC
DataSource
interface,
configuring a plain old JDBC
Driver
via bean properties, and
returning a new
Connection
from every
getConnection
call.
A basic implementation of
EvaluationContext
that focuses on a subset
of essential SpEL features and customization options, targeting simple
condition evaluation and in particular data binding scenarios.
Builder for
SimpleEvaluationContext
.
A simple
CacheResolver
that resolves the exception cache
based on a configurable
CacheManager
and the name of the
cache:
CacheResultOperation.getExceptionCacheName()
.
A simple
IdGenerator
that starts at 1, increments up to
Long.MAX_VALUE
, and then rolls over.
Simple object instantiation strategy for use in a BeanFactory.
Simplistic implementation of an instrumentable
ClassLoader
.
A SimpleJdbcCall is a multithreaded, reusable object representing a call
to a stored procedure or a stored function.
Interface specifying the API for a Simple JDBC Call implemented by
SimpleJdbcCall
.
A SimpleJdbcInsert is a multithreaded, reusable object providing easy insert
capabilities for a table.
Interface specifying the API for a Simple JDBC Insert implemented by
SimpleJdbcInsert
.
Simple implementation of
JmsHeaderMapper
.
A
JmsListenerContainerFactory
implementation to build a
standard
SimpleMessageListenerContainer
.
A
JmsListenerEndpoint
simply providing the
MessageListener
to
invoke to process an incoming message for this endpoint.
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
.
Deprecated.
in
spring-jcl
(effectively equivalent to
NoOpLog
)
Models a simple mail message, including data such as the from, to, cc, subject,
and text fields.
HandlerExceptionResolver
implementation
that allows for mapping exception class names to view names, either for a set of
given handlers or for all handlers in the DispatcherServlet.
A simple message converter which is able to handle TextMessages, BytesMessages,
MapMessages, and ObjectMessages.
A simple converter that simply unwraps the message payload as long as it matches the
expected target class.
Message listener container that uses the plain JMS client API's
MessageConsumer.setMessageListener()
method to
create concurrent MessageConsumers for the specified listeners.
Implementation of
MetadataAwareAspectInstanceFactory
that
creates a new instance of the specified aspect class for every
SimpleAspectInstanceFactory.getAspectInstance()
call.
Simple implementation of the
MetadataReaderFactory
interface,
creating a new ASM
ClassReader
for every request.
Simple
javax.xml.namespace.NamespaceContext
implementation.
Simple
NamespaceHandler
implementation that maps custom attributes
directly through to bean properties.
Simple subclass of
AbstractReflectiveMBeanInfoAssembler
that always votes yes for method and property inclusion, effectively exposing
all public methods and properties as operations and attributes.
A simple
ReflectiveProcessor
implementation that registers only a
reflection hint for the annotated type.
Simple
RequestExpectationManager
that matches requests to expectations
sequentially, i.e.
RouteMatcher
that delegates to a
PathMatcher
.
Simple
org.xml.sax.ErrorHandler
implementation:
logs warnings using the given Commons Logging logger instance,
and rethrows errors to discontinue the XML transformation.
Adapter to use the Servlet interface with the generic DispatcherServlet.
BeanPostProcessor
that applies initialization and destruction callbacks to beans that
implement the
Servlet
interface.
Simple implementation of the
SessionStatus
interface,
keeping the
complete
flag as an instance variable.
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
Subclass of Quartz's SimpleThreadPool that implements Spring's
TaskExecutor
interface
and listens to Spring lifecycle callbacks.
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 AOP Alliance
MethodInterceptor
that can be introduced
in a chain to display verbose trace information about intercepted method
invocations, with method entry and method exit info.
Default implementation of the
TransactionFactory
strategy interface,
simply wrapping a standard JTA
TransactionManager
.
A simple transaction-backed
Scope
implementation, delegating to
TransactionSynchronizationManager
's resource binding mechanism.
A simple
TransactionStatus
implementation.
Simple
javax.xml.transform.ErrorListener
implementation:
logs warnings using the given Commons Logging logger instance,
and rethrows errors to discontinue the XML transformation.
Simple data holder implementation of the
TriggerContext
interface.
A Spring
FactoryBean
for creating a Quartz
SimpleTrigger
instance, supporting bean-style usage for trigger configuration.
Simple implementation of the
TypeConverter
interface that does not operate on
a specific target object.
Implementation of the
HandlerMapping
interface to map from URLs to request handler beans.
Implementation of the
HandlerMapping
interface that maps from URLs to request handler beans.
ValueStyler
that converts objects to String form — generally for
debugging purposes — using simple styling conventions that mimic the
toString()
styling conventions for standard JDK implementations of
collections, maps, and arrays.
Straightforward implementation of
Cache.ValueWrapper
,
simply holding the value as given at construction and returning it from
SimpleValueWrapper.get()
.
Holds the shared logger named "org.springframework.web.SimpLogging" to use
for STOMP over WebSocket messaging when logging for
"org.springframework.messaging.simp" is off but logging for
"org.springframework.web" is on.
A base class for working with message headers in simple messaging protocols that
support basic messaging patterns.
MessageCondition
for SImple Messaging Protocols.
A specialization of
MessageSendingOperations
with methods for use with
the Spring Framework support for Simple Messaging Protocols (like STOMP).
A generic representation of different kinds of messages found in simple messaging
protocols like STOMP.
MessageCondition
that matches by the message type obtained via
SimpMessageHeaderAccessor.getMessageType(Map)
.
An implementation of
SimpMessageSendingOperations
.
Represents a session of connected user.
A
Scope
implementation exposing the attributes of a SiMP session
(e.g.
Represents a subscription within a user session.
A strategy for matching subscriptions.
Represents a connected user.
A registry of currently connected users.
RowMapper
implementation that converts a single column into a single
result value per row.
Implementation of
SmartDataSource
that wraps a single JDBC Connection
which is not closed after use.
A JMS ConnectionFactory adapter that returns the same Connection
from all
SingleConnectionFactory.createConnection()
calls, and ignores calls to
Connection.close()
.
Implementation of
DelegatingConnectionFactory
that wraps a
single R2DBC
Connection
which is not closed after use.
An implementation of
ConnectionFactoryLookup
that
simply wraps a single given
ConnectionFactory
returned for any connection factory name.
An implementation of the DataSourceLookup that simply wraps a
single given DataSource, returned for any data source name.
Implementation of
AspectInstanceFactory
that is backed by a
specified singleton object, returning the same instance for every
SingletonAspectInstanceFactory.getAspectInstance()
call.
Interface that defines a registry for shared bean instances.
Implementation of
MetadataAwareAspectInstanceFactory
that is backed
by a specified singleton object, returning the same instance for every
SingletonAspectInstanceFactory.getAspectInstance()
call.
SingletonSupplier
<
T
>
A
Supplier
decorator that caches a singleton result and
makes it available from
SingletonSupplier.get()
(nullable) and
SingletonSupplier.obtain()
(null-safe).
Implementation of the
TargetSource
interface
that holds a given object.
Extended variant of the standard
ApplicationListener
interface,
exposing further metadata such as the supported event and source type.
Interface to be implemented by a reloading-aware ClassLoader
(e.g.
Extension of the
jakarta.jms.ConnectionFactory
interface,
indicating how to release Connections obtained from it.
Strategy interface for loading an
ApplicationContext
for an integration
test managed by the Spring TestContext Framework.
Extension of the
javax.sql.DataSource
interface, to be
implemented by special DataSources that return JDBC Connections
in an unwrapped fashion.
SmartFactoryBean
<
T
>
Extension of the
FactoryBean
interface.
Callback interface triggered at the end of the singleton pre-instantiation phase
during
BeanFactory
bootstrap.
Extension of the
InstantiationAwareBeanPostProcessor
interface,
adding a callback for predicting the eventual type of a processed bean.
An extension of the
Lifecycle
interface for those objects that require
to be started upon
ApplicationContext
refresh and/or shutdown in a
particular order.
An extended
MessageConverter
SPI with conversion hint support.
An extended
MessageConverter
SPI with conversion hint support.
Extension of the standard JPA PersistenceUnitInfo interface, for advanced collaboration
between Spring's
LocalContainerEntityManagerFactoryBean
and
PersistenceUnitManager
implementations.
Extended variant of a
RequestBuilder
that applies its
org.springframework.test.web.servlet.request.RequestPostProcessors
as a separate step from the
RequestBuilder.buildRequest(jakarta.servlet.ServletContext)
method.
Interface to be implemented by transaction objects that are able to
return an internal rollback-only marker, typically from another
transaction that has participated and marked it as rollback-only.
Extended variant of the
Validator
interface, adding support for
validation 'hints'.
Provides additional information about a View such as whether it
performs redirects.
A SockJS implementation of
WebSocketClient
with fallback alternatives that simulate a WebSocket interaction through plain
HTTP streaming and long polling techniques.
Base class for exceptions raised while processing SockJS HTTP requests.
Represents a SockJS frame.
Applies a transport-specific format to the content of a SockJS frame resulting
in a content that can be written out.
SockJS frame types.
An
HttpRequestHandler
that allows mapping a
SockJsService
to requests
in a Servlet container.
Encode and decode messages to and from a SockJS message frame,
essentially an array of JSON-encoded messages.
An exception thrown when a message frame was successfully received over an HTTP POST
and parsed but one or more of the messages it contained could not be delivered to the
WebSocketHandler either because the handler failed or because the connection got
closed.
The main entry point for processing HTTP requests from SockJS clients.
Provides transport handling code with access to the
SockJsService
configuration
options they need to have access to.
A helper class for configuring SockJS fallback options for use with an
EnableWebSocket
and
WebSocketConfigurer
setup.
SockJS extension of Spring's standard
WebSocketSession
.
A factory for creating a SockJS session.
Indicates a serious failure that occurred in the SockJS implementation as opposed to
in user code (e.g.
Container for the base URL of a SockJS endpoint with additional helper methods
to derive related SockJS URLs: specifically, the
info
and
transport
URLs.
An implementation of
WebSocketHandler
that adds SockJS messages frames, sends
SockJS heartbeat messages, and delegates lifecycle events and messages to a target
WebSocketHandler
.
Definition for sorting bean instances by a property.
FactoryBean
implementation that takes a list of location Strings
and creates a sorted array of
Resource
instances.
Simple strategy allowing tools to control how source metadata is attached
to the bean definition metadata.
DynamicFile
that holds Java source code and provides
SourceFileAssert
support.
Assertion methods for
SourceFile
instances.
An immutable collection of
SourceFile
instances.
ApplicationListener
decorator that filters
events from a specified event source, invoking its delegate listener for
matching
ApplicationEvent
objects only.
Implementation of
HttpMessageConverter
that can read and write
Source
objects.
A SpelCompiler will take a regular parsed expression and create (and load) a class
containing byte code that does the same thing as that expression.
Captures the possible configuration settings for a compiler that can be
used when evaluating expressions.
Root exception for Spring EL related exceptions.
A
SpelExpression
represents a parsed (valid) expression that is ready to be
evaluated in a specified context.
SpEL parser.
Contains all the messages that can be produced by the Spring Expression Language.
Message kinds.
Represents a node in the AST for a parsed expression.
The common supertype of all AST nodes in a parsed Spring Expression Language
format expression.
Root exception for Spring EL related exceptions.
Configuration object for the SpEL expression parser.
Utility class exposing constants related to Spring's internal repackaging
of the ASM bytecode library: currently based on ASM 9.x plus minor patches.
Convenient base class for self-autowiring classes that gets constructed
within a Spring-based web application.
Spring's implementation of Hibernate's
BeanContainer
SPI,
delegating to a Spring
ConfigurableListableBeanFactory
.
JSF
ELResolver
that delegates to the Spring root
WebApplicationContext
,
resolving name references to Spring-defined beans.
Subclass of
AdaptableJobFactory
that also supports Spring-style
dependency injection on bean properties.
Strategy implementation for parsing Spring's
Caching
,
Cacheable
,
CacheEvict
, and
CachePut
annotations.
Empty class used to ensure that the
org.springframework.cglib
package is processed during javadoc generation.
SpringClassRule
is a custom JUnit
TestRule
that supports
class-level
features of the
Spring TestContext Framework
in standard JUnit tests by means of the
TestContextManager
and
associated support classes and annotations.
A
ServerEndpointConfig.Configurator
for initializing
ServerEndpoint
-annotated classes through Spring.
@Configuration
class that registers an
AnnotationBeanConfigurerAspect
capable of performing dependency injection services for non-Spring managed objects
annotated with @
Configurable
.
JSR-303
ConstraintValidatorFactory
implementation that delegates to a
Spring BeanFactory for creating autowired
ConstraintValidator
instances.
SpringExtension
integrates the
Spring TestContext Framework
into JUnit 5's
Jupiter
programming model.
General purpose factory loading mechanism for internal use within the framework.
Strategy for resolving constructor arguments based on their type.
Strategy for handling a failure that occurs when instantiating a factory.
SpringFailOnTimeout
is a custom JUnit
Statement
which adds
support for Spring's
@Timed
annotation by throwing an exception if the next statement in the execution
chain takes more than the specified number of milliseconds.
Simple synchronization adapter that propagates a
flush()
call
to the underlying Hibernate Session.
Allows for creating Jackson (
JsonSerializer
,
JsonDeserializer
,
KeyDeserializer
,
TypeResolverBuilder
,
TypeIdResolver
)
beans with autowiring against a Spring
ApplicationContext
.
Spring-specific subclass of Hibernate's JTASessionContext,
setting
FlushMode.MANUAL
for read-only transactions.
Adapter that implements the JTA
Synchronization
interface delegating to an underlying Spring
TransactionSynchronization
.
SpringJUnit4ClassRunner
is a custom extension of JUnit's
BlockJUnit4ClassRunner
which provides functionality of the
Spring TestContext Framework
to standard JUnit tests by means of the
TestContextManager
and associated support classes and annotations.
@SpringJUnitConfig
is a
composed annotation
that combines
@ExtendWith(SpringExtension.class)
from JUnit Jupiter with
@ContextConfiguration
from the
Spring TestContext
Framework
.
@SpringJUnitWebConfig
is a
composed annotation
that combines
@ExtendWith(SpringExtension.class)
from JUnit Jupiter with
@ContextConfiguration
and
@WebAppConfiguration
from the
Spring TestContext
Framework
.
SpringMethodRule
is a custom JUnit 4
MethodRule
that
supports instance-level and method-level features of the
Spring TestContext Framework
in standard JUnit tests by means
of the
TestContextManager
and associated support classes and
annotations.
Extension of the
RequiredModelMBean
class that ensures the
thread context ClassLoader
is switched
for the managed resource's
ClassLoader
before any invocations occur.
Custom variant of CGLIB's
DefaultNamingPolicy
, modifying the tag
in generated class names from "EnhancerByCGLIB" etc to a "SpringCGLIB" tag
and using a plain counter suffix instead of a hash code suffix (as of 6.0).
Spring-specific variant of
ObjenesisStd
/
ObjenesisBase
,
providing a cache based on
Class
keys instead of class names,
and allowing for selective use of the cache.
Static holder for local Spring properties, i.e.
Marker interface implemented by all AOP proxies.
SpringRepeat
is a custom JUnit
Statement
which adds support
for Spring's
@Repeat
annotation by repeating the test the specified number of times.
SpringRunner
is an
alias
for the
SpringJUnit4ClassRunner
.
A Spring-provided
ServletContainerInitializer
designed to support code-based
configuration of the servlet container using Spring's
WebApplicationInitializer
SPI as opposed to (or possibly in combination with) the traditional
web.xml
-based approach.
Implementation of Hibernate 3.1's
CurrentSessionContext
interface
that delegates to Spring's
SessionFactoryUtils
for providing a
Spring-managed current
Session
.
Callback for resource cleanup at the end of a Spring-managed transaction
for a pre-bound Hibernate Session.
FreeMarker
TemplateLoader
adapter that loads via a Spring
ResourceLoader
.
Strategy implementation for parsing Spring's
Transactional
annotation.
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.
Class that exposes the Spring version.
JSR-303
ConstraintValidatorFactory
implementation that delegates to
the current Spring
WebApplicationContext
for creating autowired
ConstraintValidator
instances.
@Sql
is used to annotate a test class or test method to configure
SQL
Sql.scripts()
and
Sql.statements()
to be executed against a given
database during integration tests.
Enumeration of
phases
that dictate when SQL scripts are executed.
RdbmsOperation using a JdbcTemplate and representing an SQL-based
call such as a stored procedure or a stored function.
@SqlConfig
defines metadata that is used to determine how to parse
and execute SQL scripts configured via the
@Sql
annotation.
Enumeration of
modes
that dictate how errors are handled while
executing SQL statements.
Enumeration of
modes
that dictate whether SQL scripts should be
executed within a transaction and what the transaction propagation behavior
should be.
JavaBean for holding JDBC error codes for a particular database.
Factory for creating
SQLErrorCodes
based on the
"databaseProductName" taken from the
DatabaseMetaData
.
Implementation of
SQLExceptionTranslator
that analyzes vendor-specific error codes.
SQLExceptionTranslator
implementation which analyzes the specific
SQLException
subclass thrown by the JDBC driver.
Strategy interface for translating between
SQLExceptions
and Spring's data access strategy-agnostic
DataAccessException
hierarchy.
SqlFunction
<
T
>
SQL "function" wrapper for a query that returns a single row of results.
Container annotation that aggregates several
@Sql
annotations.
Subclass of
SqlOutParameter
to represent an INOUT parameter.
Object to represent an SQL BLOB/CLOB value parameter.
@SqlMergeMode
is used to annotate a test class or test method to
configure whether method-level
@Sql
declarations are merged with
class-level
@Sql
declarations.
Enumeration of
modes
that dictate whether method-level
@Sql
declarations are merged with class-level
@Sql
declarations.
Operation object representing an SQL-based operation such as a query or update,
as opposed to a stored procedure.
Subclass of
SqlParameter
to represent an output parameter.
Object to represent an SQL parameter definition.
Interface that defines common functionality for objects that can
offer parameter values for named SQL parameters, serving as argument
for
NamedParameterJdbcTemplate
operations.
Class that provides helper methods for the use of
SqlParameterSource
,
in particular with
NamedParameterJdbcTemplate
.
Object to represent an SQL parameter value, including parameter meta-data
such as the SQL type and the scale for numeric values.
Interface to be implemented by objects that can provide SQL strings.
Interface to be implemented by objects that can provide SQL strings.
Reusable operation object representing an SQL query.
Represents a returned
ResultSet
from a stored procedure call.
Interface to be implemented for retrieving values for more complex database-specific
types not supported by the standard
CallableStatement.getObject
method.
Represents a returned update count from a stored procedure call.
Metadata interface for Spring's
SqlRowSet
, analogous to JDBC's
ResultSetMetaData
.
ResultSetExtractor
implementation that returns a Spring
SqlRowSet
representation for each given
ResultSet
.
TestExecutionListener
that provides support for executing SQL
scripts
and inlined
statements
configured via the
@Sql
annotation.
SQL Server specific implementation for the
CallMetaDataProvider
interface.
DataFieldMaxValueIncrementer
that increments the maximum value of a given SQL Server table
with the equivalent of an auto-increment column.
DataFieldMaxValueIncrementer
that retrieves the next value of a given
SQL Server sequence.
SQLExceptionTranslator
implementation that analyzes the SQL state in
the
SQLException
based on the first two digits (the SQL state "class").
Interface to be implemented for setting values for more complex database-specific
types not supported by the standard
setObject
method.
Reusable operation object representing an SQL update.
Simple interface for complex types to be set as statement parameters.
Exception thrown when we're not ignoring
SQLWarnings
.
Exception thrown when the underlying implementation does not support the
requested feature of the API.
Abstraction for handling XML fields in specific databases.
Subinterface of
SqlValue
that supports passing in XML data to specified column and adds a
cleanup callback, to be invoked after the value has been set and
the corresponding statement has been executed.
A specialization of
ResponseBodyEmitter
for sending
Server-Sent Events
.
A builder for an SSE event.
A holder for SSL session information.
A
MockMvcBuilder
that accepts
@Controller
registrations
thus allowing full control over the instantiation and initialization of
controllers and their dependencies similar to plain unit tests, and also
making it possible to test one controller at a time.
AnnotationMetadata
implementation that uses standard reflection
to introspect a given
Class
.
Standard implementation of the
BeanExpressionResolver
interface, parsing and evaluating Spring EL using Spring's expression module.
BeanInfoFactory
implementation that performs standard
Introspector
inspection.
ClassMetadata
implementation that uses standard reflection
to introspect a given
Class
.
Environment
implementation suitable for use in 'standard' (i.e.
A powerful and highly configurable
EvaluationContext
implementation.
Standard implementation of the
JmsActivationSpecFactory
interface.
MethodMetadata
implementation that uses standard reflection
to introspect a given
Method
.
Spring MultipartHttpServletRequest adapter, wrapping a Servlet HttpServletRequest
and its Part objects.
Standard implementation of
OperatorOverloader
.
ParameterNameDiscoverer
implementation which uses JDK 8's reflection facilities
for introspecting parameter names (based on the "-parameters" compiler flag).
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
.
A Servlet implementation of
AsyncWebRequest
.
Environment
implementation to be used by
Servlet
-based web
applications.
Standard implementation of the
MultipartResolver
interface,
based on the Servlet
Part
API.
Utility methods for standard Servlet
Part
handling.
A subclass of
WebSocketExtension
that can be constructed from a
Extension
.
A basic
TypeComparator
implementation: supports comparison of
Number
types as well as types implementing
Comparable
.
Default implementation of the
TypeConverter
interface,
delegating to a core Spring
ConversionService
.
A simple implementation of
TypeLocator
that uses the context ClassLoader
(or any ClassLoader set upon it).
WebSocketClient
implementation for use with the Jakarta WebSocket API.
A WebSocketClient based on the standard Jakarta WebSocket API.
Adapter for the Jakarta WebSocket API (JSR-356) that delegates events to a
reactive
WebSocketHandler
and its session.
Adapts a
WebSocketHandler
to the standard WebSocket for Java API.
Spring
WebSocketSession
adapter for a standard Java (JSR 356)
Session
.
A
WebSocketSession
for use with the standard WebSocket for Java API.
A WebSocket
RequestUpgradeStrategy
for the Jakarta WebSocket API 2.1+.
A WebSocket
RequestUpgradeStrategy
for the Jakarta WebSocket API 2.1+.
Step recording metrics about a particular phase or action happening during the
ApplicationStartup
.
Simple key/value association for storing step metadata.
Immutable collection of
StartupStep.Tag
.
StatementCallback
<
T
>
Generic callback interface for code that operates on a JDBC Statement.
Utility methods for PreparedStatementSetter/Creator and CallableStatementCreator
implementations, providing sophisticated parameter management (including support
for LOB values).
Represents a function that filters an
ExecuteFunction
.
ApplicationContext
implementation
which supports programmatic registration of beans and messages,
rather than reading bean definitions from external configuration sources.
Static
BeanFactory
implementation
which allows one to register existing singleton instances programmatically.
Simple implementation of
MessageSource
which allows messages to be registered programmatically.
Convenient abstract superclass for static method matchers, which don't care
about arguments at runtime.
Convenient superclass when we want to force subclasses to implement the
MethodMatcher
interface but subclasses will want to be pointcuts.
Convenient base class for Advisors that are also static pointcuts.
Static implementation of the
ScriptSource
interface,
encapsulating a given String that contains the script source text.
Static
WebApplicationContext
implementation for testing.
Assertions on the response status.
Factory for assertions on the response status.
Convenience methods for working with the StAX API.
A
MessageHandler
that handles messages by
forwarding them to a STOMP broker.
Contract for access to session counters.
Registration class for configuring a
StompBrokerRelayMessageHandler
.
Base class for STOMP client implementations.
Represents a STOMP command.
Raised after a failure to encode or decode a STOMP message.
Decodes one or more STOMP frames contained in a
ByteBuffer
.
An encoder for STOMP frames.
A contract for registering STOMP over WebSocket endpoints.
Contract to handle a STOMP frame.
A
MessageHeaderAccessor
to use when creating a
Message
from
a decoded STOMP frame, or when encoding a
Message
to a STOMP frame.
Represents STOMP frame headers.
Simple delegation to StompDecoder and StompEncoder.
Represents a STOMP session with operations to send messages,
create subscriptions and receive messages on those subscriptions.
A handle to use to track receipts.
A handle to use to unsubscribe or to track a receipt.
A contract for client STOMP session lifecycle events including a callback
when the session is established and notifications of transport or message
handling failures.
Abstract adapter class for
StompSessionHandler
with mostly empty
implementation methods except for
StompSessionHandlerAdapter.getPayloadType(org.springframework.messaging.simp.stomp.StompHeaders)
which returns String
as the default Object type expected for STOMP ERROR frame payloads.
A
SubProtocolErrorHandler
for use with STOMP.
A
SubProtocolHandler
for STOMP that supports versions 1.0, 1.1, and 1.2
of the STOMP specification.
Contract for access to session counters.
A
TcpConnectionHandler
for use with STOMP connections, exposing
further information about the connection.
A contract for configuring a STOMP over WebSocket endpoint.
Simple stop watch, allowing for timing of a number of tasks, exposing total
running time and running time for each named task.
Nested class to hold data about one task executed within the
StopWatch
.
Superclass for object abstractions of RDBMS stored procedures.
Represents an HTTP output message that allows for setting a streaming body.
Defines the contract for bodies that can be written directly to an
OutputStream
.
A controller method return value type for asynchronous request processing
where the application can write directly to the response
OutputStream
without holding up the Servlet container thread.
Supports return values of type
StreamingResponseBody
and also
ResponseEntity<StreamingResponseBody>
.
A SockJS session for use with streaming HTTP transports.
Simple utility methods for dealing with streams.
Custom
PropertyEditor
for String arrays.
Decode from a data buffer stream to a
String
stream, either splitting
or aggregating incoming data chunks to realign along newlines delimiters
and produce a stream of strings.
Implementation of
HttpMessageConverter
that can read and write strings.
Expression language AST node that represents a string literal.
A
MessageConverter
that supports MIME type "text/plain" with the
payload converted to and from a String.
Custom
PropertyEditor
for converting
MultipartFiles
to Strings.
This class implements a simple String → int mapping for a fixed set of keys.
Property editor that trims Strings.
Miscellaneous
String
utility methods.
Simple strategy interface for resolving a String value.
Simple utility class to allow for convenient access to value
styling logic, mainly to support descriptive logging messages.
An interface for WebSocket handlers that support sub-protocols as defined in RFC 6455.
A contract for handling sub-protocol errors sent to clients.
A contract for handling WebSocket messages as part of a higher level protocol,
referred to as "sub-protocol" in the WebSocket RFC specification.
An implementation of
WebSocketHandler
that delegates incoming WebSocket
messages to a
SubProtocolHandler
along with a
MessageChannel
to which
the sub-protocol handler can send messages from WebSocket clients to the application.
Contract for access to session counters.
A
MessageChannel
that maintains a registry of subscribers and invokes
them to handle messages sent through this channel.
Annotation for mapping subscription messages onto specific handler methods based
on the destination of a subscription.
HandlerMethodReturnValueHandler
for replying directly to a
subscription.
Interface to be implemented by message listener objects that suggest a specific
name for a durable subscription that they might be registered with.
A registry of subscription by session that allows looking up subscriptions.
SuccessCallback
<
T
>
Deprecated.
as of 6.0, in favor of
CompletableFuture.whenComplete(BiConsumer)
Convenience utilities for
Supplier
handling.
DataFieldMaxValueIncrementer
that increments the maximum value of a given Sybase table
with the equivalent of an auto-increment column.
Sybase specific implementation for the
CallMetaDataProvider
interface.
DataFieldMaxValueIncrementer
that increments the maximum value of a given Sybase table
with the equivalent of an auto-increment column.
An extension of
HandlerMethodArgumentResolver
for implementations
that are synchronous in nature and do not block to resolve values.
An extension of
HandlerMethodArgumentResolver
for implementations
that are synchronous in nature and do not block to resolve values.
Exception thrown when a synchronized local transaction failed to complete
(after the main transaction has already completed).
Extension of
HandlerMethod
that invokes the underlying method via
InvocableHandlerMethod
but uses sync argument resolvers only and
thus can return directly a
HandlerResult
with no async wrappers.
TaskExecutor
implementation that executes each task
synchronously
in the calling thread.
A
MethodParameter
variant which synthesizes annotations that
declare attribute aliases via
@AliasFor
.
Specialization of
MapPropertySource
designed for use with
system environment variables
.
Implementation of
ProfileValueSource
which uses system properties as
the underlying source.
Helper class for resolving placeholders in texts.
Class to manage context meta-data used for the configuration
and execution of operations on a database table.
Interface specifying the API to be implemented by a class providing table meta-data.
Factory used to create a
TableMetaDataProvider
implementation
based on the type of database being used.
Holder of meta-data for a specific parameter that is used for table processing.
Utility class for tag library related code, exposing functionality
such as translating
Strings
to web scopes.
Utility class for writing HTML content to a
Writer
instance.
Minimal interface for exposing the target class behind a proxy.
A
TargetSource
is used to obtain the current "target" of
an AOP invocation, which will be invoked via reflection if no around
advice chooses to end the interceptor chain itself.
Implementations can create special target sources, such as pooling target
sources, for particular beans.
Holder class defining a
Runnable
to be executed as a task, typically at a
scheduled time or interval.
A callback interface for a decorator to be applied to any
Runnable
about to be executed.
Simple task executor interface that abstracts the execution
of a
Runnable
.
Adapter that takes a JDK
java.util.concurrent.Executor
and
exposes a Spring
TaskExecutor
for it.
FactoryBean
for creating
ThreadPoolTaskExecutor
instances,
primarily used behind the XML task namespace.
A registration class for customizing the properties of
ThreadPoolTaskExecutor
.
Configuration constants for internal sharing across subpackages.
NamespaceHandler
for the 'task' namespace.
Exception thrown when a
TaskExecutor
rejects to accept
a given task for execution.
Task scheduler interface that abstracts the scheduling of
Runnables
based on different kinds of triggers.
Deprecated.
as of 5.3.16 since the common executors do not support start timeouts
Utility methods for decorating tasks with error handling.
TcpConnection
<
P
>
A contract for sending messages and managing a TCP connection.
A contract for managing lifecycle events for a TCP connection including
the handling of incoming messages.
TcpMessageCodec
<
P
>
Contract to encode and decode a
Message
to and from a
ByteBuffer
allowing a higher-level protocol (e.g.
TcpOperations
<
P
>
A contract for establishing TCP connections.
An expression parser that understands templates.
Configurable
ParserContext
implementation for template parsing.
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).
LobCreator
implementation based on temporary LOBs,
using JDBC 4.0's
Connection.createBlob()
/
Connection.createClob()
mechanism.
Represents a ternary expression, for example: "someCheck()?true:false".
Collection of utility methods for working with Spring's core testing annotations.
Filesystem-based ahead-of-time (AOT) processing base implementation that scans
the provided classpath roots for Spring integration test classes and then
generates AOT artifacts for those test classes in the configured output directories.
Utility that can be used to dynamically compile and test Java source code.
@TestConstructor
is a type-level annotation that is used to configure
how the parameters of a test class constructor are autowired from components
in the test's
ApplicationContext
.
Defines autowiring modes for parameters in a test constructor.
Utility methods for working with
@TestConstructor
.
TestContext
encapsulates the context in which a test is executed,
agnostic of the actual testing framework in use.
TestContextAnnotationUtils
is a collection of utility methods that
complements the standard support already available in
AnnotationUtils
and
AnnotatedElementUtils
, while transparently honoring
@NestedTestConfiguration
semantics.
Descriptor for an
Annotation
, including the
class
on which the annotation is
declared
as well as the
merged annotation
instance.
Untyped
extension of
TestContextAnnotationUtils.AnnotationDescriptor
that is used
to describe the declaration of one of several candidate annotation types
where the actual annotation type cannot be predetermined.
Thrown if an error occurs during AOT build-time processing or AOT run-time
execution in the
Spring TestContext Framework
.
TestContextAotGenerator
generates AOT artifacts for integration tests
that depend on support from the
Spring TestContext Framework
.
TestContextBootstrapper
defines the SPI for bootstrapping the
Spring TestContext Framework
.
Base class for events published by the
EventPublishingTestExecutionListener
.
TestContextManager
is the main entry point into the
Spring
TestContext Framework
.
Utility methods for working with resources within the
Spring TestContext
Framework
.
Collection of utilities for working with
SpringFactoriesLoader
within
the
Spring TestContext Framework
.
Utility methods for working with transactions and data access related beans
within the
Spring TestContext Framework
.
TestExecutionListener
defines a
listener
API for reacting to
test execution events published by the
TestContextManager
with which
the listener is registered.
TestExecutionListeners
defines class-level metadata for configuring
which
TestExecutionListeners
should be
registered with a
TestContextManager
.
Enumeration of
modes
that dictate whether explicitly
declared listeners are merged with the default listeners when
@TestExecutionListeners
is declared on a class that does
not
inherit listeners from a superclass or enclosing
class.
GenerationContext
test implementation that uses
InMemoryGeneratedFiles
and can configure a
TestCompiler
instance.
@TestPropertySource
is a class-level annotation that is used to
configure the
TestPropertySource.locations()
of properties files and inlined
TestPropertySource.properties()
to be added to the
Environment
's set of
PropertySources
for an
ApplicationContext
for integration tests.
@TestPropertySources
is a container for one or more
@TestPropertySource
declarations.
Utility methods for working with
@TestPropertySource
and adding test
PropertySources
to the
Environment
.
Contract for registering
RuntimeHints
for integration tests run with
the
Spring TestContext Framework
based on the
ClassLoader
of the deployment unit.
Simple utility for finding available TCP ports on
localhost
for use in
integration testing scenarios.
TestTransaction
provides a collection of static utility methods for
programmatic interaction with
test-managed transactions
within
test
methods,
before
methods, and
after
methods.
The
<textarea>
tag renders an HTML 'textarea'.
A text WebSocket message.
A convenient base class for
WebSocketHandler
implementations
that process text messages only.
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
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
Deprecated.
as of 6.0, with no direct replacement
Alternative to an object pool.
Statistics for a ThreadLocal TargetSource.
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
.
Implementation of Spring's
TaskScheduler
interface, wrapping
a native
ScheduledThreadPoolExecutor
.
A
BiFunction
that allows invocation of code that throws a checked
exception.
ThrowingConsumer
<
T
>
A
Consumer
that allows invocation of code that throws a checked
exception.
A
Function
that allows invocation of code that throws a checked
exception.
ThrowingSupplier
<
T
>
A
Supplier
that allows invocation of code that throws a checked exception.
Tag interface for throws advice.
Interceptor to wrap an after-throwing advice.
Test annotation for use with JUnit 4 to indicate that a test method has to finish
execution in a
specified time period
.
Sends a 503 (SERVICE_UNAVAILABLE) in case of a timeout if the response is not
already committed.
Sends a 503 (SERVICE_UNAVAILABLE) in case of a timeout if the response is not
already committed.
Extension of
LocaleContext
, adding awareness of the current time zone.
Editor for
java.util.TimeZone
, translating timezone IDs into
TimeZone
objects.
Deprecated.
ServletHttpHandlerAdapter
extension that uses Tomcat APIs for reading
from the request and writing to the response with
ByteBuffer
.
LoadTimeWeaver
implementation
for Tomcat's new
org.apache.tomcat.InstrumentableClassLoader
.
A WebSocket
RequestUpgradeStrategy
for Apache Tomcat.
A WebSocket
RequestUpgradeStrategy
for Apache Tomcat.
WebSocketClient
implementation for use with Tomcat,
based on the Jakarta WebSocket API.
Spring
WebSocketSession
adapter for Tomcat's
Session
.
Utility class that builds pretty-printing
toString()
methods
with pluggable styling conventions.
A strategy interface for pretty-printing
toString()
methods.
Extension of
DataBuffer
that allows for buffers that can be given
hints for debugging purposes.
Describes a transaction attribute on an individual method or on a class.
An
ApplicationListener
that is invoked according to a
TransactionPhase
.
Callback to be invoked on synchronization-driven event processing,
wrapping the target listener invocation (
TransactionalApplicationListener.processEvent(E)
).
TransactionalApplicationListener
adapter that delegates the processing of
an event to a target
ApplicationListener
instance.
GenericApplicationListener
adapter that delegates the processing of
an event to a
TransactionalEventListener
annotated method.
An
EventListener
that is invoked according to a
TransactionPhase
.
EventListenerFactory
implementation that handles
TransactionalEventListener
annotated methods.
Operator class that simplifies programmatic transaction demarcation and
transaction exception handling.
A marker interface for manually created transactional proxies.
TestExecutionListener
that provides support for executing tests
within
test-managed transactions
by honoring Spring's
@Transactional
annotation.
Strategy interface for parsing known transaction annotation types.
Base class for transactional aspects, such as the
TransactionInterceptor
or an AspectJ aspect.
Coroutines-supporting extension of the callback interface.
Simple callback interface for proceeding with the target invocation.
Opaque object used to hold transaction information.
This interface adds a
rollbackOn
specification to
TransactionDefinition
.
PropertyEditor for
TransactionAttribute
objects.
Strategy interface used by
TransactionInterceptor
for metadata retrieval.
Advisor driven by a
TransactionAttributeSource
, used to include
a
TransactionInterceptor
only for methods that are transactional.
Property editor that converts a String into a
TransactionAttributeSource
.
Cache decorator which synchronizes its
TransactionAwareCacheDecorator.put(java.lang.Object, java.lang.Object)
,
TransactionAwareCacheDecorator.evict(java.lang.Object)
and
TransactionAwareCacheDecorator.clear()
operations with Spring-managed transactions (through Spring's
TransactionSynchronizationManager
), performing the actual cache
put/evict/clear operation only in the after-commit phase of a successful
transaction.
Proxy for a target
CacheManager
, exposing transaction-aware
Cache
objects
which synchronize their
Cache.put(java.lang.Object, java.lang.Object)
operations with Spring-managed transactions
(through Spring's
TransactionSynchronizationManager
),
performing the actual cache put operation only in the after-commit phase of a successful transaction.
Proxy for a target JMS
ConnectionFactory
, adding awareness of
Spring-managed transactions.
Proxy for a target R2DBC
ConnectionFactory
, adding awareness
of Spring-managed transactions.
Proxy for a target JDBC
DataSource
, adding awareness of
Spring-managed transactions.
TransactionCallback
<
T
>
Callback interface for reactive transactional code.
TransactionCallback
<
T
>
Callback interface for transactional code.
Simple convenience class for TransactionCallback implementation.
Mutable transaction context that encapsulates transactional synchronizations and
resources in the scope of a single transaction.
Delegate to register and obtain transactional contexts.
Interface that defines Spring-compliant transaction properties.
Superclass for all transaction exceptions.
Common representation of the current state of a transaction.
Strategy interface for creating JTA
Transaction
objects based on specified transactional characteristics.
Runtime exception mirroring the JMS TransactionInProgressException.
AOP Alliance MethodInterceptor for declarative transaction
management using the common Spring transaction infrastructure
(
PlatformTransactionManager
/
ReactiveTransactionManager
).
Selects which implementation of
AbstractTransactionManagementConfiguration
should be used based on the value of
EnableTransactionManagement.mode()
on the
importing
@Configuration
class.
Interface to be implemented by @
Configuration
classes annotated with @
EnableTransactionManagement
that wish to
(or need to) explicitly specify the default
PlatformTransactionManager
bean
(or
ReactiveTransactionManager
bean) to be used for annotation-driven
transaction management, as opposed to the default approach of a by-type lookup.
Configuration constants for internal sharing across subpackages.
Marker interface for Spring transaction manager implementations,
either traditional or reactive.
Interface specifying basic transaction execution operations.
The phase in which a transactional event listener applies.
Proxy factory bean for simplified declarative transaction handling.
Runtime exception mirroring the JMS TransactionRolledBackException.
Representation of the status of a transaction.
Exception thrown when attempting to suspend an existing transaction
but transaction suspension is not supported by the underlying backend.
Interface for reactive transaction synchronization callbacks.
Interface for transaction synchronization callbacks.
Deprecated.
as of 5.3, in favor of the default methods on the
TransactionSynchronization
interface
Central delegate that manages resources and transaction synchronizations per
subscriber context.
Central delegate that manages resources and transaction synchronizations per thread.
Utility methods for triggering specific
TransactionSynchronization
callback methods on all currently registered synchronizations.
Exception thrown when a general transaction system error is encountered,
like on commit or rollback.
Template class that simplifies programmatic transaction demarcation and
transaction exception handling.
Exception to be thrown when a transaction has timed out.
Superclass for exceptions caused by inappropriate usage of
a Spring transaction API.
An extension of
ByteArrayResource
that a
ResourceTransformer
can use to represent an original resource preserving all other information
except the content.
An extension of
ByteArrayResource
that a
ResourceTransformer
can use to represent an original resource preserving all other information
except the content.
Contains common behavior relating to
Transformers
and the
javax.xml.transform
package in general.
The
<transform>
tag provides transformation for reference data values
from controllers and other objects inside a
spring:bind
tag (or a
data-bound form element tag from Spring's form tag library).
Root of the hierarchy of data access exceptions that are considered transient -
where a previously failed operation might be able to succeed when the operation
is retried without any intervention by application-level functionality.
Data access exception thrown when a resource fails temporarily
and the operation can be retried.
A client-side implementation for a SockJS transport.
Handle a SockJS session URL, i.e.
A basic implementation of
SockJsService
with support for SPI-based transport handling and session management.
Exposes information, typically to
Transport
and
session
implementations, about a request
to connect to a SockJS server endpoint over a given transport.
SockJS transport types.
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.
NamespaceHandler
allowing for the configuration of
declarative transaction management using either XML or using annotations.
A Java field or method type.
Captures primitive types and their corresponding class objects, plus one special
TypeCode.OBJECT
entry that represents all reference (non-primitive) types.
Instances of a type comparator should be able to compare pairs of objects for equality.
Interface that defines type conversion methods.
A type converter can convert values between different types encountered during
expression evaluation.
Base implementation of the
TypeConverter
interface, using a package-private delegate.
Contextual descriptor about a type to convert from or to.
Holder for a typed String value.
Encapsulates an object and a
TypeDescriptor
that describes it.
Base interface for type filters using a
MetadataReader
.
Collection of utilities for working with
@ComponentScan
type filters
.
A hint that describes the need for reflection on a type.
Builder for
TypeHint
.
Implementers of this interface are expected to be able to locate types.
Exception thrown on mismatch between Java type and database type:
for example on an attempt to set an object of the wrong type
in an RDBMS column.
Exception thrown on a type mismatch when trying to set a bean property.
Exception thrown if a type mismatch is encountered for an object
located in a JNDI environment.
The path to a type argument, wildcard bound, array element type, or static inner type within an
enclosing type.
Spring AOP
ClassFilter
implementation using AspectJ type matching.
Type abstraction that can be used to refer to types that are not available as
a
Class
yet.
A reference to a type appearing in a class, field or method declaration, or on an instruction.
Represents a reference to a type, for example
"T(String)"
or
"T(com.example.Foo)"
.
Utility to work with generic type parameters.
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.
Normal superclass when we can't distinguish anything more specific
than "something went wrong with the underlying resource": for example,
an SQLException from JDBC we can't pinpoint more precisely.
JmsException to be thrown when no other matching subclass found.
Exception that indicates that the cause cannot be distinguished further.
Exception thrown when we can't classify a
R2dbcException
into
one of our generic data access exceptions.
Thrown when we cannot determine anything more specific than "something went
wrong while processing an SQL script": for example, a
SQLException
from JDBC that we cannot pinpoint more precisely.
Thrown when we cannot determine anything more specific than "something went wrong
while processing an SQL script": for example, an
R2dbcException
from R2DBC that we cannot pinpoint more precisely.
Exception thrown when we can't classify an SQLException into
one of our generic data access exceptions.
Used by
Proxy
as a replacement for
java.lang.reflect.UndeclaredThrowableException
.
A
GeneratorStrategy
suitable for use with
Enhancer
which
causes all undeclared exceptions thrown from within a proxied method to be wrapped
in an alternative exception of your choice.
Adapt
HttpHandler
to the Undertow
HttpHandler
.
A WebSocket
RequestUpgradeStrategy
for Undertow.
A WebSocket
RequestUpgradeStrategy
for WildFly and its underlying
Undertow web server.
Undertow based implementation of
WebSocketClient
.
Undertow
WebSocketConnectionCallback
implementation that adapts and
delegates to a Spring
WebSocketHandler
.
Spring
WebSocketSession
implementation that adapts to an Undertow
WebSocketChannel
.
An XHR transport based on Undertow's
UndertowClient
.
Thrown when an attempt to commit a transaction resulted
in an unexpected rollback.
Exception thrown when an attempt is made to use an unsupported
Advisor or Advice type.
Raised when no suitable
HttpMessageConverter
could be
found to extract the response.
Exception thrown when an unknown (or custom) HTTP status code is received.
Exception thrown when an unknown (or custom) HTTP status code is received.
Defines the contract for Object XML Mapping unmarshallers.
Exception thrown on unmarshalling failure.
RequestExpectationManager
that matches requests to expectations
regardless of the order of declaration of expected requests.
Exception thrown when a bean depends on other beans or simple properties
that were not specified in the bean factory definition, although
dependency checking was enabled.
ServerWebInputException
subclass that indicates an unsatisfied
parameter condition, as typically expressed using an
@RequestMapping
annotation at the
@Controller
type level.
ServletRequestBindingException
subclass that indicates an unsatisfied
parameter condition, as typically expressed using an
@RequestMapping
annotation at the
@Controller
type level.
Exception thrown to indicate that a
Content-Type
is not supported.
Exception for errors that fit response status 415 (unsupported media type).
UpdatableSqlQuery
<
T
>
Reusable RDBMS query in which concrete subclasses must implement
the abstract updateRow(ResultSet, int, context) method to update each
row of the JDBC ResultSet and optionally map contents into an object.
Contract for fetching the number of affected rows.
Builder-style methods to prepare and expand a URI template with variables.
Factory to create
UriBuilder
instances with shared configuration
such as a base URI, an encoding mode strategy, and others across all URI
builder instances created through a factory.
Represents an immutable collection of URI components, mapping component type to
String values.
Defines the contract for URI Template variables.
Builder for
UriComponents
.
Resolvers argument values of type
UriComponentsBuilder
.
Strategy for contributing to the building of a
UriComponents
by
looking at a method parameter and an argument value and deciding what
part of the target URL should be updated.
Editor for
java.net.URI
, to directly populate a URI property
instead of using a String property as bridge.
Representation of a URI template that can be expanded with URI variables via
UriTemplate.expand(Map)
,
UriTemplate.expand(Object[])
, or matched to a URL via
UriTemplate.match(String)
.
Defines methods for expanding a URI template with variables.
Utility methods for URI encoding and decoding based on RFC 3986.
HttpServiceArgumentResolver
that resolves the URL for the request
from a
URI
argument.
CorsConfigurationSource
that uses URL patterns to select the
CorsConfiguration
for a request.
CorsConfigurationSource
that uses URL path patterns to select the
CorsConfiguration
for a request.
A
ViewResolver
that allows direct resolution of symbolic view names
to URLs without explicit mapping definitions.
Simple implementation of the
ViewResolver
interface, allowing for direct resolution of symbolic view names to URLs,
without explicit mapping definitions.
Assist with configuring properties of a
UrlBasedViewResolver
.
Assist with configuring a
UrlBasedViewResolver
.
Editor for
java.net.URL
, to directly populate a URL property
instead of using a String property as bridge.
Simple
Controller
implementation that transforms the virtual
path of a URL into a view name and returns that view.
Helper class for URL path matching.
A
WebRequestMatcher
that allows matching on
WebRequest#getUrl().toExternalForm()
using a regular expression.
Resource
implementation for
java.net.URL
locators.
The
<url>
tag creates URLs.
An adapter for a target JMS
ConnectionFactory
, applying the
given user credentials to every standard
createConnection()
call,
that is, implicitly invoking
createConnection(username, password)
on the target.
An adapter for a target JDBC
DataSource
, applying the specified
user credentials to every standard
getConnection()
call, implicitly
invoking
getConnection(username, password)
on the target.
MessageHandler
with support for "user" destinations.
A strategy for resolving a "user" destination by translating it to one or more
actual destinations one per active user session.
Contains the result from parsing a "user" destination from a source message
and translating it to target destinations (one per active user session).
MessageHandler
that handles user registry broadcasts from other
application servers and periodically broadcasts the content of the local
user registry.
Interceptor that checks the authorization of the current user via the
user's roles, as evaluated by HttpServletRequest's isUserInRole method.
Adapter for a JTA UserTransaction handle, taking a JTA
TransactionManager
reference and creating
a JTA
UserTransaction
handle for it.
NamespaceHandler
for the
util
namespace.
Editor for
java.util.UUID
, translating UUID
String representations into UUID objects and back.
Variant of JSR-303's
Valid
, supporting the
specification of validation groups.
Utility class for handling validation annotations.
Exception thrown on marshalling validation failure.
Utility class offering convenient methods for invoking a
Validator
and for rejecting empty fields.
A validator for application-specific objects.
Annotation used at the field or method/constructor parameter level
that indicates a default value expression for the annotated element.
Common annotation value constants.
Common value constants shared between bind annotations.
Represents a reference to a value.
A ValueRef for the null value.
A ValueRef holder for a single value, which cannot be set.
Strategy that encapsulates value String styling algorithms
according to Spring conventions.
Represents a variable reference — for example,
#someVar
.
A strategy for extracting and embedding a resource version in its URL path.
Resolves request paths containing a version string that can be used as part
of an HTTP caching strategy in which a resource is cached with a date in the
distant future (e.g.
Resolves request paths containing a version string that can be used as part
of an HTTP caching strategy in which a resource is cached with a date in the
distant future (e.g.
A strategy to determine the version of a static resource and to apply and/or
extract it from the URL path.
An extension of
VersionPathStrategy
that adds a method
to determine the actual version of a
Resource
.
JBoss VFS based
Resource
implementation.
Utility for detecting and accessing JBoss VFS in the classpath.
Contract to render
HandlerResult
to the HTTP response.
MVC View for a web interaction.
Assist with the registration of a single view controller.
Assists with the registration of simple automated controllers pre-configured
with status code and/or a view.
Handles return values that are of type
View
.
Handles return values of types
void
and
String
interpreting them
as view name reference.
HandlerResultHandler
that encapsulates the view resolution algorithm
supporting the following return types:
Void
or no value -- default view name
String
-- view name unless
@ModelAttribute
-annotated
View
-- View to render with
Model
-- attributes to add to the model
Map
-- attributes to add to the model
Rendering
-- use case driven API for view resolution
@ModelAttribute
-- attribute for the model
Non-simple value -- attribute for the model
Contract to resolve a view name to a
View
instance.
Interface to be implemented by objects that can resolve views by name.
A
ViewResolver
that delegates to others.
Assist with the configuration of a chain of
ViewResolver
's supporting
different template mechanisms.
Assist with the configuration of a chain of
ViewResolver
instances.
Parses the
view-resolvers
MVC namespace element and registers
ViewResolver
bean definitions.
Base class for
ViewResolver
implementations with shared properties.
Factory for assertions on the selected view.
WeakCacheKey
<
T
>
Allows to check for object equality, yet the class does not keep strong reference to the target.
ClassFileTransformer-based weaver, allowing for a list of transformers to be
applied on a class byte array.
@WebAppConfiguration
is a class-level annotation that is used to
declare that the
ApplicationContext
loaded for an integration test
should be a
WebApplicationContext
.
Interface to provide configuration for a web application.
Special JSF
ELResolver
that exposes the Spring
WebApplicationContext
instance under a variable named "webApplicationContext".
Convenience methods for retrieving the root
WebApplicationContext
for
a given
ServletContext
.
Interface to be implemented in Servlet environments in order to configure the
ServletContext
programmatically -- as opposed to (or possibly in conjunction
with) the traditional
web.xml
-based approach.
Convenient superclass for application objects running in a
WebApplicationContext
.
Listener that sets a system property to the web application root directory.
SPI for resolving custom arguments for a specific handler method parameter.
The central class for managing asynchronous request processing, mainly intended
as an SPI and not typically used directly by application classes.
WebAsyncTask
<
V
>
Holder for a
Callable
, a timeout value, and a task executor.
Utility methods related to processing asynchronous web requests.
Callback interface for initializing a
WebDataBinder
for performing
data binding in the context of a specific web request.
Non-blocking, reactive client to perform HTTP requests, exposing a fluent,
reactive API over underlying HTTP client libraries such as Reactor Netty.
A mutable builder for creating a
WebClient
.
Contract for specifying request headers and body leading up to the exchange.
Contract for specifying request headers, body and URI for a request.
Contract for specifying request headers leading up to the exchange.
Contract for specifying request headers and URI for a request.
Contract for specifying response operations following the exchange.
Contract for specifying the URI for a request.
Abstract base class for exception published by
WebClient
in case of errors.
Exceptions that contain actual HTTP request data.
Exceptions that contain actual HTTP response data.
WebClientResponseException
for HTTP status 502 Bad Gateway.
WebClientResponseException
for status HTTP 400 Bad Request.
WebClientResponseException
for status HTTP 409 Conflict.
WebClientResponseException
for status HTTP 403 Forbidden.
WebClientResponseException
for status HTTP 504 Gateway Timeout.
WebClientResponseException
for status HTTP 410 Gone.
WebClientResponseException
for status HTTP 500 Internal Server Error.
WebClientResponseException
for status HTTP 405 Method Not Allowed.
WebClientResponseException
for status HTTP 406 Not Acceptable.
WebClientResponseException
for status HTTP 404 Not Found.
WebClientResponseException
for status HTTP 501 Not Implemented.
WebClientResponseException
for status HTTP 503 Service Unavailable.
WebClientResponseException
for status HTTP 429 Too Many Requests.
WebClientResponseException
for status HTTP 401 Unauthorized.
WebClientResponseException
for status HTTP 422 Unprocessable Entity.
WebClientResponseException
for status HTTP 415 Unsupported Media Type.
WebConnectionHtmlUnitDriver
enables configuration of the
WebConnection
for an
HtmlUnitDriver
instance.
Convenient superclass for any kind of web content generator,
like
AbstractController
and
WebContentInterceptor
.
Handler interceptor that checks the request for supported methods and a
required session and prepares the response by applying the configured
cache settings.
Special
DataBinder
for data binding from web request parameters
to JavaBean objects.
A factory for creating a
WebDataBinder
instance for a named target object.
WebDelegatingSmartContextLoader
is a concrete implementation of
AbstractDelegatingSmartContextLoader
that delegates to a
GenericXmlWebContextLoader
(or a
GenericGroovyXmlWebContextLoader
if
Groovy is present on the classpath) and an
AnnotationConfigWebContextLoader
.
Contract for handling exceptions during web server exchange processing.
ServerWebInputException
subclass that indicates a data binding or
validation failure.
Specialized
DataBinder
to perform data
binding from URL query parameters or form data in the request data to Java objects.
Contract for interception-style, chained processing of Web requests that may
be used to implement cross-cutting, application-agnostic requirements such
as security, timeouts, and others.
Contract to allow a
WebFilter
to delegate to the next in the chain.
The main class for Spring WebFlux configuration.
Defines callback methods to customize the configuration for WebFlux
applications enabled via
@EnableWebFlux
.
A
WebFluxConfigurer
that delegates to one or more others.
Common WebFlux exception handler that detects instances of
ResponseStatusException
(inherited from the base class) as well as exceptions annotated with
@ResponseStatus
by determining the HTTP status
for them and updating the status of the response accordingly.
Contract to handle a web request.
WebHandler
that decorates and delegates to another
WebHandler
.
This builder has two purposes:
BlockHoundIntegration
for spring-web classes.
A
ResourceResolver
that delegates to the chain to locate a resource and then
attempts to find a matching versioned resource contained in a WebJar JAR file.
A
ResourceResolver
that delegates to the chain to locate a resource and then
attempts to find a matching versioned resource contained in a WebJar JAR file.
A WebSocket
RequestUpgradeStrategy
for Oracle's WebLogic.
WebMergedContextConfiguration
encapsulates the
merged
context
configuration declared on a test class and all of its superclasses and
enclosing classes via
@ContextConfiguration
,
@WebAppConfiguration
,
@ActiveProfiles
, and
@TestPropertySource
.
This is the main class providing the configuration behind the MVC Java config.
Defines callback methods to customize the Java-based configuration for
Spring MVC enabled via
@EnableWebMvc
.
A registry for STOMP over WebSocket endpoints that maps the endpoints with a
HandlerMapping
for use in Spring MVC.
An abstract base class for configuring STOMP over WebSocket/SockJS endpoints.
Generic interface for a web request.
Special
DataBinder
to perform data binding
from web request parameters to JavaBeans, including support for multipart files.
Adapter that implements the Servlet HandlerInterceptor interface
and wraps an underlying WebRequestInterceptor.
Interface for general web request interception.
Strategy for matching on a
WebRequest
.
Main contract for using a server-side session that provides access to session
attributes across HTTP requests.
Contract for session ID resolution strategies.
Main class for access to the
WebSession
for an HTTP request.
Resolves method argument value of type
WebSession
.
Strategy for
WebSession
persistence.
A subclass of
SimpAnnotationMethodMessageHandler
to provide support
for
ControllerAdvice
with global
@MessageExceptionHandler
methods.
Contract for reactive-style handling of a WebSocket session.
Contract for initiating a WebSocket request.
An extension of
AbstractClientSockJsSession
wrapping and delegating
to an actual WebSocket session.
Configuration support for WebSocket request handling.
Defines callback methods to configure the WebSocket request handling
via
@EnableWebSocket
.
WebSocket
connection manager
that connects
to the server via
WebSocketClient
and handles the session with a
WebSocketHandler
.
A FactoryBean for creating and configuring a
WebSocketContainer
through Spring XML configuration.
Represents a WebSocket extension as defined in the RFC 6455.
Handler for a WebSocket session.
A handler for WebSocket messages and lifecycle events.
HandlerAdapter
that allows
DispatcherHandler
to support
handlers of type
WebSocketHandler
with such handlers mapped to
URL patterns via
SimpleUrlHandlerMapping
.
Wraps another
WebSocketHandler
instance and delegates to it.
A factory for applying decorators to a WebSocketHandler.
Extension of
SimpleUrlHandlerMapping
with support for more
precise mapping of WebSocket handshake requests to handlers of type
WebSocketHttpRequestHandler
.
Provides methods for configuring a WebSocket handler.
Provides methods for configuring
WebSocketHandler
request mappings.
An
HttpHeaders
variant that adds support for
the HTTP headers defined by the WebSocket specification RFC 6455.
A
HttpRequestHandler
for processing WebSocket handshake requests.
Representation of a WebSocket message.
WebSocketMessage
<
T
>
A message that can be handled or sent on a WebSocket connection.
WebSocket message types.
Extends
AbstractMessageBrokerConfiguration
and adds configuration for
receiving and responding to STOMP messages from WebSocket clients.
Defines methods for configuring message handling with simple messaging
protocols (e.g.
A central class for aggregating information about internal state and counters
from key infrastructure components of the setup that comes with
@EnableWebSocketMessageBroker
for Java config and
<websocket:message-broker>
for XML.
NamespaceHandler
for Spring WebSocket
configuration namespace.
A SockJS session for use with the WebSocket transport.
A service to delegate WebSocket-related HTTP requests to.
Represents a WebSocket session.
A WebSocket session abstraction.
Wraps another
WebSocketSession
instance
and delegates to it.
A STOMP over WebSocket client that connects using an implementation of
WebSocketClient
including
SockJsClient
.
Adapter class to convert a
WebSocketExtension
to a Jetty
ExtensionConfig
.
Adapt an instance of
WebSocketExtension
to
the
Extension
interface.
A SockJS
Transport
that uses a
WebSocketClient
.
WebSocket-based
TransportHandler
.
Configure the processing of messages received from and sent to WebSocket clients.
A predicate for use with
AbstractUrlHandlerMapping.setHandlerPredicate(java.util.function.BiPredicate<java.lang.Object, org.springframework.web.server.ServerWebExchange>)
to ensure only WebSocket handshake requests are matched to handlers of type
WebSocketHandler
.
WebSphere support for upgrading an
HttpServletRequest
during a
WebSocket handshake.
Client for testing web servers that uses
WebClient
internally to
perform requests while also providing a fluent API to verify responses.
Spec for expectations on the response body content.
Spec for expectations on the response body decoded to a single Object.
Steps for customizing the
WebClient
used to test with,
internally delegating to a
WebClient.Builder
.
Specification for customizing controller configuration equivalent to, and
internally delegating to, a
WebFluxConfigurer
.
Spec for expectations on the response body decoded to a List.
Base specification for setting up tests without a server.
Specification for providing body of a request.
Specification for providing the body and the URI of a request.
Specification for adding request headers and performing an exchange.
Specification for providing request headers and the URI of a request.
Chained API for applying assertions to a response.
Specification for customizing router function configuration.
Specification for providing the URI of a request.
Contract that frameworks or applications can use to pre-package a set of
customizations to a
WebTestClient.Builder
and expose that
as a shortcut.
Web-specific implementation of the
TestContextBootstrapper
SPI.
Miscellaneous utilities for web applications.
Callback interface used to write file content.
Extended interface for a resource that supports writing to it.
An extension of
AbstractClientSockJsSession
for use with HTTP
transports simulating a WebSocket session.
A
TransportHandler
based on XHR (long) polling.
A
TransportHandler
that receives messages over HTTP.
A
TransportHandler
that sends messages over an HTTP streaming request.
A SockJS
Transport
that uses HTTP requests to simulate a WebSocket
interaction.
Bean definition reader for XML bean definitions.
XML-specific BeanDefinitionStoreException subclass that wraps a
SAXException
, typically a
SAXParseException
which contains information about the error location.
Interface defining handling involved with providing
OutputStream
data for XML input.
Interface defining handling involved with providing
Writer
data for XML input.
Decodes a
DataBuffer
stream into a stream of
XMLEvents
.
A helper class for assertions on XML content.
Root of the hierarchy of Object XML Mapping exceptions.
Extension of
ReaderContext
,
specific to use with an
XmlBeanDefinitionReader
.
Interface defining handling involved with providing
Result
data for XML input.
Detects whether an XML stream is using DTD- or XSD-based validation.
Deprecated.
as of 5.3, in favor of Spring's common view resolver variants
and/or custom resolver implementations
WebApplicationContext
implementation
which takes its configuration from XML documents, understood by an
XmlBeanDefinitionReader
.
XPath assertions for the
WebTestClient
.
A helper class for applying assertions via XPath expressions.
Factory methods for request content
RequestMatcher
implementations
that use an XPath expression.
Factory for assertions on the response content using XPath expressions.
XSLT-driven View that allows for response context to be rendered as the
result of an XSLT transformation.
ViewResolver
implementation that
resolves instances of
XsltView
by translating the supplied view name
into the URL of the XSLT stylesheet.
Implementation of the
Marshaller
interface for XStream.
Factory for a
Map
that reads from a YAML source, preserving the
YAML-declared value types and their structure.
Base class for YAML factories.
Strategy interface used to test if properties match.
Callback interface used to process the YAML parsing results.
Status returned from
YamlProcessor.DocumentMatcher.matches(java.util.Properties)
.
Method to use for resolving resources.
Factory for
Properties
that reads from a YAML source,
exposing a flat structure of String property values.
Sub-interface of
ReactiveOutputMessage
that has support for "zero-copy"
file transfers.
Editor for
java.time.ZoneId
, translating zone ID Strings into
ZoneId
objects.
推荐文章