All Classes and Interfaces

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.
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.
Abstract base class for Encoder implementations.
Base class for a return value handler that encodes return values to Flux<DataBuffer> through the configured Encoders.
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.
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 (batch) 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.
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.
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 Filters 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, e.g.
A prefix-based VersionPathStrategy, e.g.
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.
Access visibility types as determined by the modifiers on a Member or ResolvableType.
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.
JobFactory implementation that supports Runnable objects as well as standard Quartz Job instances.
 
 
 
 
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.
@EventListener annotation used to consume an AfterTestExecutionEvent published by the EventPublishingTestExecutionListener.
@EventListener annotation used to consume an AfterTestMethodEvent published by the EventPublishingTestExecutionListener.
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.
Simple Pointcut that looks for a specific annotation being present on a class or method.
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.
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 the 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.
Exception to be thrown when an async request times out.
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.
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: e.g.
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, i.e.
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.
@EventListener annotation used to consume a BeforeTestExecution published by the EventPublishingTestExecutionListener.
@EventListener annotation used to consume a BeforeTestMethodEvent published by the EventPublishingTestExecutionListener.
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.
Value object representing value and null bindings for a Statement using BindMarkers.
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.
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.
A Comparator for Boolean objects that can sort either true or false first.
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.
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.
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.
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.
Editor for a Character, to populate a property of type Character or char from a String value.
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.
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 ConcurrentHashMap that uses soft or weak references for both keys and values.
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.
Generic callback interface for code that operates on a JDBC Connection.
Used to set up a database during initialization and clean up a database during destruction.
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.
Base class that can be used to implement a standard Encoder and/or Decoder.
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.
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.
Used to set up a database during initialization and clean up a database during destruction.
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 Connections 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).
 
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 Advisors 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 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.
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 Decoders 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 HttpMessageReader for parsing "multipart/form-data" requests to a stream of Parts.
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 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 provides an alternative to using a Callable for asynchronous request processing.
Handles a DeferredResult value when set.
Handler for return values of type DeferredResult, ListenableFuture, and CompletionStage.
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.
Simple Quartz Job adapter that delegates to a given Runnable instance.
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.
Adds a textual description to bean definitions derived from Component or Bean.
Simple Resource implementation that holds a resource description but does not point to an actually readable resource.
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.
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.
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 MBeans from the Spring context, as well as all @ManagedResource annotated beans.
Enables Spring's scheduled task execution capability, similar to functionality found in Spring's <task:*> XML namespace.
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.
Entity-specific subtype of ServerResponse that exposes entity data.
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.
Represents a function that executes a Statement for a (delayed) Result stream.
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 ModelMap that implements the Model interface.
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.
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.
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, based on file name prefixes and file extensions with convenience to support multiple classpath locations.
GeneratedFiles implementation that stores generated files using a FileSystem.
Resource implementation for java.io.File and java.nio.file.Path handles with a file system target.
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.
WebHandlerDecorator that invokes a chain of WebFilters before invoking the delegate WebHandler.
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.
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.
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.
A concrete variant of SqlQuery which can be configured with a RowMapper.
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 HandlerFunctions.
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.
Encapsulates information about a handler method consisting of a method and a bean.
Encapsulates information about a handler method consisting of a method and a bean.
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.
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.
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.
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.
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.
Represents an HTTP input message, consisting of headers and a readable body.
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.
Extension of Decoder exposing extra methods relevant in the context of HTTP request or response body decoding.
Extension of Encoder exposing extra methods relevant in the context of HTTP request or response body encoding.
Strategy for reading from a ReactiveHttpInputMessage and decoding the stream of bytes to Objects of type <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 output message, consisting of headers and a writable body.
Represents an HTTP (byte) range for use with the HTTP "Range" header.
Represents an HTTP request message, consisting of a method and a URI.
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.