导图社区 SpringFramework_API_.6.1.6
Java Doc: SpringFramework_API_.6.1.6,Spring Framework的API提供了丰富的功能和接口,帮助开发者构建企业级Java应用程序。
编辑于2024-04-15 06:35:06这是一篇关于【计算机】plantuml官方文档完全脑图笔记-序列图的思维导图,全面且系统地介绍了plantuml序列图的各个组成部分及其相关细节。
从汉朝到清朝,涵盖了多个朝代的统治时期。并且包含不同统治势力的年号。结构为朝代 -> 帝王 -> 年号 -> 起讫时间、使用年数,条理清晰、结构严谨。
Java Doc: SpringFramework_API_.6.1.6,Spring Framework的API提供了丰富的功能和接口,帮助开发者构建企业级Java应用程序。
社区模板帮助中心,点此进入>>
这是一篇关于【计算机】plantuml官方文档完全脑图笔记-序列图的思维导图,全面且系统地介绍了plantuml序列图的各个组成部分及其相关细节。
从汉朝到清朝,涵盖了多个朝代的统治时期。并且包含不同统治势力的年号。结构为朝代 -> 帝王 -> 年号 -> 起讫时间、使用年数,条理清晰、结构严谨。
Java Doc: SpringFramework_API_.6.1.6,Spring Framework的API提供了丰富的功能和接口,帮助开发者构建企业级Java应用程序。
SpringFramework_API 6.1.6
org
aopalliance
aop
package org.aopalliance.aop The core AOP Alliance advice marker.
Interfaces
Advice
Tag interface for Advice.
Exceptions
AspectException
Superclass for all AOP infrastructure exceptions.
intercept
package org.aopalliance.intercept The AOP Alliance reflective interception abstraction.
Interfaces
ConstructorInterceptor
Intercepts the construction of a new object.
ConstructorInvocation
Description of an invocation to a constructor, given to an interceptor upon constructor-call.
Interceptor
This interface represents a generic interceptor.
Invocation
This interface represents an invocation in the program.
Joinpoint
This interface represents a generic runtime joinpoint (in the AOP terminology).
MethodInterceptor
Intercepts calls on an interface on its way to the target.
MethodInvocation
Description of an invocation to a method, given to an interceptor upon method-call.
apache
commons
logging
logging
package org.apache.commons.logging Spring's variant of the Commons Logging API: with special support for Log4J 2, SLF4J and java.util.logging. This is a custom bridge along the lines of jcl-over-slf4j. You may exclude spring-jcl and switch to jcl-over-slf4j instead if you prefer the hard-bound SLF4J bridge. However, Spring's own bridge provides a better out-of-the-box experience when using Log4J 2 or java.util.logging, with no extra bridge jars necessary, and also easier setup of SLF4J with Logback (no JCL exclude, no JCL bridge). Log is equivalent to the original. However, LogFactory is a very different implementation which is minimized and optimized for Spring's purposes, detecting Log4J 2.x and SLF4J 1.7 in the framework classpath and falling back to java.util.logging. If you run into any issues with this implementation, consider excluding spring-jcl and switching to the standard commons-logging artifact or to jcl-over-slf4j. Note that this Commons Logging bridge is only meant to be used for framework logging purposes, both in the core framework and in extensions. For applications, prefer direct use of Log4J/SLF4J or java.util.logging.
Related Packages
org.apache.commons.logging.impl
Spring's variant of the Commons Logging API : with special support for Log4J 2, SLF4J and java.util.logging .
Interfaces
Log
A simple logging interface abstracting logging APIs.
Classes
LogFactory
A minimal incarnation of Apache Commons Logging's LogFactory API, providing just the common Log lookup methods.
LogFactoryService
Deprecated. since it is only meant to be used in the above-mentioned fallback scenario
impl
package org.apache.commons.logging.impl Spring's variant of the Commons Logging API: with special support for Log4J 2, SLF4J and java.util.logging. This impl package is only present for binary compatibility with existing Commons Logging usage, e.g. in Commons Configuration. NoOpLog can be used as a Log fallback instance, and SimpleLog is not meant to work (issuing a warning when used).
Related Packages
org.apache.commons.logging Spring's variant of the Commons Logging API: with special support for Log4J 2, SLF4J and java.util.logging.
Classes
NoOpLog
Trivial implementation of Log that throws away all messages.
SimpleLog
Deprecated. in spring-jcl (effectively equivalent to NoOpLog )
springframework
aop
aop
@NonNullApi @NonNullFields package org.springframework.aop Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces. Any AOP Alliance MethodInterceptor is usable in Spring. Spring AOP also offers: Introduction support A Pointcut abstraction, supporting "static" pointcuts (class and method-based) and "dynamic" pointcuts (also considering method arguments). There are currently no AOP Alliance interfaces for pointcuts. A full range of advice types, including around, before, after returning and throws advice. Extensibility allowing arbitrary custom advice types to be plugged in without modifying the core framework. Spring AOP can be used programmatically or (preferably) integrated with the Spring IoC container.
Related Packages
org.springframework.aop.aspectj
AspectJ integration package.
org.springframework.aop.config
Support package for declarative AOP configuration, with XML schema being the primary configuration format.
org.springframework.aop.framework
Package containing Spring's basic AOP infrastructure, compliant with the AOP Alliance interfaces.
org.springframework.aop.interceptor
Provides miscellaneous interceptor implementations.
org.springframework.aop.scope
Support for AOP-based scoping of target objects, with configurable backend.
org.springframework.aop.support
Convenience classes for using Spring's AOP API.
org.springframework.aop.target
Various TargetSource implementations for use with Spring AOP.
Interfaces
Advisor
Base interface holding AOP advice (action to take at a joinpoint) and a filter determining the applicability of the advice (such as a pointcut).
AfterAdvice
Common marker interface for after advice, such as AfterReturningAdvice and ThrowsAdvice .
AfterReturningAdvice
After returning advice is invoked only on normal method return, not if an exception is thrown.
BeforeAdvice
Common marker interface for before advice, such as MethodBeforeAdvice .
ClassFilter
Filter that restricts matching of a pointcut or introduction to a given set of target classes.
DynamicIntroductionAdvice
Subinterface of AOP Alliance Advice that allows additional interfaces to be implemented by an Advice, and available via a proxy using that interceptor.
IntroductionAdvisor
Superinterface for advisors that perform one or more AOP introductions .
IntroductionAwareMethodMatcher
A specialized type of MethodMatcher that takes into account introductions when matching methods.
IntroductionInfo
Interface supplying the information necessary to describe an introduction.
IntroductionInterceptor
Subinterface of AOP Alliance MethodInterceptor that allows additional interfaces to be implemented by the interceptor, and available via a proxy using that interceptor.
MethodBeforeAdvice
Advice invoked before a method is invoked.
MethodMatcher
Part of a Pointcut : Checks whether the target method is eligible for advice.
Pointcut
Core Spring pointcut abstraction.
PointcutAdvisor
Superinterface for all Advisors that are driven by a pointcut.
ProxyMethodInvocation
Extension of the AOP Alliance MethodInvocation interface, allowing access to the proxy that the method invocation was made through.
RawTargetAccess
Marker for AOP proxy interfaces (in particular: introduction interfaces) that explicitly intend to return the raw target object (which would normally get replaced with the proxy object when returned from a method invocation).
SpringProxy
Marker interface implemented by all AOP proxies.
TargetClassAware
Minimal interface for exposing the target class behind a proxy.
TargetSource
A TargetSource is used to obtain the current "target" of an AOP invocation, which will be invoked via reflection if no around advice chooses to end the interceptor chain itself.
ThrowsAdvice
Tag interface for throws advice.
Exceptions
AopInvocationException
Exception that gets thrown when an AOP invocation failed because of misconfiguration or unexpected runtime issues.
aspectj
aspectj
@NonNullApi @NonNullFields package org.springframework.aop.aspectj AspectJ integration package. Includes Spring AOP advice implementations for AspectJ 5 annotation-style methods, and an AspectJExpressionPointcut: a Spring AOP Pointcut implementation that allows use of the AspectJ pointcut expression language with the Spring AOP runtime framework. Note that use of this package does not require the use of the ajc compiler or AspectJ load-time weaver. It is intended to enable the use of a valuable subset of AspectJ functionality, with consistent semantics, with the proxy-based Spring AOP framework.
Related Packages
org.springframework.aop
Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.
org.springframework.aop.aspectj.annotation
Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
org.springframework.aop.aspectj.autoproxy
Base classes enabling auto-proxying based on AspectJ.
Classes
AbstractAspectJAdvice
Base class for AOP Alliance Advice classes wrapping an AspectJ aspect or an AspectJ-annotated advice method.
AspectJAdviceParameterNameDiscoverer
ParameterNameDiscoverer implementation that tries to deduce parameter names for an advice method from the pointcut expression, returning, and throwing clauses.
AspectJAfterAdvice
Spring AOP advice wrapping an AspectJ after advice method.
AspectJAfterReturningAdvice
Spring AOP advice wrapping an AspectJ after-returning advice method.
AspectJAfterThrowingAdvice
Spring AOP advice wrapping an AspectJ after-throwing advice method.
AspectJAopUtils
Utility methods for dealing with AspectJ advisors.
AspectJAroundAdvice
Spring AOP around advice (MethodInterceptor) that wraps an AspectJ advice method.
AspectJExpressionPointcut
Spring Pointcut implementation that uses the AspectJ weaver to evaluate a pointcut expression.
AspectJExpressionPointcutAdvisor
Spring AOP Advisor that can be used for any AspectJ pointcut expression.
AspectJMethodBeforeAdvice
Spring AOP advice that wraps an AspectJ before method.
AspectJPointcutAdvisor
AspectJPointcutAdvisor adapts an AbstractAspectJAdvice to the PointcutAdvisor interface.
AspectJProxyUtils
Utility methods for working with AspectJ proxies.
AspectJWeaverMessageHandler
Implementation of AspectJ's IMessageHandler interface that routes AspectJ weaving messages through the same logging system as the regular Spring messages.
DeclareParentsAdvisor
Introduction advisor delegating to the given object.
MethodInvocationProceedingJoinPoint
An implementation of the AspectJ ProceedingJoinPoint interface wrapping an AOP Alliance MethodInvocation .
SimpleAspectInstanceFactory
Implementation of AspectInstanceFactory that creates a new instance of the specified aspect class for every SimpleAspectInstanceFactory.getAspectInstance() call.
SingletonAspectInstanceFactory
Implementation of AspectInstanceFactory that is backed by a specified singleton object, returning the same instance for every SingletonAspectInstanceFactory.getAspectInstance() call.
TypePatternClassFilter
Spring AOP ClassFilter implementation using AspectJ type matching.
Interfaces
AspectInstanceFactory
Interface implemented to provide an instance of an AspectJ aspect.
AspectJPrecedenceInformation
Interface to be implemented by types that can supply the information needed to sort advice/advisors by AspectJ's precedence rules.
InstantiationModelAwarePointcutAdvisor
Interface to be implemented by Spring AOP Advisors wrapping AspectJ aspects that may have a lazy initialization strategy.
Exceptions
AspectJAdviceParameterNameDiscoverer.AmbiguousBindingException
Thrown in response to an ambiguous binding being detected when trying to resolve a method's parameter names.
annotation
@NonNullApi @NonNullFields package org.springframework.aop.aspectj.annotation Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP. Normally to be used through an AspectJAutoProxyCreator rather than directly.
Related Packages
org.springframework.aop.aspectj
AspectJ integration package.
org.springframework.aop.aspectj.autoproxy
Base classes enabling auto-proxying based on AspectJ.
Classes
AbstractAspectJAdvisorFactory
Abstract base class for factories that can create Spring AOP Advisors given AspectJ classes from classes honoring the AspectJ 5 annotation syntax.
AbstractAspectJAdvisorFactory.AspectJAnnotation
Class modeling an AspectJ annotation, exposing its type enumeration and pointcut String.
AnnotationAwareAspectJAutoProxyCreator
AspectJAwareAdvisorAutoProxyCreator subclass that processes all AspectJ annotation aspects in the current application context, as well as Spring Advisors.
AspectJProxyFactory
AspectJ-based proxy factory, allowing for programmatic building of proxies which include AspectJ aspects (code style as well annotation style).
AspectMetadata
Metadata for an AspectJ aspect class, with an additional Spring AOP pointcut for the per clause.
BeanFactoryAspectInstanceFactory
AspectInstanceFactory implementation backed by a Spring BeanFactory .
BeanFactoryAspectJAdvisorsBuilder
Helper for retrieving @AspectJ beans from a BeanFactory and building Spring Advisors based on them, for use with auto-proxying.
LazySingletonAspectInstanceFactoryDecorator
Decorator to cause a MetadataAwareAspectInstanceFactory to instantiate only once.
PrototypeAspectInstanceFactory
AspectInstanceFactory backed by a BeanFactory -provided prototype, enforcing prototype semantics.
ReflectiveAspectJAdvisorFactory
Factory that can create Spring AOP Advisors given AspectJ classes from classes honoring AspectJ's annotation syntax, using reflection to invoke the corresponding advice methods.
ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor
Synthetic advisor that instantiates the aspect.
SimpleMetadataAwareAspectInstanceFactory
Implementation of MetadataAwareAspectInstanceFactory that creates a new instance of the specified aspect class for every SimpleAspectInstanceFactory.getAspectInstance() call.
SingletonMetadataAwareAspectInstanceFactory
Implementation of MetadataAwareAspectInstanceFactory that is backed by a specified singleton object, returning the same instance for every SingletonAspectInstanceFactory.getAspectInstance() call.
Enum Classes
AbstractAspectJAdvisorFactory.AspectJAnnotationType
Enum for AspectJ annotation types.
Interfaces
AspectJAdvisorFactory
Interface for factories that can create Spring AOP Advisors from classes annotated with AspectJ annotation syntax.
MetadataAwareAspectInstanceFactory
Subinterface of AspectInstanceFactory that returns AspectMetadata associated with AspectJ-annotated classes.
Exceptions
NotAnAtAspectException
Extension of AopConfigException thrown when trying to perform an advisor generation operation on a class that is not an AspectJ annotation-style aspect.
autoproxy
@NonNullApi @NonNullFields package org.springframework.aop.aspectj.autoproxy Base classes enabling auto-proxying based on AspectJ. Support for AspectJ annotation aspects resides in the "aspectj.annotation" package.
Related Packages
org.springframework.aop.aspectj
AspectJ integration package.
org.springframework.aop.aspectj.annotation
Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
Classes
AspectJAwareAdvisorAutoProxyCreator
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.
config
@NonNullApi @NonNullFields package org.springframework.aop.config Support package for declarative AOP configuration, with XML schema being the primary configuration format.
Related Packages
org.springframework.aop
Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.
Classes
AbstractInterceptorDrivenBeanDefinitionDecorator
Base implementation for BeanDefinitionDecorators wishing to add an interceptor to the resulting bean.
AdviceEntry
ParseState entry representing an advice element.
AdvisorComponentDefinition
ComponentDefinition that bridges the gap between the advisor bean definition configured by the tag and the component definition infrastructure.
AdvisorEntry
ParseState entry representing an advisor.
AopConfigUtils
Utility class for handling registration of AOP auto-proxy creators.
AopNamespaceHandler
NamespaceHandler for the aop namespace.
AopNamespaceUtils
Utility class for handling registration of auto-proxy creators used internally by the ' aop ' namespace tags.
AspectComponentDefinition
ComponentDefinition that holds an aspect definition, including its nested pointcuts.
AspectEntry
ParseState entry representing an aspect.
MethodLocatingFactoryBean
FactoryBean implementation that locates a Method on a specified bean.
PointcutComponentDefinition
ComponentDefinition implementation that holds a pointcut definition.
PointcutEntry
ParseState entry representing a pointcut.
SimpleBeanFactoryAwareAspectInstanceFactory
Implementation of AspectInstanceFactory that locates the aspect from the BeanFactory using a configured bean name.
framework
framework
@NonNullApi @NonNullFields package org.springframework.aop.framework Package containing Spring's basic AOP infrastructure, compliant with the AOP Alliance interfaces. Spring AOP supports proxying interfaces or classes, introductions, and offers static and dynamic pointcuts. Any Spring AOP proxy can be cast to the ProxyConfig AOP configuration interface in this package to add or remove interceptors. The ProxyFactoryBean is a convenient way to create AOP proxies in a BeanFactory or ApplicationContext. However, proxies can be created programmatically using the ProxyFactory class.
Related Packages
org.springframework.aop
Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.
org.springframework.aop.framework.adapter
SPI package allowing Spring AOP framework to handle arbitrary advice types.
org.springframework.aop.framework.autoproxy
Bean post-processors for use in ApplicationContexts to simplify AOP usage by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
Classes
AbstractAdvisingBeanPostProcessor
Base class for BeanPostProcessor implementations that apply a Spring AOP Advisor to specific beans.
AbstractSingletonProxyFactoryBean
Convenient superclass for FactoryBean types that produce singleton-scoped proxy objects.
AdvisedSupport
Base class for AOP proxy configuration managers.
AopContext
Class containing static methods used to obtain information about the current AOP invocation.
AopProxyUtils
Utility methods for AOP proxy factories.
DefaultAdvisorChainFactory
A simple but definitive way of working out an advice chain for a Method, given an Advised object.
DefaultAopProxyFactory
Default AopProxyFactory implementation, creating either a CGLIB proxy or a JDK dynamic proxy.
ProxyConfig
Convenience superclass for configuration used in creating proxies, to ensure that all proxy creators have consistent properties.
ProxyCreatorSupport
Base class for proxy factories.
ProxyFactory
Factory for AOP proxies for programmatic use, rather than via declarative setup in a bean factory.
ProxyFactoryBean
FactoryBean implementation that builds an AOP proxy based on beans in a Spring BeanFactory .
ProxyProcessorSupport
Base class with common functionality for proxy processors, in particular ClassLoader management and the ProxyProcessorSupport.evaluateProxyInterfaces(java.lang.Class, org.springframework.aop.framework.ProxyFactory) algorithm.
ReflectiveMethodInvocation
Spring's implementation of the AOP Alliance MethodInvocation interface, implementing the extended ProxyMethodInvocation interface.
Interfaces
Advised
Interface to be implemented by classes that hold the configuration of a factory of AOP proxies.
AdvisedSupportListener
Listener to be registered on ProxyCreatorSupport objects Allows for receiving callbacks on activation and change of advice.
AdvisorChainFactory
Factory interface for advisor chains.
AopInfrastructureBean
Marker interface that indicates a bean that is part of Spring's AOP infrastructure.
AopProxy
Delegate interface for a configured AOP proxy, allowing for the creation of actual proxy objects.
AopProxyFactory
Interface to be implemented by factories that are able to create AOP proxies based on AdvisedSupport configuration objects.
Exceptions
AopConfigException
Exception that gets thrown on illegal AOP configuration arguments.
adapter
@NonNullApi @NonNullFields package org.springframework.aop.framework.adapter SPI package allowing Spring AOP framework to handle arbitrary advice types. Users who want merely to use the Spring AOP framework, rather than extend its capabilities, don't need to concern themselves with this package. You may wish to use these adapters to wrap Spring-specific advices, such as MethodBeforeAdvice, in MethodInterceptor, to allow their use in another AOP framework supporting the AOP Alliance interfaces. These adapters do not depend on any other Spring framework classes to allow such usage.
Related Packages
org.springframework.aop.framework
Package containing Spring's basic AOP infrastructure, compliant with the AOP Alliance interfaces.
org.springframework.aop.framework.autoproxy
Bean post-processors for use in ApplicationContexts to simplify AOP usage by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
Interfaces
AdvisorAdapter
Interface allowing extension to the Spring AOP framework to allow handling of new Advisors and Advice types.
AdvisorAdapterRegistry
Interface for registries of Advisor adapters.
Classes
AdvisorAdapterRegistrationManager
BeanPostProcessor that registers AdvisorAdapter beans in the BeanFactory with an AdvisorAdapterRegistry (by default the GlobalAdvisorAdapterRegistry ).
AfterReturningAdviceInterceptor
Interceptor to wrap an AfterReturningAdvice .
DefaultAdvisorAdapterRegistry
Default implementation of the AdvisorAdapterRegistry interface.
GlobalAdvisorAdapterRegistry
Singleton to publish a shared DefaultAdvisorAdapterRegistry instance.
MethodBeforeAdviceInterceptor
Interceptor to wrap a MethodBeforeAdvice .
ThrowsAdviceInterceptor
Interceptor to wrap an after-throwing advice.
Exceptions
UnknownAdviceTypeException
Exception thrown when an attempt is made to use an unsupported Advisor or Advice type.
autoproxy
autoproxy
@NonNullApi @NonNullFields package org.springframework.aop.framework.autoproxy Bean post-processors for use in ApplicationContexts to simplify AOP usage by automatically creating AOP proxies without the need to use a ProxyFactoryBean. The various post-processors in this package need only be added to an ApplicationContext (typically in an XML bean definition document) to automatically proxy selected beans. NB: Automatic auto-proxying is not supported for BeanFactory implementations, as post-processors beans are only automatically detected in application contexts. Post-processors can be explicitly registered on a ConfigurableBeanFactory instead.
Related Packages
org.springframework.aop.framework
Package containing Spring's basic AOP infrastructure, compliant with the AOP Alliance interfaces.
org.springframework.aop.framework.autoproxy.target
Various TargetSourceCreator implementations for use with Spring's AOP auto-proxying support.
org.springframework.aop.framework.adapter
SPI package allowing Spring AOP framework to handle arbitrary advice types.
Classes
AbstractAdvisorAutoProxyCreator
Generic auto proxy creator that builds AOP proxies for specific beans based on detected Advisors for each bean.
AbstractAutoProxyCreator
BeanPostProcessor implementation that wraps each eligible bean with an AOP proxy, delegating to specified interceptors before invoking the bean itself.
AbstractBeanFactoryAwareAdvisingPostProcessor
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 ).
AutoProxyUtils
Utilities for auto-proxy aware components.
BeanFactoryAdvisorRetrievalHelper
Helper for retrieving standard Spring Advisors from a BeanFactory, for use with auto-proxying.
BeanNameAutoProxyCreator
Auto proxy creator that identifies beans to proxy via a list of names.
DefaultAdvisorAutoProxyCreator
BeanPostProcessor implementation that creates AOP proxies based on all candidate Advisor s in the current BeanFactory .
InfrastructureAdvisorAutoProxyCreator
Auto-proxy creator that considers infrastructure Advisor beans only, ignoring any application-defined Advisors.
ProxyCreationContext
Holder for the current proxy creation context, as exposed by auto-proxy creators such as AbstractAdvisorAutoProxyCreator .
Interfaces
TargetSourceCreator
Implementations can create special target sources, such as pooling target sources, for particular beans.
target
@NonNullApi @NonNullFields package org.springframework.aop.framework.autoproxy.target Various TargetSourceCreator implementations for use with Spring's AOP auto-proxying support.
Related Packages
org.springframework.aop.framework.autoproxy
Bean post-processors for use in ApplicationContexts to simplify AOP usage by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
Classes
AbstractBeanFactoryBasedTargetSourceCreator
Convenient superclass for TargetSourceCreator implementations that require creating multiple instances of a prototype bean.
LazyInitTargetSourceCreator
TargetSourceCreator that enforces a LazyInitTargetSource for each bean that is defined as "lazy-init".
QuickTargetSourceCreator
Convenient TargetSourceCreator using bean name prefixes to create one of three well-known TargetSource types: : CommonsPool2TargetSource % ThreadLocalTargetSource ! PrototypeTargetSource
interceptor
@NonNullApi @NonNullFields package org.springframework.aop.interceptor Provides miscellaneous interceptor implementations. More specific interceptors can be found in corresponding functionality packages, like "transaction" and "orm".
Related Packages
org.springframework.aop
Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.
Classes
AbstractMonitoringInterceptor
Base class for monitoring interceptors, such as performance monitors.
AbstractTraceInterceptor
Base MethodInterceptor implementation for tracing.
AsyncExecutionAspectSupport
Base class for asynchronous method execution aspects, such as org.springframework.scheduling.annotation.AnnotationAsyncExecutionInterceptor or org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect .
AsyncExecutionInterceptor
AOP Alliance MethodInterceptor that processes method invocations asynchronously, using a given AsyncTaskExecutor .
ConcurrencyThrottleInterceptor
Interceptor that throttles concurrent access, blocking invocations if a specified concurrency limit is reached.
CustomizableTraceInterceptor
MethodInterceptor implementation that allows for highly customizable method-level tracing, using placeholders.
DebugInterceptor
AOP Alliance MethodInterceptor that can be introduced in a chain to display verbose information about intercepted invocations to the logger.
ExposeBeanNameAdvisors
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.
ExposeInvocationInterceptor
Interceptor that exposes the current MethodInvocation as a thread-local object.
PerformanceMonitorInterceptor
Simple AOP Alliance MethodInterceptor for performance monitoring.
SimpleAsyncUncaughtExceptionHandler
A default AsyncUncaughtExceptionHandler that simply logs the exception.
SimpleTraceInterceptor
Simple AOP Alliance MethodInterceptor that can be introduced in a chain to display verbose trace information about intercepted method invocations, with method entry and method exit info.
Interfaces
AsyncUncaughtExceptionHandler
A strategy for handling uncaught exceptions thrown from asynchronous methods.
scope
@NonNullApi @NonNullFields package org.springframework.aop.scope Support for AOP-based scoping of target objects, with configurable backend.
Related Packages
org.springframework.aop
Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.
Classes
DefaultScopedObject
Default implementation of the ScopedObject interface.
ScopedProxyFactoryBean
Convenient proxy factory bean for scoped objects.
ScopedProxyUtils
Utility class for creating a scoped proxy.
Interfaces
ScopedObject
An AOP introduction interface for scoped objects.
support
support
@NonNullApi @NonNullFields package org.springframework.aop.support Convenience classes for using Spring's AOP API.
Related Packages
org.springframework.aop
Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.
org.springframework.aop.support.annotation
Annotation support for AOP pointcuts.
Classes
AbstractBeanFactoryPointcutAdvisor
Abstract BeanFactory-based PointcutAdvisor that allows for any Advice to be configured as reference to an Advice bean in a BeanFactory.
AbstractExpressionPointcut
Abstract superclass for expression pointcuts, offering location and expression properties.
AbstractGenericPointcutAdvisor
Abstract generic PointcutAdvisor that allows for any Advice to be configured.
AbstractPointcutAdvisor
Abstract base class for PointcutAdvisor implementations.
AbstractRegexpMethodPointcut
Abstract base regular expression pointcut bean.
AopUtils
Utility methods for AOP support code.
ClassFilters
Static utility methods for composing ClassFilters .
ComposablePointcut
Convenient class for building up pointcuts.
ControlFlowPointcut
Pointcut and method matcher for use as a simple cflow -style pointcut.
DefaultBeanFactoryPointcutAdvisor
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.
DefaultIntroductionAdvisor
Simple IntroductionAdvisor implementation that by default applies to any class.
DefaultPointcutAdvisor
Convenient Pointcut-driven Advisor implementation.
DelegatePerTargetObjectIntroductionInterceptor
Convenient implementation of the IntroductionInterceptor interface.
DelegatingIntroductionInterceptor
Convenient implementation of the IntroductionInterceptor interface.
DynamicMethodMatcher
Convenient abstract superclass for dynamic method matchers, which do care about arguments at runtime.
DynamicMethodMatcherPointcut
Convenient superclass when we want to force subclasses to implement MethodMatcher interface, but subclasses will want to be pointcuts.
IntroductionInfoSupport
Support for implementations of IntroductionInfo .
JdkRegexpMethodPointcut
Regular expression pointcut based on the java.util.regex package.
MethodMatchers
Static utility methods for composing MethodMatchers .
NameMatchMethodPointcut
Pointcut bean for simple method name matches, as an alternative to regular expression patterns.
NameMatchMethodPointcutAdvisor
Convenient class for name-match method pointcuts that hold an Advice, making them an Advisor.
Pointcuts
Pointcut constants for matching getters and setters, and static methods useful for manipulating and evaluating pointcuts.
RegexpMethodPointcutAdvisor
Convenient class for regexp method pointcuts that hold an Advice, making them an Advisor .
RootClassFilter
Simple ClassFilter implementation that passes classes (and optionally subclasses).
StaticMethodMatcher
Convenient abstract superclass for static method matchers, which don't care about arguments at runtime.
StaticMethodMatcherPointcut
Convenient superclass when we want to force subclasses to implement the MethodMatcher interface but subclasses will want to be pointcuts.
StaticMethodMatcherPointcutAdvisor
Convenient base class for Advisors that are also static pointcuts.
Interfaces
ExpressionPointcut
Interface to be implemented by pointcuts that use String expressions.
annotation
@NonNullApi @NonNullFields package org.springframework.aop.support.annotation Annotation support for AOP pointcuts.
Related Packages
org.springframework.aop.support
Convenience classes for using Spring's AOP API.
Classes
AnnotationClassFilter
Simple ClassFilter that looks for a specific annotation being present on a class.
AnnotationMatchingPointcut
Simple Pointcut that looks for a specific annotation being present on a class or method .
AnnotationMethodMatcher
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).
target
target
@NonNullApi @NonNullFields package org.springframework.aop.target Various TargetSource implementations for use with Spring AOP.
Related Packages
org.springframework.aop
Core Spring AOP interfaces, built on AOP Alliance AOP interoperability interfaces.
org.springframework.aop.target.dynamic
Support for dynamic, refreshable TargetSource implementations for use with Spring AOP.
Classes
AbstractBeanFactoryBasedTargetSource
Base class for TargetSource implementations that are based on a Spring BeanFactory , delegating to Spring-managed bean instances.
AbstractLazyCreationTargetSource
TargetSource implementation that will lazily create a user-managed object.
AbstractPoolingTargetSource
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.
AbstractPrototypeBasedTargetSource
Base class for dynamic TargetSource implementations that create new prototype bean instances to support a pooling or new-instance-per-invocation strategy.
CommonsPool2TargetSource
TargetSource implementation that holds objects in a configurable Apache Commons2 Pool.
EmptyTargetSource
Canonical TargetSource when there is no target (or just the target class known), and behavior is supplied by interfaces and advisors only.
HotSwappableTargetSource
TargetSource implementation that caches a local target object, but allows the target to be swapped while the application is running.
LazyInitTargetSource
TargetSource that lazily accesses a singleton bean from a BeanFactory .
PrototypeTargetSource
TargetSource implementation that creates a new instance of the target bean for each request, destroying each instance on release (after each request).
SimpleBeanTargetSource
Simple TargetSource implementation, freshly obtaining the specified target bean from its containing Spring BeanFactory .
SingletonTargetSource
Implementation of the TargetSource interface that holds a given object.
ThreadLocalTargetSource
Alternative to an object pool.
Interfaces
PoolingConfig
Config interface for a pooling target source.
ThreadLocalTargetSourceStats
Statistics for a ThreadLocal TargetSource.
dynamic
@NonNullApi @NonNullFields package org.springframework.aop.target.dynamic Support for dynamic, refreshable TargetSource implementations for use with Spring AOP.
Related Packages
org.springframework.aop.target
Various TargetSource implementations for use with Spring AOP.
Classes
AbstractRefreshableTargetSource
Abstract TargetSource implementation that wraps a refreshable target object.
BeanFactoryRefreshableTargetSource
Refreshable TargetSource that fetches fresh target beans from a BeanFactory.
Interfaces
Refreshable
Interface to be implemented by dynamic target objects, which support reloading and optionally polling for updates.
aot
aot
@NonNullApi @NonNullFields package org.springframework.aot Core package for Spring AOT infrastructure.
Related Packages
org.springframework.aot.agent
Support for recording method invocations relevant to RuntimeHints metadata.
org.springframework.aot.generate
Support classes for components that contribute generated code equivalent to a runtime behavior.
org.springframework.aot.hint
Support for registering the need for reflection, resources, java serialization and proxies at runtime.
org.springframework.aot.nativex
Support for generating GraalVM native configuration from runtime hints.
Classes
AotDetector
Utility for determining if AOT-processed optimizations must be used rather than the regular runtime.
agent
@NonNullApi @NonNullFields package org.springframework.aot.agent Support for recording method invocations relevant to RuntimeHints metadata.
Related Packages
org.springframework.aot
Core package for Spring AOT infrastructure.
org.springframework.aot.generate
Support classes for components that contribute generated code equivalent to a runtime behavior.
org.springframework.aot.hint
Support for registering the need for reflection, resources, java serialization and proxies at runtime.
org.springframework.aot.nativex
Support for generating GraalVM native configuration from runtime hints.
Enum Classes
HintType
Main types of RuntimeHints .
Classes
InstrumentedBridgeMethods
Deprecated. This class should only be used by the runtime-hints agent when instrumenting bytecode and is not considered public API.
MethodReference
Reference to a Java method, identified by its owner class and the method name.
RecordedInvocation
Record of an invocation of a method relevant to RuntimeHints .
RecordedInvocation.Builder
Builder for RecordedInvocation .
RecordedInvocationsPublisher
Publishes invocations on method relevant to RuntimeHints , as they are recorded by the RuntimeHintsAgent .
RuntimeHintsAgent
Java Agent that records method invocations related to RuntimeHints metadata.
Interfaces
RecordedInvocationsListener
Listener for invocations recorded by the RuntimeHintsAgent .
generate
@NonNullApi @NonNullFields package org.springframework.aot.generate Support classes for components that contribute generated code equivalent to a runtime behavior.
Related Packages
org.springframework.aot
Core package for Spring AOT infrastructure.
org.springframework.aot.agent
Support for recording method invocations relevant to RuntimeHints metadata.
org.springframework.aot.hint
Support for registering the need for reflection, resources, java serialization and proxies at runtime.
org.springframework.aot.nativex
Support for generating GraalVM native configuration from runtime hints.
Classes
AccessControl
Determine the access control of a Member or type signature.
ClassNameGenerator
Generate unique class names based on a target ClassName and a feature name.
DefaultGenerationContext
Default GenerationContext implementation.
DefaultMethodReference
Default MethodReference implementation based on a MethodSpec .
FileSystemGeneratedFiles
GeneratedFiles implementation that stores generated files using a FileSystem .
GeneratedClass
A single generated class.
GeneratedClasses
A managed collection of generated classes.
GeneratedMethod
A generated method.
GeneratedMethods
A managed collection of generated methods.
GeneratedTypeReference
A TypeReference for a generated type.
InMemoryGeneratedFiles
GeneratedFiles implementation that keeps generated files in-memory.
ValueCodeGenerator
Code generator for a single value.
ValueCodeGeneratorDelegates
Code generator ValueCodeGenerator.Delegate for well known value types.
ValueCodeGeneratorDelegates.CollectionDelegate<T extends Collection<?>>
Abstract ValueCodeGenerator.Delegate for Collection types.
ValueCodeGeneratorDelegates.MapDelegate
ValueCodeGenerator.Delegate for Map types.
Enum Classes
AccessControl.Visibility
Access visibility types as determined by the modifiers on a Member or ResolvableType .
GeneratedFiles.Kind
The various kinds of generated files that are supported.
Annotation Interfaces
Generated
Indicate that the type has been generated ahead of time.
Interfaces
GeneratedFiles
Interface that can be used to add source , resource , or class files generated during ahead-of-time processing.
GenerationContext
Central interface used for code generation.
MethodReference
A reference to a method with convenient code generation for referencing, or invoking it.
MethodReference.ArgumentCodeGenerator
Strategy for generating code for arguments based on their type.
ValueCodeGenerator.Delegate
Strategy interface that can be used to implement code generation for a particular value type.
Exceptions
UnsupportedTypeValueCodeGenerationException
Thrown when a ValueCodeGenerator could not generate the code for a given value.
ValueCodeGenerationException
Thrown when value code generation fails.
hint
hint
@NonNullApi @NonNullFields package org.springframework.aot.hint Support for registering the need for reflection, resources, java serialization and proxies at runtime.
Related Packages
org.springframework.aot
Core package for Spring AOT infrastructure.
org.springframework.aot.hint.annotation
Annotation support for runtime hints.
org.springframework.aot.hint.predicate
Predicate support for runtime hints.
org.springframework.aot.hint.support
Convenience classes for using runtime hints.
org.springframework.aot.agent
Support for recording method invocations relevant to RuntimeHints metadata.
org.springframework.aot.generate
Support classes for components that contribute generated code equivalent to a runtime behavior.
org.springframework.aot.nativex
Support for generating GraalVM native configuration from runtime hints.
Classes
AbstractTypeReference
Base TypeReference implementation that ensures consistent behaviour for equals() , hashCode() , and toString() based on the canonical name .
BindingReflectionHintsRegistrar
Register the necessary reflection hints so that the specified type can be bound at runtime.
ExecutableHint
A hint that describes the need for reflection on a Method or Constructor .
ExecutableHint.Builder
Builder for ExecutableHint .
FieldHint
A hint that describes the need for reflection on a Field .
JavaSerializationHint
A hint that describes the need for Java serialization at runtime.
JavaSerializationHint.Builder
Builder for JavaSerializationHint .
JdkProxyHint
A hint that describes the need for a JDK interface-based Proxy .
JdkProxyHint.Builder
Builder for JdkProxyHint .
MemberHint
Base hint that describes the need for reflection on a Member .
ProxyHints
Gather the need for using proxies at runtime.
ReflectionHints
Gather the need for reflection at runtime.
ResourceBundleHint
A hint that describes the need to access a ResourceBundle .
ResourceBundleHint.Builder
Builder for ResourceBundleHint .
ResourceHints
Gather the need for resources available at runtime.
ResourcePatternHint
A hint that describes resources that should be made available at runtime.
ResourcePatternHints
A collection of ResourcePatternHint describing whether resources should be made available at runtime using a matching algorithm based on include/exclude patterns.
ResourcePatternHints.Builder
Builder for ResourcePatternHints .
RuntimeHints
Gather hints that can be used to optimize the application runtime.
SerializationHints
Gather the need for Java serialization at runtime.
TypeHint
A hint that describes the need for reflection on a type.
TypeHint.Builder
Builder for TypeHint .
Interfaces
ConditionalHint
Contract for runtime hints that only apply if the described condition is met.
RuntimeHintsRegistrar
Contract for registering RuntimeHints based on the ClassLoader of the deployment unit.
TypeReference
Type abstraction that can be used to refer to types that are not available as a Class yet.
Enum Classes
ExecutableMode
Represent the need of reflection for a given Executable .
MemberCategory
Predefined Member categories.
annotation
@NonNullApi @NonNullFields package org.springframework.aot.hint.annotation Annotation support for runtime hints.
Related Packages
org.springframework.aot.hint
Support for registering the need for reflection, resources, java serialization and proxies at runtime.
org.springframework.aot.hint.predicate
Predicate support for runtime hints.
org.springframework.aot.hint.support
Convenience classes for using runtime hints.
Annotation Interfaces
Reflective
Indicate that the annotated element requires reflection.
RegisterReflectionForBinding
Indicates that the classes specified in the annotation attributes require some reflection hints for binding or reflection-based serialization purposes.
Interfaces
ReflectiveProcessor
Process an AnnotatedElement and register the necessary reflection hints for it.
Classes
ReflectiveRuntimeHintsRegistrar
Process @Reflective annotated elements.
RegisterReflectionForBindingProcessor
A ReflectiveProcessor implementation that registers reflection hints for data binding purpose (class, constructors, fields, properties, record components, including types transitively used on properties and record components).
SimpleReflectiveProcessor
A simple ReflectiveProcessor implementation that registers only a reflection hint for the annotated type.
predicate
@NonNullApi @NonNullFields package org.springframework.aot.hint.predicate Predicate support for runtime hints.
Related Packages
org.springframework.aot.hint
Support for registering the need for reflection, resources, java serialization and proxies at runtime.
org.springframework.aot.hint.annotation
Annotation support for runtime hints.
org.springframework.aot.hint.support
Convenience classes for using runtime hints.
Classes
ProxyHintsPredicates
Generator of ProxyHints predicates, testing whether the given hints match the expected behavior for proxies.
ReflectionHintsPredicates
Generator of ReflectionHints predicates, testing whether the given hints match the expected behavior for reflection.
ReflectionHintsPredicates.ConstructorHintPredicate
ReflectionHintsPredicates.ExecutableHintPredicate<T extends Executable>
ReflectionHintsPredicates.FieldHintPredicate
ReflectionHintsPredicates.MethodHintPredicate
ReflectionHintsPredicates.TypeHintPredicate
ResourceHintsPredicates
Generator of ResourceHints predicates, testing whether the given hints match the expected behavior for resources.
RuntimeHintsPredicates
Static generator of predicates that test whether the given RuntimeHints instance matches the expected behavior for reflection, resource, serialization, or proxy generation.
SerializationHintsPredicates
Generator of SerializationHints predicates, testing whether the given hints match the expected behavior for serialization.
support
@NonNullApi @NonNullFields package org.springframework.aot.hint.support Convenience classes for using runtime hints.
Related Packages
org.springframework.aot.hint
Support for registering the need for reflection, resources, java serialization and proxies at runtime.
org.springframework.aot.hint.annotation
Annotation support for runtime hints.
org.springframework.aot.hint.predicate
Predicate support for runtime hints.
Classes
ClassHintUtils
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.
FilePatternResourceHintsRegistrar
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.
FilePatternResourceHintsRegistrar.Builder
Builder for FilePatternResourceHintsRegistrar .
nativex
@NonNullApi @NonNullFields package org.springframework.aot.nativex Support for generating GraalVM native configuration from runtime hints.
Related Packages
org.springframework.aot
Core package for Spring AOT infrastructure.
org.springframework.aot.agent
Support for recording method invocations relevant to RuntimeHints metadata.
org.springframework.aot.generate
Support classes for components that contribute generated code equivalent to a runtime behavior.
org.springframework.aot.hint
Support for registering the need for reflection, resources, java serialization and proxies at runtime.
Classes
FileNativeConfigurationWriter
A NativeConfigurationWriter implementation that writes the configuration to disk.
NativeConfigurationWriter
Write RuntimeHints as GraalVM native configuration.
test
agent
@NonNullApi @NonNullFields package org.springframework.aot.test.agent Testing support for the RuntimeHintsAgent.
Annotation Interfaces
EnabledIfRuntimeHintsAgent
@EnabledIfRuntimeHintsAgent signals that the annotated test class or test method is only enabled if the RuntimeHintsAgent is loaded on the current JVM.
Classes
RuntimeHintsInvocations
A wrapper for RecordedInvocation that is the starting point for RuntimeHints AssertJ assertions.
RuntimeHintsInvocationsAssert
AssertJ assertions that can be applied to RuntimeHintsInvocations .
RuntimeHintsRecorder
Invocations relevant to RuntimeHints recorded during the execution of a block of code instrumented by the RuntimeHintsAgent .
generate
@NonNullApi @NonNullFields package org.springframework.aot.test.generate Test support for core AOT classes.
Classes
CompilerFiles
Adapter class that can be used to apply AOT GeneratedFiles to the TestCompiler .
TestGenerationContext
GenerationContext test implementation that uses InMemoryGeneratedFiles and can configure a TestCompiler instance.
asm
package org.springframework.asm Spring's repackaging of ASM 9.x (with Spring-specific patches; for internal use only). This repackaging technique avoids any potential conflicts with dependencies on ASM at the application level or from third-party libraries and frameworks. As this repackaging happens at the class file level, sources and javadocs are not available here.
Classes
AnnotationVisitor
A visitor to visit a Java annotation.
Attribute
A non standard class, field, method or Code attribute, as defined in the Java Virtual Machine Specification (JVMS).
ByteVector
A dynamically extensible vector of bytes.
ClassReader
A parser to make a ClassVisitor visit a ClassFile structure, as defined in the Java Virtual Machine Specification (JVMS).
ClassVisitor
A visitor to visit a Java class.
ClassWriter
A ClassVisitor that generates a corresponding ClassFile structure, as defined in the Java Virtual Machine Specification (JVMS).
ConstantDynamic
A constant whose value is computed at runtime, with a bootstrap method.
FieldVisitor
A visitor to visit a Java field.
Handle
A reference to a field or a method.
Label
A position in the bytecode of a method.
MethodVisitor
A visitor to visit a Java method.
ModuleVisitor
A visitor to visit a Java module.
RecordComponentVisitor
A visitor to visit a record component.
SpringAsmInfo
Utility class exposing constants related to Spring's internal repackaging of the ASM bytecode library: currently based on ASM 9.x plus minor patches.
Type
A Java field or method type.
TypePath
The path to a type argument, wildcard bound, array element type, or static inner type within an enclosing type.
TypeReference
A reference to a type appearing in a class, field or method declaration, or on an instruction.
Exceptions
ClassTooLargeException
Exception thrown when the constant pool of a class produced by a ClassWriter is too large.
MethodTooLargeException
Exception thrown when the Code attribute of a method produced by a ClassWriter is too large.
Interfaces
Opcodes
The JVM opcodes, access flags and array type codes.
cache
cache
@NonNullApi @NonNullFields package org.springframework.cache Spring's generic cache abstraction. Concrete implementations are provided in the subpackages.
Related Packages
org.springframework.cache.annotation
Annotations and supporting classes for declarative cache management.
org.springframework.cache.aspectj
AspectJ-based caching support.
org.springframework.cache.caffeine
Support classes for the open source cache in Caffeine library, allowing to set up Caffeine caches within Spring's cache abstraction.
org.springframework.cache.concurrent
Implementation package for java.util.concurrent based caches.
org.springframework.cache.config
Support package for declarative caching configuration, with XML schema being the primary configuration format.
org.springframework.cache.interceptor
AOP-based solution for declarative caching demarcation.
org.springframework.cache.jcache
Implementation package for JSR-107 (javax.cache aka "JCache") based caches.
org.springframework.cache.support
Support classes for the org.springframework.cache package.
org.springframework.cache.transaction
Transaction-aware decorators for the org.springframework.cache package.
Interfaces
Cache
Interface that defines common cache operations.
Cache.ValueWrapper
A (wrapper) object representing a cache value.
CacheManager
Spring's central cache manager SPI.
Exceptions
Cache.ValueRetrievalException
Wrapper exception to be thrown from Cache.get(Object, Callable) in case of the value loader callback failing with an exception.
annotation
@NonNullApi @NonNullFields package org.springframework.cache.annotation Annotations and supporting classes for declarative cache management. Hooked into Spring's cache interception infrastructure via CacheOperationSource.
Related Packages
org.springframework.cache
Spring's generic cache abstraction.
Classes
AbstractCachingConfiguration
Abstract base @Configuration class providing common structure for enabling Spring's annotation-driven cache management capability.
AbstractCachingConfiguration.CachingConfigurerSupplier
AnnotationCacheOperationSource
Implementation of the CacheOperationSource interface for working with caching metadata in annotation format.
CachingConfigurationSelector
Selects which implementation of AbstractCachingConfiguration should be used based on the value of EnableCaching.mode() on the importing @Configuration class.
CachingConfigurerSupport
Deprecated. as of 6.0 in favor of implementing CachingConfigurer directly
ProxyCachingConfiguration
@Configuration class that registers the Spring infrastructure beans necessary to enable proxy-based annotation-driven cache management.
SpringCacheAnnotationParser
Strategy implementation for parsing Spring's Caching , Cacheable , CacheEvict , and CachePut annotations.
Interfaces
AnnotationCacheOperationSource.CacheOperationProvider
Callback interface providing CacheOperation instance(s) based on a given CacheAnnotationParser .
CacheAnnotationParser
Strategy interface for parsing known caching annotation types.
CachingConfigurer
Interface to be implemented by @ Configuration classes annotated with @ EnableCaching that wish or need to specify explicitly how caches are resolved and how keys are generated for annotation-driven cache management.
Annotation Interfaces
Cacheable
Annotation indicating that the result of invoking a method (or all methods in a class) can be cached.
CacheConfig
@CacheConfig provides a mechanism for sharing common cache-related settings at the class level.
CacheEvict
Annotation indicating that a method (or all methods on a class) triggers a cache evict operation.
CachePut
Annotation indicating that a method (or all methods on a class) triggers a cache put operation.
Caching
Group annotation for multiple cache annotations (of different or the same type).
EnableCaching
Enables Spring's annotation-driven cache management capability, similar to the support found in Spring's XML namespace.
aspectj
@NonNullApi @NonNullFields package org.springframework.cache.aspectj AspectJ-based caching support.
Related Packages
org.springframework.cache
Spring's generic cache abstraction.
Classes
AspectJCachingConfiguration
@Configuration class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven cache management.
AspectJJCacheConfiguration
@Configuration class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven cache management for standard JSR-107 annotations.
caffeine
@NonNullApi @NonNullFields package org.springframework.cache.caffeine Support classes for the open source cache in Caffeine library, allowing to set up Caffeine caches within Spring's cache abstraction.
Related Packages
org.springframework.cache
Spring's generic cache abstraction.
Classes
CaffeineCache
Spring Cache adapter implementation on top of a Caffeine Cache instance.
CaffeineCacheManager
CacheManager implementation that lazily builds CaffeineCache instances for each CaffeineCacheManager.getCache(java.lang.String) request.
concurrent
@NonNullApi @NonNullFields package org.springframework.cache.concurrent Implementation package for java.util.concurrent based caches. Provides a CacheManager and Cache implementation for use in a Spring context, using a JDK based thread pool at runtime.
Related Packages
org.springframework.cache
Spring's generic cache abstraction.
Classes
ConcurrentMapCache
Simple Cache implementation based on the core JDK java.util.concurrent package.
ConcurrentMapCacheFactoryBean
FactoryBean for easy configuration of a ConcurrentMapCache when used within a Spring container.
ConcurrentMapCacheManager
CacheManager implementation that lazily builds ConcurrentMapCache instances for each ConcurrentMapCacheManager.getCache(java.lang.String) request.
config
@NonNullApi @NonNullFields package org.springframework.cache.config Support package for declarative caching configuration, with XML schema being the primary configuration format. See EnableCaching for details on code-based configuration without XML.
Related Packages
org.springframework.cache
Spring's generic cache abstraction.
Classes
CacheManagementConfigUtils
Configuration constants for internal sharing across subpackages.
CacheNamespaceHandler
NamespaceHandler allowing for the configuration of declarative cache management using either XML or using annotations.
interceptor
@NonNullApi @NonNullFields package org.springframework.cache.interceptor AOP-based solution for declarative caching demarcation. Builds on the AOP infrastructure in org.springframework.aop.framework. Any POJO can be cache-advised with Spring.
Related Packages
org.springframework.cache
Spring's generic cache abstraction.
Classes
AbstractCacheInvoker
A base component for invoking Cache operations and using a configurable CacheErrorHandler when an exception occurs.
AbstractCacheResolver
A base CacheResolver implementation that requires the concrete implementation to provide the collection of cache name(s) based on the invocation context.
AbstractFallbackCacheOperationSource
Abstract implementation of CacheOperationSource that caches operations for methods and implements a fallback policy: 1.
BeanFactoryCacheOperationSourceAdvisor
Advisor driven by a CacheOperationSource , used to include a cache advice bean for methods that are cacheable.
CacheableOperation
Class describing a cache 'cacheable' operation.
CacheableOperation.Builder
A builder that can be used to create a CacheableOperation .
CacheAspectSupport
Base class for caching aspects, such as the CacheInterceptor or an AspectJ aspect.
CacheAspectSupport.CacheOperationMetadata
Metadata of a cache operation that does not depend on a particular invocation which makes it a good candidate for caching.
CacheEvictOperation
Class describing a cache 'evict' operation.
CacheEvictOperation.Builder
A builder that can be used to create a CacheEvictOperation .
CacheInterceptor
AOP Alliance MethodInterceptor for declarative cache management using the common Spring caching infrastructure ( Cache ).
CacheOperation
Base class for cache operations.
CacheOperation.Builder
Base class for builders that can be used to create a CacheOperation .
CacheProxyFactoryBean
Proxy factory bean for simplified declarative caching handling.
CachePutOperation
Class describing a cache 'put' operation.
CachePutOperation.Builder
A builder that can be used to create a CachePutOperation .
CompositeCacheOperationSource
Composite CacheOperationSource implementation that iterates over a given array of CacheOperationSource instances.
LoggingCacheErrorHandler
A CacheErrorHandler implementation that logs error messages.
NamedCacheResolver
A CacheResolver that forces the resolution to a configurable collection of name(s) against a given CacheManager .
NameMatchCacheOperationSource
Simple CacheOperationSource implementation that allows attributes to be matched by registered name.
SimpleCacheErrorHandler
A simple CacheErrorHandler that does not handle the exception at all, simply throwing it back at the client.
SimpleCacheResolver
A simple CacheResolver that resolves the Cache instance(s) based on a configurable CacheManager and the name of the cache(s) as provided by getCacheNames() .
SimpleKey
A simple key as returned from the SimpleKeyGenerator .
SimpleKeyGenerator
Simple key generator.
Interfaces
BasicOperation
The base interface that all cache operations must implement.
CacheErrorHandler
A strategy for handling cache-related errors.
CacheOperationInvocationContext<O extends BasicOperation>
Representation of the context of the invocation of a cache operation.
CacheOperationInvoker
Abstract the invocation of a cache operation.
CacheOperationSource
Interface used by CacheInterceptor .
CacheResolver
Determine the Cache instance(s) to use for an intercepted method invocation.
KeyGenerator
Cache key generator.
Exceptions
CacheOperationInvoker.ThrowableWrapper
Wrap any exception thrown while invoking CacheOperationInvoker.invoke() .
jcache
jcache
@NonNullApi @NonNullFields package org.springframework.cache.jcache Implementation package for JSR-107 (javax.cache aka "JCache") based caches. Provides a CacheManager and Cache implementation for use in a Spring context, using a JSR-107 compliant cache provider.
Related Packages
org.springframework.cache
Spring's generic cache abstraction.
org.springframework.cache.jcache.config
Support package for declarative JSR-107 caching configuration.
org.springframework.cache.jcache.interceptor
AOP-based solution for declarative caching demarcation using JSR-107 annotations.
Classes
JCacheCache
Cache implementation on top of a javax.cache.Cache instance.
JCacheCacheManager
CacheManager implementation backed by a JCache javax.cache.CacheManager .
JCacheManagerFactoryBean
FactoryBean for a JCache javax.cache.CacheManager , obtaining a pre-defined CacheManager by name through the standard JCache javax.cache.Caching class.
config
@NonNullApi @NonNullFields package org.springframework.cache.jcache.config Support package for declarative JSR-107 caching configuration. Used by Spring's caching configuration when it detects the JSR-107 API and Spring's JCache implementation. Provides an extension of the CachingConfigurer that exposes the exception cache resolver to use (see JCacheConfigurer).
Related Packages
org.springframework.cache.jcache
Implementation package for JSR-107 (javax.cache aka "JCache") based caches.
org.springframework.cache.jcache.interceptor
AOP-based solution for declarative caching demarcation using JSR-107 annotations.
Classes
AbstractJCacheConfiguration
Abstract JSR-107 specific @Configuration class providing common structure for enabling JSR-107 annotation-driven cache management capability.
JCacheConfigurerSupport
Deprecated. as of 6.0 in favor of implementing JCacheConfigurer directly
ProxyJCacheConfiguration
@Configuration class that registers the Spring infrastructure beans necessary to enable proxy-based annotation-driven JSR-107 cache management.
Interfaces
JCacheConfigurer
Extension of CachingConfigurer for the JSR-107 implementation.
interceptor
@NonNullApi @NonNullFields package org.springframework.cache.jcache.interceptor AOP-based solution for declarative caching demarcation using JSR-107 annotations. Strongly based on the infrastructure in org.springframework.cache.interceptor that deals with Spring's caching annotations. Builds on the AOP infrastructure in org.springframework.aop.framework. Any POJO can be cache-advised with Spring.
Related Packages
org.springframework.cache.jcache
Implementation package for JSR-107 (javax.cache aka "JCache") based caches.
org.springframework.cache.jcache.config
Support package for declarative JSR-107 caching configuration.
Classes
AbstractFallbackJCacheOperationSource
Abstract implementation of JCacheOperationSource that caches operations for methods and implements a fallback policy: 1.
AnnotationJCacheOperationSource
Implementation of the JCacheOperationSource interface that reads the JSR-107 CacheResult , CachePut , CacheRemove and CacheRemoveAll annotations.
BeanFactoryJCacheOperationSourceAdvisor
Advisor driven by a JCacheOperationSource , used to include a cache advice bean for methods that are cacheable.
DefaultJCacheOperationSource
The default JCacheOperationSource implementation delegating default operations to configurable services with sensible defaults when not present.
JCacheAspectSupport
Base class for JSR-107 caching aspects, such as the JCacheInterceptor or an AspectJ aspect.
JCacheInterceptor
AOP Alliance MethodInterceptor for declarative cache management using JSR-107 caching annotations.
JCacheOperationSourcePointcut
Deprecated, for removal: This API element is subject to removal in a future version. since 6.0.10, as it is not used by the framework anymore
SimpleExceptionCacheResolver
A simple CacheResolver that resolves the exception cache based on a configurable CacheManager and the name of the cache: CacheResultOperation.getExceptionCacheName() .
Interfaces
JCacheOperation<A extends Annotation>
Model the base of JSR-107 cache operation through an interface contract.
JCacheOperationSource
Interface used by JCacheInterceptor .
support
@NonNullApi @NonNullFields package org.springframework.cache.support Support classes for the org.springframework.cache package. Provides abstract classes for cache managers and caches.
Related Packages
org.springframework.cache
Spring's generic cache abstraction.
Classes
AbstractCacheManager
Abstract base class implementing the common CacheManager methods.
AbstractValueAdaptingCache
Common base class for Cache implementations that need to adapt null values (and potentially other such special values) before passing them on to the underlying store.
CompositeCacheManager
Composite CacheManager implementation that iterates over a given collection of delegate CacheManager instances.
NoOpCache
A no operation Cache implementation suitable for disabling caching.
NoOpCacheManager
A basic, no operation CacheManager implementation suitable for disabling caching, typically used for backing cache declarations without an actual backing store.
NullValue
Simple serializable class that serves as a null replacement for cache stores which otherwise do not support null values.
SimpleCacheManager
Simple cache manager working against a given collection of caches.
SimpleValueWrapper
Straightforward implementation of Cache.ValueWrapper , simply holding the value as given at construction and returning it from SimpleValueWrapper.get() .
transaction
@NonNullApi @NonNullFields package org.springframework.cache.transaction Transaction-aware decorators for the org.springframework.cache package. Provides synchronization of put operations with Spring-managed transactions.
Related Packages
org.springframework.cache
Spring's generic cache abstraction.
Classes
AbstractTransactionSupportingCacheManager
Base class for CacheManager implementations that want to support built-in awareness of Spring-managed transactions.
TransactionAwareCacheDecorator
Cache decorator which synchronizes its TransactionAwareCacheDecorator.put(java.lang.Object, java.lang.Object) , TransactionAwareCacheDecorator.evict(java.lang.Object) and TransactionAwareCacheDecorator.clear() operations with Spring-managed transactions (through Spring's TransactionSynchronizationManager ), performing the actual cache put/evict/clear operation only in the after-commit phase of a successful transaction.
TransactionAwareCacheManagerProxy
Proxy for a target CacheManager , exposing transaction-aware Cache objects which synchronize their Cache.put(java.lang.Object, java.lang.Object) operations with Spring-managed transactions (through Spring's TransactionSynchronizationManager ), performing the actual cache put operation only in the after-commit phase of a successful transaction.
cglib
cglib
package org.springframework.cglib Spring's repackaging of CGLIB 3.3 (with Spring-specific patches; for internal use only). This repackaging technique avoids any potential conflicts with dependencies on CGLIB at the application level or from third-party libraries and frameworks.
Related Packages
org.springframework.cglib.beans
Spring's repackaging of the CGLIB beans package (for internal use only).
org.springframework.cglib.core
Spring's repackaging of the CGLIB core package (for internal use only).
org.springframework.cglib.proxy
Spring's repackaging of the CGLIB proxy package (for internal use only).
org.springframework.cglib.reflect
Spring's repackaging of the CGLIB reflect package (for internal use only).
org.springframework.cglib.transform
Spring's repackaging of the CGLIB transform package (for internal use only).
org.springframework.cglib.util
Spring's repackaging of the CGLIB util package (for internal use only).
Classes
SpringCglibInfo
Empty class used to ensure that the org.springframework.cglib package is processed during javadoc generation.
beans
package org.springframework.cglib.beans Spring's repackaging of the CGLIB beans package (for internal use only).
Related Packages
org.springframework.cglib
Spring's repackaging of CGLIB 3.3 (with Spring-specific patches; for internal use only).
org.springframework.cglib.core
Spring's repackaging of the CGLIB core package (for internal use only).
org.springframework.cglib.proxy
Spring's repackaging of the CGLIB proxy package (for internal use only).
org.springframework.cglib.reflect
Spring's repackaging of the CGLIB reflect package (for internal use only).
org.springframework.cglib.transform
Spring's repackaging of the CGLIB transform package (for internal use only).
org.springframework.cglib.util
Spring's repackaging of the CGLIB util package (for internal use only).
Classes
BeanCopier
BeanCopier.Generator
BeanGenerator
BeanMap
A Map -based view of a JavaBean.
BeanMap.Generator
BulkBean
BulkBean.Generator
FixedKeySet
ImmutableBean
ImmutableBean.Generator
Exceptions
BulkBeanException
core
core
package org.springframework.cglib.core Spring's repackaging of the CGLIB core package (for internal use only).
Related Packages
org.springframework.cglib
Spring's repackaging of CGLIB 3.3 (with Spring-specific patches; for internal use only).
org.springframework.cglib.core.internal
Spring's repackaging of the CGLIB core internal package (for internal use only).
org.springframework.cglib.beans
Spring's repackaging of the CGLIB beans package (for internal use only).
org.springframework.cglib.proxy
Spring's repackaging of the CGLIB proxy package (for internal use only).
org.springframework.cglib.reflect
Spring's repackaging of the CGLIB reflect package (for internal use only).
org.springframework.cglib.transform
Spring's repackaging of the CGLIB transform package (for internal use only).
org.springframework.cglib.util
Spring's repackaging of the CGLIB util package (for internal use only).
Classes
AbstractClassGenerator<T>
Abstract class for all code-generating CGLIB utilities.
AbstractClassGenerator.ClassLoaderData
AbstractClassGenerator.Source
Block
ClassEmitter
ClassesKey
ClassInfo
ClassLoaderAwareGeneratorStrategy
CGLIB GeneratorStrategy variant which exposes the application ClassLoader as current thread context ClassLoader for the time of class generation.
ClassNameReader
ClassTransformer
CodeEmitter
CollectionUtils
DebuggingClassWriter
DefaultGeneratorStrategy
DefaultNamingPolicy
The default policy used by AbstractClassGenerator .
DuplicatesPredicate
EmitUtils
EmitUtils.ArrayDelimiters
KeyFactory
Generates classes to handle multi-valued keys, for use in things such as Maps and Sets.
KeyFactory.Generator
Local
LocalVariablesSorter
A MethodVisitor that renumbers local variables in their order of appearance.
MethodInfo
MethodInfoTransformer
MethodWrapper
ReflectUtils
RejectModifierPredicate
Signature
A representation of a method signature, containing the method name, return type, and parameter types.
SpringNamingPolicy
Custom variant of CGLIB's DefaultNamingPolicy , modifying the tag in generated class names from "EnhancerByCGLIB" etc to a "SpringCGLIB" tag and using a plain counter suffix instead of a hash code suffix (as of 6.0).
TinyBitSet
Deprecated.
TypeUtils
VisibilityPredicate
WeakCacheKey<T>
Allows to check for object equality, yet the class does not keep strong reference to the target.
Interfaces
ClassGenerator
Constants
Converter
Customizer
Customizes key types for KeyFactory when building equals, hashCode, and toString.
FieldTypeCustomizer
Customizes key types for KeyFactory right in constructor.
GeneratorStrategy
The GeneratorStrategy is responsible for taking a ClassGenerator and producing a byte array containing the data for the generated Class .
HashCodeCustomizer
KeyFactoryCustomizer
Marker interface for customizers of KeyFactory
NamingPolicy
Customize the generated class name for AbstractClassGenerator -based utilities.
ObjectSwitchCallback
Predicate
ProcessArrayCallback
ProcessSwitchCallback
Transformer
Exceptions
CodeGenerationException
internal
package org.springframework.cglib.core.internal Spring's repackaging of the CGLIB core internal package (for internal use only).
Related Packages
org.springframework.cglib.core
Spring's repackaging of the CGLIB core package (for internal use only).
Classes
CustomizerRegistry
LoadingCache<K, KK, V>
Interfaces
Function<K, V>
proxy
package org.springframework.cglib.proxy Spring's repackaging of the CGLIB proxy package (for internal use only).
Related Packages
org.springframework.cglib
Spring's repackaging of CGLIB 3.3 (with Spring-specific patches; for internal use only).
org.springframework.cglib.beans
Spring's repackaging of the CGLIB beans package (for internal use only).
org.springframework.cglib.core
Spring's repackaging of the CGLIB core package (for internal use only).
org.springframework.cglib.reflect
Spring's repackaging of the CGLIB reflect package (for internal use only).
org.springframework.cglib.transform
Spring's repackaging of the CGLIB transform package (for internal use only).
org.springframework.cglib.util
Spring's repackaging of the CGLIB util package (for internal use only).
Interfaces
Callback
All callback interfaces used by Enhancer extend this interface.
CallbackFilter
Map methods of subclasses generated by Enhancer to a particular callback.
Dispatcher
Dispatching Enhancer callback.
Factory
All enhanced instances returned by the Enhancer class implement this interface.
FixedValue
Enhancer callback that simply returns the value to return from the proxied method.
InvocationHandler
InvocationHandler replacement (unavailable under JDK 1.2).
LazyLoader
Lazy-loading Enhancer callback.
MethodInterceptor
General-purpose Enhancer callback which provides for "around advice".
NoOp
Methods using this Enhancer callback will delegate directly to the default (super) implementation in the base class.
ProxyRefDispatcher
Dispatching Enhancer callback.
Classes
CallbackHelper
Enhancer
Generates dynamic subclasses to enable method interception.
InterfaceMaker
Generates new interfaces at runtime.
MethodProxy
Classes generated by Enhancer pass this object to the registered MethodInterceptor objects when an intercepted method is invoked.
Mixin
Mixin allows multiple objects to be combined into a single larger object.
Mixin.Generator
Proxy
This class is meant to be used as replacement for java.lang.reflect.Proxy under JDK 1.2.
Exceptions
UndeclaredThrowableException
Used by Proxy as a replacement for java.lang.reflect.UndeclaredThrowableException .
reflect
package org.springframework.cglib.reflect Spring's repackaging of the CGLIB reflect package (for internal use only).
Related Packages
org.springframework.cglib
Spring's repackaging of CGLIB 3.3 (with Spring-specific patches; for internal use only).
org.springframework.cglib.beans
Spring's repackaging of the CGLIB beans package (for internal use only).
org.springframework.cglib.core
Spring's repackaging of the CGLIB core package (for internal use only).
org.springframework.cglib.proxy
Spring's repackaging of the CGLIB proxy package (for internal use only).
org.springframework.cglib.transform
Spring's repackaging of the CGLIB transform package (for internal use only).
org.springframework.cglib.util
Spring's repackaging of the CGLIB util package (for internal use only).
Classes
ConstructorDelegate
ConstructorDelegate.Generator
FastClass
FastClass.Generator
FastConstructor
FastMember
FastMethod
MethodDelegate
DOCUMENTATION FROM APACHE AVALON DELEGATE CLASS
MethodDelegate.Generator
MulticastDelegate
MulticastDelegate.Generator
transform
transform
package org.springframework.cglib.transform Spring's repackaging of the CGLIB transform package (for internal use only).
Related Packages
org.springframework.cglib
Spring's repackaging of CGLIB 3.3 (with Spring-specific patches; for internal use only).
org.springframework.cglib.transform.impl
Spring's repackaging of the CGLIB transform impl package (for internal use only).
org.springframework.cglib.beans
Spring's repackaging of the CGLIB beans package (for internal use only).
org.springframework.cglib.core
Spring's repackaging of the CGLIB core package (for internal use only).
org.springframework.cglib.proxy
Spring's repackaging of the CGLIB proxy package (for internal use only).
org.springframework.cglib.reflect
Spring's repackaging of the CGLIB reflect package (for internal use only).
org.springframework.cglib.util
Spring's repackaging of the CGLIB util package (for internal use only).
Classes
AbstractClassFilterTransformer
AbstractClassLoader
AbstractClassTransformer
AnnotationVisitorTee
ClassEmitterTransformer
ClassFilterTransformer
ClassReaderGenerator
ClassTransformerChain
ClassTransformerTee
ClassVisitorTee
FieldVisitorTee
MethodFilterTransformer
MethodVisitorTee
TransformingClassGenerator
TransformingClassLoader
Interfaces
ClassFilter
ClassTransformerFactory
MethodFilter
impl
package org.springframework.cglib.transform.impl Spring's repackaging of the CGLIB transform impl package (for internal use only).
Related Packages
org.springframework.cglib.transform
Spring's repackaging of the CGLIB transform package (for internal use only).
Classes
AbstractInterceptFieldCallback
AccessFieldTransformer
AddDelegateTransformer
AddInitTransformer
AddPropertyTransformer
AddStaticInitTransformer
FieldProviderTransformer
InterceptFieldTransformer
UndeclaredThrowableStrategy
A GeneratorStrategy suitable for use with Enhancer which causes all undeclared exceptions thrown from within a proxied method to be wrapped in an alternative exception of your choice.
UndeclaredThrowableTransformer
Interfaces
AccessFieldTransformer.Callback
FieldProvider
InterceptFieldCallback
InterceptFieldEnabled
InterceptFieldFilter
util
package org.springframework.cglib.util Spring's repackaging of the CGLIB util package (for internal use only).
Related Packages
org.springframework.cglib
Spring's repackaging of CGLIB 3.3 (with Spring-specific patches; for internal use only).
org.springframework.cglib.beans
Spring's repackaging of the CGLIB beans package (for internal use only).
org.springframework.cglib.core
Spring's repackaging of the CGLIB core package (for internal use only).
org.springframework.cglib.proxy
Spring's repackaging of the CGLIB proxy package (for internal use only).
org.springframework.cglib.reflect
Spring's repackaging of the CGLIB reflect package (for internal use only).
org.springframework.cglib.transform
Spring's repackaging of the CGLIB transform package (for internal use only).
Classes
ParallelSorter
For the efficient sorting of multiple arrays in parallel.
ParallelSorter.Generator
StringSwitcher
This class implements a simple String → int mapping for a fixed set of keys.
StringSwitcher.Generator
context
context
@NonNullApi @NonNullFields package org.springframework.context This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API. There is no necessity for Spring applications to depend on ApplicationContext or even BeanFactory functionality explicitly. One of the strengths of the Spring architecture is that application objects can often be configured without any dependency on Spring-specific APIs.
Related Packages
org.springframework.context.annotation
Annotation support for the Application Context, including JSR-250 "common" annotations, component-scanning, and Java-based metadata for creating Spring-managed objects.
org.springframework.context.aot
AOT support for application contexts.
org.springframework.context.config
Support package for advanced application context configuration, with XML schema being the primary configuration format.
org.springframework.context.event
Support classes for application events, like standard context events.
org.springframework.context.expression
Expression parsing support within a Spring application context.
org.springframework.context.i18n
Abstraction for determining the current Locale, plus global holder that exposes a thread-bound Locale.
org.springframework.context.index
Support package for reading and managing the components index.
org.springframework.context.support
Classes supporting the org.springframework.context package, such as abstract base classes for ApplicationContext implementations and a MessageSource implementation.
org.springframework.context.weaving
Load-time weaving support for a Spring application context, building on Spring's LoadTimeWeaver abstraction.
Interfaces
ApplicationContext
Central interface to provide configuration for an application.
ApplicationContextAware
Interface to be implemented by any object that wishes to be notified of the ApplicationContext that it runs in.
ApplicationContextInitializer<C extends ConfigurableApplicationContext>
Callback interface for initializing a Spring ConfigurableApplicationContext prior to being refreshed .
ApplicationEventPublisher
Interface that encapsulates event publication functionality.
ApplicationEventPublisherAware
Interface to be implemented by any object that wishes to be notified of the ApplicationEventPublisher (typically the ApplicationContext) that it runs in.
ApplicationListener<E extends ApplicationEvent>
Interface to be implemented by application event listeners.
ApplicationStartupAware
Interface to be implemented by any object that wishes to be notified of the ApplicationStartup that it runs with.
ConfigurableApplicationContext
SPI interface to be implemented by most if not all application contexts.
EmbeddedValueResolverAware
Interface to be implemented by any object that wishes to be notified of a StringValueResolver for the resolution of embedded definition values.
EnvironmentAware
Interface to be implemented by any bean that wishes to be notified of the Environment that it runs in.
HierarchicalMessageSource
Sub-interface of MessageSource to be implemented by objects that can resolve messages hierarchically.
Lifecycle
A common interface defining methods for start/stop lifecycle control.
LifecycleProcessor
Strategy interface for processing Lifecycle beans within the ApplicationContext.
MessageSource
Strategy interface for resolving messages, with support for the parameterization and internationalization of such messages.
MessageSourceAware
Interface to be implemented by any object that wishes to be notified of the MessageSource (typically the ApplicationContext) that it runs in.
MessageSourceResolvable
Interface for objects that are suitable for message resolution in a MessageSource .
Phased
Interface for objects that may participate in a phased process such as lifecycle management.
ResourceLoaderAware
Interface to be implemented by any object that wishes to be notified of the ResourceLoader (typically the ApplicationContext) that it runs in.
SmartLifecycle
An extension of the Lifecycle interface for those objects that require to be started upon ApplicationContext refresh and/or shutdown in a particular order.
Exceptions
ApplicationContextException
Exception thrown during application context initialization.
NoSuchMessageException
Exception thrown when a message can't be resolved.
Classes
ApplicationEvent
Class to be extended by all application events.
PayloadApplicationEvent<T>
An ApplicationEvent that carries an arbitrary payload.
annotation
annotation
@NonNullApi @NonNullFields package org.springframework.context.annotation Annotation support for the Application Context, including JSR-250 "common" annotations, component-scanning, and Java-based metadata for creating Spring-managed objects.
Related Packages
org.springframework.context
This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API.
org.springframework.context.annotation.aspectj
AspectJ-based dependency injection support driven by the @Configurable annotation.
Enum Classes
AdviceMode
Enumeration used to determine whether JDK proxy-based or AspectJ weaving-based advice should be applied.
ConfigurationCondition.ConfigurationPhase
The various configuration phases where the condition could be evaluated.
EnableLoadTimeWeaving.AspectJWeaving
AspectJ weaving enablement options.
FilterType
Enumeration of the type filters that may be used in conjunction with @ComponentScan .
ScopedProxyMode
Enumerates the various scoped-proxy options.
Classes
AdviceModeImportSelector<A extends Annotation>
Convenient base class for ImportSelector implementations that select imports based on an AdviceMode value from an annotation (such as the @Enable* annotations).
AnnotatedBeanDefinitionReader
Convenient adapter for programmatic registration of bean classes.
AnnotationBeanNameGenerator
BeanNameGenerator implementation for bean classes annotated with the @Component annotation or with another annotation that is itself annotated with @Component as a meta-annotation.
AnnotationConfigApplicationContext
Standalone application context, accepting component classes as input — in particular @Configuration -annotated classes, but also plain @Component types and JSR-330 compliant classes using jakarta.inject annotations.
AnnotationConfigBeanDefinitionParser
Parser for the element.
AnnotationConfigUtils
Utility class that allows for convenient registration of common BeanPostProcessor and BeanFactoryPostProcessor definitions for annotation-based configuration.
AnnotationScopeMetadataResolver
A ScopeMetadataResolver implementation that by default checks for the presence of Spring's @Scope annotation on the bean class.
AutoProxyRegistrar
Registers an auto proxy creator against the current BeanDefinitionRegistry as appropriate based on an @Enable* annotation having mode and proxyTargetClass attributes set to the correct values.
ClassPathBeanDefinitionScanner
A bean definition scanner that detects bean candidates on the classpath, registering corresponding bean definitions with a given registry ( BeanFactory or ApplicationContext ).
ClassPathScanningCandidateComponentProvider
A component provider that scans for candidate components starting from a specified base package.
CommonAnnotationBeanPostProcessor
BeanPostProcessor implementation that supports common Java annotations out of the box, in particular the common annotations in the jakarta.annotation package.
CommonAnnotationBeanPostProcessor.LookupElement
Class representing generic injection information about an annotated field or setter method, supporting @Resource and related annotations.
ComponentScanBeanDefinitionParser
Parser for the element.
ConfigurationClassPostProcessor
BeanFactoryPostProcessor used for bootstrapping processing of @Configuration classes.
ConfigurationClassUtils
Utilities for identifying and configuring Configuration classes.
ContextAnnotationAutowireCandidateResolver
Complete implementation of the AutowireCandidateResolver strategy interface, providing support for qualifier annotations as well as for lazy resolution driven by the Lazy annotation in the context.annotation package.
DeferredImportSelector.Group.Entry
An entry that holds the AnnotationMetadata of the importing Configuration class and the class name to import.
FullyQualifiedAnnotationBeanNameGenerator
An extension of AnnotationBeanNameGenerator that uses the fully qualified class name as the default bean name if an explicit bean name is not supplied via a supported type-level annotation such as @Component (see AnnotationBeanNameGenerator for details on supported annotations).
ImportAwareAotBeanPostProcessor
A BeanPostProcessor that honours ImportAware callback using a mapping computed at build time.
Jsr330ScopeMetadataResolver
Simple ScopeMetadataResolver implementation that follows JSR-330 scoping rules: defaulting to prototype scope unless Singleton is present.
LoadTimeWeavingConfiguration
@Configuration class that registers a LoadTimeWeaver bean.
MBeanExportConfiguration
@Configuration class that registers a AnnotationMBeanExporter bean.
ResourceElementResolver
Resolver for the injection of named beans on a field or method element, following the rules of the Resource annotation but without any JNDI support.
ScannedGenericBeanDefinition
Extension of the GenericBeanDefinition class, based on an ASM ClassReader, with support for annotation metadata exposed through the AnnotatedBeanDefinition interface.
ScopeMetadata
Describes scope characteristics for a Spring-managed bean including the scope name and the scoped-proxy behavior.
TypeFilterUtils
Collection of utilities for working with @ComponentScan type filters .
Interfaces
AnnotationConfigRegistry
Common interface for annotation config application contexts, defining AnnotationConfigRegistry.register(java.lang.Class...) and AnnotationConfigRegistry.scan(java.lang.String...) methods.
Condition
A single condition that must be matched in order for a component to be registered.
ConditionContext
Context information for use by Condition implementations.
ConfigurationCondition
A Condition that offers more fine-grained control when used with @Configuration .
DeferredImportSelector
A variation of ImportSelector that runs after all @Configuration beans have been processed.
DeferredImportSelector.Group
Interface used to group results from different import selectors.
ImportAware
Interface to be implemented by any @ Configuration class that wishes to be injected with the AnnotationMetadata of the @ Configuration class that imported it.
ImportBeanDefinitionRegistrar
Interface to be implemented by types that register additional bean definitions when processing @ Configuration classes.
ImportSelector
Interface to be implemented by types that determine which @ Configuration class(es) should be imported based on a given selection criteria, usually one or more annotation attributes.
LoadTimeWeavingConfigurer
Interface to be implemented by @Configuration classes annotated with @EnableLoadTimeWeaving that wish to customize the LoadTimeWeaver instance to be used.
ScopeMetadataResolver
Strategy interface for resolving the scope of bean definitions.
Annotation Interfaces
Bean
Indicates that a method produces a bean to be managed by the Spring container.
ComponentScan
Configures component scanning directives for use with @Configuration classes.
ComponentScan.Filter
Declares the type filter to be used as an include filter or exclude filter .
ComponentScans
Container annotation that aggregates several ComponentScan annotations.
Conditional
Indicates that a component is only eligible for registration when all specified conditions match.
Configuration
Indicates that a class declares one or more @Bean methods and may be processed by the Spring container to generate bean definitions and service requests for those beans at runtime, for example:
DependsOn
Beans on which the current bean depends.
Description
Adds a textual description to bean definitions derived from Component or Bean .
EnableAspectJAutoProxy
Enables support for handling components marked with AspectJ's @Aspect annotation, similar to functionality found in Spring's XML element.
EnableLoadTimeWeaving
Activates a Spring LoadTimeWeaver for this application context, available as a bean with the name "loadTimeWeaver", similar to the element in Spring XML.
EnableMBeanExport
Enables default exporting of all standard MBean s from the Spring context, as well as all @ManagedResource annotated beans.
Import
Indicates one or more component classes to import — typically @Configuration classes.
ImportResource
Indicates one or more resources containing bean definitions to import.
ImportRuntimeHints
Indicates that one or more RuntimeHintsRegistrar implementations should be processed.
Lazy
Indicates whether a bean is to be lazily initialized.
Primary
Indicates that a bean should be given preference when multiple candidates are qualified to autowire a single-valued dependency.
Profile
Indicates that a component is eligible for registration when one or more specified profiles are active.
PropertySource
Annotation providing a convenient and declarative mechanism for adding a PropertySource to Spring's Environment .
PropertySources
Container annotation that aggregates several PropertySource annotations.
Role
Indicates the 'role' hint for a given bean.
Scope
When used as a type-level annotation in conjunction with @Component , @Scope indicates the name of a scope to use for instances of the annotated type.
aspectj
@NonNullApi @NonNullFields package org.springframework.context.annotation.aspectj AspectJ-based dependency injection support driven by the @Configurable annotation.
Related Packages
org.springframework.context.annotation
Annotation support for the Application Context, including JSR-250 "common" annotations, component-scanning, and Java-based metadata for creating Spring-managed objects.
Annotation Interfaces
EnableSpringConfigured
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).
Classes
SpringConfiguredConfiguration
@Configuration class that registers an AnnotationBeanConfigurerAspect capable of performing dependency injection services for non-Spring managed objects annotated with @ Configurable .
aot
@NonNullApi @NonNullFields package org.springframework.context.aot AOT support for application contexts.
Related Packages
org.springframework.context
This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API.
Classes
AbstractAotProcessor<T>
Abstract base class for filesystem-based ahead-of-time (AOT) processing.
AbstractAotProcessor.Settings
Common settings for AOT processors.
AbstractAotProcessor.Settings.Builder
Fluent builder API for AbstractAotProcessor.Settings .
ApplicationContextAotGenerator
Process an ApplicationContext and its BeanFactory to generate code that represents the state of the bean factory, as well as the necessary hints that can be used at runtime in a constrained environment.
ContextAotProcessor
Filesystem-based ahead-of-time (AOT) processing base implementation.
Interfaces
AotApplicationContextInitializer<C extends ConfigurableApplicationContext>
Specialized ApplicationContextInitializer used to initialize a ConfigurableApplicationContext using artifacts that were generated ahead-of-time.
config
@NonNullApi @NonNullFields package org.springframework.context.config Support package for advanced application context configuration, with XML schema being the primary configuration format.
Related Packages
org.springframework.context
This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API.
Classes
ContextNamespaceHandler
NamespaceHandler for the ' context ' namespace.
event
@NonNullApi @NonNullFields package org.springframework.context.event Support classes for application events, like standard context events. To be supported by all major application context implementations.
Related Packages
org.springframework.context
This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API.
Classes
AbstractApplicationEventMulticaster
Abstract implementation of the ApplicationEventMulticaster interface, providing the basic listener registration facility.
ApplicationContextEvent
Base class for events raised for an ApplicationContext .
ApplicationListenerMethodAdapter
GenericApplicationListener adapter that delegates the processing of an event to an EventListener annotated method.
ContextClosedEvent
Event raised when an ApplicationContext gets closed.
ContextRefreshedEvent
Event raised when an ApplicationContext gets initialized or refreshed.
ContextStartedEvent
Event raised when an ApplicationContext gets started.
ContextStoppedEvent
Event raised when an ApplicationContext gets stopped.
DefaultEventListenerFactory
Default EventListenerFactory implementation that supports the regular EventListener annotation.
EventListenerMethodProcessor
Registers EventListener methods as individual ApplicationListener instances.
EventPublicationInterceptor
Interceptor that publishes an ApplicationEvent to all ApplicationListeners registered with an ApplicationEventPublisher after each successful method invocation.
GenericApplicationListenerAdapter
GenericApplicationListener adapter that determines supported event types through introspecting the generically declared type of the target listener.
SimpleApplicationEventMulticaster
Simple implementation of the ApplicationEventMulticaster interface.
SourceFilteringListener
ApplicationListener decorator that filters events from a specified event source, invoking its delegate listener for matching ApplicationEvent objects only.
Interfaces
ApplicationEventMulticaster
Interface to be implemented by objects that can manage a number of ApplicationListener objects and publish events to them.
EventListenerFactory
Strategy interface for creating ApplicationListener for methods annotated with EventListener .
GenericApplicationListener
Extended variant of the standard ApplicationListener interface, exposing further metadata such as the supported event and source type.
SmartApplicationListener
Extended variant of the standard ApplicationListener interface, exposing further metadata such as the supported event and source type.
Annotation Interfaces
EventListener
Annotation that marks a method as a listener for application events.
expression
@NonNullApi @NonNullFields package org.springframework.context.expression Expression parsing support within a Spring application context.
Related Packages
org.springframework.context
This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API.
Classes
AnnotatedElementKey
Represent an AnnotatedElement on a particular Class and is suitable as a key.
BeanExpressionContextAccessor
EL property accessor that knows how to traverse the beans and contextual objects of a Spring BeanExpressionContext .
BeanFactoryAccessor
EL property accessor that knows how to traverse the beans of a Spring BeanFactory .
BeanFactoryResolver
EL bean resolver that operates against a Spring BeanFactory .
CachedExpressionEvaluator
Shared utility class used to evaluate and cache SpEL expressions that are defined on AnnotatedElement .
CachedExpressionEvaluator.ExpressionKey
An expression key.
EnvironmentAccessor
Read-only EL property accessor that knows how to retrieve keys of a Spring Environment instance.
MapAccessor
EL property accessor that knows how to traverse the keys of a standard Map .
MethodBasedEvaluationContext
A method-based EvaluationContext that provides explicit support for method-based invocations.
StandardBeanExpressionResolver
Standard implementation of the BeanExpressionResolver interface, parsing and evaluating Spring EL using Spring's expression module.
i18n
@NonNullApi @NonNullFields package org.springframework.context.i18n Abstraction for determining the current Locale, plus global holder that exposes a thread-bound Locale.
Related Packages
org.springframework.context
This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API.
Interfaces
LocaleContext
Strategy interface for determining the current Locale.
TimeZoneAwareLocaleContext
Extension of LocaleContext , adding awareness of the current time zone.
Classes
LocaleContextHolder
Simple holder class that associates a LocaleContext instance with the current thread.
SimpleLocaleContext
Simple implementation of the LocaleContext interface, always returning a specified Locale .
SimpleTimeZoneAwareLocaleContext
Simple implementation of the TimeZoneAwareLocaleContext interface, always returning a specified Locale and TimeZone .
index
index
@NonNullApi @NonNullFields package org.springframework.context.index Support package for reading and managing the components index.
Related Packages
org.springframework.context
This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API.
org.springframework.context.index.processor
Core package for Spring Framework's scanned component index.
Classes
CandidateComponentsIndex
Deprecated, for removal: This API element is subject to removal in a future version. as of 6.1, in favor of the AOT engine.
CandidateComponentsIndexLoader
Deprecated, for removal: This API element is subject to removal in a future version. as of 6.1, in favor of the AOT engine.
processor
package org.springframework.context.index.processor Core package for Spring Framework's scanned component index.
Related Packages
org.springframework.context.index
Support package for reading and managing the components index.
Classes
CandidateComponentsIndexer
Deprecated, for removal: This API element is subject to removal in a future version. as of 6.1, in favor of the AOT engine.
support
@NonNullApi @NonNullFields package org.springframework.context.support Classes supporting the org.springframework.context package, such as abstract base classes for ApplicationContext implementations and a MessageSource implementation.
Related Packages
org.springframework.context
This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API.
Classes
AbstractApplicationContext
Abstract implementation of the ApplicationContext interface.
AbstractMessageSource
Abstract implementation of the HierarchicalMessageSource interface, implementing common handling of message variants, making it easy to implement a specific strategy for a concrete MessageSource.
AbstractRefreshableApplicationContext
Base class for ApplicationContext implementations which are supposed to support multiple calls to AbstractApplicationContext.refresh() , creating a new internal bean factory instance every time.
AbstractRefreshableConfigApplicationContext
AbstractRefreshableApplicationContext subclass that adds common handling of specified config locations.
AbstractResourceBasedMessageSource
Abstract base class for MessageSource implementations based on resource bundle conventions, such as ResourceBundleMessageSource and ReloadableResourceBundleMessageSource .
AbstractXmlApplicationContext
Convenient base class for ApplicationContext implementations, drawing configuration from XML documents containing bean definitions understood by an XmlBeanDefinitionReader .
ApplicationObjectSupport
Convenient superclass for application objects that want to be aware of the application context, e.g.
ClassPathXmlApplicationContext
Standalone XML application context, taking the context definition files from the class path, interpreting plain paths as class path resource names that include the package path (e.g.
ConversionServiceFactoryBean
A factory providing convenient access to a ConversionService configured with converters appropriate for most environments.
DefaultLifecycleProcessor
Spring's default implementation of the LifecycleProcessor strategy.
DefaultMessageSourceResolvable
Spring's default implementation of the MessageSourceResolvable interface.
DelegatingMessageSource
Empty MessageSource that delegates all calls to the parent MessageSource.
EmbeddedValueResolutionSupport
Convenient base class for components with a need for embedded value resolution (i.e.
FileSystemXmlApplicationContext
Standalone XML application context, taking the context definition files from the file system or from URLs, interpreting plain paths as relative file system locations (e.g.
GenericApplicationContext
Generic ApplicationContext implementation that holds a single internal DefaultListableBeanFactory instance and does not assume a specific bean definition format.
GenericGroovyApplicationContext
An ApplicationContext implementation that extends GenericApplicationContext and implements GroovyObject such that beans can be retrieved with the dot de-reference syntax instead of using AbstractApplicationContext.getBean(java.lang.String) .
GenericXmlApplicationContext
Convenient application context with built-in XML support.
MessageSourceAccessor
Helper class for easy access to messages from a MessageSource, providing various overloaded getMessage methods.
MessageSourceResourceBundle
Helper class that allows for accessing a Spring MessageSource as a ResourceBundle .
MessageSourceSupport
Base class for message source implementations, providing support infrastructure such as MessageFormat handling but not implementing concrete methods defined in the MessageSource .
PropertySourcesPlaceholderConfigurer
Specialization of PlaceholderConfigurerSupport that resolves ${...} placeholders within bean definition property values and @Value annotations against the current Spring Environment and its set of PropertySources .
ReloadableResourceBundleMessageSource
Spring-specific MessageSource implementation that accesses resource bundles using specified basenames, participating in the Spring ApplicationContext 's resource loading.
ResourceBundleMessageSource
MessageSource implementation that accesses resource bundles using specified basenames.
SimpleThreadScope
A simple thread-backed Scope implementation.
StaticApplicationContext
ApplicationContext implementation which supports programmatic registration of beans and messages, rather than reading bean definitions from external configuration sources.
StaticMessageSource
Simple implementation of MessageSource which allows messages to be registered programmatically.
weaving
@NonNullApi @NonNullFields package org.springframework.context.weaving Load-time weaving support for a Spring application context, building on Spring's LoadTimeWeaver abstraction.
Related Packages
org.springframework.context
This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API.
Classes
AspectJWeavingEnabler
Post-processor that registers AspectJ's ClassPreProcessorAgentAdapter with the Spring application context's default LoadTimeWeaver .
DefaultContextLoadTimeWeaver
Default LoadTimeWeaver bean for use in an application context, decorating an automatically detected internal LoadTimeWeaver .
LoadTimeWeaverAwareProcessor
BeanPostProcessor implementation that passes the context's default LoadTimeWeaver to beans that implement the LoadTimeWeaverAware interface.
Interfaces
LoadTimeWeaverAware
Interface to be implemented by any object that wishes to be notified of the application context's default LoadTimeWeaver .
core
core
@NonNullApi @NonNullFields package org.springframework.core Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
Related Packages
org.springframework.core.annotation
Core support package for annotations, meta-annotations, and merged annotations with attribute overrides.
org.springframework.core.codec
Encoder and Decoder abstractions to convert between a reactive stream of bytes and Java objects.
org.springframework.core.convert
Type conversion system API.
org.springframework.core.env
Spring's environment abstraction consisting of bean definition profile and hierarchical property source support.
org.springframework.core.io
Generic abstraction for (file-based) resources, used throughout the framework.
org.springframework.core.log
Useful delegates for Spring's logging conventions.
org.springframework.core.metrics
Support package for recording metrics during application startup.
org.springframework.core.serializer
Root package for Spring's serializer interfaces and implementations.
org.springframework.core.style
Support for styling values as Strings, with ToStringCreator as central class.
org.springframework.core.task
This package defines Spring's core TaskExecutor abstraction, and provides SyncTaskExecutor and SimpleAsyncTaskExecutor implementations.
org.springframework.core.type
Core support package for type introspection.
Interfaces
AliasRegistry
Common interface for managing aliases.
AttributeAccessor
Interface defining a generic contract for attaching and accessing metadata to/from arbitrary objects.
DecoratingProxy
Interface to be implemented by decorating proxies, in particular Spring AOP proxies but potentially also custom proxies with decorator semantics.
InfrastructureProxy
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.
MethodIntrospector.MetadataLookup<T>
A callback interface for metadata lookup on a given method.
OrderComparator.OrderSourceProvider
Strategy interface to provide an order source for a given object.
Ordered
Ordered is an interface that can be implemented by objects that should be orderable , for example in a Collection .
ParameterNameDiscoverer
Interface to discover parameter names for methods and constructors.
PriorityOrdered
Extension of the Ordered interface, expressing a priority ordering: PriorityOrdered objects are always applied before plain Ordered objects regardless of their order values.
ResolvableTypeProvider
Any object can implement this interface to provide its actual ResolvableType .
SmartClassLoader
Interface to be implemented by a reloading-aware ClassLoader (e.g.
Classes
AttributeAccessorSupport
Support class for AttributeAccessors , providing a base implementation of all methods.
BridgeMethodResolver
Helper for resolving synthetic bridge Methods to the Method being bridged.
CollectionFactory
Factory for collections that is aware of common Java and Spring collection types.
ConfigurableObjectInputStream
Special ObjectInputStream subclass that resolves class names against a specific ClassLoader .
Constants
Deprecated. since 6.1 with no replacement; use an enum, map, or similar custom solution instead
Conventions
Provides methods to support various naming and other conventions used throughout the framework.
CoroutinesUtils
Utilities for working with Kotlin Coroutines.
DecoratingClassLoader
Base class for decorating ClassLoaders such as OverridingClassLoader and ShadowingClassLoader , providing common handling of excluded packages and classes.
DefaultParameterNameDiscoverer
Default implementation of the ParameterNameDiscoverer strategy interface, delegating to the Java 8 standard reflection mechanism.
ExceptionDepthComparator
Comparator capable of sorting exceptions based on their depth from the thrown exception type.
GenericTypeResolver
Helper class for resolving generic types against type variables.
KotlinDetector
A common delegate for detecting Kotlin's presence and for identifying Kotlin types.
KotlinReflectionParameterNameDiscoverer
ParameterNameDiscoverer implementation which uses Kotlin's reflection facilities for introspecting parameter names.
MethodClassKey
A common key class for a method against a specific target class, including MethodClassKey.toString() representation and Comparable support (as suggested for custom HashMap keys as of Java 8).
MethodIntrospector
Defines the algorithm for searching for metadata-associated methods exhaustively including interfaces and parent classes while also dealing with parameterized methods as well as common scenarios encountered with interface and class-based proxies.
MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
NamedInheritableThreadLocal<T>
InheritableThreadLocal subclass that exposes a specified name as NamedInheritableThreadLocal.toString() result (allowing for introspection).
NamedThreadLocal<T>
ThreadLocal subclass that exposes a specified name as NamedThreadLocal.toString() result (allowing for introspection).
NativeDetector
A common delegate for detecting a GraalVM native image environment.
NestedExceptionUtils
Helper class for implementing exception classes which are capable of holding nested exceptions.
OrderComparator
Comparator implementation for Ordered objects, sorting by order value ascending, respectively by priority descending.
OverridingClassLoader
ClassLoader that does not always delegate to the parent loader as normal class loaders do.
ParameterizedTypeReference<T>
The purpose of this class is to enable capturing and passing a generic Type .
PrioritizedParameterNameDiscoverer
ParameterNameDiscoverer implementation that tries several discoverer delegates in succession.
ReactiveAdapter
Adapter for a Reactive Streams Publisher to and from an async/reactive type such as CompletableFuture , RxJava Observable , and others.
ReactiveAdapterRegistry
A registry of adapters to adapt Reactive Streams Publisher to/from various async/reactive types such as CompletableFuture , RxJava Flowable , etc.
ReactiveAdapterRegistry.SpringCoreBlockHoundIntegration
BlockHoundIntegration for spring-core classes.
ReactiveTypeDescriptor
Describes the semantics of a reactive type including boolean checks for ReactiveTypeDescriptor.isMultiValue() , ReactiveTypeDescriptor.isNoValue() , and ReactiveTypeDescriptor.supportsEmpty() .
ResolvableType
Encapsulates a Java Type , providing access to supertypes , interfaces , and generic parameters along with the ability to ultimately resolve to a Class .
SimpleAliasRegistry
Simple implementation of the AliasRegistry interface.
SpringProperties
Static holder for local Spring properties, i.e.
SpringVersion
Class that exposes the Spring version.
StandardReflectionParameterNameDiscoverer
ParameterNameDiscoverer implementation which uses JDK 8's reflection facilities for introspecting parameter names (based on the "-parameters" compiler flag).
Exceptions
Constants.ConstantException
Exception thrown when the Constants class is asked for an invalid constant name.
NestedCheckedException
Handy class for wrapping checked Exceptions with a root cause.
NestedRuntimeException
Handy class for wrapping runtime Exceptions with a root cause.
Enum Classes
NativeDetector.Context
Native image context as defined in GraalVM's ImageInfo .
annotation
@NonNullApi @NonNullFields package org.springframework.core.annotation Core support package for annotations, meta-annotations, and merged annotations with attribute overrides.
Related Packages
org.springframework.core
Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
Annotation Interfaces
AliasFor
@AliasFor is an annotation that is used to declare aliases for annotation attributes.
Order
@Order defines the sort order for an annotated component.
Classes
AnnotatedElementUtils
General utility methods for finding annotations, meta-annotations, and repeatable annotations on AnnotatedElements .
AnnotatedMethod
A convenient wrapper for a Method handle, providing deep annotation introspection on methods and method parameters, including the exposure of interface-declared parameter annotations from the concrete target method.
AnnotationAttributes
LinkedHashMap subclass representing annotation attribute key-value pairs as read by AnnotationUtils , AnnotatedElementUtils , and Spring's reflection- and ASM-based AnnotationMetadata implementations.
AnnotationAwareOrderComparator
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).
AnnotationUtils
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 ).
MergedAnnotationCollectors
Collector implementations that provide various reduction operations for MergedAnnotation instances.
MergedAnnotationPredicates
Predicate implementations that provide various test operations for MergedAnnotations .
MergedAnnotations.Search
Fluent API for configuring the search algorithm used in the MergedAnnotations model and performing a search.
MergedAnnotationSelectors
MergedAnnotationSelector implementations that provide various options for MergedAnnotation instances.
OrderUtils
General utility for determining the order of an object based on its type declaration.
RepeatableContainers
Strategy used to determine annotations that act as containers for other annotations.
SynthesizingMethodParameter
A MethodParameter variant which synthesizes annotations that declare attribute aliases via @AliasFor .
Exceptions
AnnotationConfigurationException
Thrown by AnnotationUtils and synthesized annotations if an annotation is improperly configured.
Interfaces
AnnotationFilter
Callback interface that can be used to filter specific annotation types.
MergedAnnotation<A extends Annotation>
A single merged annotation returned from a MergedAnnotations collection.
MergedAnnotations
Provides access to a collection of merged annotations, usually obtained from a source such as a Class or Method .
MergedAnnotationSelector<A extends Annotation>
Strategy interface used to select between two MergedAnnotation instances.
Enum Classes
MergedAnnotation.Adapt
Adaptations that can be applied to attribute values when creating Maps or AnnotationAttributes .
MergedAnnotations.SearchStrategy
Search strategies supported by MergedAnnotations.search(SearchStrategy) as well as MergedAnnotations.from(AnnotatedElement, SearchStrategy) and variants of that method.
codec
@NonNullApi @NonNullFields package org.springframework.core.codec Encoder and Decoder abstractions to convert between a reactive stream of bytes and Java objects.
Related Packages
org.springframework.core
Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
Classes
AbstractCharSequenceDecoder<T extends CharSequence>
Abstract base class that decodes from a data buffer stream to a CharSequence stream.
AbstractDataBufferDecoder<T>
Abstract base class for Decoder implementations that can decode a DataBuffer directly to the target element type.
AbstractDecoder<T>
Abstract base class for Decoder implementations.
AbstractEncoder<T>
Abstract base class for Encoder implementations.
AbstractSingleValueEncoder<T>
Abstract base class for Encoder classes that can only deal with a single value.
ByteArrayDecoder
Decoder for byte arrays.
ByteArrayEncoder
Encoder for byte arrays.
ByteBufferDecoder
Decoder for ByteBuffers .
ByteBufferEncoder
Encoder for ByteBuffers .
CharBufferDecoder
Decode from a data buffer stream to a CharBuffer stream, either splitting or aggregating incoming data chunks to realign along newlines delimiters and produce a stream of char buffers.
CharSequenceEncoder
Encode from a CharSequence stream to a bytes stream.
DataBufferDecoder
Simple pass-through decoder for DataBuffers .
DataBufferEncoder
Simple pass-through encoder for DataBuffers .
Hints
Constants and convenience methods for working with hints.
Netty5BufferDecoder
Decoder for Buffers .
Netty5BufferEncoder
Encoder for Buffers .
NettyByteBufDecoder
Decoder for ByteBufs .
NettyByteBufEncoder
Encoder for ByteBufs .
ResourceDecoder
Decoder for Resources .
ResourceEncoder
Encoder for Resources .
ResourceRegionEncoder
Encoder for ResourceRegions .
StringDecoder
Decode from a data buffer stream to a String stream, either splitting or aggregating incoming data chunks to realign along newlines delimiters and produce a stream of strings.
Exceptions
CodecException
General error that indicates a problem while encoding and decoding to and from an Object stream.
DecodingException
Indicates an issue with decoding the input stream with a focus on content related issues such as a parse failure.
EncodingException
Indicates an issue with encoding the input Object stream with a focus on not being able to encode Objects.
Interfaces
Decoder<T>
Strategy for decoding a DataBuffer input stream into an output stream of elements of type .
Encoder<T>
Strategy to encode a stream of Objects of type into an output stream of bytes.
convert
convert
@NonNullApi @NonNullFields package org.springframework.core.convert Type conversion system API.
Related Packages
org.springframework.core
Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
org.springframework.core.convert.converter
SPI to implement Converters for the type conversion system.
org.springframework.core.convert.support
Default implementation of the type conversion system.
Exceptions
ConversionException
Base class for exceptions thrown by the conversion system.
ConversionFailedException
Exception to be thrown when an actual type conversion attempt fails.
ConverterNotFoundException
Exception to be thrown when a suitable converter could not be found in a given conversion service.
Interfaces
ConversionService
A service interface for type conversion.
Classes
Property
A description of a JavaBeans Property that allows us to avoid a dependency on java.beans.PropertyDescriptor .
TypeDescriptor
Contextual descriptor about a type to convert from or to.
converter
@NonNullApi @NonNullFields package org.springframework.core.convert.converter SPI to implement Converters for the type conversion system.
Related Packages
org.springframework.core.convert
Type conversion system API.
org.springframework.core.convert.support
Default implementation of the type conversion system.
Interfaces
ConditionalConverter
Allows a Converter , GenericConverter or ConverterFactory to conditionally execute based on attributes of the source and target TypeDescriptor .
ConditionalGenericConverter
A GenericConverter that may conditionally execute based on attributes of the source and target TypeDescriptor .
Converter<S, T>
A converter converts a source object of type S to a target of type T .
ConverterFactory<S, R>
A factory for "ranged" converters that can convert objects from S to subtypes of R.
ConverterRegistry
For registering converters with a type conversion system.
GenericConverter
Generic converter interface for converting between two or more types.
Classes
ConvertingComparator<S, T>
A Comparator that converts values before they are compared.
GenericConverter.ConvertiblePair
Holder for a source-to-target class pair.
support
@NonNullApi @NonNullFields package org.springframework.core.convert.support Default implementation of the type conversion system.
Related Packages
org.springframework.core.convert
Type conversion system API.
org.springframework.core.convert.converter
SPI to implement Converters for the type conversion system.
Interfaces
ConfigurableConversionService
Configuration interface to be implemented by most if not all ConversionService types.
Classes
ConversionServiceFactory
A factory for common ConversionService configurations.
ConvertingPropertyEditorAdapter
Adapter that exposes a PropertyEditor for any given ConversionService and specific target type.
DefaultConversionService
A specialization of GenericConversionService configured by default with converters appropriate for most environments.
GenericConversionService
Base ConversionService implementation suitable for use in most environments.
env
@NonNullApi @NonNullFields package org.springframework.core.env Spring's environment abstraction consisting of bean definition profile and hierarchical property source support.
Related Packages
org.springframework.core
Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
Classes
AbstractEnvironment
Abstract base class for Environment implementations.
AbstractPropertyResolver
Abstract base class for resolving properties against any underlying source.
CommandLinePropertySource<T>
Abstract base class for PropertySource implementations backed by command line arguments.
CompositePropertySource
Composite PropertySource implementation that iterates over a set of PropertySource instances.
EnumerablePropertySource<T>
A PropertySource implementation capable of interrogating its underlying source object to enumerate all possible property name/value pairs.
JOptCommandLinePropertySource
Deprecated. since 6.1 with no plans for a replacement
MapPropertySource
PropertySource that reads keys and values from a Map object.
MutablePropertySources
The default implementation of the PropertySources interface.
PropertiesPropertySource
PropertySource implementation that extracts properties from a Properties object.
PropertySource<T>
Abstract base class representing a source of name/value property pairs.
PropertySource.StubPropertySource
PropertySource to be used as a placeholder in cases where an actual property source cannot be eagerly initialized at application context creation time.
PropertySourcesPropertyResolver
PropertyResolver implementation that resolves property values against an underlying set of PropertySources .
SimpleCommandLinePropertySource
CommandLinePropertySource implementation backed by a simple String array.
StandardEnvironment
Environment implementation suitable for use in 'standard' (i.e.
SystemEnvironmentPropertySource
Specialization of MapPropertySource designed for use with system environment variables .
Interfaces
ConfigurableEnvironment
Configuration interface to be implemented by most if not all Environment types.
ConfigurablePropertyResolver
Configuration interface to be implemented by most if not all PropertyResolver types.
Environment
Interface representing the environment in which the current application is running.
EnvironmentCapable
Interface indicating a component that contains and exposes an Environment reference.
Profiles
Profile predicate that may be accepted by an Environment .
PropertyResolver
Interface for resolving properties against any underlying source.
PropertySources
Holder containing one or more PropertySource objects.
Exceptions
MissingRequiredPropertiesException
Exception thrown when required properties are not found.
io
io
@NonNullApi @NonNullFields package org.springframework.core.io Generic abstraction for (file-based) resources, used throughout the framework.
Related Packages
org.springframework.core
Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
org.springframework.core.io.buffer
Generic abstraction for working with byte buffer implementations.
org.springframework.core.io.support
Support classes for Spring's resource abstraction.
Classes
AbstractFileResolvingResource
Abstract base class for resources which resolve URLs into File references, such as UrlResource or ClassPathResource .
AbstractResource
Convenience base class for Resource implementations, pre-implementing typical behavior.
ByteArrayResource
Resource implementation for a given byte array.
ClassPathResource
Resource implementation for class path resources.
ClassRelativeResourceLoader
ResourceLoader implementation that interprets plain resource paths as relative to a given java.lang.Class .
DefaultResourceLoader
Default implementation of the ResourceLoader interface.
DefaultResourceLoader.ClassPathContextResource
ClassPathResource that explicitly expresses a context-relative path through implementing the ContextResource interface.
DescriptiveResource
Simple Resource implementation that holds a resource description but does not point to an actually readable resource.
FileSystemResource
Resource implementation for java.io.File and java.nio.file.Path handles with a file system target.
FileSystemResourceLoader
ResourceLoader implementation that resolves plain paths as file system resources rather than as class path resources (the latter is DefaultResourceLoader 's default strategy).
FileUrlResource
Subclass of UrlResource which assumes file resolution, to the degree of implementing the WritableResource interface for it.
InputStreamResource
Resource implementation for a given InputStream .
ModuleResource
Resource implementation for Module resolution, performing ModuleResource.getInputStream() access via Module.getResourceAsStream(java.lang.String) .
PathResource
Resource implementation for Path handles, performing all operations and transformations via the Path API.
ResourceEditor
Editor for Resource descriptors, to automatically convert String locations e.g.
UrlResource
Resource implementation for java.net.URL locators.
VfsResource
JBoss VFS based Resource implementation.
VfsUtils
Utility for detecting and accessing JBoss VFS in the classpath.
Interfaces
ContextResource
Extended interface for a resource that is loaded from an enclosing 'context', e.g.
InputStreamSource
Simple interface for objects that are sources for an InputStream .
ProtocolResolver
A resolution strategy for protocol-specific resource handles.
Resource
Interface for a resource descriptor that abstracts from the actual type of underlying resource, such as a file or class path resource.
ResourceLoader
Strategy interface for loading resources (e.g., class path or file system resources).
WritableResource
Extended interface for a resource that supports writing to it.
buffer
@NonNullApi @NonNullFields package org.springframework.core.io.buffer Generic abstraction for working with byte buffer implementations.
Related Packages
org.springframework.core.io
Generic abstraction for (file-based) resources, used throughout the framework.
org.springframework.core.io.support
Support classes for Spring's resource abstraction.
Interfaces
CloseableDataBuffer
Extension of DataBuffer that allows for buffers that can be used in a try -with-resources statement.
DataBuffer
Basic abstraction over byte buffers.
DataBuffer.ByteBufferIterator
A dedicated iterator type that ensures the lifecycle of iterated ByteBuffer elements.
DataBufferFactory
A factory for DataBuffers , allowing for allocation and wrapping of data buffers.
DataBufferUtils.Matcher
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.
PooledDataBuffer
Extension of DataBuffer that allows for buffers that share a memory pool.
TouchableDataBuffer
Extension of DataBuffer that allows for buffers that can be given hints for debugging purposes.
Exceptions
DataBufferLimitException
Exception that indicates the cumulative number of bytes consumed from a stream of DataBuffer 's exceeded some pre-configured limit.
Classes
DataBufferUtils
Utility class for working with DataBuffers .
DataBufferWrapper
Provides a convenient implementation of the DataBuffer interface that can be overridden to adapt the delegate.
DefaultDataBuffer
Default implementation of the DataBuffer interface that uses a ByteBuffer internally.
DefaultDataBufferFactory
Default implementation of the DataBufferFactory interface.
LimitedDataBufferList
Custom List to collect data buffers with and enforce a limit on the total number of bytes buffered.
Netty5DataBuffer
Implementation of the DataBuffer interface that wraps a Netty 5 Buffer .
Netty5DataBufferFactory
Implementation of the DataBufferFactory interface based on a Netty 5 BufferAllocator .
NettyDataBuffer
Implementation of the DataBuffer interface that wraps a Netty 4 ByteBuf .
NettyDataBufferFactory
Implementation of the DataBufferFactory interface based on a Netty 4 ByteBufAllocator .
support
@NonNullApi @NonNullFields package org.springframework.core.io.support Support classes for Spring's resource abstraction. Includes a ResourcePatternResolver mechanism.
Related Packages
org.springframework.core.io
Generic abstraction for (file-based) resources, used throughout the framework.
org.springframework.core.io.buffer
Generic abstraction for working with byte buffer implementations.
Classes
DefaultPropertySourceFactory
The default implementation for PropertySourceFactory , wrapping every resource in a ResourcePropertySource .
EncodedResource
Holder that combines a Resource descriptor with a specific encoding or Charset to be used for reading from the resource.
LocalizedResourceHelper
Helper class for loading a localized resource, specified through name, extension and current locale.
PathMatchingResourcePatternResolver
A ResourcePatternResolver implementation that is able to resolve a specified resource location path into one or more matching Resources.
PropertiesLoaderSupport
Base class for JavaBean-style components that need to load properties from one or more resources.
PropertiesLoaderUtils
Convenient utility methods for loading of java.util.Properties , performing standard handling of input streams.
PropertySourceProcessor
Contribute property sources to the Environment .
ResourceArrayPropertyEditor
Editor for Resource arrays, to automatically convert String location patterns (e.g.
ResourcePatternUtils
Utility class for determining whether a given URL is a resource location that can be loaded via a ResourcePatternResolver .
ResourcePropertySource
Subclass of PropertiesPropertySource that loads a Properties object from a given Resource or resource location such as "classpath:/com/myco/foo.properties" or "file:/path/to/file.xml" .
ResourceRegion
Region of a Resource implementation, materialized by a position within the Resource and a byte count for the length of that region.
SpringFactoriesLoader
General purpose factory loading mechanism for internal use within the framework.
Record Classes
PropertySourceDescriptor Descriptor for a PropertySource.
Interfaces
PropertySourceFactory
Strategy interface for creating resource-based PropertySource wrappers.
ResourcePatternResolver
Strategy interface for resolving a location pattern (for example, an Ant-style path pattern) into Resource objects.
SpringFactoriesLoader.ArgumentResolver
Strategy for resolving constructor arguments based on their type.
SpringFactoriesLoader.FailureHandler
Strategy for handling a failure that occurs when instantiating a factory.
log
@NonNullApi @NonNullFields package org.springframework.core.log Useful delegates for Spring's logging conventions.
Related Packages
org.springframework.core
Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
Classes
LogAccessor
A convenient accessor for Commons Logging, providing not only CharSequence based log methods but also Supplier based variants for use with Java 8 lambda expressions.
LogDelegateFactory
Factory for common Log delegates with Spring's logging conventions.
LogFormatUtils
Utility methods for formatting and logging messages.
LogMessage
A simple log message type for use with Commons Logging, allowing for convenient lazy resolution of a given Supplier instance (typically bound to a lambda expression) or a printf-style format string ( String.format(java.lang.String, java.lang.Object...) ) in its LogMessage.toString() .
metrics
metrics
@NonNullApi @NonNullFields package org.springframework.core.metrics Support package for recording metrics during application startup.
Related Packages
org.springframework.core
Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
org.springframework.core.metrics.jfr
Support package for recording startup metrics using Java Flight Recorder.
Interfaces
ApplicationStartup
Instruments the application startup phase using steps .
StartupStep
Step recording metrics about a particular phase or action happening during the ApplicationStartup .
StartupStep.Tag
Simple key/value association for storing step metadata.
StartupStep.Tags
Immutable collection of StartupStep.Tag .
jfr
@NonNullApi @NonNullFields package org.springframework.core.metrics.jfr Support package for recording startup metrics using Java Flight Recorder.
Related Packages
org.springframework.core.metrics
Support package for recording metrics during application startup.
Classes
FlightRecorderApplicationStartup
ApplicationStartup implementation for the Java Flight Recorder.
serializer
serializer
@NonNullApi @NonNullFields package org.springframework.core.serializer Root package for Spring's serializer interfaces and implementations. Provides an abstraction over various serialization techniques. Includes exceptions for serialization and deserialization failures.
Related Packages
org.springframework.core
Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
org.springframework.core.serializer.support
Support classes for Spring's serializer abstraction.
Classes
DefaultDeserializer
A default Deserializer implementation that reads an input stream using Java serialization.
DefaultSerializer
A Serializer implementation that writes an object to an output stream using Java serialization.
Interfaces
Deserializer<T>
A strategy interface for converting from data in an InputStream to an Object.
Serializer<T>
A strategy interface for streaming an object to an OutputStream.
support
@NonNullApi @NonNullFields package org.springframework.core.serializer.support Support classes for Spring's serializer abstraction. Includes adapters to the Converter SPI.
Related Packages
org.springframework.core.serializer
Root package for Spring's serializer interfaces and implementations.
Classes
DeserializingConverter
A Converter that delegates to a Deserializer to convert data in a byte array to an object.
SerializationDelegate
A convenient delegate with pre-arranged configuration state for common serialization needs.
SerializingConverter
A Converter that delegates to a Serializer to convert an object to a byte array.
Exceptions
SerializationFailedException
Wrapper for the native IOException (or similar) when a Serializer or Deserializer failed.
style
@NonNullApi @NonNullFields package org.springframework.core.style Support for styling values as Strings, with ToStringCreator as central class.
Related Packages
org.springframework.core
Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
Classes
DefaultToStringStyler
Spring's default toString() styler.
DefaultValueStyler
Converts objects to String form, generally for debugging purposes, using Spring's toString styling conventions.
SimpleValueStyler
ValueStyler that converts objects to String form — generally for debugging purposes — using simple styling conventions that mimic the toString() styling conventions for standard JDK implementations of collections, maps, and arrays.
StylerUtils
Simple utility class to allow for convenient access to value styling logic, mainly to support descriptive logging messages.
ToStringCreator
Utility class that builds pretty-printing toString() methods with pluggable styling conventions.
Interfaces
ToStringStyler
A strategy interface for pretty-printing toString() methods.
ValueStyler
Strategy that encapsulates value String styling algorithms according to Spring conventions.
task
task
@NonNullApi @NonNullFields package org.springframework.core.task This package defines Spring's core TaskExecutor abstraction, and provides SyncTaskExecutor and SimpleAsyncTaskExecutor implementations.
Related Packages
org.springframework.core
Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
org.springframework.core.task.support
Support classes for Spring's TaskExecutor abstraction.
Interfaces
AsyncListenableTaskExecutor
Deprecated. as of 6.0, in favor of AsyncTaskExecutor.submitCompletable(Runnable) and AsyncTaskExecutor.submitCompletable(Callable)
AsyncTaskExecutor
Extended interface for asynchronous TaskExecutor implementations, offering support for Callable .
TaskDecorator
A callback interface for a decorator to be applied to any Runnable about to be executed.
TaskExecutor
Simple task executor interface that abstracts the execution of a Runnable .
Classes
SimpleAsyncTaskExecutor
TaskExecutor implementation that fires up a new Thread for each task, executing it asynchronously.
SyncTaskExecutor
TaskExecutor implementation that executes each task synchronously in the calling thread.
VirtualThreadTaskExecutor
A TaskExecutor implementation based on virtual threads in JDK 21+.
Exceptions
TaskRejectedException
Exception thrown when a TaskExecutor rejects to accept a given task for execution.
TaskTimeoutException
Deprecated. as of 5.3.16 since the common executors do not support start timeouts
support
@NonNullApi @NonNullFields package org.springframework.core.task.support Support classes for Spring's TaskExecutor abstraction. Includes an adapter for the standard ExecutorService interface.
Related Packages
org.springframework.core.task
This package defines Spring's core TaskExecutor abstraction, and provides SyncTaskExecutor and SimpleAsyncTaskExecutor implementations.
Classes
CompositeTaskDecorator
Composite TaskDecorator that delegates to other task decorators.
ContextPropagatingTaskDecorator
TaskDecorator that wraps the execution of tasks, assisting with context propagation.
ExecutorServiceAdapter
Adapter that takes a Spring TaskExecutor and exposes a full java.util.concurrent.ExecutorService for it.
TaskExecutorAdapter
Adapter that takes a JDK java.util.concurrent.Executor and exposes a Spring TaskExecutor for it.
test
io
support
@NonNullApi @NonNullFields package org.springframework.core.test.io.support Test support classes for Spring's I/O support.
Classes
MockSpringFactoriesLoader
Simple mock SpringFactoriesLoader implementation that can be used for testing purposes.
tools
@NonNullApi @NonNullFields package org.springframework.core.test.tools Support classes for compiling and testing generated code.
Classes
ClassFile
In memory representation of a Java class.
ClassFiles
An immutable collection of ClassFile instances.
Compiled
Fully compiled results provided from a TestCompiler .
DynamicClassLoader
ClassLoader used to expose dynamically generated content.
DynamicFile
Abstract base class for dynamically generated files.
DynamicFileAssert<A extends DynamicFileAssert<A, F>, F extends DynamicFile>
Assertion methods for DynamicFile instances.
ResourceFile
DynamicFile that holds resource file content and provides ResourceFileAssert support.
ResourceFileAssert
Assertion methods for ResourceFile instances.
ResourceFiles
An immutable collection of ResourceFile instances.
SourceFile
DynamicFile that holds Java source code and provides SourceFileAssert support.
SourceFileAssert
Assertion methods for SourceFile instances.
SourceFiles
An immutable collection of SourceFile instances.
TestCompiler
Utility that can be used to dynamically compile and test Java source code.
Exceptions
CompilationException
Exception thrown when code cannot compile.
Annotation Interfaces
CompileWithForkedClassLoader
Annotation that registers a JUnit Jupiter extension for test classes or test methods that need to use a forked classloader with compiled code.
Interfaces
WritableContent
Callback interface used to write file content.
type
type
@NonNullApi @NonNullFields package org.springframework.core.type Core support package for type introspection.
Related Packages
org.springframework.core
Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
org.springframework.core.type.classreading
Support classes for reading annotation and class-level metadata.
org.springframework.core.type.filter
Core support package for type filtering (e.g.
Interfaces
AnnotatedTypeMetadata
Defines access to the annotations of a specific type ( class or method ), in a form that does not necessarily require class loading of the types being inspected.
AnnotationMetadata
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.
ClassMetadata
Interface that defines abstract metadata of a specific class, in a form that does not require that class to be loaded yet.
MethodMetadata
Interface that defines abstract access to the annotations of a specific method, in a form that does not require that method's class to be loaded yet.
Classes
StandardAnnotationMetadata
AnnotationMetadata implementation that uses standard reflection to introspect a given Class .
StandardClassMetadata
ClassMetadata implementation that uses standard reflection to introspect a given Class .
StandardMethodMetadata
MethodMetadata implementation that uses standard reflection to introspect a given Method .
classreading
@NonNullApi @NonNullFields package org.springframework.core.type.classreading Support classes for reading annotation and class-level metadata.
Related Packages
org.springframework.core.type
Core support package for type introspection.
org.springframework.core.type.filter
Core support package for type filtering (e.g.
Classes
CachingMetadataReaderFactory
Caching implementation of the MetadataReaderFactory interface, caching a MetadataReader instance per Spring Resource handle (i.e.
SimpleMetadataReaderFactory
Simple implementation of the MetadataReaderFactory interface, creating a new ASM ClassReader for every request.
Exceptions
ClassFormatException
Exception that indicates an incompatible class format encountered in a class file during metadata reading.
Interfaces
MetadataReader
Simple facade for accessing class metadata, as read by an ASM ClassReader .
MetadataReaderFactory
Factory interface for MetadataReader instances.
filter
@NonNullApi @NonNullFields package org.springframework.core.type.filter Core support package for type filtering (e.g. for classpath scanning).
Related Packages
org.springframework.core.type
Core support package for type introspection.
org.springframework.core.type.classreading
Support classes for reading annotation and class-level metadata.
Classes
AbstractClassTestingTypeFilter
Type filter that exposes a ClassMetadata object to subclasses, for class testing purposes.
AbstractTypeHierarchyTraversingFilter
Type filter that is aware of traversing over hierarchy.
AnnotationTypeFilter
A simple TypeFilter which matches classes with a given annotation, checking inherited annotations as well.
AspectJTypeFilter
Type filter that uses AspectJ type pattern for matching.
AssignableTypeFilter
A simple filter which matches classes that are assignable to a given type.
RegexPatternTypeFilter
A simple filter for matching a fully-qualified class name with a regex Pattern .
Interfaces
TypeFilter
Base interface for type filters using a MetadataReader .
dao
dao
@NonNullApi @NonNullFields package org.springframework.dao Exception hierarchy enabling sophisticated error handling independent of the data access approach in use. For example, when DAOs and data access frameworks use the exceptions in this package (and custom subclasses), calling code can detect and handle common problems such as deadlocks without being tied to a particular data access strategy, such as JDBC. All these exceptions are unchecked, meaning that calling code can leave them uncaught and treat all data access exceptions as fatal. The classes in this package are discussed in Chapter 9 of Expert One-On-One J2EE Design and Development by Rod Johnson (Wrox, 2002).
Related Packages
org.springframework.dao.annotation
Annotation support for DAOs.
org.springframework.dao.support
Support classes for DAO implementations, providing miscellaneous utility methods.
Exceptions
CannotAcquireLockException
Exception thrown on failure to acquire a lock during an update, for example during a "select for update" statement.
CannotSerializeTransactionException
Deprecated. as of 6.0.3, in favor of PessimisticLockingFailureException / CannotAcquireLockException
CleanupFailureDataAccessException
Deprecated. as of 6.0.3 since it is not in use within core JDBC/ORM support
ConcurrencyFailureException
Exception thrown on various data access concurrency failures.
DataAccessException
Root of the hierarchy of data access exceptions discussed in Expert One-On-One J2EE Design and Development .
DataAccessResourceFailureException
Data access exception thrown when a resource fails completely: for example, if we can't connect to a database using JDBC.
DataIntegrityViolationException
Exception thrown when an attempt to insert or update data results in violation of an integrity constraint.
DataRetrievalFailureException
Exception thrown if certain expected data could not be retrieved, e.g.
DeadlockLoserDataAccessException
Deprecated. as of 6.0.3, in favor of PessimisticLockingFailureException / CannotAcquireLockException
DuplicateKeyException
Exception thrown when an attempt to insert or update data results in violation of a primary key or unique constraint.
EmptyResultDataAccessException
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.
IncorrectResultSizeDataAccessException
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.
IncorrectUpdateSemanticsDataAccessException
Data access exception thrown when something unintended appears to have happened with an update, but the transaction hasn't already been rolled back.
InvalidDataAccessApiUsageException
Exception thrown on incorrect usage of the API, such as failing to "compile" a query object that needed compilation before execution.
InvalidDataAccessResourceUsageException
Root for exceptions thrown when we use a data access resource incorrectly.
NonTransientDataAccessException
Root of the hierarchy of data access exceptions that are considered non-transient - where a retry of the same operation would fail unless the cause of the Exception is corrected.
NonTransientDataAccessResourceException
Data access exception thrown when a resource fails completely and the failure is permanent.
OptimisticLockingFailureException
Exception thrown on an optimistic locking violation.
PermissionDeniedDataAccessException
Exception thrown when the underlying resource denied a permission to access a specific element, such as a specific database table.
PessimisticLockingFailureException
Exception thrown on a pessimistic locking violation.
QueryTimeoutException
Exception to be thrown on a query timeout.
RecoverableDataAccessException
Data access exception thrown when a previously failed operation might be able to succeed if the application performs some recovery steps and retries the entire transaction or in the case of a distributed transaction, the transaction branch.
TransientDataAccessException
Root of the hierarchy of data access exceptions that are considered transient - where a previously failed operation might be able to succeed when the operation is retried without any intervention by application-level functionality.
TransientDataAccessResourceException
Data access exception thrown when a resource fails temporarily and the operation can be retried.
TypeMismatchDataAccessException
Exception thrown on mismatch between Java type and database type: for example on an attempt to set an object of the wrong type in an RDBMS column.
UncategorizedDataAccessException
Normal superclass when we can't distinguish anything more specific than "something went wrong with the underlying resource": for example, an SQLException from JDBC we can't pinpoint more precisely.
annotation
@NonNullApi @NonNullFields package org.springframework.dao.annotation Annotation support for DAOs. Contains a bean post-processor for translating persistence exceptions based on a repository stereotype annotation.
Related Packages
org.springframework.dao
Exception hierarchy enabling sophisticated error handling independent of the data access approach in use.
org.springframework.dao.support
Support classes for DAO implementations, providing miscellaneous utility methods.
Classes
PersistenceExceptionTranslationAdvisor
Spring AOP exception translation aspect for use at Repository or DAO layer level.
PersistenceExceptionTranslationPostProcessor
Bean post-processor that automatically applies persistence exception translation to any bean marked with Spring's @ Repository annotation, adding a corresponding PersistenceExceptionTranslationAdvisor to the exposed proxy (either an existing AOP proxy or a newly generated proxy that implements all of the target's interfaces).
support
@NonNullApi @NonNullFields package org.springframework.dao.support Support classes for DAO implementations, providing miscellaneous utility methods.
Related Packages
org.springframework.dao
Exception hierarchy enabling sophisticated error handling independent of the data access approach in use.
org.springframework.dao.annotation
Annotation support for DAOs.
Classes
ChainedPersistenceExceptionTranslator
Implementation of PersistenceExceptionTranslator that supports chaining, allowing the addition of PersistenceExceptionTranslator instances in order.
DaoSupport
Generic base class for DAOs, defining template methods for DAO initialization.
DataAccessUtils
Miscellaneous utility methods for DAO implementations.
PersistenceExceptionTranslationInterceptor
AOP Alliance MethodInterceptor that provides persistence exception translation based on a given PersistenceExceptionTranslator.
Interfaces
PersistenceExceptionTranslator
Interface implemented by Spring integrations with data access technologies that throw runtime exceptions, such as JPA and Hibernate.
ejb
config
@NonNullApi @NonNullFields package org.springframework.ejb.config Support package for EJB/Jakarta EE-related configuration, with XML schema being the primary configuration format.
Classes
JeeNamespaceHandler
NamespaceHandler for the ' jee ' namespace.
expression
expression
@NonNullApi @NonNullFields package org.springframework.expression Core abstractions behind the Spring Expression Language.
Related Packages
org.springframework.expression.common
Common utility classes behind the Spring Expression Language .
org.springframework.expression.spel
SpEL's central implementation package.
Exceptions
AccessException
An AccessException is thrown by an accessor if it has an unexpected problem.
EvaluationException
Represent an exception that occurs during expression evaluation.
ExpressionException
Superclass for exceptions that can occur whilst processing expressions.
ExpressionInvocationTargetException
This exception wraps (as cause) a checked exception thrown by some method that SpEL invokes.
ParseException
Represent an exception that occurs during expression parsing.
Interfaces
BeanResolver
A bean resolver can be registered with the evaluation context and will kick in for bean references: @myBeanName and &myBeanName expressions.
ConstructorExecutor
A ConstructorExecutor is built by a ConstructorResolver and can be cached by the infrastructure to repeat an operation quickly without going back to the resolvers.
ConstructorResolver
A constructor resolver attempts to locate a constructor and returns a ConstructorExecutor that can be used to invoke that constructor.
EvaluationContext
Expressions are executed in an evaluation context.
Expression
An expression capable of evaluating itself against context objects.
ExpressionParser
Parses expression strings into compiled expressions that can be evaluated.
MethodExecutor
A MethodExecutor is built by a MethodResolver and can be cached by the infrastructure to repeat an operation quickly without going back to the resolvers.
MethodFilter
MethodFilter instances allow SpEL users to fine tune the behaviour of the method resolution process.
MethodResolver
A method resolver attempts to locate a method and returns a MethodExecutor that can be used to invoke that method.
OperatorOverloader
By default, the mathematical operators defined in Operation support simple types like numbers.
ParserContext
Input provided to an expression parser that can influence an expression parsing/compilation routine.
PropertyAccessor
A property accessor is able to read from (and possibly write to) an object's properties.
TypeComparator
Instances of a type comparator should be able to compare pairs of objects for equality.
TypeConverter
A type converter can convert values between different types encountered during expression evaluation.
TypeLocator
Implementers of this interface are expected to be able to locate types.
Enum Classes
Operation
Supported operations that an OperatorOverloader can implement for any pair of operands.
Classes
TypedValue
Encapsulates an object and a TypeDescriptor that describes it.
common
@NonNullApi @NonNullFields package org.springframework.expression.common Common utility classes behind the Spring Expression Language.
Related Packages
org.springframework.expression
Core abstractions behind the Spring Expression Language .
org.springframework.expression.spel
SpEL's central implementation package.
Classes
CompositeStringExpression
Represents a template expression broken into pieces.
ExpressionUtils
Common utility functions that may be used by any Expression Language provider.
LiteralExpression
A very simple, hard-coded implementation of the Expression interface that represents a string literal.
TemplateAwareExpressionParser
An expression parser that understands templates.
TemplateParserContext
Configurable ParserContext implementation for template parsing.
spel
spel
@NonNullApi @NonNullFields package org.springframework.expression.spel SpEL's central implementation package.
Related Packages
org.springframework.expression
Core abstractions behind the Spring Expression Language .
org.springframework.expression.spel.ast
SpEL's abstract syntax tree.
org.springframework.expression.spel.standard
SpEL's standard parser implementation.
org.springframework.expression.spel.support
SpEL's default implementations for various core abstractions.
org.springframework.expression.common
Common utility classes behind the Spring Expression Language .
Classes
CodeFlow
Manages the class being generated by the compilation process.
CompiledExpression
Base superclass for compiled expressions.
ExpressionState
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.
SpelParserConfiguration
Configuration object for the SpEL expression parser.
Interfaces
CodeFlow.ClinitAdder
Interface used to generate clinit static initializer blocks.
CodeFlow.FieldAdder
Interface used to generate fields.
CompilablePropertyAccessor
A compilable PropertyAccessor is able to generate bytecode that represents the access operation, facilitating compilation to bytecode of expressions that use the accessor.
SpelNode
Represents a node in the AST for a parsed expression.
Exceptions
InternalParseException
Wraps a real parse exception.
SpelEvaluationException
Root exception for Spring EL related exceptions.
SpelParseException
Root exception for Spring EL related exceptions.
Enum Classes
SpelCompilerMode
Captures the possible configuration settings for a compiler that can be used when evaluating expressions.
SpelMessage
Contains all the messages that can be produced by the Spring Expression Language.
SpelMessage.Kind
Message kinds.
ast
@NonNullApi @NonNullFields package org.springframework.expression.spel.ast SpEL's abstract syntax tree.
Related Packages
org.springframework.expression.spel
SpEL's central implementation package.
org.springframework.expression.spel.standard
SpEL's standard parser implementation.
org.springframework.expression.spel.support
SpEL's default implementations for various core abstractions.
Classes
Assign
Represents assignment.
AstUtils
Utilities methods for use in the Ast classes.
BeanReference
Represents a bean reference to a type, for example @foo or @'foo.bar' .
BooleanLiteral
Represents the literal values TRUE and FALSE .
CompoundExpression
Represents a DOT separated expression sequence, such as property1.property2.methodOne() or property1?.property2?.methodOne() when the null-safe navigation operator is used.
ConstructorReference
Represents the invocation of a constructor.
Elvis
Represents the Elvis operator ?: .
FloatLiteral
Expression language AST node that represents a float literal.
FunctionReference
A function reference is of the form "#someFunction(a,b,c)".
Identifier
An 'identifier' SpelNode .
Indexer
An Indexer can index into some proceeding structure to access a particular piece of it.
InlineList
Represent a list in an expression, e.g.
InlineMap
Represent a map in an expression, e.g.
IntLiteral
Expression language AST node that represents an integer literal.
Literal
Common superclass for nodes representing literals (boolean, string, number, etc).
LongLiteral
Expression language AST node that represents a long integer literal.
MethodReference
Expression language AST node that represents a method reference.
NullLiteral
Expression language AST node that represents null.
OpAnd
Represents the boolean AND operation.
OpDec
Decrement operator.
OpDivide
Implements division operator.
OpEQ
Implements the equality operator.
Operator
Common supertype for operators that operate on either one or two operands.
Operator.DescriptorComparison
A descriptor comparison encapsulates the result of comparing descriptor for two operands and describes at what level they are compatible.
OperatorBetween
Represents the between operator.
OperatorInstanceof
The operator 'instanceof' checks if an object is of the class specified in the right-hand operand, in the same way that instanceof does in Java.
OperatorMatches
Implements the matches operator.
OperatorNot
Represents a NOT operation.
OperatorPower
The power operator.
OpGE
Implements greater-than-or-equal operator.
OpGT
Implements the greater-than operator.
OpInc
Increment operator.
OpLE
Implements the less-than-or-equal operator.
OpLT
Implements the less-than operator.
OpMinus
The minus operator supports: subtraction of numbers subtraction of an int from a string of one character (effectively decreasing that character), so 'd' - 3 = 'a'
OpModulus
Implements the modulus operator.
OpMultiply
Implements the multiply operator.
OpNE
Implements the not-equal operator.
OpOr
Represents the boolean OR operation.
OpPlus
The plus operator will: add numbers concatenate strings
Projection
Represents projection, where a given operation is performed on all elements in some input sequence, returning a new sequence of the same size.
PropertyOrFieldReference
Represents a simple property or field reference.
QualifiedIdentifier
Represents a dot separated sequence of strings that indicate a package qualified type reference.
RealLiteral
Expression language AST node that represents a real literal.
Selection
Represents selection over a map or collection.
SpelNodeImpl
The common supertype of all AST nodes in a parsed Spring Expression Language format expression.
StringLiteral
Expression language AST node that represents a string literal.
Ternary
Represents a ternary expression, for example: "someCheck()?true:false".
TypeReference
Represents a reference to a type, for example "T(String)" or "T(com.example.Foo)" .
ValueRef.NullValueRef
A ValueRef for the null value.
ValueRef.TypedValueHolderValueRef
A ValueRef holder for a single value, which cannot be set.
VariableReference
Represents a variable reference — for example, #root , #this , #someVar , etc.
Enum Classes
TypeCode
Captures primitive types and their corresponding class objects, plus one special TypeCode.OBJECT entry that represents all reference (non-primitive) types.
Interfaces
ValueRef
Represents a reference to a value.
standard
@NonNullApi @NonNullFields package org.springframework.expression.spel.standard SpEL's standard parser implementation.
Related Packages
org.springframework.expression.spel
SpEL's central implementation package.
org.springframework.expression.spel.ast
SpEL's abstract syntax tree.
org.springframework.expression.spel.support
SpEL's default implementations for various core abstractions.
Classes
SpelCompiler
A SpelCompiler will take a regular parsed expression and create (and load) a class containing byte code that does the same thing as that expression.
SpelExpression
A SpelExpression represents a parsed (valid) expression that is ready to be evaluated in a specified context.
SpelExpressionParser
SpEL parser.
support
@NonNullApi @NonNullFields package org.springframework.expression.spel.support SpEL's default implementations for various core abstractions.
Related Packages
org.springframework.expression.spel
SpEL's central implementation package.
org.springframework.expression.spel.ast
SpEL's abstract syntax tree.
org.springframework.expression.spel.standard
SpEL's standard parser implementation.
Classes
BooleanTypedValue
A TypedValue for booleans.
DataBindingMethodResolver
An MethodResolver variant for data binding purposes, using reflection to access instance methods on a given target object.
DataBindingPropertyAccessor
An PropertyAccessor variant for data binding purposes, using reflection to access properties for reading and possibly writing.
ReflectionHelper
Utility methods used by the reflection resolver code to discover the appropriate methods/constructors and fields that should be used in expressions.
ReflectiveConstructorExecutor
A simple ConstructorExecutor implementation that runs a constructor using reflective invocation.
ReflectiveConstructorResolver
A constructor resolver that uses reflection to locate the constructor that should be invoked.
ReflectiveMethodExecutor
MethodExecutor that works via reflection.
ReflectiveMethodResolver
Reflection-based MethodResolver used by default in StandardEvaluationContext unless explicit method resolvers have been specified.
ReflectivePropertyAccessor
A powerful PropertyAccessor that uses reflection to access properties for reading and possibly also for writing on a target instance.
ReflectivePropertyAccessor.OptimalPropertyAccessor
An optimized form of a PropertyAccessor that will use reflection but only knows how to access a particular property on a particular class.
SimpleEvaluationContext
A basic implementation of EvaluationContext that focuses on a subset of essential SpEL features and customization options, targeting simple condition evaluation and in particular data binding scenarios.
SimpleEvaluationContext.Builder
Builder for SimpleEvaluationContext .
StandardEvaluationContext
A powerful and highly configurable EvaluationContext implementation.
StandardOperatorOverloader
Standard implementation of OperatorOverloader .
StandardTypeComparator
A basic TypeComparator implementation: supports comparison of Number types as well as types implementing Comparable .
StandardTypeConverter
Default implementation of the TypeConverter interface, delegating to a core Spring ConversionService .
StandardTypeLocator
A simple implementation of TypeLocator that uses the default ClassLoader or a supplied ClassLoader to locate types.
format
format
@NonNullApi @NonNullFields package org.springframework.format An API for defining Formatters to format field model values for display in a UI.
Related Packages
org.springframework.format.annotation
Annotations for declaratively configuring field formatting rules.
org.springframework.format.datetime
Formatters for java.util.Date properties.
org.springframework.format.number
Formatters for java.lang.Number properties.
org.springframework.format.support
Support classes for the formatting package, providing common implementations as well as adapters.
Interfaces
AnnotationFormatterFactory<A extends Annotation>
A factory that creates formatters to format values of fields annotated with a particular Annotation .
Formatter<T>
Formats objects of type T.
FormatterRegistrar
Registers Converters and Formatters with a FormattingConversionService through the FormatterRegistry SPI.
FormatterRegistry
A registry of field formatting logic.
Parser<T>
Parses text strings to produce instances of T.
Printer<T>
Prints objects of type T for display.
annotation
@NonNullApi @NonNullFields package org.springframework.format.annotation Annotations for declaratively configuring field formatting rules.
Related Packages
org.springframework.format
An API for defining Formatters to format field model values for display in a UI.
org.springframework.format.datetime
Formatters for java.util.Date properties.
org.springframework.format.number
Formatters for java.lang.Number properties.
org.springframework.format.support
Support classes for the formatting package, providing common implementations as well as adapters.
Annotation Interfaces
DateTimeFormat
Declares that a field or method parameter should be formatted as a date or time.
NumberFormat
Declares that a field or method parameter should be formatted as a number.
Enum Classes
DateTimeFormat.ISO
Common ISO date time format patterns.
NumberFormat.Style
Common number format styles.
datetime
datetime
@NonNullApi @NonNullFields package org.springframework.format.datetime Formatters for java.util.Date properties.
Related Packages
org.springframework.format
An API for defining Formatters to format field model values for display in a UI.
org.springframework.format.datetime.standard
Integration with the JSR-310 java.time package in JDK 8.
org.springframework.format.annotation
Annotations for declaratively configuring field formatting rules.
org.springframework.format.number
Formatters for java.lang.Number properties.
org.springframework.format.support
Support classes for the formatting package, providing common implementations as well as adapters.
Classes
DateFormatter
A formatter for Date types.
DateFormatterRegistrar
Configures basic date formatting for use with Spring, primarily for DateTimeFormat declarations.
DateTimeFormatAnnotationFormatterFactory
Formats fields annotated with the DateTimeFormat annotation using a DateFormatter .
standard
@NonNullApi @NonNullFields package org.springframework.format.datetime.standard Integration with the JSR-310 java.time package in JDK 8.
Related Packages
org.springframework.format.datetime
Formatters for java.util.Date properties.
Classes
DateTimeContext
A context that holds user-specific java.time (JSR-310) settings such as the user's Chronology (calendar system) and time zone.
DateTimeContextHolder
A holder for a thread-local user DateTimeContext .
DateTimeFormatterFactory
Factory that creates a JSR-310 DateTimeFormatter .
DateTimeFormatterFactoryBean
FactoryBean that creates a JSR-310 DateTimeFormatter .
DateTimeFormatterRegistrar
Configures the JSR-310 java.time formatting system for use with Spring.
InstantFormatter
Formatter implementation for a JSR-310 Instant , following JSR-310's parsing rules for an Instant (that is, not using a configurable DateTimeFormatter ): accepting the default ISO_INSTANT format as well as RFC_1123_DATE_TIME (which is commonly used for HTTP date header values), as of Spring 4.3.
Jsr310DateTimeFormatAnnotationFormatterFactory
Formats fields annotated with the DateTimeFormat annotation using the JSR-310 java.time package in JDK 8.
TemporalAccessorParser
Parser implementation for a JSR-310 TemporalAccessor , using a DateTimeFormatter (the contextual one, if available).
TemporalAccessorPrinter
Printer implementation for a JSR-310 TemporalAccessor , using a DateTimeFormatter ) (the contextual one, if available).
number
number
@NonNullApi @NonNullFields package org.springframework.format.number Formatters for java.lang.Number properties.
Related Packages
org.springframework.format
An API for defining Formatters to format field model values for display in a UI.
org.springframework.format.number.money
Integration with the JSR-354 javax.money package.
org.springframework.format.annotation
Annotations for declaratively configuring field formatting rules.
org.springframework.format.datetime
Formatters for java.util.Date properties.
org.springframework.format.support
Support classes for the formatting package, providing common implementations as well as adapters.
Classes
AbstractNumberFormatter
Abstract formatter for Numbers, providing a AbstractNumberFormatter.getNumberFormat(java.util.Locale) template method.
CurrencyStyleFormatter
A BigDecimal formatter for number values in currency style.
NumberFormatAnnotationFormatterFactory
Formats fields annotated with the NumberFormat annotation.
NumberStyleFormatter
A general-purpose number formatter using NumberFormat's number style.
PercentStyleFormatter
A formatter for number values in percent style.
money
@NonNullApi @NonNullFields package org.springframework.format.number.money Integration with the JSR-354 javax.money package.
Related Packages
org.springframework.format.number
Formatters for java.lang.Number properties.
Classes
CurrencyUnitFormatter
Formatter for JSR-354 CurrencyUnit values, from and to currency code Strings.
Jsr354NumberFormatAnnotationFormatterFactory
Formats MonetaryAmount fields annotated with Spring's common NumberFormat annotation.
MonetaryAmountFormatter
Formatter for JSR-354 MonetaryAmount values, delegating to MonetaryAmountFormat.format(javax.money.MonetaryAmount) and MonetaryAmountFormat.parse(java.lang.CharSequence) .
support
@NonNullApi @NonNullFields package org.springframework.format.support Support classes for the formatting package, providing common implementations as well as adapters.
Related Packages
org.springframework.format
An API for defining Formatters to format field model values for display in a UI.
org.springframework.format.annotation
Annotations for declaratively configuring field formatting rules.
org.springframework.format.datetime
Formatters for java.util.Date properties.
org.springframework.format.number
Formatters for java.lang.Number properties.
Classes
DefaultFormattingConversionService
A specialization of FormattingConversionService configured by default with converters and formatters appropriate for most applications.
FormatterPropertyEditorAdapter
Adapter that bridges between Formatter and PropertyEditor .
FormattingConversionService
A ConversionService implementation designed to be configured as a FormatterRegistry .
FormattingConversionServiceFactoryBean
A factory providing convenient access to a FormattingConversionService configured with converters and formatters for common types such as numbers and datetimes.
http
http
@NonNullApi @NonNullFields package org.springframework.http Contains a basic abstraction over client/server-side HTTP. This package contains the HttpInputMessage and HttpOutputMessage interfaces.
Related Packages
org.springframework.http.client
Contains an abstraction over client-side HTTP.
org.springframework.http.codec
Provides implementations of Encoder and Decoder for web use.
org.springframework.http.converter
Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
org.springframework.http.server
Contains an abstraction over server-side HTTP.
org.springframework.http.support
This package provides internal HTTP support classes, to be used by higher-level client and server classes.
Classes
CacheControl
A builder for creating "Cache-Control" HTTP response headers.
ContentDisposition
Representation of the Content-Disposition type and parameters as defined in RFC 6266.
HttpCookie
Represents an HTTP cookie as a name-value pair consistent with the content of the "Cookie" request header.
HttpEntity<T>
Represents an HTTP request or response entity, consisting of headers and body.
HttpHeaders
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.
HttpLogging
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.
HttpMethod
Represents an HTTP request method.
HttpRange
Represents an HTTP (byte) range for use with the HTTP "Range" header.
MediaType
A subclass of MimeType that adds support for quality parameters as defined in the HTTP specification.
MediaTypeEditor
Editor for MediaType descriptors, to automatically convert String specifications (e.g.
MediaTypeFactory
A factory delegate for resolving MediaType objects from Resource handles or filenames.
ProblemDetail
Representation for an RFC 7807 problem detail.
RequestEntity<T>
Extension of HttpEntity that also exposes the HTTP method and the target URL.
RequestEntity.UriTemplateRequestEntity<T>
RequestEntity initialized with a URI template and variables instead of a URI .
ResponseCookie
An HttpCookie subclass with the additional attributes allowed in the "Set-Cookie" response header.
ResponseEntity<T>
Extension of HttpEntity that adds an HttpStatusCode status code.
Interfaces
ContentDisposition.Builder
A mutable builder for ContentDisposition .
HttpInputMessage
Represents an HTTP input message, consisting of headers and a readable body .
HttpMessage
Represents the base interface for HTTP request and response messages.
HttpOutputMessage
Represents an HTTP output message, consisting of headers and a writable body .
HttpRequest
Represents an HTTP request message, consisting of a method and a URI .
HttpStatusCode
Represents an HTTP response status code.
ReactiveHttpInputMessage
A "reactive" HTTP input message that exposes the input as Publisher .
ReactiveHttpOutputMessage
A "reactive" HTTP output message that accepts output as a Publisher .
RequestEntity.BodyBuilder
Defines a builder that adds a body to the response entity.
RequestEntity.HeadersBuilder<B extends RequestEntity.HeadersBuilder<B>>
Defines a builder that adds headers to the request entity.
ResponseCookie.ResponseCookieBuilder
A builder for a server-defined HttpCookie with attributes.
ResponseEntity.BodyBuilder
Defines a builder that adds a body to the response entity.
ResponseEntity.HeadersBuilder<B extends ResponseEntity.HeadersBuilder<B>>
Defines a builder that adds headers to the response entity.
StreamingHttpOutputMessage
Represents an HTTP output message that allows for setting a streaming body.
StreamingHttpOutputMessage.Body
Defines the contract for bodies that can be written directly to an OutputStream .
ZeroCopyHttpOutputMessage
Sub-interface of ReactiveOutputMessage that has support for "zero-copy" file transfers.
Enum Classes
HttpStatus
Enumeration of HTTP status codes.
HttpStatus.Series
Enumeration of HTTP status series.
Exceptions
InvalidMediaTypeException
Exception thrown from MediaType.parseMediaType(String) in case of encountering an invalid media type specification String.
client
client
@NonNullApi @NonNullFields package org.springframework.http.client Contains an abstraction over client-side HTTP. This package contains the ClientHttpRequest and ClientHttpResponse, as well as a basic implementation of these interfaces.
Related Packages
org.springframework.http
Contains a basic abstraction over client/server-side HTTP.
org.springframework.http.client.observation
This package provides support for client HTTP Observation .
org.springframework.http.client.reactive
Abstractions for reactive HTTP client support including ClientHttpRequest and ClientHttpResponse as well as a ClientHttpConnector .
org.springframework.http.client.support
This package provides generic HTTP support classes, to be used by higher-level classes like RestTemplate.
org.springframework.http.codec
Provides implementations of Encoder and Decoder for web use.
org.springframework.http.converter
Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
org.springframework.http.server
Contains an abstraction over server-side HTTP.
org.springframework.http.support
This package provides internal HTTP support classes, to be used by higher-level client and server classes.
Classes
AbstractClientHttpRequest
Abstract base for ClientHttpRequest that makes sure that headers and body are not written multiple times.
AbstractClientHttpRequestFactoryWrapper
Abstract base class for ClientHttpRequestFactory implementations that decorate another delegate request factory.
AbstractClientHttpResponse
Deprecated, for removal: This API element is subject to removal in a future version. as of 6.0, with no direct replacement; scheduled for removal in 6.2
BufferingClientHttpRequestFactory
Wrapper for a ClientHttpRequestFactory that buffers all outgoing and incoming streams in memory.
HttpComponentsClientHttpRequestFactory
ClientHttpRequestFactory implementation that uses Apache HttpComponents HttpClient to create requests.
InterceptingClientHttpRequestFactory
ClientHttpRequestFactory wrapper with support for ClientHttpRequestInterceptors .
JdkClientHttpRequestFactory
ClientHttpRequestFactory implementation based on the Java HttpClient .
JettyClientHttpRequestFactory
ClientHttpRequestFactory implementation based on Jetty's HttpClient .
MultipartBodyBuilder
Prepare the body of a multipart request, resulting in a MultiValueMap .
OkHttp3ClientHttpRequestFactory
Deprecated, for removal: This API element is subject to removal in a future version. since 6.1, in favor of other ClientHttpRequestFactory implementations; scheduled for removal in 6.2
ReactorNettyClientRequestFactory
Reactor-Netty implementation of ClientHttpRequestFactory .
ReactorResourceFactory
Factory to manage Reactor Netty resources, i.e.
SimpleClientHttpRequestFactory
ClientHttpRequestFactory implementation that uses standard JDK facilities.
Interfaces
ClientHttpRequest
Represents a client-side HTTP request.
ClientHttpRequestExecution
Represents the context of a client-side HTTP request execution.
ClientHttpRequestFactory
Factory for ClientHttpRequest objects.
ClientHttpRequestInitializer
Callback interface for initializing a ClientHttpRequest prior to it being used.
ClientHttpRequestInterceptor
Contract to intercept client-side HTTP requests.
ClientHttpResponse
Represents a client-side HTTP response.
MultipartBodyBuilder.PartBuilder
Builder that allows for further customization of part headers.
observation
@NonNullApi @NonNullFields package org.springframework.http.client.observation This package provides support for client HTTP Observation.
Related Packages
org.springframework.http.client
Contains an abstraction over client-side HTTP.
org.springframework.http.client.reactive
Abstractions for reactive HTTP client support including ClientHttpRequest and ClientHttpResponse as well as a ClientHttpConnector .
org.springframework.http.client.support
This package provides generic HTTP support classes, to be used by higher-level classes like RestTemplate.
Enum Classes
ClientHttpObservationDocumentation
Documented KeyValues for HTTP client observations.
ClientHttpObservationDocumentation.HighCardinalityKeyNames
ClientHttpObservationDocumentation.LowCardinalityKeyNames
Classes
ClientRequestObservationContext
Context that holds information for metadata collection during the client HTTP exchanges observations.
DefaultClientRequestObservationConvention
Default implementation for a ClientRequestObservationConvention , extracting information from the ClientRequestObservationContext .
Interfaces
ClientRequestObservationConvention
Interface for an ObservationConvention for client HTTP exchanges .
reactive
@NonNullApi @NonNullFields package org.springframework.http.client.reactive Abstractions for reactive HTTP client support including ClientHttpRequest and ClientHttpResponse as well as a ClientHttpConnector.
Related Packages
org.springframework.http.client
Contains an abstraction over client-side HTTP.
org.springframework.http.client.observation
This package provides support for client HTTP Observation .
org.springframework.http.client.support
This package provides generic HTTP support classes, to be used by higher-level classes like RestTemplate.
Classes
AbstractClientHttpRequest
Base class for ClientHttpRequest implementations.
AbstractClientHttpResponse
Base class for ClientHttpResponse implementations.
ClientHttpRequestDecorator
Wraps another ClientHttpRequest and delegates all methods to it.
ClientHttpResponseDecorator
Wraps another ClientHttpResponse and delegates all methods to it.
HttpComponentsClientHttpConnector
ClientHttpConnector implementation for the Apache HttpComponents HttpClient 5.x.
JdkClientHttpConnector
ClientHttpConnector for the Java HttpClient .
JdkHttpClientResourceFactory
Factory to manage JDK HttpClient resources such as a shared Executor within the lifecycle of a Spring ApplicationContext .
JettyClientHttpConnector
ClientHttpConnector for the Jetty Reactive Streams HttpClient.
JettyResourceFactory
Factory to manage Jetty resources, i.e.
ReactorClientHttpConnector
Reactor-Netty implementation of ClientHttpConnector .
ReactorNetty2ClientHttpConnector
Reactor Netty 2 (Netty 5) implementation of ClientHttpConnector .
ReactorNetty2ResourceFactory
Factory to manage Reactor Netty resources, i.e.
ReactorResourceFactory
Deprecated. since 6.1 due to a package change; use ReactorResourceFactory instead.
Interfaces
ClientHttpConnector
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 .
ClientHttpRequest
Represents a client-side reactive HTTP request.
ClientHttpResponse
Represents a client-side reactive HTTP response.
support
@NonNullApi @NonNullFields package org.springframework.http.client.support This package provides generic HTTP support classes, to be used by higher-level classes like RestTemplate.
Related Packages
org.springframework.http.client
Contains an abstraction over client-side HTTP.
org.springframework.http.client.observation
This package provides support for client HTTP Observation .
org.springframework.http.client.reactive
Abstractions for reactive HTTP client support including ClientHttpRequest and ClientHttpResponse as well as a ClientHttpConnector .
Classes
BasicAuthenticationInterceptor
ClientHttpRequestInterceptor to apply a given HTTP Basic Authentication username/password pair, unless a custom Authorization header has already been set.
HttpAccessor
Base class for RestTemplate and other HTTP accessing gateway helpers, defining common properties such as the ClientHttpRequestFactory to operate on.
HttpRequestWrapper
Provides a convenient implementation of the HttpRequest interface that can be overridden to adapt the request.
InterceptingHttpAccessor
Base class for RestTemplate and other HTTP accessing gateway helpers, adding interceptor-related properties to HttpAccessor 's common properties.
ProxyFactoryBean
FactoryBean that creates a java.net.Proxy .
codec
codec
@NonNullApi @NonNullFields package org.springframework.http.codec Provides implementations of Encoder and Decoder for web use. Also declares a high-level HttpMessageReader and HttpMessageWriter for reading and writing the body of HTTP requests and responses.
Related Packages
org.springframework.http
Contains a basic abstraction over client/server-side HTTP.
org.springframework.http.codec.cbor
CBOR encoder and decoder support.
org.springframework.http.codec.json
JSON encoder and decoder support.
org.springframework.http.codec.multipart
Multipart support.
org.springframework.http.codec.protobuf
Provides an encoder and a decoder for Google Protocol Buffers .
org.springframework.http.codec.support
Provides implementations of ClientCodecConfigurer and ServerCodecConfigurer based on the converter implementations from org.springframework.http.codec.json and co.
org.springframework.http.codec.xml
XML encoder and decoder support.
Interfaces
ClientCodecConfigurer
Extension of CodecConfigurer for HTTP message reader and writer options relevant on the client side.
ClientCodecConfigurer.ClientDefaultCodecs
CodecConfigurer.DefaultCodecs extension with extra client-side options.
CodecConfigurer
Defines a common interface for configuring either client or server HTTP message readers and writers.
CodecConfigurer.CustomCodecs
Registry for custom HTTP message readers and writers.
CodecConfigurer.DefaultCodecConfig
Exposes the values of properties configured through CodecConfigurer.defaultCodecs() that are applied to default codecs.
CodecConfigurer.DefaultCodecs
Customize or replace the HTTP message readers and writers registered by default.
CodecConfigurer.MultipartCodecs
Registry and container for multipart HTTP message writers.
HttpMessageDecoder<T>
Extension of Decoder exposing extra methods relevant in the context of HTTP request or response body decoding.
HttpMessageEncoder<T>
Extension of Encoder exposing extra methods relevant in the context of HTTP request or response body encoding.
HttpMessageReader<T>
Strategy for reading from a ReactiveHttpInputMessage and decoding the stream of bytes to Objects of type .
HttpMessageWriter<T>
Strategy for encoding a stream of objects of type and writing the encoded stream of bytes to an ReactiveHttpOutputMessage .
ServerCodecConfigurer
Extension of CodecConfigurer for HTTP message reader and writer options relevant on the server side.
ServerCodecConfigurer.ServerDefaultCodecs
CodecConfigurer.DefaultCodecs extension with extra server-side options.
ServerSentEvent.Builder<T>
A mutable builder for a SseEvent .
Classes
DecoderHttpMessageReader<T>
HttpMessageReader that wraps and delegates to a Decoder .
EncoderHttpMessageWriter<T>
HttpMessageWriter that wraps and delegates to an Encoder .
FormHttpMessageReader
Implementation of an HttpMessageReader to read HTML form data, i.e.
FormHttpMessageWriter
HttpMessageWriter for writing a MultiValueMap as HTML form data, i.e.
KotlinSerializationBinaryDecoder<T extends kotlinx.serialization.BinaryFormat>
Abstract base class for Decoder implementations that defer to Kotlin binary serializers.
KotlinSerializationBinaryEncoder<T extends kotlinx.serialization.BinaryFormat>
Abstract base class for Encoder implementations that defer to Kotlin binary serializers.
KotlinSerializationStringDecoder<T extends kotlinx.serialization.StringFormat>
Abstract base class for Decoder implementations that defer to Kotlin string serializers.
KotlinSerializationStringEncoder<T extends kotlinx.serialization.StringFormat>
Abstract base class for Encoder implementations that defer to Kotlin string serializers.
KotlinSerializationSupport<T extends kotlinx.serialization.SerialFormat>
Base class providing support methods for encoding and decoding with Kotlin serialization.
LoggingCodecSupport
Base class for Encoder , Decoder , HttpMessageReader , or HttpMessageWriter that uses a logger and shows potentially sensitive request data.
ResourceHttpMessageReader
HttpMessageReader that wraps and delegates to a ResourceDecoder that extracts the filename from the "Content-Disposition" header, if available, and passes it as the ResourceDecoder.FILENAME_HINT .
ResourceHttpMessageWriter
HttpMessageWriter that can write a Resource .
ServerSentEvent<T>
Representation for a Server-Sent Event for use with Spring's reactive Web support.
ServerSentEventHttpMessageReader
Reader that supports a stream of ServerSentEvents and also plain Objects which is the same as an ServerSentEvent with data only.
ServerSentEventHttpMessageWriter
HttpMessageWriter for "text/event-stream" responses.
cbor
@NonNullApi @NonNullFields package org.springframework.http.codec.cbor CBOR encoder and decoder support.
Related Packages
org.springframework.http.codec
Provides implementations of Encoder and Decoder for web use.
org.springframework.http.codec.json
JSON encoder and decoder support.
org.springframework.http.codec.multipart
Multipart support.
org.springframework.http.codec.protobuf
Provides an encoder and a decoder for Google Protocol Buffers .
org.springframework.http.codec.support
Provides implementations of ClientCodecConfigurer and ServerCodecConfigurer based on the converter implementations from org.springframework.http.codec.json and co.
org.springframework.http.codec.xml
XML encoder and decoder support.
Classes
Jackson2CborDecoder
Decode bytes into CBOR and convert to Object's with Jackson.
Jackson2CborEncoder
Encode from an Object to bytes of CBOR objects using Jackson.
KotlinSerializationCborDecoder
Decode a byte stream into CBOR and convert to Objects with kotlinx.serialization .
KotlinSerializationCborEncoder
Encode from an Object stream to a byte stream of CBOR objects using kotlinx.serialization .
json
@NonNullApi @NonNullFields package org.springframework.http.codec.json JSON encoder and decoder support.
Related Packages
org.springframework.http.codec
Provides implementations of Encoder and Decoder for web use.
org.springframework.http.codec.cbor
CBOR encoder and decoder support.
org.springframework.http.codec.multipart
Multipart support.
org.springframework.http.codec.protobuf
Provides an encoder and a decoder for Google Protocol Buffers .
org.springframework.http.codec.support
Provides implementations of ClientCodecConfigurer and ServerCodecConfigurer based on the converter implementations from org.springframework.http.codec.json and co.
org.springframework.http.codec.xml
XML encoder and decoder support.
Classes
AbstractJackson2Decoder
Abstract base class for Jackson 2.x decoding, leveraging non-blocking parsing.
AbstractJackson2Encoder
Base class providing support methods for Jackson 2.x encoding.
Jackson2CodecSupport
Base class providing support methods for Jackson 2.x encoding and decoding.
Jackson2JsonDecoder
Decode a byte stream into JSON and convert to Object's with Jackson 2.x, leveraging non-blocking parsing.
Jackson2JsonEncoder
Encode from an Object stream to a byte stream of JSON objects using Jackson 2.x.
Jackson2SmileDecoder
Decode a byte stream into Smile and convert to Object's with Jackson 2.x, leveraging non-blocking parsing.
Jackson2SmileEncoder
Encode from an Object stream to a byte stream of Smile objects using Jackson 2.x.
KotlinSerializationJsonDecoder
Decode a byte stream into JSON and convert to Object's with kotlinx.serialization .
KotlinSerializationJsonEncoder
Encode from an Object stream to a byte stream of JSON objects using kotlinx.serialization .
multipart
@NonNullApi @NonNullFields package org.springframework.http.codec.multipart Multipart support.
Related Packages
org.springframework.http.codec
Provides implementations of Encoder and Decoder for web use.
org.springframework.http.codec.cbor
CBOR encoder and decoder support.
org.springframework.http.codec.json
JSON encoder and decoder support.
org.springframework.http.codec.protobuf
Provides an encoder and a decoder for Google Protocol Buffers .
org.springframework.http.codec.support
Provides implementations of ClientCodecConfigurer and ServerCodecConfigurer based on the converter implementations from org.springframework.http.codec.json and co.
org.springframework.http.codec.xml
XML encoder and decoder support.
Classes
DefaultPartHttpMessageReader
Default HttpMessageReader for parsing "multipart/form-data" requests to a stream of Part s.
MultipartHttpMessageReader
HttpMessageReader for reading "multipart/form-data" requests into a MultiValueMap .
MultipartHttpMessageWriter
HttpMessageWriter for writing a MultiValueMap as multipart form data, i.e.
MultipartWriterSupport
Support class for multipart HTTP message writers.
PartEventHttpMessageReader
HttpMessageReader for parsing "multipart/form-data" requests to a stream of PartEvent elements.
PartEventHttpMessageWriter
HttpMessageWriter for writing PartEvent objects.
PartHttpMessageWriter
HttpMessageWriter for writing with Part .
Interfaces
FilePart
Specialization of Part that represents an uploaded file received in a multipart request.
FilePartEvent
Represents an event triggered for a file upload.
FormFieldPart
Specialization of Part for a form field.
FormPartEvent
Represents an event triggered for a form field.
Part
Representation for a part in a "multipart/form-data" request.
PartEvent
Represents an event for a "multipart/form-data" request.
protobuf
@NonNullApi @NonNullFields package org.springframework.http.codec.protobuf Provides an encoder and a decoder for Google Protocol Buffers.
Related Packages
org.springframework.http.codec
Provides implementations of Encoder and Decoder for web use.
org.springframework.http.codec.cbor
CBOR encoder and decoder support.
org.springframework.http.codec.json
JSON encoder and decoder support.
org.springframework.http.codec.multipart
Multipart support.
org.springframework.http.codec.support
Provides implementations of ClientCodecConfigurer and ServerCodecConfigurer based on the converter implementations from org.springframework.http.codec.json and co.
org.springframework.http.codec.xml
XML encoder and decoder support.
Classes
KotlinSerializationProtobufDecoder
Decode a byte stream into a protocol Buffer and convert to Objects with kotlinx.serialization .
KotlinSerializationProtobufEncoder
Decode a byte stream into a Protocol Buffer and convert to Objects with kotlinx.serialization .
ProtobufCodecSupport
Base class providing support methods for Protobuf encoding and decoding.
ProtobufDecoder
A Decoder that reads Message s using Google Protocol Buffers .
ProtobufEncoder
An Encoder that writes Message s using Google Protocol Buffers .
ProtobufHttpMessageWriter
HttpMessageWriter that can write a protobuf Message and adds X-Protobuf-Schema , X-Protobuf-Message headers and a delimited=true parameter is added to the content type if a flux is serialized.
support
@NonNullApi @NonNullFields package org.springframework.http.codec.support Provides implementations of ClientCodecConfigurer and ServerCodecConfigurer based on the converter implementations from org.springframework.http.codec.json and co.
Related Packages
org.springframework.http.codec
Provides implementations of Encoder and Decoder for web use.
org.springframework.http.codec.cbor
CBOR encoder and decoder support.
org.springframework.http.codec.json
JSON encoder and decoder support.
org.springframework.http.codec.multipart
Multipart support.
org.springframework.http.codec.protobuf
Provides an encoder and a decoder for Google Protocol Buffers .
org.springframework.http.codec.xml
XML encoder and decoder support.
Classes
DefaultClientCodecConfigurer
Default implementation of ClientCodecConfigurer .
DefaultServerCodecConfigurer
Default implementation of ServerCodecConfigurer .
xml
@NonNullApi @NonNullFields package org.springframework.http.codec.xml XML encoder and decoder support.
Related Packages
org.springframework.http.codec
Provides implementations of Encoder and Decoder for web use.
org.springframework.http.codec.cbor
CBOR encoder and decoder support.
org.springframework.http.codec.json
JSON encoder and decoder support.
org.springframework.http.codec.multipart
Multipart support.
org.springframework.http.codec.protobuf
Provides an encoder and a decoder for Google Protocol Buffers .
org.springframework.http.codec.support
Provides implementations of ClientCodecConfigurer and ServerCodecConfigurer based on the converter implementations from org.springframework.http.codec.json and co.
Classes
Jaxb2XmlDecoder
Decode from a bytes stream containing XML elements to a stream of Object s (POJOs).
Jaxb2XmlEncoder
Encode from single value to a byte stream containing XML elements.
XmlEventDecoder
Decodes a DataBuffer stream into a stream of XMLEvents .
converter
converter
@NonNullApi @NonNullFields package org.springframework.http.converter Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
Related Packages
org.springframework.http
Contains a basic abstraction over client/server-side HTTP.
org.springframework.http.converter.cbor
Provides an HttpMessageConverter for the CBOR data format.
org.springframework.http.converter.feed
Provides HttpMessageConverter implementations for handling Atom and RSS feeds.
org.springframework.http.converter.json
Provides HttpMessageConverter implementations for handling JSON.
org.springframework.http.converter.protobuf
Provides an HttpMessageConverter implementation for handling Google Protocol Buffers .
org.springframework.http.converter.smile
Provides an HttpMessageConverter for the Smile data format ("binary JSON").
org.springframework.http.converter.support
Provides a comprehensive HttpMessageConverter variant for form handling.
org.springframework.http.converter.xml
Provides HttpMessageConverter implementations for handling XML.
Classes
AbstractGenericHttpMessageConverter<T>
Abstract base class for most GenericHttpMessageConverter implementations.
AbstractHttpMessageConverter<T>
Abstract base class for most HttpMessageConverter implementations.
AbstractKotlinSerializationHttpMessageConverter<T extends kotlinx.serialization.SerialFormat>
Abstract base class for HttpMessageConverter implementations that use Kotlin serialization.
BufferedImageHttpMessageConverter
Implementation of HttpMessageConverter that can read and write BufferedImages .
ByteArrayHttpMessageConverter
Implementation of HttpMessageConverter that can read and write byte arrays.
FormHttpMessageConverter
Implementation of HttpMessageConverter to read and write 'normal' HTML forms and also to write (but not read) multipart data (e.g.
KotlinSerializationBinaryHttpMessageConverter<T extends kotlinx.serialization.BinaryFormat>
Abstract base class for HttpMessageConverter implementations that defer to Kotlin binary serializers.
KotlinSerializationStringHttpMessageConverter<T extends kotlinx.serialization.StringFormat>
Abstract base class for HttpMessageConverter implementations that defer to Kotlin string serializers.
ObjectToStringHttpMessageConverter
An HttpMessageConverter that uses StringHttpMessageConverter for reading and writing content and a ConversionService for converting the String content to and from the target object type.
ResourceHttpMessageConverter
Implementation of HttpMessageConverter that can read/write Resources and supports byte range requests.
ResourceRegionHttpMessageConverter
Implementation of HttpMessageConverter that can write a single ResourceRegion or Collections of ResourceRegions .
StringHttpMessageConverter
Implementation of HttpMessageConverter that can read and write strings.
Interfaces
GenericHttpMessageConverter<T>
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.
HttpMessageConverter<T>
Strategy interface for converting from and to HTTP requests and responses.
Exceptions
HttpMessageConversionException
Thrown by HttpMessageConverter implementations when a conversion attempt fails.
HttpMessageNotReadableException
Thrown by HttpMessageConverter implementations when the HttpMessageConverter.read(java.lang.Class, org.springframework.http.HttpInputMessage) method fails.
HttpMessageNotWritableException
Thrown by HttpMessageConverter implementations when the HttpMessageConverter.write(T, org.springframework.http.MediaType, org.springframework.http.HttpOutputMessage) method fails.
cbor
@NonNullApi @NonNullFields package org.springframework.http.converter.cbor Provides an HttpMessageConverter for the CBOR data format.
Related Packages
org.springframework.http.converter
Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
Classes
KotlinSerializationCborHttpMessageConverter
Implementation of HttpMessageConverter that can read and write CBOR using kotlinx.serialization .
MappingJackson2CborHttpMessageConverter
Implementation of HttpMessageConverter that can read and write the CBOR data format using the dedicated Jackson 2.x extension .
feed
@NonNullApi @NonNullFields package org.springframework.http.converter.feed Provides HttpMessageConverter implementations for handling Atom and RSS feeds. Based on the ROME tools project.
Related Packages
org.springframework.http.converter
Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
Classes
AbstractWireFeedHttpMessageConverter<T extends com.rometools.rome.feed.WireFeed>
Abstract base class for Atom and RSS Feed message converters, using the ROME tools project.
AtomFeedHttpMessageConverter
Implementation of HttpMessageConverter that can read and write Atom feeds.
RssChannelHttpMessageConverter
Implementation of HttpMessageConverter that can read and write RSS feeds.
json
@NonNullApi @NonNullFields package org.springframework.http.converter.json Provides HttpMessageConverter implementations for handling JSON.
Related Packages
org.springframework.http.converter
Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
Classes
AbstractJackson2HttpMessageConverter
Abstract base class for Jackson based and content type independent HttpMessageConverter implementations.
AbstractJsonHttpMessageConverter
Common base class for plain JSON converters, e.g.
GsonBuilderUtils
A simple utility class for obtaining a Google Gson 2.x GsonBuilder which Base64-encodes byte[] properties when reading and writing JSON.
GsonFactoryBean
A FactoryBean for creating a Google Gson 2.x Gson instance.
GsonHttpMessageConverter
Implementation of HttpMessageConverter that can read and write JSON using the Google Gson library.
Jackson2ObjectMapperBuilder
A builder used to create ObjectMapper instances with a fluent API.
Jackson2ObjectMapperFactoryBean
A FactoryBean for creating a Jackson 2.x ObjectMapper (default) or XmlMapper ( createXmlMapper property set to true) with setters to enable or disable Jackson features from within XML configuration.
JsonbHttpMessageConverter
Implementation of HttpMessageConverter that can read and write JSON using the JSON Binding API .
KotlinSerializationJsonHttpMessageConverter
Implementation of HttpMessageConverter that can read and write JSON using kotlinx.serialization .
MappingJackson2HttpMessageConverter
Implementation of HttpMessageConverter that can read and write JSON using Jackson 2.x's ObjectMapper .
MappingJacksonInputMessage
HttpInputMessage that can eventually stores a Jackson view that will be used to deserialize the message.
MappingJacksonValue
A simple holder for the POJO to serialize via MappingJackson2HttpMessageConverter along with further serialization instructions to be passed in to the converter.
SpringHandlerInstantiator
Allows for creating Jackson ( JsonSerializer , JsonDeserializer , KeyDeserializer , TypeResolverBuilder , TypeIdResolver ) beans with autowiring against a Spring ApplicationContext .
Interfaces
ProblemDetailJacksonMixin
An interface to associate Jackson annotations with ProblemDetail to avoid a hard dependency on the Jackson library.
ProblemDetailJacksonXmlMixin
Provides the same declarations as ProblemDetailJacksonMixin and some additional ones to support XML serialization when jackson-dataformat-xml is on the classpath.
protobuf
@NonNullApi @NonNullFields package org.springframework.http.converter.protobuf Provides an HttpMessageConverter implementation for handling Google Protocol Buffers.
Related Packages
org.springframework.http.converter
Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
Classes
KotlinSerializationProtobufHttpMessageConverter
Implementation of HttpMessageConverter that can read and write Protocol Buffers using kotlinx.serialization .
ProtobufHttpMessageConverter
An HttpMessageConverter that reads and writes com.google.protobuf.Messages using Google Protocol Buffers .
ProtobufJsonFormatHttpMessageConverter
Subclass of ProtobufHttpMessageConverter which enforces the use of Protobuf 3 and its official library "com.google.protobuf:protobuf-java-util" for JSON processing.
smile
@NonNullApi @NonNullFields package org.springframework.http.converter.smile Provides an HttpMessageConverter for the Smile data format ("binary JSON").
Related Packages
org.springframework.http.converter
Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
Classes
MappingJackson2SmileHttpMessageConverter
Implementation of HttpMessageConverter that can read and write Smile data format ("binary JSON") using the dedicated Jackson 2.x extension .
support
@NonNullApi @NonNullFields package org.springframework.http.converter.support Provides a comprehensive HttpMessageConverter variant for form handling.
Related Packages
org.springframework.http.converter
Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
Classes
AllEncompassingFormHttpMessageConverter
Extension of FormHttpMessageConverter , adding support for XML and JSON-based parts.
xml
@NonNullApi @NonNullFields package org.springframework.http.converter.xml Provides HttpMessageConverter implementations for handling XML.
Related Packages
org.springframework.http.converter
Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
Classes
AbstractJaxb2HttpMessageConverter<T>
Abstract base class for HttpMessageConverters that use JAXB2.
AbstractXmlHttpMessageConverter<T>
Abstract base class for HttpMessageConverters that convert from/to XML.
Jaxb2CollectionHttpMessageConverter<T extends Collection>
An HttpMessageConverter that can read XML collections using JAXB2.
Jaxb2RootElementHttpMessageConverter
Implementation of HttpMessageConverter that can read and write XML using JAXB2.
MappingJackson2XmlHttpMessageConverter
Implementation of HttpMessageConverter that can read and write XML using Jackson 2.x extension component for reading and writing XML encoded data .
MarshallingHttpMessageConverter
Implementation of HttpMessageConverter that can read and write XML using Spring's Marshaller and Unmarshaller abstractions.
SourceHttpMessageConverter<T extends Source>
Implementation of HttpMessageConverter that can read and write Source objects.
server
server
@NonNullApi @NonNullFields package org.springframework.http.server Contains an abstraction over server-side HTTP. This package contains the ServerHttpRequest and ServerHttpResponse, as well as a Servlet-based implementation of these interfaces.
Related Packages
org.springframework.http
Contains a basic abstraction over client/server-side HTTP.
org.springframework.http.server.observation
Instrumentation for observing HTTP server applications.
org.springframework.http.server.reactive
Abstractions for reactive HTTP server support including a ServerHttpRequest and ServerHttpResponse along with an HttpHandler for processing.
org.springframework.http.client
Contains an abstraction over client-side HTTP.
org.springframework.http.codec
Provides implementations of Encoder and Decoder for web use.
org.springframework.http.converter
Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
org.springframework.http.support
This package provides internal HTTP support classes, to be used by higher-level client and server classes.
Classes
DelegatingServerHttpResponse
Implementation of ServerHttpResponse that delegates all calls to a given target ServerHttpResponse .
PathContainer.Options
Options to customize parsing based on the type of input path.
ServletServerHttpAsyncRequestControl
A ServerHttpAsyncRequestControl to use on Servlet containers.
ServletServerHttpRequest
ServerHttpRequest implementation that is based on a HttpServletRequest .
ServletServerHttpResponse
ServerHttpResponse implementation that is based on a HttpServletResponse .
Interfaces
PathContainer
Structured representation of a URI path parsed via PathContainer.parsePath(String) into a sequence of PathContainer.Separator and PathContainer.PathSegment elements.
PathContainer.Element
A path element, either separator or path segment.
PathContainer.PathSegment
Path segment element.
PathContainer.Separator
Path separator element.
RequestPath
Specialization of PathContainer that subdivides the path into a RequestPath.contextPath() and the remaining RequestPath.pathWithinApplication() .
ServerHttpAsyncRequestControl
A control that can put the processing of an HTTP request in asynchronous mode during which the response remains open until explicitly closed.
ServerHttpRequest
Represents a server-side HTTP request.
ServerHttpResponse
Represents a server-side HTTP response.
observation
@NonNullApi @NonNullFields package org.springframework.http.server.observation Instrumentation for observing HTTP server applications.
Related Packages
org.springframework.http.server
Contains an abstraction over server-side HTTP.
org.springframework.http.server.reactive
Abstractions for reactive HTTP server support including a ServerHttpRequest and ServerHttpResponse along with an HttpHandler for processing.
Classes
DefaultServerRequestObservationConvention
Default ServerRequestObservationConvention .
ServerRequestObservationContext
Context that holds information for metadata collection regarding Servlet HTTP requests observations.
Enum Classes
ServerHttpObservationDocumentation
Documented KeyValues for the HTTP server observations for Servlet-based web applications.
ServerHttpObservationDocumentation.HighCardinalityKeyNames
ServerHttpObservationDocumentation.LowCardinalityKeyNames
Interfaces
ServerRequestObservationConvention
Interface for an ObservationConvention for Servlet HTTP requests .
reactive
reactive
@NonNullApi @NonNullFields package org.springframework.http.server.reactive Abstractions for reactive HTTP server support including a ServerHttpRequest and ServerHttpResponse along with an HttpHandler for processing. Also provides implementations adapting to different runtimes including Servlet containers, Netty + Reactor IO, and Undertow.
Related Packages
org.springframework.http.server
Contains an abstraction over server-side HTTP.
org.springframework.http.server.reactive.observation
Instrumentation for observing reactive HTTP server applications.
org.springframework.http.server.observation
Instrumentation for observing HTTP server applications.
Classes
AbstractListenerReadPublisher<T>
Abstract base class for Publisher implementations that bridge between event-listener read APIs and Reactive Streams.
AbstractListenerServerHttpResponse
Abstract base class for listener-based server responses.
AbstractListenerWriteFlushProcessor<T>
An alternative to AbstractListenerWriteProcessor but instead writing a Publisher> with flush boundaries enforces after the completion of each nested Publisher.
AbstractListenerWriteProcessor<T>
Abstract base class for Processor implementations that bridge between event-listener write APIs and Reactive Streams.
AbstractServerHttpRequest
Common base class for ServerHttpRequest implementations.
AbstractServerHttpResponse
Base class for ServerHttpResponse implementations.
ChannelSendOperator<T>
Given a write function that accepts a source Publisher to write with and returns Publisher 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.
ContextPathCompositeHandler
HttpHandler delegating requests to one of several HttpHandler 's based on simple, prefix-based mappings.
HttpHeadResponseDecorator
ServerHttpResponse decorator for HTTP HEAD requests.
JettyHttpHandlerAdapter
ServletHttpHandlerAdapter extension that uses Jetty APIs for writing to the response with ByteBuffer .
ReactorHttpHandlerAdapter
Adapt HttpHandler to the Reactor Netty channel handling function.
ReactorNetty2HttpHandlerAdapter
Adapt HttpHandler to the Reactor Netty 5 channel handling function.
ServerHttpRequestDecorator
Wraps another ServerHttpRequest and delegates all methods to it.
ServerHttpResponseDecorator
Wraps another ServerHttpResponse and delegates all methods to it.
ServletHttpHandlerAdapter
Adapt HttpHandler to an HttpServlet using Servlet Async support and Servlet non-blocking I/O.
TomcatHttpHandlerAdapter
ServletHttpHandlerAdapter extension that uses Tomcat APIs for reading from the request and writing to the response with ByteBuffer .
UndertowHttpHandlerAdapter
Adapt HttpHandler to the Undertow HttpHandler .
Interfaces
HttpHandler
Lowest level contract for reactive HTTP request handling that serves as a common denominator across different runtimes.
HttpHandlerDecoratorFactory
Contract for applying a decorator to an HttpHandler .
ServerHttpRequest
Represents a reactive server-side HTTP request.
ServerHttpRequest.Builder
Builder for mutating an existing ServerHttpRequest .
ServerHttpResponse
Represents a reactive server-side HTTP response.
SslInfo
A holder for SSL session information.
observation
@NonNullApi @NonNullFields package org.springframework.http.server.reactive.observation Instrumentation for observing reactive HTTP server applications.
Related Packages
org.springframework.http.server.reactive
Abstractions for reactive HTTP server support including a ServerHttpRequest and ServerHttpResponse along with an HttpHandler for processing.
Classes
DefaultServerRequestObservationConvention
Default ServerRequestObservationConvention .
ServerRequestObservationContext
Context that holds information for metadata collection regarding reactive HTTP requests observations.
Enum Classes
ServerHttpObservationDocumentation
Documented KeyValues for the HTTP server observations for reactive web applications.
ServerHttpObservationDocumentation.HighCardinalityKeyNames
ServerHttpObservationDocumentation.LowCardinalityKeyNames
Interfaces
ServerRequestObservationConvention
Interface for an ObservationConvention for reactive HTTP requests .
support
@NonNullApi @NonNullFields package org.springframework.http.support This package provides internal HTTP support classes, to be used by higher-level client and server classes.
Related Packages
org.springframework.http
Contains a basic abstraction over client/server-side HTTP.
org.springframework.http.client
Contains an abstraction over client-side HTTP.
org.springframework.http.codec
Provides implementations of Encoder and Decoder for web use.
org.springframework.http.converter
Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
org.springframework.http.server
Contains an abstraction over server-side HTTP.
Classes
HttpComponentsHeadersAdapter
MultiValueMap implementation for wrapping Apache HttpComponents HttpClient headers.
JettyHeadersAdapter
MultiValueMap implementation for wrapping Jetty HTTP headers.
Netty4HeadersAdapter
MultiValueMap implementation for wrapping Netty 4 HTTP headers.
Netty5HeadersAdapter
MultiValueMap implementation for wrapping Netty HTTP headers.
instrument
instrument
package org.springframework.instrument Core package for byte code instrumentation.
Related Packages
org.springframework.instrument.classloading
Support package for load time weaving based on class loaders, as required by JPA providers (but not JPA-specific).
Classes
InstrumentationSavingAgent
Java agent that saves the Instrumentation interface from the JVM for later use.
classloading
classloading
@NonNullApi @NonNullFields package org.springframework.instrument.classloading Support package for load time weaving based on class loaders, as required by JPA providers (but not JPA-specific).
Related Packages
org.springframework.instrument
Core package for byte code instrumentation.
org.springframework.instrument.classloading.glassfish
Support for class instrumentation on GlassFish.
org.springframework.instrument.classloading.jboss
Support for class instrumentation on JBoss AS 6 and 7.
org.springframework.instrument.classloading.tomcat
Support for class instrumentation on Tomcat.
Classes
InstrumentationLoadTimeWeaver
LoadTimeWeaver relying on VM Instrumentation .
ReflectiveLoadTimeWeaver
LoadTimeWeaver which uses reflection to delegate to an underlying ClassLoader with well-known transformation hooks.
ResourceOverridingShadowingClassLoader
Subclass of ShadowingClassLoader that overrides attempts to locate certain files.
ShadowingClassLoader
ClassLoader decorator that shadows an enclosing ClassLoader, applying registered transformers to all affected classes.
SimpleInstrumentableClassLoader
Simplistic implementation of an instrumentable ClassLoader .
SimpleLoadTimeWeaver
LoadTimeWeaver that builds and exposes a SimpleInstrumentableClassLoader .
SimpleThrowawayClassLoader
ClassLoader that can be used to load classes without bringing them into the parent loader.
WeavingTransformer
ClassFileTransformer-based weaver, allowing for a list of transformers to be applied on a class byte array.
Interfaces
LoadTimeWeaver
Defines the contract for adding one or more ClassFileTransformers to a ClassLoader .
glassfish
@NonNullApi @NonNullFields package org.springframework.instrument.classloading.glassfish Support for class instrumentation on GlassFish.
Related Packages
org.springframework.instrument.classloading
Support package for load time weaving based on class loaders, as required by JPA providers (but not JPA-specific).
org.springframework.instrument.classloading.jboss
Support for class instrumentation on JBoss AS 6 and 7.
org.springframework.instrument.classloading.tomcat
Support for class instrumentation on Tomcat.
Classes
GlassFishLoadTimeWeaver
LoadTimeWeaver implementation for GlassFish's org.glassfish.api.deployment.InstrumentableClassLoader InstrumentableClassLoader .
jboss
@NonNullApi @NonNullFields package org.springframework.instrument.classloading.jboss Support for class instrumentation on JBoss AS 6 and 7.
Related Packages
org.springframework.instrument.classloading
Support package for load time weaving based on class loaders, as required by JPA providers (but not JPA-specific).
org.springframework.instrument.classloading.glassfish
Support for class instrumentation on GlassFish.
org.springframework.instrument.classloading.tomcat
Support for class instrumentation on Tomcat.
Classes
JBossLoadTimeWeaver
LoadTimeWeaver implementation for JBoss's instrumentable ClassLoader.
tomcat
@NonNullApi @NonNullFields package org.springframework.instrument.classloading.tomcat Support for class instrumentation on Tomcat.
Related Packages
org.springframework.instrument.classloading
Support package for load time weaving based on class loaders, as required by JPA providers (but not JPA-specific).
org.springframework.instrument.classloading.glassfish
Support for class instrumentation on GlassFish.
org.springframework.instrument.classloading.jboss
Support for class instrumentation on JBoss AS 6 and 7.
Classes
TomcatLoadTimeWeaver
LoadTimeWeaver implementation for Tomcat's new org.apache.tomcat.InstrumentableClassLoader .
jca
endpoint
@NonNullApi @NonNullFields package org.springframework.jca.endpoint This package provides a facility for generic JCA message endpoint management.
Classes
AbstractMessageEndpointFactory
Abstract base implementation of the JCA 1.7 MessageEndpointFactory interface, providing transaction management capabilities as well as ClassLoader exposure for endpoint invocations.
GenericMessageEndpointFactory
Generic implementation of the JCA 1.7 MessageEndpointFactory interface, providing transaction management capabilities for any kind of message listener object (e.g.
GenericMessageEndpointManager
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.
Exceptions
GenericMessageEndpointFactory.InternalResourceException
Internal exception thrown when a ResourceException has been encountered during the endpoint invocation.
support
@NonNullApi @NonNullFields package org.springframework.jca.support Provides generic support classes for JCA usage within Spring, mainly for local setup of a JCA ResourceAdapter and/or ConnectionFactory.
Classes
LocalConnectionFactoryBean
FactoryBean that creates a local JCA connection factory in "non-managed" mode (as defined by the Java Connector Architecture specification).
ResourceAdapterFactoryBean
FactoryBean that bootstraps the specified JCA 1.7 ResourceAdapter , starting it with a local BootstrapContext and exposing it for bean references.
SimpleBootstrapContext
Simple implementation of the JCA 1.7 BootstrapContext interface, used for bootstrapping a JCA ResourceAdapter in a local environment.
jdbc
jdbc
@NonNullApi @NonNullFields package org.springframework.jdbc The classes in this package make JDBC easier to use and reduce the likelihood of common errors. In particular, they: Simplify error handling, avoiding the need for try/catch/finally blocks in application code. Present exceptions to application code in a generic hierarchy of unchecked exceptions, enabling applications to catch data access exceptions without being dependent on JDBC, and to ignore fatal exceptions there is no value in catching. Allow the implementation of error handling to be modified to target different RDBMSes without introducing proprietary dependencies into application code. This package and related packages are discussed in Chapter 9 of Expert One-On-One J2EE Design and Development by Rod Johnson (Wrox, 2002).
Related Packages
org.springframework.jdbc.config
Defines the Spring JDBC configuration namespace.
org.springframework.jdbc.core
Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.
org.springframework.jdbc.datasource
Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations.
org.springframework.jdbc.object
The classes in this package represent RDBMS queries, updates, and stored procedures as threadsafe, reusable objects.
org.springframework.jdbc.support
Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages.
Exceptions
BadSqlGrammarException
Exception thrown when SQL specified is invalid.
CannotGetJdbcConnectionException
Fatal exception thrown when we can't connect to an RDBMS using JDBC.
IncorrectResultSetColumnCountException
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 column.
InvalidResultSetAccessException
Exception thrown when a ResultSet has been accessed in an invalid fashion.
JdbcUpdateAffectedIncorrectNumberOfRowsException
Exception thrown when a JDBC update affects an unexpected number of rows.
LobRetrievalFailureException
Exception to be thrown when a LOB could not be retrieved.
SQLWarningException
Exception thrown when we're not ignoring SQLWarnings .
UncategorizedSQLException
Exception thrown when we can't classify an SQLException into one of our generic data access exceptions.
config
@NonNullApi @NonNullFields package org.springframework.jdbc.config Defines the Spring JDBC configuration namespace.
Related Packages
org.springframework.jdbc
The classes in this package make JDBC easier to use and reduce the likelihood of common errors.
org.springframework.jdbc.core
Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.
org.springframework.jdbc.datasource
Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations.
org.springframework.jdbc.object
The classes in this package represent RDBMS queries, updates, and stored procedures as threadsafe, reusable objects.
org.springframework.jdbc.support
Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages.
Classes
JdbcNamespaceHandler
NamespaceHandler for JDBC configuration namespace.
SortedResourcesFactoryBean
FactoryBean implementation that takes a list of location Strings and creates a sorted array of Resource instances.
core
core
@NonNullApi @NonNullFields package org.springframework.jdbc.core Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.
Related Packages
org.springframework.jdbc
The classes in this package make JDBC easier to use and reduce the likelihood of common errors.
org.springframework.jdbc.core.metadata
Context metadata abstraction for the configuration and execution of table inserts and stored procedure calls.
org.springframework.jdbc.core.namedparam
JdbcTemplate variant with named parameter support.
org.springframework.jdbc.core.simple
Simplification layer for common JDBC interactions.
org.springframework.jdbc.core.support
Classes supporting the org.springframework.jdbc.core package.
org.springframework.jdbc.config
Defines the Spring JDBC configuration namespace.
org.springframework.jdbc.datasource
Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations.
org.springframework.jdbc.object
The classes in this package represent RDBMS queries, updates, and stored procedures as threadsafe, reusable objects.
org.springframework.jdbc.support
Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages.
Classes
ArgumentPreparedStatementSetter
Simple adapter for PreparedStatementSetter that applies a given array of arguments.
ArgumentTypePreparedStatementSetter
Simple adapter for PreparedStatementSetter that applies the given arrays of arguments and JDBC argument types.
BeanPropertyRowMapper<T>
RowMapper implementation that converts a row into a new instance of the specified mapped target class.
CallableStatementCreatorFactory
Helper class that efficiently creates multiple CallableStatementCreator objects with different parameters based on an SQL statement and a single set of parameter declarations.
ColumnMapRowMapper
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.
DataClassRowMapper<T>
RowMapper implementation that converts a row into a new instance of the specified mapped target class.
JdbcTemplate
This is the central delegate in the JDBC core package. It can be used directly for many data access purposes, supporting any kind of JDBC operation.
PreparedStatementCreatorFactory
Helper class that efficiently creates multiple PreparedStatementCreator objects with different parameters based on an SQL statement and a single set of parameter declarations.
ResultSetSupportingSqlParameter
Common base class for ResultSet-supporting SqlParameters like SqlOutParameter and SqlReturnResultSet .
RowCountCallbackHandler
Implementation of RowCallbackHandler.
RowMapperResultSetExtractor<T>
Adapter implementation of the ResultSetExtractor interface that delegates to a RowMapper which is supposed to create an object for each row.
SimplePropertyRowMapper<T>
RowMapper implementation that converts a row into a new instance of the specified mapped target class.
SingleColumnRowMapper<T>
RowMapper implementation that converts a single column into a single result value per row.
SqlInOutParameter
Subclass of SqlOutParameter to represent an INOUT parameter.
SqlOutParameter
Subclass of SqlParameter to represent an output parameter.
SqlParameter
Object to represent an SQL parameter definition.
SqlParameterValue
Object to represent an SQL parameter value, including parameter meta-data such as the SQL type and the scale for numeric values.
SqlReturnResultSet
Represents a returned ResultSet from a stored procedure call.
SqlReturnUpdateCount
Represents a returned update count from a stored procedure call.
SqlRowSetResultSetExtractor
ResultSetExtractor implementation that returns a Spring SqlRowSet representation for each given ResultSet .
StatementCreatorUtils
Utility methods for PreparedStatementSetter/Creator and CallableStatementCreator implementations, providing sophisticated parameter management (including support for LOB values).
Interfaces
BatchPreparedStatementSetter
Batch update callback interface used by the JdbcTemplate class.
CallableStatementCallback<T>
Generic callback interface for code that operates on a CallableStatement.
CallableStatementCreator
One of the three central callback interfaces used by the JdbcTemplate class.
ConnectionCallback<T>
Generic callback interface for code that operates on a JDBC Connection.
DisposableSqlTypeValue
Subinterface of SqlTypeValue that adds a cleanup callback, to be invoked after the value has been set and the corresponding statement has been executed.
InterruptibleBatchPreparedStatementSetter
Extension of the BatchPreparedStatementSetter interface, adding a batch exhaustion check.
JdbcOperations
Interface specifying a basic set of JDBC operations.
ParameterDisposer
Interface to be implemented by objects that can close resources allocated by parameters like SqlLobValue objects.
ParameterizedPreparedStatementSetter<T>
Parameterized callback interface used by the JdbcTemplate class for batch updates.
ParameterMapper
Implement this interface when parameters need to be customized based on the connection.
PreparedStatementCallback<T>
Generic callback interface for code that operates on a PreparedStatement.
PreparedStatementCreator
One of the two central callback interfaces used by the JdbcTemplate class.
PreparedStatementSetter
General callback interface used by the JdbcTemplate class.
ResultSetExtractor<T>
Callback interface used by JdbcTemplate 's query methods.
RowCallbackHandler
An interface used by JdbcTemplate and NamedParameterJdbcTemplate for processing rows of a ResultSet on a per-row basis.
RowMapper<T>
An interface used by JdbcTemplate for mapping rows of a ResultSet on a per-row basis.
SqlProvider
Interface to be implemented by objects that can provide SQL strings.
SqlReturnType
Interface to be implemented for retrieving values for more complex database-specific types not supported by the standard CallableStatement.getObject method.
SqlTypeValue
Interface to be implemented for setting values for more complex database-specific types not supported by the standard setObject method.
StatementCallback<T>
Generic callback interface for code that operates on a JDBC Statement.
metadata
@NonNullApi @NonNullFields package org.springframework.jdbc.core.metadata Context metadata abstraction for the configuration and execution of table inserts and stored procedure calls.
Related Packages
org.springframework.jdbc.core
Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.
org.springframework.jdbc.core.namedparam
JdbcTemplate variant with named parameter support.
org.springframework.jdbc.core.simple
Simplification layer for common JDBC interactions.
org.springframework.jdbc.core.support
Classes supporting the org.springframework.jdbc.core package.
Classes
CallMetaDataContext
Class to manage context meta-data used for the configuration and execution of a stored procedure call.
CallMetaDataProviderFactory
Factory used to create a CallMetaDataProvider implementation based on the type of database being used.
CallParameterMetaData
Holder of meta-data for a specific parameter that is used for call processing.
Db2CallMetaDataProvider
DB2 specific implementation for the CallMetaDataProvider interface.
DerbyCallMetaDataProvider
Derby specific implementation for the CallMetaDataProvider interface.
DerbyTableMetaDataProvider
The Derby specific implementation of TableMetaDataProvider .
GenericCallMetaDataProvider
A generic implementation of the CallMetaDataProvider interface.
GenericTableMetaDataProvider
A generic implementation of the TableMetaDataProvider interface which should provide enough features for all supported databases.
HanaCallMetaDataProvider
SAP HANA specific implementation for the CallMetaDataProvider interface.
HsqlTableMetaDataProvider
The HSQL specific implementation of TableMetaDataProvider .
OracleCallMetaDataProvider
Oracle-specific implementation for the CallMetaDataProvider interface.
OracleTableMetaDataProvider
Oracle-specific implementation of the TableMetaDataProvider .
PostgresCallMetaDataProvider
Postgres-specific implementation for the CallMetaDataProvider interface.
PostgresTableMetaDataProvider
The PostgreSQL specific implementation of TableMetaDataProvider .
SqlServerCallMetaDataProvider
SQL Server specific implementation for the CallMetaDataProvider interface.
SybaseCallMetaDataProvider
Sybase specific implementation for the CallMetaDataProvider interface.
TableMetaDataContext
Class to manage context meta-data used for the configuration and execution of operations on a database table.
TableMetaDataProviderFactory
Factory used to create a TableMetaDataProvider implementation based on the type of database being used.
TableParameterMetaData
Holder of meta-data for a specific parameter that is used for table processing.
Interfaces
CallMetaDataProvider
Interface specifying the API to be implemented by a class providing call meta-data.
TableMetaDataProvider
Interface specifying the API to be implemented by a class providing table meta-data.
namedparam
@NonNullApi @NonNullFields package org.springframework.jdbc.core.namedparam JdbcTemplate variant with named parameter support. NamedParameterJdbcTemplate is a wrapper around JdbcTemplate that adds support for named parameter parsing. It does not implement the JdbcOperations interface or extend JdbcTemplate, but implements the dedicated NamedParameterJdbcOperations interface. If you need the full power of Spring JDBC for less common operations, use the getJdbcOperations() method of NamedParameterJdbcTemplate and work with the returned classic template, or use a JdbcTemplate instance directly.
Related Packages
org.springframework.jdbc.core
Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.
org.springframework.jdbc.core.metadata
Context metadata abstraction for the configuration and execution of table inserts and stored procedure calls.
org.springframework.jdbc.core.simple
Simplification layer for common JDBC interactions.
org.springframework.jdbc.core.support
Classes supporting the org.springframework.jdbc.core package.
Classes
AbstractSqlParameterSource
Abstract base class for SqlParameterSource implementations.
BeanPropertySqlParameterSource
SqlParameterSource implementation that obtains parameter values from bean properties of a given JavaBean object.
EmptySqlParameterSource
A simple empty implementation of the SqlParameterSource interface.
MapSqlParameterSource
SqlParameterSource implementation that holds a given Map of parameters.
NamedParameterJdbcDaoSupport
Extension of JdbcDaoSupport that exposes a NamedParameterJdbcTemplate as well.
NamedParameterJdbcTemplate
Template class with a basic set of JDBC operations, allowing the use of named parameters rather than traditional '?' placeholders.
NamedParameterUtils
Helper methods for named parameter parsing.
ParsedSql
Holds information about a parsed SQL statement.
SimplePropertySqlParameterSource
SqlParameterSource implementation that obtains parameter values from bean properties of a given JavaBean object, from component accessors of a record class, or from raw field access.
SqlParameterSourceUtils
Class that provides helper methods for the use of SqlParameterSource , in particular with NamedParameterJdbcTemplate .
Interfaces
NamedParameterJdbcOperations
Interface specifying a basic set of JDBC operations allowing the use of named parameters rather than the traditional '?' placeholders.
SqlParameterSource
Interface that defines common functionality for objects that can offer parameter values for named SQL parameters, serving as argument for NamedParameterJdbcTemplate operations.
simple
@NonNullApi @NonNullFields package org.springframework.jdbc.core.simple Simplification layer for common JDBC interactions. JdbcClient provides a fluent API for JDBC query and update operations, supporting JDBC-style positional as well as Spring-style named parameters. SimpleJdbcInsert and SimpleJdbcCall take advantage of database meta-data provided by the JDBC driver to simplify the application code. Much of the parameter specification becomes unnecessary since it can be looked up in the meta-data.
Related Packages
org.springframework.jdbc.core
Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.
org.springframework.jdbc.core.metadata
Context metadata abstraction for the configuration and execution of table inserts and stored procedure calls.
org.springframework.jdbc.core.namedparam
JdbcTemplate variant with named parameter support.
org.springframework.jdbc.core.support
Classes supporting the org.springframework.jdbc.core package.
Classes
AbstractJdbcCall
Abstract class to provide base functionality for easy stored procedure calls based on configuration options and database meta-data.
AbstractJdbcInsert
Abstract class to provide base functionality for easy (batch) inserts based on configuration options and database meta-data.
SimpleJdbcCall
A SimpleJdbcCall is a multithreaded, reusable object representing a call to a stored procedure or a stored function.
SimpleJdbcInsert
A SimpleJdbcInsert is a multi-threaded, reusable object providing easy (batch) insert capabilities for a table.
Interfaces
JdbcClient
A fluent JdbcClient with common JDBC query and update operations, supporting JDBC-style positional as well as Spring-style named parameters with a convenient unified facade for JDBC PreparedStatement execution.
JdbcClient.MappedQuerySpec<T>
A specification for RowMapper-mapped queries.
JdbcClient.ResultQuerySpec
A specification for simple result queries.
JdbcClient.StatementSpec
A statement specification for parameter bindings and query/update execution.
SimpleJdbcCallOperations
Interface specifying the API for a Simple JDBC Call implemented by SimpleJdbcCall .
SimpleJdbcInsertOperations
Interface specifying the API for a Simple JDBC Insert implemented by SimpleJdbcInsert .
support
@NonNullApi @NonNullFields package org.springframework.jdbc.core.support Classes supporting the org.springframework.jdbc.core package. Contains a DAO base class for JdbcTemplate usage.
Related Packages
org.springframework.jdbc.core
Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.
org.springframework.jdbc.core.metadata
Context metadata abstraction for the configuration and execution of table inserts and stored procedure calls.
org.springframework.jdbc.core.namedparam
JdbcTemplate variant with named parameter support.
org.springframework.jdbc.core.simple
Simplification layer for common JDBC interactions.
Classes
AbstractInterruptibleBatchPreparedStatementSetter
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) .
AbstractLobCreatingPreparedStatementCallback
Abstract PreparedStatementCallback implementation that manages a LobCreator .
AbstractLobStreamingResultSetExtractor<T>
Abstract ResultSetExtractor implementation that assumes streaming of LOB data.
AbstractSqlTypeValue
Abstract implementation of the SqlTypeValue interface, for convenient creation of type values that are supposed to be passed into the PreparedStatement.setObject method.
JdbcBeanDefinitionReader
Deprecated. as of 5.3, in favor of Spring's common bean definition formats and/or custom reader implementations
JdbcDaoSupport
Convenient superclass for JDBC-based data access objects.
SqlBinaryValue
Object to represent a binary parameter value for a SQL statement, e.g.
SqlCharacterValue
Object to represent a character-based parameter value for a SQL statement, e.g.
SqlLobValue
Object to represent an SQL BLOB/CLOB value parameter.
datasource
datasource
@NonNullApi @NonNullFields package org.springframework.jdbc.datasource Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations.
Related Packages
org.springframework.jdbc
The classes in this package make JDBC easier to use and reduce the likelihood of common errors.
org.springframework.jdbc.datasource.embedded
Provides extensible support for creating embedded database instances.
org.springframework.jdbc.datasource.init
Provides extensible support for initializing databases through scripts.
org.springframework.jdbc.datasource.lookup
Provides a strategy for looking up JDBC DataSources by name.
org.springframework.jdbc.config
Defines the Spring JDBC configuration namespace.
org.springframework.jdbc.core
Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.
org.springframework.jdbc.object
The classes in this package represent RDBMS queries, updates, and stored procedures as threadsafe, reusable objects.
org.springframework.jdbc.support
Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages.
Classes
AbstractDataSource
Abstract base class for Spring's DataSource implementations, taking care of the padding.
AbstractDriverBasedDataSource
Abstract base class for JDBC DataSource implementations that operate on a JDBC Driver .
ConnectionHolder
Resource holder wrapping a JDBC Connection .
DataSourceTransactionManager
PlatformTransactionManager implementation for a single JDBC DataSource .
DataSourceUtils
Helper class that provides static methods for obtaining JDBC Connection s from a DataSource .
DelegatingDataSource
JDBC DataSource implementation that delegates all calls to a given target DataSource .
DriverManagerDataSource
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.
IsolationLevelDataSourceAdapter
An adapter for a target DataSource , applying the current Spring transaction's isolation level (and potentially specified user credentials) to every getConnection call.
JdbcTransactionObjectSupport
Convenient base class for JDBC-aware transaction objects.
LazyConnectionDataSourceProxy
Proxy for a target DataSource, fetching actual JDBC Connections lazily, i.e.
ShardingKeyDataSourceAdapter
An adapter for a target DataSource , designed to apply sharding keys, if specified, to every standard #getConnection call, returning a direct connection to the shard corresponding to the specified sharding key value.
SimpleConnectionHandle
Simple implementation of the ConnectionHandle interface, containing a given JDBC Connection.
SimpleDriverDataSource
Simple implementation of the standard JDBC DataSource interface, configuring a plain old JDBC Driver via bean properties, and returning a new Connection from every getConnection call.
SingleConnectionDataSource
Implementation of SmartDataSource that wraps a single JDBC Connection which is not closed after use.
TransactionAwareDataSourceProxy
Proxy for a target JDBC DataSource , adding awareness of Spring-managed transactions.
UserCredentialsDataSourceAdapter
An adapter for a target JDBC DataSource , applying the specified user credentials to every standard getConnection() call, implicitly invoking getConnection(username, password) on the target.
Interfaces
ConnectionHandle
Simple interface to be implemented by handles for a JDBC Connection.
ConnectionProxy
Subinterface of Connection to be implemented by Connection proxies.
ShardingKeyProvider
Strategy interface for determining sharding keys which are used to establish direct shard connections in the context of sharded databases.
SmartDataSource
Extension of the javax.sql.DataSource interface, to be implemented by special DataSources that return JDBC Connections in an unwrapped fashion.
embedded
@NonNullApi @NonNullFields package org.springframework.jdbc.datasource.embedded Provides extensible support for creating embedded database instances.
Related Packages
org.springframework.jdbc.datasource
Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations.
org.springframework.jdbc.datasource.init
Provides extensible support for initializing databases through scripts.
org.springframework.jdbc.datasource.lookup
Provides a strategy for looking up JDBC DataSources by name.
Interfaces
ConnectionProperties
ConnectionProperties serves as a simple data container that allows essential JDBC connection properties to be configured consistently, independent of the actual DataSource implementation.
DataSourceFactory
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 .
EmbeddedDatabase
EmbeddedDatabase serves as a handle to an embedded database instance.
EmbeddedDatabaseConfigurer
EmbeddedDatabaseConfigurer encapsulates the configuration required to create, connect to, and shut down a specific type of embedded database such as HSQL, H2, or Derby.
Classes
EmbeddedDatabaseBuilder
A builder that provides a convenient API for constructing an embedded database.
EmbeddedDatabaseFactory
Factory for creating an EmbeddedDatabase instance.
EmbeddedDatabaseFactoryBean
A subclass of EmbeddedDatabaseFactory that implements FactoryBean for registration as a Spring bean.
OutputStreamFactory
Internal helper for exposing dummy OutputStreams to embedded databases such as Derby, preventing the creation of a log file.
Enum Classes
EmbeddedDatabaseType
A supported embedded database type.
init
@NonNullApi @NonNullFields package org.springframework.jdbc.datasource.init Provides extensible support for initializing databases through scripts.
Related Packages
org.springframework.jdbc.datasource
Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations.
org.springframework.jdbc.datasource.embedded
Provides extensible support for creating embedded database instances.
org.springframework.jdbc.datasource.lookup
Provides a strategy for looking up JDBC DataSources by name.
Exceptions
CannotReadScriptException
Thrown by ScriptUtils if an SQL script cannot be read.
ScriptException
Root of the hierarchy of data access exceptions that are related to processing of SQL scripts.
ScriptParseException
Thrown by ScriptUtils if an SQL script cannot be properly parsed.
ScriptStatementFailedException
Thrown by ScriptUtils if a statement in an SQL script failed when executing it against the target database.
UncategorizedScriptException
Thrown when we cannot determine anything more specific than "something went wrong while processing an SQL script": for example, a SQLException from JDBC that we cannot pinpoint more precisely.
Classes
CompositeDatabasePopulator
Composite DatabasePopulator that delegates to a list of given DatabasePopulator implementations, executing all scripts.
DatabasePopulatorUtils
Utility methods for executing a DatabasePopulator .
DataSourceInitializer
Used to set up a database during initialization and clean up a database during destruction.
ResourceDatabasePopulator
Populates, initializes, or cleans up a database using SQL scripts defined in external resources.
ScriptUtils
Generic utility methods for working with SQL scripts in conjunction with JDBC.
Interfaces
DatabasePopulator
Strategy used to populate, initialize, or clean up a database.
lookup
@NonNullApi @NonNullFields package org.springframework.jdbc.datasource.lookup Provides a strategy for looking up JDBC DataSources by name.
Related Packages
org.springframework.jdbc.datasource
Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations.
org.springframework.jdbc.datasource.embedded
Provides extensible support for creating embedded database instances.
org.springframework.jdbc.datasource.init
Provides extensible support for initializing databases through scripts.
Classes
AbstractRoutingDataSource
Abstract DataSource implementation that routes AbstractRoutingDataSource.getConnection() calls to one of various target DataSources based on a lookup key.
BeanFactoryDataSourceLookup
DataSourceLookup implementation based on a Spring BeanFactory .
IsolationLevelDataSourceRouter
DataSource that routes to one of various target DataSources based on the current transaction isolation level.
JndiDataSourceLookup
JNDI-based DataSourceLookup implementation.
MapDataSourceLookup
Simple DataSourceLookup implementation that relies on a map for doing lookups.
SingleDataSourceLookup
An implementation of the DataSourceLookup that simply wraps a single given DataSource, returned for any data source name.
Interfaces
DataSourceLookup
Strategy interface for looking up DataSources by name.
Exceptions
DataSourceLookupFailureException
Exception to be thrown by a DataSourceLookup implementation, indicating that the specified DataSource could not be obtained.
object
@NonNullApi @NonNullFields package org.springframework.jdbc.object The classes in this package represent RDBMS queries, updates, and stored procedures as threadsafe, reusable objects. This approach is modeled by JDO, although objects returned by queries are of course "disconnected" from the database. This higher-level JDBC abstraction depends on the lower-level abstraction in the org.springframework.jdbc.core package. Exceptions thrown are as in the org.springframework.dao package, meaning that code using this package does not need to implement JDBC or RDBMS-specific error handling. This package and related packages are discussed in Chapter 9 of Expert One-On-One J2EE Design and Development by Rod Johnson (Wrox, 2002).
Related Packages
org.springframework.jdbc
The classes in this package make JDBC easier to use and reduce the likelihood of common errors.
org.springframework.jdbc.config
Defines the Spring JDBC configuration namespace.
org.springframework.jdbc.core
Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.
org.springframework.jdbc.datasource
Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations.
org.springframework.jdbc.support
Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages.
Classes
BatchSqlUpdate
SqlUpdate subclass that performs batch update operations.
GenericSqlQuery<T>
A concrete variant of SqlQuery which can be configured with a RowMapper .
GenericStoredProcedure
Concrete implementation making it possible to define the RDBMS stored procedures in an application context without writing a custom Java implementation class.
MappingSqlQuery<T>
Reusable query in which concrete subclasses must implement the abstract mapRow(ResultSet, int) method to convert each row of the JDBC ResultSet into an object.
MappingSqlQueryWithParameters<T>
Reusable RDBMS query in which concrete subclasses must implement the abstract mapRow(ResultSet, int) method to map each row of the JDBC ResultSet into an object.
RdbmsOperation
An "RDBMS operation" is a multithreaded, reusable object representing a query, update, or stored procedure call.
SqlCall
RdbmsOperation using a JdbcTemplate and representing an SQL-based call such as a stored procedure or a stored function.
SqlFunction<T>
SQL "function" wrapper for a query that returns a single row of results.
SqlOperation
Operation object representing an SQL-based operation such as a query or update, as opposed to a stored procedure.
SqlQuery<T>
Reusable operation object representing an SQL query.
SqlUpdate
Reusable operation object representing an SQL update.
StoredProcedure
Superclass for object abstractions of RDBMS stored procedures.
UpdatableSqlQuery<T>
Reusable RDBMS query in which concrete subclasses must implement the abstract updateRow(ResultSet, int, context) method to update each row of the JDBC ResultSet and optionally map contents into an object.
support
support
@NonNullApi @NonNullFields package org.springframework.jdbc.support Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages. Provides a translator from SQLExceptions Spring's generic DataAccessExceptions. Can be used independently, for example in custom JDBC access code, or in JDBC-based O/R mapping layers.
Related Packages
org.springframework.jdbc
The classes in this package make JDBC easier to use and reduce the likelihood of common errors.
org.springframework.jdbc.support.incrementer
Provides a support framework for incrementing database table values via sequences, with implementations for various databases.
org.springframework.jdbc.support.lob
Provides a strategy interface for Large OBject handling, as well as a customizable default implementation.
org.springframework.jdbc.support.rowset
Provides a convenient holder for disconnected result sets.
org.springframework.jdbc.support.xml
Abstraction for handling fields of SQLXML data type.
org.springframework.jdbc.config
Defines the Spring JDBC configuration namespace.
org.springframework.jdbc.core
Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.
org.springframework.jdbc.datasource
Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations.
org.springframework.jdbc.object
The classes in this package represent RDBMS queries, updates, and stored procedures as threadsafe, reusable objects.
Classes
AbstractFallbackSQLExceptionTranslator
Base class for SQLExceptionTranslator implementations that allow for a fallback to some other SQLExceptionTranslator , as well as for custom overrides.
CustomSQLErrorCodesTranslation
JavaBean for holding custom JDBC error codes translation for a particular database.
CustomSQLExceptionTranslatorRegistrar
Registry for custom SQLExceptionTranslator instances for specific databases.
CustomSQLExceptionTranslatorRegistry
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".
DatabaseStartupValidator
Bean that checks if a database has already started up.
GeneratedKeyHolder
The standard implementation of the KeyHolder interface, to be used for holding auto-generated keys (as potentially returned by JDBC insert statements).
JdbcAccessor
Base class for JdbcTemplate and other JDBC-accessing DAO helpers, defining common properties such as DataSource and exception translator.
JdbcTransactionManager
JdbcAccessor -aligned subclass of the plain DataSourceTransactionManager , adding common JDBC exception translation for the commit and rollback step.
JdbcUtils
Generic utility methods for working with JDBC.
SqlArrayValue
Common SqlValue implementation for JDBC Array creation based on the JDBC 4 Connection.createArrayOf(java.lang.String, java.lang.Object[]) method.
SQLErrorCodes
JavaBean for holding JDBC error codes for a particular database.
SQLErrorCodesFactory
Factory for creating SQLErrorCodes based on the "databaseProductName" taken from the DatabaseMetaData .
SQLErrorCodeSQLExceptionTranslator
Implementation of SQLExceptionTranslator that analyzes vendor-specific error codes.
SQLExceptionSubclassTranslator
SQLExceptionTranslator implementation which analyzes the specific SQLException subclass thrown by the JDBC driver.
SQLStateSQLExceptionTranslator
SQLExceptionTranslator implementation that analyzes the SQL state in the SQLException based on the first two digits (the SQL state "class").
Interfaces
DatabaseMetaDataCallback<T>
A callback interface used by the JdbcUtils class.
KeyHolder
Interface for retrieving keys, typically used for auto-generated keys as potentially returned by JDBC insert statements.
SQLExceptionTranslator
Strategy interface for translating between SQLExceptions and Spring's data access strategy-agnostic DataAccessException hierarchy.
SqlValue
Simple interface for complex types to be set as statement parameters.
Exceptions
MetaDataAccessException
Exception indicating that something went wrong during JDBC meta-data lookup.
incrementer
@NonNullApi @NonNullFields package org.springframework.jdbc.support.incrementer Provides a support framework for incrementing database table values via sequences, with implementations for various databases. Can be used independently, for example in custom JDBC access code.
Related Packages
org.springframework.jdbc.support
Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages.
org.springframework.jdbc.support.lob
Provides a strategy interface for Large OBject handling, as well as a customizable default implementation.
org.springframework.jdbc.support.rowset
Provides a convenient holder for disconnected result sets.
org.springframework.jdbc.support.xml
Abstraction for handling fields of SQLXML data type.
Classes
AbstractColumnMaxValueIncrementer
Abstract base class for DataFieldMaxValueIncrementer implementations that use a column in a custom sequence table.
AbstractDataFieldMaxValueIncrementer
Base implementation of DataFieldMaxValueIncrementer that delegates to a single AbstractDataFieldMaxValueIncrementer.getNextKey() template method that returns a long .
AbstractIdentityColumnMaxValueIncrementer
Abstract base class for DataFieldMaxValueIncrementer implementations which are based on identity columns in a sequence-like table.
AbstractSequenceMaxValueIncrementer
Abstract base class for DataFieldMaxValueIncrementer implementations that use a database sequence.
Db2LuwMaxValueIncrementer
DataFieldMaxValueIncrementer that retrieves the next value of a given sequence on DB2 LUW (for Linux, Unix and Windows).
Db2MainframeMaxValueIncrementer
DataFieldMaxValueIncrementer that retrieves the next value of a given sequence on DB2 for the mainframe (z/OS, DB2/390, DB2/400).
DerbyMaxValueIncrementer
DataFieldMaxValueIncrementer that increments the maximum value of a given Derby table with the equivalent of an auto-increment column.
H2SequenceMaxValueIncrementer
DataFieldMaxValueIncrementer that retrieves the next value of a given H2 sequence.
HanaSequenceMaxValueIncrementer
DataFieldMaxValueIncrementer that retrieves the next value of a given SAP HANA sequence.
HsqlMaxValueIncrementer
DataFieldMaxValueIncrementer that increments the maximum value of a given HSQL table with the equivalent of an auto-increment column.
HsqlSequenceMaxValueIncrementer
DataFieldMaxValueIncrementer that retrieves the next value of a given HSQL sequence.
MariaDBSequenceMaxValueIncrementer
DataFieldMaxValueIncrementer that retrieves the next value of a given MariaDB sequence.
MySQLIdentityColumnMaxValueIncrementer
DataFieldMaxValueIncrementer that increments the maximum counter value of an auto-increment column of a given MySQL table.
MySQLMaxValueIncrementer
DataFieldMaxValueIncrementer that increments the maximum value of a given MySQL table with the equivalent of an auto-increment column.
OracleSequenceMaxValueIncrementer
DataFieldMaxValueIncrementer that retrieves the next value of a given Oracle sequence.
PostgresSequenceMaxValueIncrementer
DataFieldMaxValueIncrementer that retrieves the next value of a given PostgreSQL sequence.
SqlServerMaxValueIncrementer
DataFieldMaxValueIncrementer that increments the maximum value of a given SQL Server table with the equivalent of an auto-increment column.
SqlServerSequenceMaxValueIncrementer
DataFieldMaxValueIncrementer that retrieves the next value of a given SQL Server sequence.
SybaseAnywhereMaxValueIncrementer
DataFieldMaxValueIncrementer that increments the maximum value of a given Sybase table with the equivalent of an auto-increment column.
SybaseMaxValueIncrementer
DataFieldMaxValueIncrementer that increments the maximum value of a given Sybase table with the equivalent of an auto-increment column.
Interfaces
DataFieldMaxValueIncrementer
Interface that defines contract of incrementing any data store field's maximum value.
lob
Provides a strategy interface for Large OBject handling, as well as a customizable default implementation.
rowset
@NonNullApi @NonNullFields package org.springframework.jdbc.support.rowset Provides a convenient holder for disconnected result sets. Supported by JdbcTemplate, but can be used independently too.
Related Packages
org.springframework.jdbc.support
Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages.
org.springframework.jdbc.support.incrementer
Provides a support framework for incrementing database table values via sequences, with implementations for various databases.
org.springframework.jdbc.support.lob
Provides a strategy interface for Large OBject handling, as well as a customizable default implementation.
org.springframework.jdbc.support.xml
Abstraction for handling fields of SQLXML data type.
Classes
ResultSetWrappingSqlRowSet
The default implementation of Spring's SqlRowSet interface, wrapping a ResultSet , catching any SQLExceptions and translating them to a corresponding Spring InvalidResultSetAccessException .
ResultSetWrappingSqlRowSetMetaData
The default implementation of Spring's SqlRowSetMetaData interface, wrapping a ResultSetMetaData instance, catching any SQLExceptions and translating them to a corresponding Spring InvalidResultSetAccessException .
Interfaces
SqlRowSet
Mirror interface for RowSet , representing a disconnected variant of ResultSet data.
SqlRowSetMetaData
Metadata interface for Spring's SqlRowSet , analogous to JDBC's ResultSetMetaData .
xml
@NonNullApi @NonNullFields package org.springframework.jdbc.support.xml Abstraction for handling fields of SQLXML data type.
Related Packages
org.springframework.jdbc.support
Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages.
org.springframework.jdbc.support.incrementer
Provides a support framework for incrementing database table values via sequences, with implementations for various databases.
org.springframework.jdbc.support.lob
Provides a strategy interface for Large OBject handling, as well as a customizable default implementation.
org.springframework.jdbc.support.rowset
Provides a convenient holder for disconnected result sets.
Classes
Jdbc4SqlXmlHandler
Default implementation of the SqlXmlHandler interface.
Exceptions
SqlXmlFeatureNotImplementedException
Exception thrown when the underlying implementation does not support the requested feature of the API.
Interfaces
SqlXmlHandler
Abstraction for handling XML fields in specific databases.
SqlXmlValue
Subinterface of SqlValue that specifically indicates passing in XML data to a specified column.
XmlBinaryStreamProvider
Interface defining handling involved with providing OutputStream data for XML input.
XmlCharacterStreamProvider
Interface defining handling involved with providing Writer data for XML input.
XmlResultProvider
Interface defining handling involved with providing Result data for XML input.
jms
jms
@NonNullApi @NonNullFields package org.springframework.jms This package contains integration classes for JMS, allowing for Spring-style JMS access.
Related Packages
org.springframework.jms.annotation
Annotations and support classes for declarative JMS listener endpoints.
org.springframework.jms.config
Support package for declarative messaging configuration, with Java configuration and XML schema support.
org.springframework.jms.connection
Provides a PlatformTransactionManager implementation for a single JMS ConnectionFactory, and a SingleConnectionFactory adapter.
org.springframework.jms.core
Core package of the JMS support.
org.springframework.jms.listener
This package contains the base message listener container facility.
org.springframework.jms.support
This package provides generic JMS support classes, to be used by higher-level classes like JmsTemplate.
Exceptions
IllegalStateException
Runtime exception mirroring the JMS IllegalStateException.
InvalidClientIDException
Runtime exception mirroring the JMS InvalidClientIDException.
InvalidDestinationException
Runtime exception mirroring the JMS InvalidDestinationException.
InvalidSelectorException
Runtime exception mirroring the JMS InvalidSelectorException.
JmsException
Base class for exception thrown by the framework whenever it encounters a problem related to JMS.
JmsSecurityException
Runtime exception mirroring the JMS JMSSecurityException.
MessageEOFException
Runtime exception mirroring the JMS MessageEOFException.
MessageFormatException
Runtime exception mirroring the JMS MessageFormatException.
MessageNotReadableException
Runtime exception mirroring the JMS MessageNotReadableException.
MessageNotWriteableException
Runtime exception mirroring the JMS MessageNotWriteableException.
ResourceAllocationException
Runtime exception mirroring the JMS ResourceAllocationException.
TransactionInProgressException
Runtime exception mirroring the JMS TransactionInProgressException.
TransactionRolledBackException
Runtime exception mirroring the JMS TransactionRolledBackException.
UncategorizedJmsException
JmsException to be thrown when no other matching subclass found.
annotation
@NonNullApi @NonNullFields package org.springframework.jms.annotation Annotations and support classes for declarative JMS listener endpoints.
Related Packages
org.springframework.jms
This package contains integration classes for JMS, allowing for Spring-style JMS access.
org.springframework.jms.config
Support package for declarative messaging configuration, with Java configuration and XML schema support.
org.springframework.jms.connection
Provides a PlatformTransactionManager implementation for a single JMS ConnectionFactory, and a SingleConnectionFactory adapter.
org.springframework.jms.core
Core package of the JMS support.
org.springframework.jms.listener
This package contains the base message listener container facility.
org.springframework.jms.support
This package provides generic JMS support classes, to be used by higher-level classes like JmsTemplate.
Annotation Interfaces
EnableJms
Enable JMS listener annotated endpoints that are created under the cover by a JmsListenerContainerFactory .
JmsListener
Annotation that marks a method to be the target of a JMS message listener on the specified JmsListener.destination() .
JmsListeners
Container annotation that aggregates several JmsListener annotations.
Classes
JmsBootstrapConfiguration
@Configuration class that registers a JmsListenerAnnotationBeanPostProcessor bean capable of processing Spring's @JmsListener annotation.
JmsListenerAnnotationBeanPostProcessor
Bean post-processor that registers methods annotated with JmsListener to be invoked by a JMS message listener container created under the cover by a JmsListenerContainerFactory according to the attributes of the annotation.
Interfaces
JmsListenerConfigurer
Optional interface to be implemented by a Spring managed bean willing to customize how JMS listener endpoints are configured.
config
@NonNullApi @NonNullFields package org.springframework.jms.config Support package for declarative messaging configuration, with Java configuration and XML schema support.
Related Packages
org.springframework.jms
This package contains integration classes for JMS, allowing for Spring-style JMS access.
org.springframework.jms.annotation
Annotations and support classes for declarative JMS listener endpoints.
org.springframework.jms.connection
Provides a PlatformTransactionManager implementation for a single JMS ConnectionFactory, and a SingleConnectionFactory adapter.
org.springframework.jms.core
Core package of the JMS support.
org.springframework.jms.listener
This package contains the base message listener container facility.
org.springframework.jms.support
This package provides generic JMS support classes, to be used by higher-level classes like JmsTemplate.
Classes
AbstractJmsListenerContainerFactory<C extends AbstractMessageListenerContainer>
Base JmsListenerContainerFactory for Spring's base container implementation.
AbstractJmsListenerEndpoint
Base model for a JMS listener endpoint.
DefaultJcaListenerContainerFactory
A JmsListenerContainerFactory implementation to build a JCA-based JmsMessageEndpointManager .
DefaultJmsListenerContainerFactory
A JmsListenerContainerFactory implementation to build a regular DefaultMessageListenerContainer .
JmsListenerConfigUtils
Configuration constants for internal sharing across subpackages.
JmsListenerEndpointRegistrar
Helper bean for registering JmsListenerEndpoint with a JmsListenerEndpointRegistry .
JmsListenerEndpointRegistry
Creates the necessary MessageListenerContainer instances for the registered endpoints .
JmsNamespaceHandler
A NamespaceHandler for the JMS namespace.
MethodJmsListenerEndpoint
A JmsListenerEndpoint providing the method to invoke to process an incoming message for this endpoint.
SimpleJmsListenerContainerFactory
A JmsListenerContainerFactory implementation to build a standard SimpleMessageListenerContainer .
SimpleJmsListenerEndpoint
A JmsListenerEndpoint simply providing the MessageListener to invoke to process an incoming message for this endpoint.
Interfaces
JmsListenerContainerFactory<C extends MessageListenerContainer>
Factory of MessageListenerContainer based on a JmsListenerEndpoint definition.
JmsListenerEndpoint
Model for a JMS listener endpoint.
connection
@NonNullApi @NonNullFields package org.springframework.jms.connection Provides a PlatformTransactionManager implementation for a single JMS ConnectionFactory, and a SingleConnectionFactory adapter.
Related Packages
org.springframework.jms
This package contains integration classes for JMS, allowing for Spring-style JMS access.
org.springframework.jms.annotation
Annotations and support classes for declarative JMS listener endpoints.
org.springframework.jms.config
Support package for declarative messaging configuration, with Java configuration and XML schema support.
org.springframework.jms.core
Core package of the JMS support.
org.springframework.jms.listener
This package contains the base message listener container facility.
org.springframework.jms.support
This package provides generic JMS support classes, to be used by higher-level classes like JmsTemplate.
Classes
CachingConnectionFactory
SingleConnectionFactory subclass that adds Session caching as well as MessageProducer and MessageConsumer caching.
ChainedExceptionListener
Implementation of the JMS ExceptionListener interface that supports chaining, allowing the addition of multiple ExceptionListener instances in order.
ConnectionFactoryUtils
Helper class for managing a JMS ConnectionFactory , in particular for obtaining transactional JMS resources for a given ConnectionFactory.
DelegatingConnectionFactory
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.
JmsResourceHolder
Resource holder wrapping a JMS Connection and a JMS Session .
JmsTransactionManager
PlatformTransactionManager implementation for a single JMS ConnectionFactory .
SingleConnectionFactory
A JMS ConnectionFactory adapter that returns the same Connection from all SingleConnectionFactory.createConnection() calls, and ignores calls to Connection.close() .
TransactionAwareConnectionFactoryProxy
Proxy for a target JMS ConnectionFactory , adding awareness of Spring-managed transactions.
UserCredentialsConnectionFactoryAdapter
An adapter for a target JMS ConnectionFactory , applying the given user credentials to every standard createConnection() call, that is, implicitly invoking createConnection(username, password) on the target.
Interfaces
ConnectionFactoryUtils.ResourceFactory
Callback interface for resource creation.
SessionProxy
Subinterface of Session to be implemented by Session proxies.
SmartConnectionFactory
Extension of the jakarta.jms.ConnectionFactory interface, indicating how to release Connections obtained from it.
Exceptions
SynchedLocalTransactionFailedException
Exception thrown when a synchronized local transaction failed to complete (after the main transaction has already completed).
core
core
@NonNullApi @NonNullFields package org.springframework.jms.core Core package of the JMS support. Provides a JmsTemplate class and various callback interfaces.
Related Packages
org.springframework.jms
This package contains integration classes for JMS, allowing for Spring-style JMS access.
org.springframework.jms.core.support
Classes supporting the org.springframework.jms.core package.
org.springframework.jms.annotation
Annotations and support classes for declarative JMS listener endpoints.
org.springframework.jms.config
Support package for declarative messaging configuration, with Java configuration and XML schema support.
org.springframework.jms.connection
Provides a PlatformTransactionManager implementation for a single JMS ConnectionFactory, and a SingleConnectionFactory adapter.
org.springframework.jms.listener
This package contains the base message listener container facility.
org.springframework.jms.support
This package provides generic JMS support classes, to be used by higher-level classes like JmsTemplate.
Interfaces
BrowserCallback<T>
Callback for browsing the messages in a JMS queue.
JmsMessageOperations
A specialization of MessageSendingOperations , MessageReceivingOperations and MessageRequestReplyOperations for JMS related operations that allow to specify a destination name rather than the actual Destination .
JmsOperations
Specifies a basic set of JMS operations.
MessageCreator
Creates a JMS message given a Session .
MessagePostProcessor
To be used with JmsTemplate's send method that converts an object to a message.
ProducerCallback<T>
Callback for sending a message to a JMS destination.
SessionCallback<T>
Callback for executing any number of operations on a provided Session .
Classes
JmsMessagingTemplate
An implementation of JmsMessageOperations .
JmsTemplate
Helper class that simplifies synchronous JMS access code.
support
@NonNullApi @NonNullFields package org.springframework.jms.core.support Classes supporting the org.springframework.jms.core package. Contains a base class for JmsTemplate usage.
Related Packages
org.springframework.jms.core
Core package of the JMS support.
Classes
JmsGatewaySupport
Convenient superclass for application classes that need JMS access.
listener
listener
@NonNullApi @NonNullFields package org.springframework.jms.listener This package contains the base message listener container facility. It also offers the DefaultMessageListenerContainer and SimpleMessageListenerContainer implementations, based on the plain JMS client API.
Related Packages
org.springframework.jms
This package contains integration classes for JMS, allowing for Spring-style JMS access.
org.springframework.jms.listener.adapter
Message listener adapter mechanism that delegates to target listener methods, converting messages to appropriate message content types (such as String or byte array) that get passed into listener methods.
org.springframework.jms.listener.endpoint
This package provides JCA-based endpoint management for JMS message listeners.
org.springframework.jms.annotation
Annotations and support classes for declarative JMS listener endpoints.
org.springframework.jms.config
Support package for declarative messaging configuration, with Java configuration and XML schema support.
org.springframework.jms.connection
Provides a PlatformTransactionManager implementation for a single JMS ConnectionFactory, and a SingleConnectionFactory adapter.
org.springframework.jms.core
Core package of the JMS support.
org.springframework.jms.support
This package provides generic JMS support classes, to be used by higher-level classes like JmsTemplate.
Classes
AbstractJmsListeningContainer
Common base class for all containers which need to implement listening based on a JMS Connection (either shared or freshly obtained for each attempt).
AbstractMessageListenerContainer
Abstract base class for Spring message listener container implementations.
AbstractPollingMessageListenerContainer
Base class for listener container implementations which are based on polling.
DefaultMessageListenerContainer
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).
SimpleMessageListenerContainer
Message listener container that uses the plain JMS client API's MessageConsumer.setMessageListener() method to create concurrent MessageConsumers for the specified listeners.
Exceptions
AbstractJmsListeningContainer.SharedConnectionNotInitializedException
Exception that indicates that the initial setup of this container's shared JMS Connection failed.
Interfaces
MessageListenerContainer
Internal abstraction used by the framework representing a message listener container.
SessionAwareMessageListener<M extends Message>
Variant of the standard JMS MessageListener interface, offering not only the received Message but also the underlying JMS Session object.
SubscriptionNameProvider
Interface to be implemented by message listener objects that suggest a specific name for a durable subscription that they might be registered with.
adapter
@NonNullApi @NonNullFields package org.springframework.jms.listener.adapter Message listener adapter mechanism that delegates to target listener methods, converting messages to appropriate message content types (such as String or byte array) that get passed into listener methods.
Related Packages
org.springframework.jms.listener
This package contains the base message listener container facility.
org.springframework.jms.listener.endpoint
This package provides JCA-based endpoint management for JMS message listeners.
Classes
AbstractAdaptableMessageListener
An abstract JMS MessageListener adapter providing the necessary infrastructure to extract the payload of a JMS Message .
JmsResponse<T>
Return type of any JMS listener method used to indicate the actual response destination alongside the response itself.
MessageListenerAdapter
Message listener adapter that delegates the handling of messages to target listener methods via reflection, with flexible message type conversion.
MessagingMessageListenerAdapter
A MessageListener adapter that invokes a configurable InvocableHandlerMethod .
Exceptions
ListenerExecutionFailedException
Exception to be thrown when the execution of a listener method failed.
ReplyFailureException
Exception to be thrown when the reply of a message failed to be sent.
endpoint
@NonNullApi @NonNullFields package org.springframework.jms.listener.endpoint This package provides JCA-based endpoint management for JMS message listeners.
Related Packages
org.springframework.jms.listener
This package contains the base message listener container facility.
org.springframework.jms.listener.adapter
Message listener adapter mechanism that delegates to target listener methods, converting messages to appropriate message content types (such as String or byte array) that get passed into listener methods.
Classes
DefaultJmsActivationSpecFactory
Default implementation of the JmsActivationSpecFactory interface.
JmsActivationSpecConfig
Common configuration object for activating a JMS message endpoint.
JmsMessageEndpointFactory
JMS-specific implementation of the JCA 1.7 MessageEndpointFactory interface, providing transaction management capabilities for a JMS listener object (e.g.
JmsMessageEndpointManager
Extension of the generic JCA 1.5 GenericMessageEndpointManager , adding JMS-specific support for ActivationSpec configuration.
StandardJmsActivationSpecFactory
Standard implementation of the JmsActivationSpecFactory interface.
Interfaces
JmsActivationSpecFactory
Strategy interface for creating JCA 1.5 ActivationSpec objects based on a configured JmsActivationSpecConfig object.
Exceptions
JmsMessageEndpointFactory.JmsResourceException
Internal exception thrown when a ResourceException has been encountered during the endpoint invocation.
support
support
@NonNullApi @NonNullFields package org.springframework.jms.support This package provides generic JMS support classes, to be used by higher-level classes like JmsTemplate.
Related Packages
org.springframework.jms
This package contains integration classes for JMS, allowing for Spring-style JMS access.
org.springframework.jms.support.converter
Provides a MessageConverter abstraction to convert between Java objects and JMS messages.
org.springframework.jms.support.destination
Support classes for Spring's JMS framework.
org.springframework.jms.annotation
Annotations and support classes for declarative JMS listener endpoints.
org.springframework.jms.config
Support package for declarative messaging configuration, with Java configuration and XML schema support.
org.springframework.jms.connection
Provides a PlatformTransactionManager implementation for a single JMS ConnectionFactory, and a SingleConnectionFactory adapter.
org.springframework.jms.core
Core package of the JMS support.
org.springframework.jms.listener
This package contains the base message listener container facility.
Classes
JmsAccessor
Base class for JmsTemplate and other JMS-accessing gateway helpers, defining common properties such as the JMS ConnectionFactory to operate on.
JmsMessageHeaderAccessor
A MessageHeaderAccessor implementation giving access to JMS-specific headers.
JmsUtils
Generic utility methods for working with JMS.
QosSettings
Gather the Quality-of-Service settings that can be used when sending a message.
SimpleJmsHeaderMapper
Simple implementation of JmsHeaderMapper .
Interfaces
JmsHeaderMapper
Strategy interface for mapping Message headers to an outbound JMS Message (e.g.
JmsHeaders
Pre-defined names and prefixes to be used for setting and/or retrieving JMS attributes from/to generic message headers.
converter
@NonNullApi @NonNullFields package org.springframework.jms.support.converter Provides a MessageConverter abstraction to convert between Java objects and JMS messages.
Related Packages
org.springframework.jms.support
This package provides generic JMS support classes, to be used by higher-level classes like JmsTemplate.
org.springframework.jms.support.destination
Support classes for Spring's JMS framework.
Classes
MappingJackson2MessageConverter
Message converter that uses Jackson 2.x to convert messages to and from JSON.
MarshallingMessageConverter
Spring JMS MessageConverter that uses a Marshaller and Unmarshaller .
MessagingMessageConverter
Convert a Message from the messaging abstraction to and from a Message using an underlying MessageConverter for the payload and a JmsHeaderMapper to map the JMS headers to and from standard message headers.
SimpleMessageConverter
A simple message converter which is able to handle TextMessages, BytesMessages, MapMessages, and ObjectMessages.
Exceptions
MessageConversionException
Thrown by MessageConverter implementations when the conversion of an object to/from a Message fails.
Interfaces
MessageConverter
Strategy interface that specifies a converter between Java objects and JMS messages.
SmartMessageConverter
An extended MessageConverter SPI with conversion hint support.
Enum Classes
MessageType
Constants that indicate a target message type to convert to: a TextMessage , a BytesMessage , a MapMessage or an ObjectMessage .
destination
@NonNullApi @NonNullFields package org.springframework.jms.support.destination Support classes for Spring's JMS framework.
Related Packages
org.springframework.jms.support
This package provides generic JMS support classes, to be used by higher-level classes like JmsTemplate.
org.springframework.jms.support.converter
Provides a MessageConverter abstraction to convert between Java objects and JMS messages.
Classes
BeanFactoryDestinationResolver
DestinationResolver implementation based on a Spring BeanFactory .
DynamicDestinationResolver
Simple DestinationResolver implementation resolving destination names as dynamic destinations.
JmsDestinationAccessor
Base class for JmsTemplate and other JMS-accessing gateway helpers, adding destination-related properties to JmsAccessor's common properties.
JndiDestinationResolver
DestinationResolver implementation which interprets destination names as JNDI locations (with a configurable fallback strategy).
Interfaces
CachingDestinationResolver
Extension of the DestinationResolver interface, exposing methods for clearing the cache.
DestinationResolver
Strategy interface for resolving JMS destinations.
Exceptions
DestinationResolutionException
Thrown by a DestinationResolver when it cannot resolve a destination name.
jmx
jmx
@NonNullApi @NonNullFields package org.springframework.jmx This package contains Spring's JMX support, which includes registration of Spring-managed beans as JMX MBeans as well as access to remote JMX MBeans.
Related Packages
org.springframework.jmx.access
Provides support for accessing remote MBean resources.
org.springframework.jmx.export
This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
org.springframework.jmx.support
Contains support classes for connecting to local and remote MBeanServer s and for exposing an MBeanServer to remote clients.
Exceptions
JmxException
General base exception to be thrown on JMX errors.
MBeanServerNotFoundException
Exception thrown when we cannot locate an instance of an MBeanServer , or when more than one instance is found.
access
@NonNullApi @NonNullFields package org.springframework.jmx.access Provides support for accessing remote MBean resources.
Related Packages
org.springframework.jmx
This package contains Spring's JMX support, which includes registration of Spring-managed beans as JMX MBeans as well as access to remote JMX MBeans.
org.springframework.jmx.export
This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
org.springframework.jmx.support
Contains support classes for connecting to local and remote MBeanServer s and for exposing an MBeanServer to remote clients.
Exceptions
InvalidInvocationException
Thrown when trying to invoke an operation on a proxy that is not exposed by the proxied MBean resource's management interface.
InvocationFailureException
Thrown when an invocation on an MBean resource failed with an exception (either a reflection exception or an exception thrown by the target method itself).
MBeanConnectFailureException
Thrown when an invocation failed because of an I/O problem on the MBeanServerConnection.
MBeanInfoRetrievalException
Thrown if an exception is encountered when trying to retrieve MBean metadata.
Classes
MBeanClientInterceptor
MethodInterceptor that routes calls to an MBean running on the supplied MBeanServerConnection .
MBeanProxyFactoryBean
Creates a proxy to a managed resource running either locally or remotely.
NotificationListenerRegistrar
Registrar object that associates a specific NotificationListener with one or more MBeans in an MBeanServer (typically via a MBeanServerConnection ).
export
export
@NonNullApi @NonNullFields package org.springframework.jmx.export This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
Related Packages
org.springframework.jmx
This package contains Spring's JMX support, which includes registration of Spring-managed beans as JMX MBeans as well as access to remote JMX MBeans.
org.springframework.jmx.export.annotation
Annotations for MBean exposure.
org.springframework.jmx.export.assembler
Provides a strategy for MBeanInfo assembly.
org.springframework.jmx.export.metadata
Provides generic JMX metadata classes and basic support for reading JMX metadata in a provider-agnostic manner.
org.springframework.jmx.export.naming
Provides a strategy for ObjectName creation.
org.springframework.jmx.export.notification
Provides supporting infrastructure to allow Spring-created MBeans to send JMX notifications.
Classes
MBeanExporter
JMX exporter that allows for exposing any Spring-managed bean to a JMX MBeanServer , without the need to define any JMX-specific information in the bean classes.
NotificationListenerBean
Helper class that aggregates a NotificationListener , a NotificationFilter , and an arbitrary handback object.
SpringModelMBean
Extension of the RequiredModelMBean class that ensures the thread context ClassLoader is switched for the managed resource's ClassLoader before any invocations occur.
Interfaces
MBeanExporterListener
A listener that allows application code to be notified when an MBean is registered and unregistered via an MBeanExporter .
MBeanExportOperations
Interface that defines the set of MBean export operations that are intended to be accessed by application developers during application runtime.
Exceptions
MBeanExportException
Exception thrown in case of failure when exporting an MBean.
UnableToRegisterMBeanException
Exception thrown when we are unable to register an MBean, for example because of a naming conflict.
annotation
@NonNullApi @NonNullFields package org.springframework.jmx.export.annotation Annotations for MBean exposure. Hooked into Spring's JMX export infrastructure via a special JmxAttributeSource implementation.
Related Packages
org.springframework.jmx.export
This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
org.springframework.jmx.export.assembler
Provides a strategy for MBeanInfo assembly.
org.springframework.jmx.export.metadata
Provides generic JMX metadata classes and basic support for reading JMX metadata in a provider-agnostic manner.
org.springframework.jmx.export.naming
Provides a strategy for ObjectName creation.
org.springframework.jmx.export.notification
Provides supporting infrastructure to allow Spring-created MBeans to send JMX notifications.
Classes
AnnotationJmxAttributeSource
Implementation of the JmxAttributeSource interface that reads annotations and exposes the corresponding attributes.
AnnotationMBeanExporter
Convenient subclass of Spring's standard MBeanExporter , activating annotation usage for JMX exposure of Spring beans: ManagedResource , ManagedAttribute , ManagedOperation , etc.
Annotation Interfaces
ManagedAttribute
Method-level annotation that indicates to expose a given bean property as a JMX attribute, corresponding to the ManagedAttribute .
ManagedMetric
Method-level annotation that indicates to expose a given bean property as a JMX attribute, with added descriptor properties to indicate that it is a metric.
ManagedNotification
Type-level annotation that indicates a JMX notification emitted by a bean.
ManagedNotifications
Type-level annotation used as a container for one or more @ManagedNotification declarations.
ManagedOperation
Method-level annotation that indicates to expose a given method as a JMX operation, corresponding to the ManagedOperation attribute.
ManagedOperationParameter
Method-level annotation used to provide metadata about operation parameters, corresponding to a ManagedOperationParameter attribute.
ManagedOperationParameters
Method-level annotation used as a container for one or more @ManagedOperationParameter declarations.
ManagedResource
Class-level annotation that indicates to register instances of a class with a JMX server, corresponding to the ManagedResource attribute.
assembler
@NonNullApi @NonNullFields package org.springframework.jmx.export.assembler Provides a strategy for MBeanInfo assembly. Used by MBeanExporter to determine the attributes and operations to expose for Spring-managed beans.
Related Packages
org.springframework.jmx.export
This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
org.springframework.jmx.export.annotation
Annotations for MBean exposure.
org.springframework.jmx.export.metadata
Provides generic JMX metadata classes and basic support for reading JMX metadata in a provider-agnostic manner.
org.springframework.jmx.export.naming
Provides a strategy for ObjectName creation.
org.springframework.jmx.export.notification
Provides supporting infrastructure to allow Spring-created MBeans to send JMX notifications.
Classes
AbstractConfigurableMBeanInfoAssembler
Base class for MBeanInfoAssemblers that support configurable JMX notification behavior.
AbstractMBeanInfoAssembler
Abstract implementation of the MBeanInfoAssembler interface that encapsulates the creation of a ModelMBeanInfo instance but delegates the creation of metadata to subclasses.
AbstractReflectiveMBeanInfoAssembler
Builds on the AbstractMBeanInfoAssembler superclass to add a basic algorithm for building metadata based on the reflective metadata of the MBean class.
InterfaceBasedMBeanInfoAssembler
Subclass of AbstractReflectiveMBeanInfoAssembler that allows for the management interface of a bean to be defined using arbitrary interfaces.
MetadataMBeanInfoAssembler
Implementation of the MBeanInfoAssembler interface that reads the management interface information from source level metadata.
MethodExclusionMBeanInfoAssembler
AbstractReflectiveMBeanInfoAssembler subclass that allows method names to be explicitly excluded as MBean operations and attributes.
MethodNameBasedMBeanInfoAssembler
Subclass of AbstractReflectiveMBeanInfoAssembler that allows to specify method names to be exposed as MBean operations and attributes.
SimpleReflectiveMBeanInfoAssembler
Simple subclass of AbstractReflectiveMBeanInfoAssembler that always votes yes for method and property inclusion, effectively exposing all public methods and properties as operations and attributes.
Interfaces
AutodetectCapableMBeanInfoAssembler
Extends the MBeanInfoAssembler to add auto-detection logic.
MBeanInfoAssembler
Interface to be implemented by all classes that can create management interface metadata for a managed resource.
metadata
@NonNullApi @NonNullFields package org.springframework.jmx.export.metadata Provides generic JMX metadata classes and basic support for reading JMX metadata in a provider-agnostic manner.
Related Packages
org.springframework.jmx.export
This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
org.springframework.jmx.export.annotation
Annotations for MBean exposure.
org.springframework.jmx.export.assembler
Provides a strategy for MBeanInfo assembly.
org.springframework.jmx.export.naming
Provides a strategy for ObjectName creation.
org.springframework.jmx.export.notification
Provides supporting infrastructure to allow Spring-created MBeans to send JMX notifications.
Classes
AbstractJmxAttribute
Base class for all JMX metadata classes.
JmxMetadataUtils
Utility methods for converting Spring JMX metadata into their plain JMX equivalents.
ManagedAttribute
Metadata that indicates to expose a given bean property as JMX attribute.
ManagedMetric
Metadata that indicates to expose a given bean property as a JMX attribute, with additional descriptor properties that indicate that the attribute is a metric.
ManagedNotification
Metadata that indicates a JMX notification emitted by a bean.
ManagedOperation
Metadata that indicates to expose a given method as JMX operation.
ManagedOperationParameter
Metadata about JMX operation parameters.
ManagedResource
Metadata indicating that instances of an annotated class are to be registered with a JMX server.
Exceptions
InvalidMetadataException
Thrown by the JmxAttributeSource when it encounters incorrect metadata on a managed resource or one of its methods.
Interfaces
JmxAttributeSource
Interface used by the MetadataMBeanInfoAssembler to read source-level metadata from a managed resource's class.
naming
@NonNullApi @NonNullFields package org.springframework.jmx.export.naming Provides a strategy for ObjectName creation. Used by MBeanExporter to determine the JMX names to use for exported Spring-managed beans.
Related Packages
org.springframework.jmx.export
This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
org.springframework.jmx.export.annotation
Annotations for MBean exposure.
org.springframework.jmx.export.assembler
Provides a strategy for MBeanInfo assembly.
org.springframework.jmx.export.metadata
Provides generic JMX metadata classes and basic support for reading JMX metadata in a provider-agnostic manner.
org.springframework.jmx.export.notification
Provides supporting infrastructure to allow Spring-created MBeans to send JMX notifications.
Classes
IdentityNamingStrategy
An implementation of the ObjectNamingStrategy interface that creates a name based on the identity of a given instance.
KeyNamingStrategy
ObjectNamingStrategy implementation that builds ObjectName instances from the key used in the "beans" map passed to MBeanExporter .
MetadataNamingStrategy
An implementation of the ObjectNamingStrategy interface that reads the ObjectName from the source-level metadata.
Interfaces
ObjectNamingStrategy
Strategy interface that encapsulates the creation of ObjectName instances.
SelfNaming
Interface that allows infrastructure components to provide their own ObjectName s to the MBeanExporter .
notification
@NonNullApi @NonNullFields package org.springframework.jmx.export.notification Provides supporting infrastructure to allow Spring-created MBeans to send JMX notifications.
Related Packages
org.springframework.jmx.export
This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
org.springframework.jmx.export.annotation
Annotations for MBean exposure.
org.springframework.jmx.export.assembler
Provides a strategy for MBeanInfo assembly.
org.springframework.jmx.export.metadata
Provides generic JMX metadata classes and basic support for reading JMX metadata in a provider-agnostic manner.
org.springframework.jmx.export.naming
Provides a strategy for ObjectName creation.
Classes
ModelMBeanNotificationPublisher
NotificationPublisher implementation that uses the infrastructure provided by the ModelMBean interface to track javax.management.NotificationListeners and send Notifications to those listeners.
Interfaces
NotificationPublisher
Simple interface allowing Spring-managed MBeans to publish JMX notifications without being aware of how those notifications are being transmitted to the MBeanServer .
NotificationPublisherAware
Interface to be implemented by any Spring-managed resource that is to be registered with an MBeanServer and wishes to send JMX javax.management.Notifications .
Exceptions
UnableToSendNotificationException
Thrown when a JMX Notification is unable to be sent.
support
@NonNullApi @NonNullFields package org.springframework.jmx.support Contains support classes for connecting to local and remote MBeanServers and for exposing an MBeanServer to remote clients.
Related Packages
org.springframework.jmx
This package contains Spring's JMX support, which includes registration of Spring-managed beans as JMX MBeans as well as access to remote JMX MBeans.
org.springframework.jmx.access
Provides support for accessing remote MBean resources.
org.springframework.jmx.export
This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
Classes
ConnectorServerFactoryBean
FactoryBean that creates a JSR-160 JMXConnectorServer , optionally registers it with the MBeanServer , and then starts it.
JmxUtils
Collection of generic utility methods to support Spring JMX.
MBeanRegistrationSupport
Provides supporting infrastructure for registering MBeans with an MBeanServer .
MBeanServerConnectionFactoryBean
FactoryBean that creates a JMX 1.2 MBeanServerConnection to a remote MBeanServer exposed via a JMXServerConnector .
MBeanServerFactoryBean
FactoryBean that obtains a MBeanServer reference through the standard JMX 1.2 MBeanServerFactory API.
NotificationListenerHolder
Helper class that aggregates a NotificationListener , a NotificationFilter , and an arbitrary handback object, as well as the names of MBeans from which the listener wishes to receive Notifications .
ObjectNameManager
Helper class for the creation of ObjectName instances.
Enum Classes
MetricType
Represents how the measurement values of a ManagedMetric will change over time.
RegistrationPolicy
Indicates registration behavior when attempting to register an MBean that already exists.
jndi
jndi
@NonNullApi @NonNullFields package org.springframework.jndi The classes in this package make JNDI easier to use, facilitating the accessing of configuration stored in JNDI, and provide useful superclasses for JNDI access classes. The classes in this package are discussed in Chapter 11 of Expert One-On-One J2EE Design and Development by Rod Johnson (Wrox, 2002).
Related Packages
org.springframework.jndi.support
Support classes for JNDI usage, including a JNDI-based BeanFactory implementation.
Classes
JndiAccessor
Convenient superclass for JNDI accessors, providing "jndiTemplate" and "jndiEnvironment" bean properties.
JndiLocatorDelegate
JndiLocatorSupport subclass with public lookup methods, for convenient use as a delegate.
JndiLocatorSupport
Convenient superclass for classes that can locate any number of JNDI objects.
JndiObjectFactoryBean
FactoryBean that looks up a JNDI object.
JndiObjectLocator
Convenient superclass for JNDI-based service locators, providing configurable lookup of a specific JNDI resource.
JndiObjectTargetSource
AOP TargetSource that provides configurable JNDI lookups for getTarget() calls.
JndiPropertySource
PropertySource implementation that reads properties from an underlying Spring JndiLocatorDelegate .
JndiTemplate
Helper class that simplifies JNDI operations.
JndiTemplateEditor
Properties editor for JndiTemplate objects.
Interfaces
JndiCallback<T>
Callback interface to be implemented by classes that need to perform an operation (such as a lookup) in a JNDI context.
Exceptions
JndiLookupFailureException
RuntimeException to be thrown in case of JNDI lookup failures, in particular from code that does not declare JNDI's checked NamingException : for example, from Spring's JndiObjectTargetSource .
TypeMismatchNamingException
Exception thrown if a type mismatch is encountered for an object located in a JNDI environment.
support
@NonNullApi @NonNullFields package org.springframework.jndi.support Support classes for JNDI usage, including a JNDI-based BeanFactory implementation.
Related Packages
org.springframework.jndi
The classes in this package make JNDI easier to use, facilitating the accessing of configuration stored in JNDI, and provide useful superclasses for JNDI access classes.
Classes
SimpleJndiBeanFactory
Simple JNDI-based implementation of Spring's BeanFactory interface.
lang
package org.springframework.lang Common annotations with language-level semantics: nullability as well as JDK API indications. These annotations sit at the lowest level of Spring's package dependency arrangement, even lower than org.springframework.util, with no Spring-specific concepts implied. Used descriptively within the framework codebase. Can be validated by build-time tools (e.g. FindBugs or Animal Sniffer), alternative JVM languages (e.g. Kotlin), as well as IDEs (e.g. IntelliJ IDEA or Eclipse with corresponding project setup).
Annotation Interfaces
NonNull
A common Spring annotation to declare that annotated elements cannot be null .
NonNullApi
A common Spring annotation to declare that parameters and return values are to be considered as non-nullable by default for a given package.
NonNullFields
A common Spring annotation to declare that fields are to be considered as non-nullable by default for a given package.
Nullable
A common Spring annotation to declare that annotated elements can be null under certain circumstances.
@NonNullApi @NonNullFields package org.springframework.mail Spring's generic mail infrastructure. Concrete implementations are provided in the subpackages.
Related Packages
org.springframework.mail.javamail
JavaMail support for Spring's mail infrastructure.
Exceptions
MailAuthenticationException
Exception thrown on failed authentication.
MailException
Base class for all mail exceptions.
MailParseException
Exception thrown if illegal message properties are encountered.
MailPreparationException
Exception to be thrown by user code if a mail cannot be prepared properly, for example when a FreeMarker template cannot be rendered for the mail text.
MailSendException
Exception thrown when a mail sending error is encountered.
Interfaces
MailMessage
This is a common interface for mail messages, allowing a user to set key values required in assembling a mail message, without needing to know if the underlying message is a simple text message or a more sophisticated MIME message.
MailSender
This interface defines a strategy for sending simple mails.
Classes
SimpleMailMessage
Models a simple mail message, including data such as the from, to, cc, subject, and text fields.
javamail
JavaMail support for Spring's mail infrastructure.
messaging
messaging
@NonNullApi @NonNullFields package org.springframework.messaging Support for working with messaging APIs and protocols.
Related Packages
org.springframework.messaging.converter
Provides support for message conversion.
org.springframework.messaging.core
Defines interfaces and implementation classes for messaging templates.
org.springframework.messaging.handler
Basic abstractions for working with message handler methods.
org.springframework.messaging.rsocket
Support for the RSocket protocol.
org.springframework.messaging.simp
Generic support for Simple Messaging Protocols including protocols such as STOMP.
org.springframework.messaging.support
Provides implementations of Message along with a MessageBuilder and MessageHeaderAccessor for building and working with messages and message headers, as well as various MessageChannel implementations and channel interceptor support.
org.springframework.messaging.tcp
Contains abstractions and implementation classes for establishing TCP connections via TcpOperations , handling messages via TcpConnectionHandler , as well as sending messages via TcpConnection .
Interfaces
Message<T>
A generic message representation with headers and body.
MessageChannel
Defines methods for sending messages.
MessageHandler
Simple contract for handling a Message .
PollableChannel
A MessageChannel from which messages may be actively received through polling.
ReactiveMessageHandler
Reactive contract for handling a Message .
SubscribableChannel
A MessageChannel that maintains a registry of subscribers and invokes them to handle messages sent through this channel.
Exceptions
MessageDeliveryException
Exception that indicates an error occurred during message delivery.
MessageHandlingException
Exception that indicates an error occurred during message handling.
MessagingException
The base exception for any failures related to messaging.
Classes
MessageHeaders
The headers for a Message .
converter
@NonNullApi @NonNullFields package org.springframework.messaging.converter Provides support for message conversion.
Related Packages
org.springframework.messaging
Support for working with messaging APIs and protocols.
Classes
AbstractJsonMessageConverter
Common base class for plain JSON converters, e.g.
AbstractMessageConverter
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.
ByteArrayMessageConverter
A MessageConverter that supports MIME type "application/octet-stream" with the payload converted to and from a byte[].
CompositeMessageConverter
A MessageConverter that delegates to a list of registered converters to be invoked until one of them returns a non-null result.
DefaultContentTypeResolver
A default ContentTypeResolver that checks the MessageHeaders.CONTENT_TYPE header or falls back to a default value.
GenericMessageConverter
An extension of the SimpleMessageConverter that uses a ConversionService to convert the payload of the message to the requested type.
GsonMessageConverter
Implementation of MessageConverter that can read and write JSON using Google Gson .
JsonbMessageConverter
Implementation of MessageConverter that can read and write JSON using the JSON Binding API .
KotlinSerializationJsonMessageConverter
Implementation of MessageConverter that can read and write JSON using kotlinx.serialization .
MappingJackson2MessageConverter
A Jackson 2 based MessageConverter implementation.
MarshallingMessageConverter
Implementation of MessageConverter that can read and write XML using Spring's Marshaller and Unmarshaller abstractions.
ProtobufJsonFormatMessageConverter
Subclass of ProtobufMessageConverter for use with the official "com.google.protobuf:protobuf-java-util" library for JSON support.
ProtobufMessageConverter
An MessageConverter that reads and writes com.google.protobuf.Messages using Google Protocol Buffers .
SimpleMessageConverter
A simple converter that simply unwraps the message payload as long as it matches the expected target class.
StringMessageConverter
A MessageConverter that supports MIME type "text/plain" with the payload converted to and from a String.
Interfaces
ContentTypeResolver
Resolve the content type for a message.
MessageConverter
A converter to turn the payload of a Message from serialized form to a typed Object and vice versa.
SmartMessageConverter
An extended MessageConverter SPI with conversion hint support.
Exceptions
MessageConversionException
An exception raised by MessageConverter implementations.
core
@NonNullApi @NonNullFields package org.springframework.messaging.core Defines interfaces and implementation classes for messaging templates.
Related Packages
org.springframework.messaging
Support for working with messaging APIs and protocols.
Classes
AbstractDestinationResolvingMessagingTemplate<D>
An extension of AbstractMessagingTemplate that adds operations for sending messages to a resolvable destination name.
AbstractMessageReceivingTemplate<D>
An extension of AbstractMessageSendingTemplate that adds support for receive style operations as defined by MessageReceivingOperations .
AbstractMessageSendingTemplate<D>
Abstract base class for implementations of MessageSendingOperations .
AbstractMessagingTemplate<D>
An extension of AbstractMessageReceivingTemplate that adds support for request-reply style operations as defined by MessageRequestReplyOperations .
BeanFactoryMessageChannelDestinationResolver
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 .
CachingDestinationResolverProxy<D>
DestinationResolver implementation that proxies a target DestinationResolver, caching its CachingDestinationResolverProxy.resolveDestination(java.lang.String) results.
GenericMessagingTemplate
A messaging template that resolves destinations names to MessageChannel 's to send and receive messages from.
Exceptions
DestinationResolutionException
Thrown by a DestinationResolver when it cannot resolve a destination.
Interfaces
DestinationResolver<D>
Strategy for resolving a String destination name to an actual destination of type .
DestinationResolvingMessageReceivingOperations<D>
Extends MessageReceivingOperations and adds operations for receiving messages from a destination specified as a (resolvable) String name.
DestinationResolvingMessageRequestReplyOperations<D>
Extends MessageRequestReplyOperations and adds operations for sending and receiving messages to and from a destination specified as a (resolvable) String name.
DestinationResolvingMessageSendingOperations<D>
Extends MessageSendingOperations and adds operations for sending messages to a destination specified as a (resolvable) String name.
MessagePostProcessor
A contract for processing a Message after it has been created, either returning a modified (effectively new) message or returning the same.
MessageReceivingOperations<D>
Operations for receiving messages from a destination.
MessageRequestReplyOperations<D>
Operations for sending messages to and receiving the reply from a destination.
MessageSendingOperations<D>
Operations for sending messages to a destination.
handler
handler
@NonNullApi @NonNullFields package org.springframework.messaging.handler Basic abstractions for working with message handler methods.
Related Packages
org.springframework.messaging
Support for working with messaging APIs and protocols.
org.springframework.messaging.handler.annotation
Annotations and support classes for handling messages.
org.springframework.messaging.handler.invocation
Common infrastructure for invoking message handler methods.
Classes
AbstractMessageCondition<T extends AbstractMessageCondition<T>>
Base class for MessageCondition's that pre-declares abstract methods AbstractMessageCondition.getContent() and AbstractMessageCondition.getToStringInfix() in order to provide implementations of AbstractMessageCondition.equals(Object) , AbstractMessageCondition.hashCode() , and AbstractMessageCondition.toString() .
CompositeMessageCondition
Composite MessageCondition that delegates to other message conditions.
DestinationPatternsMessageCondition
MessageCondition to match the destination header of a Message against one or more patterns through a RouteMatcher .
HandlerMethod
Encapsulates information about a handler method consisting of a method and a bean .
Interfaces
MessageCondition<T>
Contract for mapping conditions to messages.
MessagingAdviceBean
Represents a Spring-managed bean with cross-cutting functionality to be applied to one or more Spring beans with annotation-based message handling methods.
annotation
annotation
@NonNullApi @NonNullFields package org.springframework.messaging.handler.annotation Annotations and support classes for handling messages.
Related Packages
org.springframework.messaging.handler
Basic abstractions for working with message handler methods.
org.springframework.messaging.handler.annotation.reactive
Support classes for working with annotated message-handling methods with non-blocking, reactive contracts.
org.springframework.messaging.handler.annotation.support
Support classes for working with annotated message-handling methods.
org.springframework.messaging.handler.invocation
Common infrastructure for invoking message handler methods.
Annotation Interfaces
DestinationVariable
Annotation that indicates a method parameter should be bound to a template variable in a destination template string.
Header
Annotation which indicates that a method parameter should be bound to a message header.
Headers
Annotation which indicates that a method parameter should be bound to the headers of a message.
MessageExceptionHandler
Annotation for handling exceptions thrown from message-handling methods within a specific handler class.
MessageMapping
Annotation for mapping a Message onto a message-handling method by matching the declared patterns to a destination extracted from the message.
Payload
Annotation that binds a method parameter to the payload of a message.
SendTo
Annotation that indicates a method's return value should be converted to a Message if necessary and sent to the specified destination.
Classes
MessageMappingReflectiveProcessor
ReflectiveProcessor implementation for types annotated with @MessageMapping , @SubscribeMapping and @MessageExceptionHandler .
Interfaces
ValueConstants
Common annotation value constants.
reactive
@NonNullApi @NonNullFields package org.springframework.messaging.handler.annotation.reactive Support classes for working with annotated message-handling methods with non-blocking, reactive contracts.
Related Packages
org.springframework.messaging.handler.annotation
Annotations and support classes for handling messages.
org.springframework.messaging.handler.annotation.support
Support classes for working with annotated message-handling methods.
Classes
AbstractNamedValueMethodArgumentResolver
Abstract base class to resolve method arguments from a named value, e.g.
AbstractNamedValueMethodArgumentResolver.NamedValueInfo
Represents a named value declaration.
ContinuationHandlerMethodArgumentResolver
No-op resolver for method arguments of type Continuation .
DestinationVariableMethodArgumentResolver
Resolve for @DestinationVariable method parameters.
HeaderMethodArgumentResolver
Resolver for @Header arguments.
HeadersMethodArgumentResolver
Argument resolver for headers.
MessageMappingMessageHandler
Extension of AbstractMethodMessageHandler for reactive, non-blocking handling of messages via @MessageMapping methods.
PayloadMethodArgumentResolver
A resolver to extract and decode the payload of a message using a Decoder , where the payload is expected to be a Publisher of DataBuffer .
support
@NonNullApi @NonNullFields package org.springframework.messaging.handler.annotation.support Support classes for working with annotated message-handling methods.
Related Packages
org.springframework.messaging.handler.annotation
Annotations and support classes for handling messages.
org.springframework.messaging.handler.annotation.reactive
Support classes for working with annotated message-handling methods with non-blocking, reactive contracts.
Classes
AbstractNamedValueMethodArgumentResolver
Abstract base class to resolve method arguments from a named value, e.g.
AbstractNamedValueMethodArgumentResolver.NamedValueInfo
Represents a named value declaration.
AnnotationExceptionHandlerMethodResolver
A subclass of AbstractExceptionHandlerMethodResolver that looks for MessageExceptionHandler -annotated methods in a given class.
DefaultMessageHandlerMethodFactory
The default MessageHandlerMethodFactory implementation creating an InvocableHandlerMethod with the necessary HandlerMethodArgumentResolver instances to detect and process most of the use cases defined by MessageMapping .
DestinationVariableMethodArgumentResolver
Resolve for @DestinationVariable method parameters.
HeaderMethodArgumentResolver
Resolver for @Header arguments.
HeadersMethodArgumentResolver
Argument resolver for headers.
MessageMethodArgumentResolver
HandlerMethodArgumentResolver for Message method arguments.
PayloadMethodArgumentResolver
A resolver to extract and convert the payload of a message using a MessageConverter .
Interfaces
MessageHandlerMethodFactory
A factory for InvocableHandlerMethod that is suitable to process an incoming Message
Exceptions
MethodArgumentNotValidException
Exception to be thrown when a method argument fails validation perhaps as a result of @Valid style validation, or perhaps because it is required.
MethodArgumentTypeMismatchException
Exception that indicates that a method argument has not the expected type.
invocation
invocation
@NonNullApi @NonNullFields package org.springframework.messaging.handler.invocation Common infrastructure for invoking message handler methods.
Related Packages
org.springframework.messaging.handler
Basic abstractions for working with message handler methods.
org.springframework.messaging.handler.invocation.reactive
Common infrastructure for invoking message handler methods with non-blocking, and reactive contracts.
org.springframework.messaging.handler.annotation
Annotations and support classes for handling messages.
Classes
AbstractAsyncReturnValueHandler
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 .
AbstractExceptionHandlerMethodResolver
Cache exception handling method mappings and provide options to look up a method that should handle an exception.
AbstractMethodMessageHandler<T>
Abstract base class for HandlerMethod-based message handling.
CompletableFutureReturnValueHandler
Support for CompletableFuture (and as of 4.3.7 also CompletionStage ) as a return value type.
HandlerMethodArgumentResolverComposite
Resolves method parameters by delegating to a list of registered HandlerMethodArgumentResolvers .
HandlerMethodReturnValueHandlerComposite
A HandlerMethodReturnValueHandler that wraps and delegates to others.
InvocableHandlerMethod
Extension of HandlerMethod that invokes the underlying method with argument values resolved from the current HTTP request through a list of HandlerMethodArgumentResolver .
ListenableFutureReturnValueHandler
Deprecated. as of 6.0, in favor of CompletableFutureReturnValueHandler
ReactiveReturnValueHandler
Support for single-value reactive types (like Mono or Single ) as a return value type.
Interfaces
AsyncHandlerMethodReturnValueHandler
An extension of HandlerMethodReturnValueHandler for handling async, Future-like return value types that support success and error callbacks.
HandlerMethodArgumentResolver
Strategy interface for resolving method parameters into argument values in the context of a given Message .
HandlerMethodReturnValueHandler
Strategy interface to handle the value returned from the invocation of a method handling a Message .
Exceptions
MethodArgumentResolutionException
Common exception resulting from the invocation of HandlerMethodArgumentResolver .
reactive
@NonNullApi @NonNullFields package org.springframework.messaging.handler.invocation.reactive Common infrastructure for invoking message handler methods with non-blocking, and reactive contracts.
Related Packages
org.springframework.messaging.handler.invocation
Common infrastructure for invoking message handler methods.
Classes
AbstractEncoderMethodReturnValueHandler
Base class for a return value handler that encodes return values to Flux through the configured Encoder s.
AbstractMethodMessageHandler<T>
Abstract base class for reactive HandlerMethod-based message handling.
ArgumentResolverConfigurer
Assist with configuration for handler method argument resolvers.
HandlerMethodArgumentResolverComposite
Resolves method parameters by delegating to a list of registered HandlerMethodArgumentResolvers .
HandlerMethodReturnValueHandlerComposite
A HandlerMethodReturnValueHandler that wraps and delegates to others.
InvocableHandlerMethod
Extension of HandlerMethod that invokes the underlying method with argument values resolved from the current HTTP request through a list of HandlerMethodArgumentResolver .
ReturnValueHandlerConfigurer
Assist with configuration for handler method return value handlers.
Interfaces
HandlerMethodArgumentResolver
Strategy interface for resolving method parameters into argument values in the context of a given Message .
HandlerMethodReturnValueHandler
Handle the return value from the invocation of an annotated Message handling method.
SyncHandlerMethodArgumentResolver
An extension of HandlerMethodArgumentResolver for implementations that are synchronous in nature and do not block to resolve values.
rsocket
rsocket
@NonNullApi @NonNullFields package org.springframework.messaging.rsocket Support for the RSocket protocol.
Related Packages
org.springframework.messaging
Support for working with messaging APIs and protocols.
org.springframework.messaging.rsocket.annotation
Annotations and support classes for handling RSocket streams.
org.springframework.messaging.rsocket.service
Annotations to declare an RSocket service contract with request methods along with a proxy factory backed by an RSocketRequester .
Classes
DefaultMetadataExtractor
Default MetadataExtractor implementation that relies on Decoder s to deserialize the content of metadata entries.
PayloadUtils
Static utility methods to create Payload from DataBuffer s and vice versa.
Interfaces
MetadataExtractor
Strategy to extract a map of value(s) from Payload metadata, which could be composite metadata with multiple entries.
MetadataExtractorRegistry
Stores registrations of extractors for metadata entries.
RSocketConnectorConfigurer
Strategy to apply configuration to an RSocketConnector .
RSocketRequester
A thin wrapper around a sending RSocket with a fluent API accepting and returning higher level Objects for input and for output, along with methods to prepare routing and other metadata.
RSocketRequester.Builder
Builder to create a requester by connecting to a server.
RSocketRequester.MetadataSpec<S extends RSocketRequester.MetadataSpec<S>>
Spec for providing additional composite metadata entries.
RSocketRequester.RequestSpec
Spec to declare the input for an RSocket request.
RSocketRequester.RetrieveSpec
Spec to declare the expected output for an RSocket request.
RSocketStrategies
Access to strategies for use by RSocket requester and responder components.
RSocketStrategies.Builder
The builder options for creating RSocketStrategies .
annotation
annotation
@NonNullApi @NonNullFields package org.springframework.messaging.rsocket.annotation Annotations and support classes for handling RSocket streams.
Related Packages
org.springframework.messaging.rsocket
Support for the RSocket protocol.
org.springframework.messaging.rsocket.annotation.support
Support classes for working with annotated RSocket stream handling methods.
org.springframework.messaging.rsocket.service
Annotations to declare an RSocket service contract with request methods along with a proxy factory backed by an RSocketRequester .
Annotation Interfaces
ConnectMapping
Annotation to map the initial ConnectionSetupPayload and subsequent metadata pushes onto a handler method.
support
@NonNullApi @NonNullFields package org.springframework.messaging.rsocket.annotation.support Support classes for working with annotated RSocket stream handling methods.
Related Packages
org.springframework.messaging.rsocket.annotation
Annotations and support classes for handling RSocket streams.
Classes
RSocketFrameTypeMessageCondition
A condition to assist with mapping onto handler methods based on the RSocket frame type.
RSocketMessageHandler
Extension of MessageMappingMessageHandler to handle RSocket requests with @MessageMapping and @ConnectMapping methods, also supporting use of @RSocketExchange .
RSocketPayloadReturnValueHandler
Extension of AbstractEncoderMethodReturnValueHandler that handles encoded content by wrapping data buffers as RSocket payloads and by passing those through the RSocketPayloadReturnValueHandler.RESPONSE_HEADER header.
RSocketRequesterMethodArgumentResolver
Resolves arguments of type RSocket that can be used for making requests to the remote peer.
service
@NonNullApi @NonNullFields package org.springframework.messaging.rsocket.service Annotations to declare an RSocket service contract with request methods along with a proxy factory backed by an RSocketRequester.
Related Packages
org.springframework.messaging.rsocket
Support for the RSocket protocol.
org.springframework.messaging.rsocket.annotation
Annotations and support classes for handling RSocket streams.
Classes
DestinationVariableArgumentResolver
RSocketServiceArgumentResolver for a @DestinationVariable annotated argument.
MetadataArgumentResolver
RSocketServiceArgumentResolver for metadata entries.
PayloadArgumentResolver
RSocketServiceArgumentResolver for @Payload annotated arguments.
RSocketRequestValues
Container for RSocket request values extracted from an @RSocketExchange -annotated method and argument values passed to it.
RSocketRequestValues.Builder
Builder for RSocketRequestValues .
RSocketServiceProxyFactory
Factory to create a client proxy from an RSocket service interface with @RSocketExchange methods.
RSocketServiceProxyFactory.Builder
Builder to create an RSocketServiceProxyFactory .
Annotation Interfaces
RSocketExchange
Annotation to declare an RSocket endpoint on an RSocket service interface.
Interfaces
RSocketServiceArgumentResolver
Resolve an argument from an @RSocketExchange -annotated method to one or more RSocket request values.
simp
simp
@NonNullApi @NonNullFields package org.springframework.messaging.simp Generic support for Simple Messaging Protocols including protocols such as STOMP.
Related Packages
org.springframework.messaging
Support for working with messaging APIs and protocols.
org.springframework.messaging.simp.annotation
Annotations and for handling messages from SImple Messaging Protocols such as STOMP.
org.springframework.messaging.simp.broker
Provides a "simple" message broker implementation along with an abstract base class and other supporting types such as a registry for subscriptions.
org.springframework.messaging.simp.config
Configuration support for WebSocket messaging using higher level messaging protocols.
org.springframework.messaging.simp.stomp
Generic support for simple messaging protocols (like STOMP).
org.springframework.messaging.simp.user
Support for handling messages to "user" destinations (i.e.
Classes
SimpAttributes
A wrapper class for access to attributes associated with a SiMP session (e.g.
SimpAttributesContextHolder
Holder class to expose SiMP attributes associated with a session (e.g.
SimpLogging
Holds the shared logger named "org.springframework.web.SimpLogging" to use for STOMP over WebSocket messaging when logging for "org.springframework.messaging.simp" is off but logging for "org.springframework.web" is on.
SimpMessageHeaderAccessor
A base class for working with message headers in simple messaging protocols that support basic messaging patterns.
SimpMessageMappingInfo
MessageCondition for SImple Messaging Protocols.
SimpMessageTypeMessageCondition
MessageCondition that matches by the message type obtained via SimpMessageHeaderAccessor.getMessageType(Map) .
SimpMessagingTemplate
An implementation of SimpMessageSendingOperations .
SimpSessionScope
A Scope implementation exposing the attributes of a SiMP session (e.g.
Interfaces
SimpMessageSendingOperations
A specialization of MessageSendingOperations with methods for use with the Spring Framework support for Simple Messaging Protocols (like STOMP).
Enum Classes
SimpMessageType
A generic representation of different kinds of messages found in simple messaging protocols like STOMP.
annotation
annotation
@NonNullApi @NonNullFields package org.springframework.messaging.simp.annotation Annotations and for handling messages from SImple Messaging Protocols such as STOMP.
Related Packages
org.springframework.messaging.simp
Generic support for Simple Messaging Protocols including protocols such as STOMP.
org.springframework.messaging.simp.annotation.support
Support classes for handling messages from simple messaging protocols (like STOMP).
org.springframework.messaging.simp.broker
Provides a "simple" message broker implementation along with an abstract base class and other supporting types such as a registry for subscriptions.
org.springframework.messaging.simp.config
Configuration support for WebSocket messaging using higher level messaging protocols.
org.springframework.messaging.simp.stomp
Generic support for simple messaging protocols (like STOMP).
org.springframework.messaging.simp.user
Support for handling messages to "user" destinations (i.e.
Annotation Interfaces
SendToUser
Indicates the return value of a message-handling method should be sent as a Message to the specified destination(s) further prepended with "/user/{username}" where the user name is extracted from the headers of the input message being handled.
SubscribeMapping
Annotation for mapping subscription messages onto specific handler methods based on the destination of a subscription.
support
@NonNullApi @NonNullFields package org.springframework.messaging.simp.annotation.support Support classes for handling messages from simple messaging protocols (like STOMP).
Related Packages
org.springframework.messaging.simp.annotation
Annotations and for handling messages from SImple Messaging Protocols such as STOMP.
Exceptions
MissingSessionUserException
MessagingException thrown when a session is missing.
Classes
PrincipalMethodArgumentResolver
Resolver for arguments of type Principal , including Optional .
SendToMethodReturnValueHandler
A HandlerMethodReturnValueHandler for sending to destinations specified in a SendTo or SendToUser method-level annotations.
SimpAnnotationMethodMessageHandler
A handler for messages delegating to @MessageMapping and @SubscribeMapping annotated methods.
SubscriptionMethodReturnValueHandler
HandlerMethodReturnValueHandler for replying directly to a subscription.
broker
@NonNullApi @NonNullFields package org.springframework.messaging.simp.broker Provides a "simple" message broker implementation along with an abstract base class and other supporting types such as a registry for subscriptions.
Related Packages
org.springframework.messaging.simp
Generic support for Simple Messaging Protocols including protocols such as STOMP.
org.springframework.messaging.simp.annotation
Annotations and for handling messages from SImple Messaging Protocols such as STOMP.
org.springframework.messaging.simp.config
Configuration support for WebSocket messaging using higher level messaging protocols.
org.springframework.messaging.simp.stomp
Generic support for simple messaging protocols (like STOMP).
org.springframework.messaging.simp.user
Support for handling messages to "user" destinations (i.e.
Classes
AbstractBrokerMessageHandler
Abstract base class for a MessageHandler that broker messages to registered subscribers.
AbstractSubscriptionRegistry
Abstract base class for implementations of SubscriptionRegistry that looks up information in messages but delegates to abstract methods for the actual storage and retrieval.
BrokerAvailabilityEvent
Event raised when a broker's availability changes.
DefaultSubscriptionRegistry
Implementation of SubscriptionRegistry that stores subscriptions in memory and uses a PathMatcher for matching destinations.
OrderedMessageChannelDecorator
Decorator for an ExecutorSubscribableChannel that ensures messages are processed in the order they were published to the channel.
SimpleBrokerMessageHandler
A "simple" message broker that recognizes the message types defined in SimpMessageType , keeps track of subscriptions with the help of a SubscriptionRegistry , and sends messages to subscribers.
Interfaces
SubscriptionRegistry
A registry of subscription by session that allows looking up subscriptions.
config
@NonNullApi @NonNullFields package org.springframework.messaging.simp.config Configuration support for WebSocket messaging using higher level messaging protocols.
Related Packages
org.springframework.messaging.simp
Generic support for Simple Messaging Protocols including protocols such as STOMP.
org.springframework.messaging.simp.annotation
Annotations and for handling messages from SImple Messaging Protocols such as STOMP.
org.springframework.messaging.simp.broker
Provides a "simple" message broker implementation along with an abstract base class and other supporting types such as a registry for subscriptions.
org.springframework.messaging.simp.stomp
Generic support for simple messaging protocols (like STOMP).
org.springframework.messaging.simp.user
Support for handling messages to "user" destinations (i.e.
Classes
AbstractBrokerRegistration
Base class for message broker registration classes.
AbstractMessageBrokerConfiguration
Provides essential configuration for handling messages with simple messaging protocols such as STOMP.
ChannelRegistration
A registration class for customizing the configuration for a MessageChannel .
MessageBrokerRegistry
A registry for configuring message broker options.
SimpleBrokerRegistration
Registration class for configuring a SimpleBrokerMessageHandler .
StompBrokerRelayRegistration
Registration class for configuring a StompBrokerRelayMessageHandler .
TaskExecutorRegistration
A registration class for customizing the properties of ThreadPoolTaskExecutor .
stomp
@NonNullApi @NonNullFields package org.springframework.messaging.simp.stomp Generic support for simple messaging protocols (like STOMP).
Related Packages
org.springframework.messaging.simp
Generic support for Simple Messaging Protocols including protocols such as STOMP.
org.springframework.messaging.simp.annotation
Annotations and for handling messages from SImple Messaging Protocols such as STOMP.
org.springframework.messaging.simp.broker
Provides a "simple" message broker implementation along with an abstract base class and other supporting types such as a registry for subscriptions.
org.springframework.messaging.simp.config
Configuration support for WebSocket messaging using higher level messaging protocols.
org.springframework.messaging.simp.user
Support for handling messages to "user" destinations (i.e.
Classes
BufferingStompDecoder
An extension of StompDecoder that buffers content remaining in the input ByteBuffer after the parent class has read all (complete) STOMP frames from it.
DefaultStompSession
Default implementation of ConnectionHandlingStompSession .
ReactorNettyTcpStompClient
A STOMP over TCP client, configurable with either ReactorNettyTcpClient or ReactorNetty2TcpClient .
StompBrokerRelayMessageHandler
A MessageHandler that handles messages by forwarding them to a STOMP broker.
StompClientSupport
Base class for STOMP client implementations.
StompDecoder
Decodes one or more STOMP frames contained in a ByteBuffer .
StompEncoder
An encoder for STOMP frames.
StompHeaderAccessor
A MessageHeaderAccessor to use when creating a Message from a decoded STOMP frame, or when encoding a Message to a STOMP frame.
StompHeaders
Represents STOMP frame headers.
StompReactorNettyCodec
Simple delegation to StompDecoder and StompEncoder.
StompSessionHandlerAdapter
Abstract adapter class for StompSessionHandler with mostly empty implementation methods except for StompSessionHandlerAdapter.getPayloadType(org.springframework.messaging.simp.stomp.StompHeaders) which returns String as the default Object type expected for STOMP ERROR frame payloads.
StompTcpMessageCodec
TcpMessageCodec for STOMP, delegating to StompDecoder and StompEncoder .
Interfaces
ConnectionHandlingStompSession
A StompSession that implements TcpConnectionHandler in order to send and receive messages.
StompBrokerRelayMessageHandler.Stats
Contract for access to session counters.
StompFrameHandler
Contract to handle a STOMP frame.
StompSession
Represents a STOMP session with operations to send messages, create subscriptions and receive messages on those subscriptions.
StompSession.Receiptable
A handle to use to track receipts.
StompSession.Subscription
A handle to use to unsubscribe or to track a receipt.
StompSessionHandler
A contract for client STOMP session lifecycle events including a callback when the session is established and notifications of transport or message handling failures.
StompTcpConnectionHandler<P>
A TcpConnectionHandler for use with STOMP connections, exposing further information about the connection.
Exceptions
ConnectionLostException
Raised when the connection for a STOMP session is lost rather than closed.
StompConversionException
Raised after a failure to encode or decode a STOMP message.
Enum Classes
StompCommand
Represents a STOMP command.
user
@NonNullApi @NonNullFields package org.springframework.messaging.simp.user Support for handling messages to "user" destinations (i.e. destinations that are unique to a user's sessions), primarily translating the destinations and then forwarding the updated message to the broker. Also included is SimpUserRegistry for keeping track of connected user sessions.
Related Packages
org.springframework.messaging.simp
Generic support for Simple Messaging Protocols including protocols such as STOMP.
org.springframework.messaging.simp.annotation
Annotations and for handling messages from SImple Messaging Protocols such as STOMP.
org.springframework.messaging.simp.broker
Provides a "simple" message broker implementation along with an abstract base class and other supporting types such as a registry for subscriptions.
org.springframework.messaging.simp.config
Configuration support for WebSocket messaging using higher level messaging protocols.
org.springframework.messaging.simp.stomp
Generic support for simple messaging protocols (like STOMP).
Classes
DefaultUserDestinationResolver
A default implementation of UserDestinationResolver that relies on a SimpUserRegistry to find active sessions for a user.
MultiServerUserRegistry
SimpUserRegistry that looks up users in a "local" user registry as well as a set of "remote" user registries.
UserDestinationMessageHandler
MessageHandler with support for "user" destinations.
UserDestinationResult
Contains the result from parsing a "user" destination from a source message and translating it to target destinations (one per active user session).
UserRegistryMessageHandler
MessageHandler that handles user registry broadcasts from other application servers and periodically broadcasts the content of the local user registry.
Interfaces
DestinationUserNameProvider
A Principal can also implement this contract when getName() isn't globally unique and therefore not suited for use with "user" destinations.
SimpSession
Represents a session of connected user.
SimpSubscription
Represents a subscription within a user session.
SimpSubscriptionMatcher
A strategy for matching subscriptions.
SimpUser
Represents a connected user.
SimpUserRegistry
A registry of currently connected users.
UserDestinationResolver
A strategy for resolving a "user" destination by translating it to one or more actual destinations one per active user session.
support
@NonNullApi @NonNullFields package org.springframework.messaging.support Provides implementations of Message along with a MessageBuilder and MessageHeaderAccessor for building and working with messages and message headers, as well as various MessageChannel implementations and channel interceptor support.
Related Packages
org.springframework.messaging
Support for working with messaging APIs and protocols.
Classes
AbstractHeaderMapper<T>
A base HeaderMapper implementation.
AbstractMessageChannel
Abstract base class for MessageChannel implementations.
AbstractSubscribableChannel
Abstract base class for SubscribableChannel implementations.
ErrorMessage
A GenericMessage with a Throwable payload.
ExecutorSubscribableChannel
A SubscribableChannel that sends messages to each of its subscribers.
GenericMessage<T>
An implementation of Message with a generic payload.
IdTimestampMessageHeaderInitializer
A MessageHeaderInitializer to customize the strategy for ID and TIMESTAMP message header generation.
ImmutableMessageChannelInterceptor
A simpler interceptor that calls MessageHeaderAccessor.setImmutable() on the headers of messages passed through the preSend method.
MessageBuilder<T>
A builder for creating a GenericMessage (or ErrorMessage if the payload is of type Throwable ).
MessageHeaderAccessor
Wrapper around MessageHeaders that provides extra features such as strongly typed accessors for specific headers, the ability to leave headers in a Message mutable, and the option to suppress automatic generation of id and timestamp headers.
NativeMessageHeaderAccessor
MessageHeaderAccessor subclass that supports storage and access of headers from an external source such as a message broker.
Interfaces
ChannelInterceptor
Interface for interceptors that are able to view and/or modify the Messages being sent-to and/or received-from a MessageChannel .
ExecutorChannelInterceptor
An extension of ChannelInterceptor with callbacks to intercept the asynchronous sending of a Message to a specific subscriber through an Executor .
HeaderMapper<T>
Generic strategy interface for mapping MessageHeaders to and from other types of objects.
InterceptableChannel
A MessageChannel that maintains a list ChannelInterceptors and allows interception of message sending.
MessageHandlingRunnable
Extension of the Runnable interface with methods to obtain the MessageHandler and Message to be handled.
MessageHeaderInitializer
Callback interface for initializing a MessageHeaderAccessor .
tcp
tcp
@NonNullApi @NonNullFields package org.springframework.messaging.tcp Contains abstractions and implementation classes for establishing TCP connections via TcpOperations, handling messages via TcpConnectionHandler, as well as sending messages via TcpConnection.
Related Packages
org.springframework.messaging
Support for working with messaging APIs and protocols.
org.springframework.messaging.tcp.reactor
Contains support for TCP messaging based on Reactor.
Classes
FixedIntervalReconnectStrategy
A simple strategy for making reconnect attempts at a fixed interval.
Interfaces
ReconnectStrategy
A contract to determine the frequency of reconnect attempts after connection failure.
TcpConnection<P>
A contract for sending messages and managing a TCP connection.
TcpConnectionHandler<P>
A contract for managing lifecycle events for a TCP connection including the handling of incoming messages.
TcpOperations<P>
A contract for establishing TCP connections.
reactor
@NonNullApi @NonNullFields package org.springframework.messaging.tcp.reactor Contains support for TCP messaging based on Reactor.
Related Packages
org.springframework.messaging.tcp
Contains abstractions and implementation classes for establishing TCP connections via TcpOperations , handling messages via TcpConnectionHandler , as well as sending messages via TcpConnection .
Classes
AbstractNioBufferReactorNettyCodec<P>
Convenient base class for ReactorNettyCodec implementations that need to work with NIO ByteBuffers .
ReactorNetty2TcpClient<P>
Reactor Netty based implementation of TcpOperations .
ReactorNetty2TcpConnection<P>
Reactor Netty based implementation of TcpConnection .
ReactorNettyTcpClient<P>
Reactor Netty based implementation of TcpOperations .
ReactorNettyTcpConnection<P>
Reactor Netty based implementation of TcpConnection .
Interfaces
ReactorNettyCodec<P>
Simple holder for a decoding Function and an encoding BiConsumer to use with Reactor Netty.
TcpMessageCodec<P>
Contract to encode and decode a Message to and from a ByteBuffer allowing a higher-level protocol (e.g.
mock
env
@NonNullApi @NonNullFields package org.springframework.mock.env This package contains mock implementations of the Environment and PropertySource abstractions. These mocks are useful for developing out-of-container unit tests for code that depends on environment-specific properties.
Classes
MockEnvironment
Simple ConfigurableEnvironment implementation exposing MockEnvironment.setProperty(java.lang.String, java.lang.String) and MockEnvironment.withProperty(java.lang.String, java.lang.String) methods for testing purposes.
MockPropertySource
Simple PropertySource implementation for use in testing.
http
http
@NonNullApi @NonNullFields package org.springframework.mock.http Mock implementations of client/server-side HTTP abstractions. This package contains MockHttpInputMessage and MockHttpOutputMessage.
Related Packages
org.springframework.mock.http.client
Mock implementations of client-side HTTP abstractions.
Classes
MockHttpInputMessage
Mock implementation of HttpInputMessage .
MockHttpOutputMessage
Mock implementation of HttpOutputMessage .
client
client
@NonNullApi @NonNullFields package org.springframework.mock.http.client Mock implementations of client-side HTTP abstractions. This package contains MockClientHttpRequest and MockClientHttpResponse.
Related Packages
org.springframework.mock.http
Mock implementations of client/server-side HTTP abstractions.
org.springframework.mock.http.client.reactive
Mock implementations of reactive HTTP client contracts.
Classes
MockClientHttpRequest
Mock implementation of ClientHttpRequest .
MockClientHttpResponse
Mock implementation of ClientHttpResponse .
reactive
@NonNullApi @NonNullFields package org.springframework.mock.http.client.reactive Mock implementations of reactive HTTP client contracts.
Related Packages
org.springframework.mock.http.client
Mock implementations of client-side HTTP abstractions.
Classes
MockClientHttpRequest
Mock implementation of ClientHttpRequest .
MockClientHttpResponse
Mock implementation of ClientHttpResponse .
server
reactive
@NonNullApi @NonNullFields package org.springframework.mock.http.server.reactive Mock implementations of reactive HTTP server contracts.
Classes
MockServerHttpRequest
Mock extension of AbstractServerHttpRequest for use in tests without an actual server.
MockServerHttpResponse
Mock extension of AbstractServerHttpResponse for use in tests without an actual server.
Interfaces
MockServerHttpRequest.BaseBuilder<B extends MockServerHttpRequest.BaseBuilder<B>>
Request builder exposing properties not related to the body.
MockServerHttpRequest.BodyBuilder
A builder that adds a body to the request.
web
web
@NonNullApi @NonNullFields package org.springframework.mock.web A comprehensive set of Servlet API 6.0 mock objects, targeted at usage with Spring's Web MVC framework. Useful for testing web contexts and controllers.
Related Packages
org.springframework.mock.web.server
Mock implementations of Spring's reactive server web API abstractions.
Classes
DelegatingServletInputStream
Delegating implementation of ServletInputStream .
DelegatingServletOutputStream
Delegating implementation of ServletOutputStream .
MockAsyncContext
Mock implementation of the AsyncContext interface.
MockBodyContent
Mock implementation of the BodyContent class.
MockCookie
Extension of Cookie with extra attributes, as defined in RFC 6265 .
MockFilterChain
Mock implementation of the FilterChain interface.
MockFilterConfig
Mock implementation of the FilterConfig interface.
MockHttpServletMapping
Mock implementation of HttpServletMapping .
MockHttpServletRequest
Mock implementation of the HttpServletRequest interface.
MockHttpServletResponse
Mock implementation of the HttpServletResponse interface.
MockHttpSession
Mock implementation of the HttpSession interface.
MockJspWriter
Mock implementation of the JspWriter class.
MockMultipartFile
Mock implementation of the MultipartFile interface.
MockMultipartHttpServletRequest
Mock implementation of the MultipartHttpServletRequest interface.
MockPageContext
Mock implementation of the PageContext interface.
MockPart
Mock implementation of jakarta.servlet.http.Part .
MockRequestDispatcher
Mock implementation of the RequestDispatcher interface.
MockServletConfig
Mock implementation of the ServletConfig interface.
MockServletContext
Mock implementation of the ServletContext interface.
MockSessionCookieConfig
Mock implementation of the SessionCookieConfig interface.
PassThroughFilterChain
Implementation of the FilterChain interface which simply passes the call through to a given Filter/FilterChain combination (indicating the next Filter in the chain along with the FilterChain that it is supposed to work on) or to a given Servlet (indicating the end of the chain).
reactive
function
server
@NonNullApi @NonNullFields package org.springframework.mock.web.reactive.function.server Mock objects for the functional web framework. Useful for testing router and handler functions.
Classes
MockServerRequest
Mock implementation of ServerRequest .
Interfaces
MockServerRequest.Builder
Builder for MockServerRequest .
server
@NonNullApi @NonNullFields package org.springframework.mock.web.server Mock implementations of Spring's reactive server web API abstractions.
Related Packages
org.springframework.mock.web
A comprehensive set of Servlet API 6.0 mock objects, targeted at usage with Spring's Web MVC framework.
Classes
MockServerWebExchange
Extension of DefaultServerWebExchange for use in tests, along with MockServerHttpRequest and MockServerHttpResponse .
MockServerWebExchange.Builder
Builder for a MockServerWebExchange .
MockWebSession
Implementation of WebSession that delegates to a session instance obtained via InMemoryWebSessionStore .
objenesis
package org.springframework.objenesis Spring's repackaging of Objenesis 3.2 (with SpringObjenesis entry point; for internal use only). This repackaging technique avoids any potential conflicts with dependencies on different Objenesis versions at the application level or from third-party libraries and frameworks. As this repackaging happens at the class file level, sources and javadocs are not available here. See the original Objenesis docs for details when working with these classes.
Classes
SpringObjenesis
Spring-specific variant of ObjenesisStd / ObjenesisBase , providing a cache based on Class keys instead of class names, and allowing for selective use of the cache.
orm
orm
@NonNullApi @NonNullFields package org.springframework.orm Root package for Spring's O/R Mapping integration classes. Contains generic DataAccessExceptions related to O/R Mapping.
Related Packages
org.springframework.orm.hibernate5
Package providing integration of Hibernate 5.x with Spring concepts.
org.springframework.orm.jpa
Package providing integration of JPA (Java Persistence API) with Spring concepts.
Exceptions
ObjectOptimisticLockingFailureException
Exception thrown on an optimistic locking violation for a mapped object.
ObjectRetrievalFailureException
Exception thrown if a mapped object could not be retrieved via its identifier.
hibernate5
hibernate5
@NonNullApi @NonNullFields package org.springframework.orm.hibernate5 Package providing integration of Hibernate 5.x with Spring concepts. Contains an implementation of Spring's transaction SPI for local Hibernate transactions. This package is intentionally rather minimal, with no template classes or the like, in order to follow Hibernate recommendations as closely as possible. We recommend using Hibernate's native sessionFactory.getCurrentSession() style. This package supports Hibernate 5.x only.
Related Packages
org.springframework.orm
Root package for Spring's O/R Mapping integration classes.
org.springframework.orm.hibernate5.support
Classes supporting the org.springframework.orm.hibernate5 package.
org.springframework.orm.jpa
Package providing integration of JPA (Java Persistence API) with Spring concepts.
Interfaces
HibernateCallback<T>
Callback interface for Hibernate code.
HibernateOperations
Interface that specifies a common set of Hibernate operations as well as a general HibernateOperations.execute(org.springframework.orm.hibernate5.HibernateCallback) method for Session-based lambda expressions.
Classes
HibernateExceptionTranslator
PersistenceExceptionTranslator capable of translating HibernateException instances to Spring's DataAccessException hierarchy.
HibernateTemplate
Helper class that simplifies Hibernate data access code.
HibernateTransactionManager
PlatformTransactionManager implementation for a single Hibernate SessionFactory .
LocalSessionFactoryBean
FactoryBean that creates a Hibernate SessionFactory .
LocalSessionFactoryBuilder
A Spring-provided extension of the standard Hibernate Configuration class, adding SpringSessionContext as a default and providing convenient ways to specify a JDBC DataSource and an application class loader.
SessionFactoryUtils
Helper class featuring methods for Hibernate Session handling.
SessionHolder
Resource holder wrapping a Hibernate Session (plus an optional Transaction ).
SpringBeanContainer
Spring's implementation of Hibernate's BeanContainer SPI, delegating to a Spring ConfigurableListableBeanFactory .
SpringFlushSynchronization
Simple synchronization adapter that propagates a flush() call to the underlying Hibernate Session.
SpringJtaSessionContext
Spring-specific subclass of Hibernate's JTASessionContext, setting FlushMode.MANUAL for read-only transactions.
SpringSessionContext
Implementation of Hibernate 3.1's CurrentSessionContext interface that delegates to Spring's SessionFactoryUtils for providing a Spring-managed current Session .
SpringSessionSynchronization
Callback for resource cleanup at the end of a Spring-managed transaction for a pre-bound Hibernate Session.
Exceptions
HibernateJdbcException
Hibernate-specific subclass of UncategorizedDataAccessException, for JDBC exceptions that Hibernate wrapped.
HibernateObjectRetrievalFailureException
Hibernate-specific subclass of ObjectRetrievalFailureException.
HibernateOptimisticLockingFailureException
Hibernate-specific subclass of ObjectOptimisticLockingFailureException.
HibernateQueryException
Hibernate-specific subclass of InvalidDataAccessResourceUsageException, thrown on invalid HQL query syntax.
HibernateSystemException
Hibernate-specific subclass of UncategorizedDataAccessException, for Hibernate system errors that do not match any concrete org.springframework.dao exceptions.
support
@NonNullApi @NonNullFields package org.springframework.orm.hibernate5.support Classes supporting the org.springframework.orm.hibernate5 package.
Related Packages
org.springframework.orm.hibernate5
Package providing integration of Hibernate 5.x with Spring concepts.
Classes
HibernateDaoSupport
Convenient superclass for Hibernate-based data access objects.
OpenSessionInterceptor
Simple AOP Alliance MethodInterceptor implementation that binds a new Hibernate Session for each method invocation, if none bound before.
OpenSessionInViewFilter
Servlet Filter that binds a Hibernate Session to the thread for the entire processing of the request.
OpenSessionInViewInterceptor
Spring web request interceptor that binds a Hibernate Session to the thread for the entire processing of the request.
jpa
jpa
@NonNullApi @NonNullFields package org.springframework.orm.jpa Package providing integration of JPA (Java Persistence API) with Spring concepts. Contains EntityManagerFactory helper classes, a template plus callback for JPA access, and an implementation of Spring's transaction SPI for local JPA transactions.
Related Packages
org.springframework.orm
Root package for Spring's O/R Mapping integration classes.
org.springframework.orm.jpa.persistenceunit
Internal support for managing JPA persistence units.
org.springframework.orm.jpa.support
Classes supporting the org.springframework.orm.jpa package.
org.springframework.orm.jpa.vendor
Support classes for adapting to specific JPA vendors.
org.springframework.orm.hibernate5
Package providing integration of Hibernate 5.x with Spring concepts.
Classes
AbstractEntityManagerFactoryBean
Abstract FactoryBean that creates a local JPA EntityManagerFactory instance within a Spring application context.
DefaultJpaDialect
Default implementation of the JpaDialect interface.
EntityManagerFactoryAccessor
Base class for any class that needs to access a JPA EntityManagerFactory , usually in order to obtain a JPA EntityManager .
EntityManagerFactoryUtils
Helper class featuring methods for JPA EntityManager handling, allowing for reuse of EntityManager instances within transactions.
EntityManagerHolder
Resource holder wrapping a JPA EntityManager .
ExtendedEntityManagerCreator
Delegate for creating a variety of EntityManager proxies that follow the JPA spec's semantics for "extended" EntityManagers.
JpaTransactionManager
PlatformTransactionManager implementation for a single JPA EntityManagerFactory .
LocalContainerEntityManagerFactoryBean
FactoryBean that creates a JPA EntityManagerFactory according to JPA's standard container bootstrap contract.
LocalEntityManagerFactoryBean
FactoryBean that creates a JPA EntityManagerFactory according to JPA's standard standalone bootstrap contract.
SharedEntityManagerCreator
Delegate for creating a shareable JPA EntityManager reference for a given EntityManagerFactory .
Interfaces
EntityManagerFactoryInfo
Metadata interface for a Spring-managed JPA EntityManagerFactory .
EntityManagerProxy
Subinterface of EntityManager to be implemented by EntityManager proxies.
JpaDialect
SPI strategy that encapsulates certain functionality that standard JPA 3.0 does not offer, such as access to the underlying JDBC Connection.
JpaVendorAdapter
SPI interface that allows to plug in vendor-specific behavior into Spring's EntityManagerFactory creators.
Exceptions
JpaObjectRetrievalFailureException
JPA-specific subclass of ObjectRetrievalFailureException.
JpaOptimisticLockingFailureException
JPA-specific subclass of ObjectOptimisticLockingFailureException.
JpaSystemException
JPA-specific subclass of UncategorizedDataAccessException, for JPA system errors that do not match any concrete org.springframework.dao exceptions.
persistenceunit
@NonNullApi @NonNullFields package org.springframework.orm.jpa.persistenceunit Internal support for managing JPA persistence units.
Related Packages
org.springframework.orm.jpa
Package providing integration of JPA (Java Persistence API) with Spring concepts.
org.springframework.orm.jpa.support
Classes supporting the org.springframework.orm.jpa package.
org.springframework.orm.jpa.vendor
Support classes for adapting to specific JPA vendors.
Classes
DefaultPersistenceUnitManager
Default implementation of the PersistenceUnitManager interface.
MutablePersistenceUnitInfo
Spring's base implementation of the JPA PersistenceUnitInfo interface, used to bootstrap an EntityManagerFactory in a container.
PersistenceManagedTypesScanner
Scanner of PersistenceManagedTypes .
Interfaces
ManagedClassNameFilter
Strategy interface to filter the list of persistent managed types to include in the persistence unit.
PersistenceManagedTypes
Provide the list of managed persistent types that an entity manager should consider.
PersistenceUnitManager
Interface that defines an abstraction for finding and managing JPA PersistenceUnitInfos.
PersistenceUnitPostProcessor
Callback interface for post-processing a JPA PersistenceUnitInfo.
SmartPersistenceUnitInfo
Extension of the standard JPA PersistenceUnitInfo interface, for advanced collaboration between Spring's LocalContainerEntityManagerFactoryBean and PersistenceUnitManager implementations.
support
@NonNullApi @NonNullFields package org.springframework.orm.jpa.support Classes supporting the org.springframework.orm.jpa package.
Related Packages
org.springframework.orm.jpa
Package providing integration of JPA (Java Persistence API) with Spring concepts.
org.springframework.orm.jpa.persistenceunit
Internal support for managing JPA persistence units.
org.springframework.orm.jpa.vendor
Support classes for adapting to specific JPA vendors.
Classes
OpenEntityManagerInViewFilter
Servlet Filter that binds a JPA EntityManager to the thread for the entire processing of the request.
OpenEntityManagerInViewInterceptor
Spring web request interceptor that binds a JPA EntityManager to the thread for the entire processing of the request.
PersistenceAnnotationBeanPostProcessor
BeanPostProcessor that processes PersistenceUnit and PersistenceContext annotations, for injection of the corresponding JPA resources EntityManagerFactory and EntityManager .
SharedEntityManagerBean
FactoryBean that exposes a shared JPA EntityManager reference for a given EntityManagerFactory.
vendor
@NonNullApi @NonNullFields package org.springframework.orm.jpa.vendor Support classes for adapting to specific JPA vendors.
Related Packages
org.springframework.orm.jpa
Package providing integration of JPA (Java Persistence API) with Spring concepts.
org.springframework.orm.jpa.persistenceunit
Internal support for managing JPA persistence units.
org.springframework.orm.jpa.support
Classes supporting the org.springframework.orm.jpa package.
Classes
AbstractJpaVendorAdapter
Abstract JpaVendorAdapter implementation that defines common properties, to be translated into vendor-specific JPA properties by concrete subclasses.
EclipseLinkJpaDialect
JpaDialect implementation for Eclipse Persistence Services (EclipseLink).
EclipseLinkJpaVendorAdapter
JpaVendorAdapter implementation for Eclipse Persistence Services (EclipseLink).
HibernateJpaDialect
JpaDialect implementation for Hibernate.
HibernateJpaVendorAdapter
JpaVendorAdapter implementation for Hibernate.
Enum Classes
Database
Enumeration for common database platforms.
oxm
oxm
@NonNullApi @NonNullFields package org.springframework.oxm Root package for Spring's O/X Mapping integration classes. Contains generic Marshaller and Unmarshaller interfaces, and XmlMappingExceptions related to O/X Mapping
Related Packages
org.springframework.oxm.config
Provides an namespace handler for the Spring Object/XML namespace.
org.springframework.oxm.jaxb
Package providing integration of JAXB with Spring's O/X Mapping support.
org.springframework.oxm.mime
Contains (un)marshallers optimized to store binary data in MIME attachments.
org.springframework.oxm.support
Provides generic support classes for using Spring's O/X Mapping integration within various scenario's.
org.springframework.oxm.xstream
Package providing integration of XStream with Spring's O/X Mapping support.
Interfaces
GenericMarshaller
Subinterface of Marshaller that has support for generics.
GenericUnmarshaller
Subinterface of Unmarshaller that has support for generics.
Marshaller
Defines the contract for Object XML Mapping Marshallers.
Unmarshaller
Defines the contract for Object XML Mapping unmarshallers.
Exceptions
MarshallingException
Base class for exception thrown when a marshalling or unmarshalling error occurs.
MarshallingFailureException
Exception thrown on marshalling failure.
UncategorizedMappingException
Exception that indicates that the cause cannot be distinguished further.
UnmarshallingFailureException
Exception thrown on unmarshalling failure.
ValidationFailureException
Exception thrown on marshalling validation failure.
XmlMappingException
Root of the hierarchy of Object XML Mapping exceptions.
config
@NonNullApi @NonNullFields package org.springframework.oxm.config Provides an namespace handler for the Spring Object/XML namespace.
Related Packages
org.springframework.oxm: Root package for Spring's O/X Mapping integration classes.
org.springframework.oxm.jaxb: Package providing integration of JAXB with Spring's O/X Mapping support.
org.springframework.oxm.mime: Contains (un)marshallers optimized to store binary data in MIME attachments.
org.springframework.oxm.support: Provides generic support classes for using Spring's O/X Mapping integration within various scenario's.
org.springframework.oxm.xstream
Package providing integration of XStream with Spring's O/X Mapping support.
Classes
OxmNamespaceHandler
NamespaceHandler for the ' oxm ' namespace.
jaxb
@NonNullApi @NonNullFields package org.springframework.oxm.jaxb Package providing integration of JAXB with Spring's O/X Mapping support.
Related Packages
org.springframework.oxm
Root package for Spring's O/X Mapping integration classes.
org.springframework.oxm.config
Provides an namespace handler for the Spring Object/XML namespace.
org.springframework.oxm.mime
Contains (un)marshallers optimized to store binary data in MIME attachments.
org.springframework.oxm.support
Provides generic support classes for using Spring's O/X Mapping integration within various scenario's.
org.springframework.oxm.xstream
Package providing integration of XStream with Spring's O/X Mapping support.
Classes
Jaxb2Marshaller
Implementation of the GenericMarshaller interface for JAXB 2.2.
mime
@NonNullApi @NonNullFields package org.springframework.oxm.mime Contains (un)marshallers optimized to store binary data in MIME attachments.
Related Packages
org.springframework.oxm
Root package for Spring's O/X Mapping integration classes.
org.springframework.oxm.config
Provides an namespace handler for the Spring Object/XML namespace.
org.springframework.oxm.jaxb
Package providing integration of JAXB with Spring's O/X Mapping support.
org.springframework.oxm.support
Provides generic support classes for using Spring's O/X Mapping integration within various scenario's.
org.springframework.oxm.xstream
Package providing integration of XStream with Spring's O/X Mapping support.
Interfaces
MimeContainer
Represents a container for MIME attachments Concrete implementations might adapt a SOAPMessage or an email message.
MimeMarshaller
Subinterface of Marshaller that can use MIME attachments to optimize storage of binary data.
MimeUnmarshaller
Subinterface of Unmarshaller that can use MIME attachments to optimize storage of binary data.
support
@NonNullApi @NonNullFields package org.springframework.oxm.support Provides generic support classes for using Spring's O/X Mapping integration within various scenario's. Includes the MarshallingSource for compatibility with TrAX, MarshallingView for use within Spring Web MVC, and the MarshallingMessageConverter for use within Spring's JMS support.
Related Packages
org.springframework.oxm
Root package for Spring's O/X Mapping integration classes.
org.springframework.oxm.config
Provides an namespace handler for the Spring Object/XML namespace.
org.springframework.oxm.jaxb
Package providing integration of JAXB with Spring's O/X Mapping support.
org.springframework.oxm.mime
Contains (un)marshallers optimized to store binary data in MIME attachments.
org.springframework.oxm.xstream
Package providing integration of XStream with Spring's O/X Mapping support.
Classes
AbstractMarshaller
Abstract implementation of the Marshaller and Unmarshaller interface.
MarshallingSource
Source implementation that uses a Marshaller .Can be constructed with a Marshaller and an object to be marshalled.
SaxResourceUtils
Convenient utility methods for dealing with SAX.
xstream
@NonNullApi @NonNullFields package org.springframework.oxm.xstream Package providing integration of XStream with Spring's O/X Mapping support.
Related Packages
org.springframework.oxm
Root package for Spring's O/X Mapping integration classes.
org.springframework.oxm.config
Provides an namespace handler for the Spring Object/XML namespace.
org.springframework.oxm.jaxb
Package providing integration of JAXB with Spring's O/X Mapping support.
org.springframework.oxm.mime
Contains (un)marshallers optimized to store binary data in MIME attachments.
org.springframework.oxm.support
Provides generic support classes for using Spring's O/X Mapping integration within various scenario's.
Classes
CatchAllConverter
XStream Converter that supports all classes, but throws exceptions for (un)marshalling.
XStreamMarshaller
Implementation of the Marshaller interface for XStream.
r2dbc
r2dbc
The classes in this package make R2DBC easier to use and reduce the likelihood of common errors.
connection
connection
@NonNullApi @NonNullFields package org.springframework.r2dbc.connection Provides a utility class for easy ConnectionFactory access, a ReactiveTransactionManager for a single ConnectionFactory, and various simple ConnectionFactory implementations.
Related Packages
org.springframework.r2dbc
The classes in this package make R2DBC easier to use and reduce the likelihood of common errors.
org.springframework.r2dbc.connection.init
Provides extensible support for initializing databases through scripts.
org.springframework.r2dbc.connection.lookup
Provides a strategy for looking up R2DBC ConnectionFactories by name.
org.springframework.r2dbc.core
Core domain types around DatabaseClient.
Classes
ConnectionFactoryUtils
Helper class that provides static methods for obtaining R2DBC Connections from a ConnectionFactory .
ConnectionHolder
Resource holder wrapping a R2DBC Connection .
DelegatingConnectionFactory
R2DBC ConnectionFactory implementation that delegates all calls to a given target ConnectionFactory .
R2dbcTransactionManager
ReactiveTransactionManager implementation for a single R2DBC ConnectionFactory .
SingleConnectionFactory
Implementation of DelegatingConnectionFactory that wraps a single R2DBC Connection which is not closed after use.
TransactionAwareConnectionFactoryProxy
Proxy for a target R2DBC ConnectionFactory , adding awareness of Spring-managed transactions.
init
@NonNullApi @NonNullFields package org.springframework.r2dbc.connection.init Provides extensible support for initializing databases through scripts.
Related Packages
org.springframework.r2dbc.connection
Provides a utility class for easy ConnectionFactory access, a ReactiveTransactionManager for a single ConnectionFactory, and various simple ConnectionFactory implementations.
org.springframework.r2dbc.connection.lookup
Provides a strategy for looking up R2DBC ConnectionFactories by name.
Exceptions
CannotReadScriptException
Thrown by ScriptUtils if an SQL script cannot be read.
ScriptException
Root of the hierarchy of data access exceptions that are related to processing of SQL scripts.
ScriptParseException
Thrown by ScriptUtils if an SQL script cannot be properly parsed.
ScriptStatementFailedException
Thrown by ScriptUtils if a statement in an SQL script failed when executing it against the target database.
UncategorizedScriptException
Thrown when we cannot determine anything more specific than "something went wrong while processing an SQL script": for example, an R2dbcException from R2DBC that we cannot pinpoint more precisely.
Classes
CompositeDatabasePopulator
Composite DatabasePopulator that delegates to a list of given DatabasePopulator implementations, executing all scripts.
ConnectionFactoryInitializer
Used to set up a database during initialization and clean up a database during destruction.
ResourceDatabasePopulator
Populates, initializes, or cleans up a database using SQL scripts defined in external resources.
ScriptUtils
Generic utility methods for working with SQL scripts in conjunction with R2DBC.
Interfaces
DatabasePopulator
Strategy used to populate, initialize, or clean up a database.
lookup
@NonNullApi @NonNullFields package org.springframework.r2dbc.connection.lookup Provides a strategy for looking up R2DBC ConnectionFactories by name.
Related Packages
org.springframework.r2dbc.connection
Provides a utility class for easy ConnectionFactory access, a ReactiveTransactionManager for a single ConnectionFactory, and various simple ConnectionFactory implementations.
org.springframework.r2dbc.connection.init
Provides extensible support for initializing databases through scripts.
Classes
AbstractRoutingConnectionFactory
Abstract ConnectionFactory implementation that routes AbstractRoutingConnectionFactory.create() calls to one of various target factories based on a lookup key.
BeanFactoryConnectionFactoryLookup
ConnectionFactoryLookup implementation based on a Spring BeanFactory .
MapConnectionFactoryLookup
Simple ConnectionFactoryLookup implementation that relies on a map for doing lookups.
SingleConnectionFactoryLookup
An implementation of ConnectionFactoryLookup that simply wraps a single given ConnectionFactory returned for any connection factory name.
Interfaces
ConnectionFactoryLookup
Strategy interface for looking up ConnectionFactory by name.
Exceptions
ConnectionFactoryLookupFailureException
Exception to be thrown by a ConnectionFactoryLookup implementation, indicating that the specified ConnectionFactory could not be obtained.
core
core
@NonNullApi @NonNullFields package org.springframework.r2dbc.core Core domain types around DatabaseClient.
Related Packages
org.springframework.r2dbc
The classes in this package make R2DBC easier to use and reduce the likelihood of common errors.
org.springframework.r2dbc.core.binding
Classes providing an abstraction over SQL bind markers.
org.springframework.r2dbc.connection
Provides a utility class for easy ConnectionFactory access, a ReactiveTransactionManager for a single ConnectionFactory, and various simple ConnectionFactory implementations.
Classes
BeanPropertyRowMapper<T>
Mapping Function implementation that converts an R2DBC Readable (a Row or OutParameters ) into a new instance of the specified mapped target class.
ColumnMapRowMapper
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.
DataClassRowMapper<T>
Mapping Function implementation that converts an R2DBC Readable (a Row or OutParameters ) into a new instance of the specified mapped target class.
Parameter
Deprecated. since 6.0, use io.r2dbc.spi.Parameter instead.
Interfaces
ConnectionAccessor
Interface declaring methods that accept callback Function to operate within the scope of a Connection .
DatabaseClient
A non-blocking, reactive client for performing database calls with Reactive Streams back pressure.
DatabaseClient.Builder
A mutable builder for creating a DatabaseClient .
DatabaseClient.GenericExecuteSpec
Contract for specifying an SQL call along with options leading to the execution.
ExecuteFunction
Represents a function that executes a Statement for a (delayed) Result stream.
FetchSpec<T>
Union type for fetching results.
PreparedOperation<T>
Extension to QueryOperation for a prepared SQL query Supplier with bound parameters.
QueryOperation
Interface declaring a query operation that can be represented with a query string.
RowsFetchSpec<T>
Contract for fetching tabular results.
SqlProvider
Interface to be implemented by objects that can provide SQL strings.
StatementFilterFunction
Represents a function that filters an ExecuteFunction .
UpdatedRowsFetchSpec
Contract for fetching the number of affected rows.
binding
@NonNullApi @NonNullFields package org.springframework.r2dbc.core.binding Classes providing an abstraction over SQL bind markers.
Related Packages
org.springframework.r2dbc.core
Core domain types around DatabaseClient.
Classes
Bindings
Value object representing value and null bindings for a Statement using BindMarkers .
Bindings.Binding
Base class for value objects representing a value or a NULL binding.
BindMarkersFactoryResolver
Resolves a BindMarkersFactory from a ConnectionFactory using BindMarkersFactoryResolver.BindMarkerFactoryProvider .
MutableBindings
Mutable extension to Bindings for Value and null bindings for a Statement using BindMarkers .
Interfaces
BindMarker
A bind marker represents a single bindable parameter within a query.
BindMarkers
Bind markers represent placeholders in SQL queries for substitution for an actual parameter.
BindMarkersFactory
This class creates new BindMarkers instances to bind parameter to a specific Statement .
BindMarkersFactoryResolver.BindMarkerFactoryProvider
SPI to extend Spring's default R2DBC BindMarkersFactory discovery mechanism.
BindTarget
Target to apply bindings to.
Exceptions
BindMarkersFactoryResolver.NoBindMarkersFactoryException
Exception thrown when BindMarkersFactoryResolver cannot resolve a BindMarkersFactory .
scheduling
scheduling
@NonNullApi @NonNullFields package org.springframework.scheduling General exceptions for Spring's scheduling support, independent of any specific scheduling system.
Related Packages
org.springframework.scheduling.annotation
Annotation support for asynchronous method execution.
org.springframework.scheduling.aspectj
AspectJ-based scheduling support.
org.springframework.scheduling.concurrent
Scheduling convenience classes for the java.util.concurrent and jakarta.enterprise.concurrent packages, allowing to set up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring context.
org.springframework.scheduling.config
Support package for declarative scheduling configuration, with XML schema being the primary configuration format.
org.springframework.scheduling.quartz
Support classes for the open source scheduler Quartz , allowing to set up Quartz Schedulers, JobDetails and Triggers as beans in a Spring context.
org.springframework.scheduling.support
Generic support classes for scheduling.
Interfaces
SchedulingAwareRunnable
Extension of the Runnable interface, adding special callbacks for long-running operations.
SchedulingTaskExecutor
A TaskExecutor extension exposing scheduling characteristics that are relevant to potential task submitters.
TaskScheduler
Task scheduler interface that abstracts the scheduling of Runnables based on different kinds of triggers.
Trigger
Common interface for trigger objects that determine the next execution time of a task that they get associated with.
TriggerContext
Context object encapsulating last execution times and last completion time of a given task.
Exceptions
SchedulingException
General exception to be thrown on scheduling failures, such as the scheduler already having shut down.
annotation
@NonNullApi @NonNullFields package org.springframework.scheduling.annotation Annotation support for asynchronous method execution.
Related Packages
org.springframework.scheduling
General exceptions for Spring's scheduling support, independent of any specific scheduling system.
org.springframework.scheduling.aspectj
AspectJ-based scheduling support.
org.springframework.scheduling.concurrent
Scheduling convenience classes for the java.util.concurrent and jakarta.enterprise.concurrent packages, allowing to set up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring context.
org.springframework.scheduling.config
Support package for declarative scheduling configuration, with XML schema being the primary configuration format.
org.springframework.scheduling.quartz
Support classes for the open source scheduler Quartz , allowing to set up Quartz Schedulers, JobDetails and Triggers as beans in a Spring context.
org.springframework.scheduling.support
Generic support classes for scheduling.
Classes
AbstractAsyncConfiguration
Abstract base Configuration class providing common structure for enabling Spring's asynchronous method execution capability.
AnnotationAsyncExecutionInterceptor
Specialization of AsyncExecutionInterceptor that delegates method execution to an Executor based on the Async annotation.
AsyncAnnotationAdvisor
Advisor that activates asynchronous method execution through the Async annotation.
AsyncAnnotationBeanPostProcessor
Bean post-processor that automatically applies asynchronous invocation behavior to any bean that carries the Async annotation at class or method-level by adding a corresponding AsyncAnnotationAdvisor to the exposed proxy (either an existing AOP proxy or a newly generated proxy that implements all the target's interfaces).
AsyncConfigurationSelector
Selects which implementation of AbstractAsyncConfiguration should be used based on the value of EnableAsync.mode() on the importing @Configuration class.
AsyncConfigurerSupport
Deprecated. as of 6.0 in favor of implementing AsyncConfigurer directly
AsyncResult<V>
Deprecated. as of 6.0, in favor of CompletableFuture
ProxyAsyncConfiguration
@Configuration class that registers the Spring infrastructure beans necessary to enable proxy-based asynchronous method execution.
ScheduledAnnotationBeanPostProcessor
Bean post-processor that registers methods annotated with @Scheduled to be invoked by a TaskScheduler according to the "fixedRate", "fixedDelay", or "cron" expression provided via the annotation.
SchedulingConfiguration
@Configuration class that registers a ScheduledAnnotationBeanPostProcessor bean capable of processing Spring's @ Scheduled annotation.
Annotation Interfaces
Async
Annotation that marks a method as a candidate for asynchronous execution.
EnableAsync
Enables Spring's asynchronous method execution capability, similar to functionality found in Spring's XML namespace.
EnableScheduling
Enables Spring's scheduled task execution capability, similar to functionality found in Spring's XML namespace.
Scheduled
Annotation that marks a method to be scheduled.
Schedules
Container annotation that aggregates several Scheduled annotations.
Interfaces
AsyncConfigurer
Interface to be implemented by @ Configuration classes annotated with @ EnableAsync that wish to customize the Executor instance used when processing async method invocations or the AsyncUncaughtExceptionHandler instance used to process exception thrown from async method with void return type.
SchedulingConfigurer
Optional interface to be implemented by @Configuration classes annotated with @EnableScheduling .
aspectj
@NonNullApi @NonNullFields package org.springframework.scheduling.aspectj AspectJ-based scheduling support.
Related Packages
org.springframework.scheduling
General exceptions for Spring's scheduling support, independent of any specific scheduling system.
org.springframework.scheduling.annotation
Annotation support for asynchronous method execution.
org.springframework.scheduling.concurrent
Scheduling convenience classes for the java.util.concurrent and jakarta.enterprise.concurrent packages, allowing to set up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring context.
org.springframework.scheduling.config
Support package for declarative scheduling configuration, with XML schema being the primary configuration format.
org.springframework.scheduling.quartz
Support classes for the open source scheduler Quartz , allowing to set up Quartz Schedulers, JobDetails and Triggers as beans in a Spring context.
org.springframework.scheduling.support
Generic support classes for scheduling.
Classes
AspectJAsyncConfiguration
@Configuration class that registers the Spring infrastructure beans necessary to enable AspectJ-based asynchronous method execution.
concurrent
@NonNullApi @NonNullFields package org.springframework.scheduling.concurrent Scheduling convenience classes for the java.util.concurrent and jakarta.enterprise.concurrent packages, allowing to set up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring context. Provides support for the native java.util.concurrent interfaces as well as the Spring TaskExecutor mechanism.
Related Packages
org.springframework.scheduling
General exceptions for Spring's scheduling support, independent of any specific scheduling system.
org.springframework.scheduling.annotation
Annotation support for asynchronous method execution.
org.springframework.scheduling.aspectj
AspectJ-based scheduling support.
org.springframework.scheduling.config
Support package for declarative scheduling configuration, with XML schema being the primary configuration format.
org.springframework.scheduling.quartz
Support classes for the open source scheduler Quartz , allowing to set up Quartz Schedulers, JobDetails and Triggers as beans in a Spring context.
org.springframework.scheduling.support
Generic support classes for scheduling.
Classes
ConcurrentTaskExecutor
Adapter that takes a java.util.concurrent.Executor and exposes a Spring TaskExecutor for it.
ConcurrentTaskExecutor.ManagedTaskBuilder
Delegate that wraps a given Runnable/Callable with a JSR-236 ManagedTask, exposing a long-running hint based on SchedulingAwareRunnable and a given identity name.
ConcurrentTaskScheduler
Adapter that takes a java.util.concurrent.ScheduledExecutorService and exposes a Spring TaskScheduler for it.
CustomizableThreadFactory
Implementation of the ThreadFactory interface, allowing for customizing the created threads (name, priority, etc).
DefaultManagedAwareThreadFactory
JNDI-based variant of CustomizableThreadFactory , performing a default lookup for JSR-236's "java:comp/DefaultManagedThreadFactory" in a Jakarta EE environment, falling back to the local CustomizableThreadFactory setup if not found.
DefaultManagedTaskExecutor
JNDI-based variant of ConcurrentTaskExecutor , performing a default lookup for JSR-236's "java:comp/DefaultManagedExecutorService" in a Jakarta EE/8 environment.
DefaultManagedTaskScheduler
JNDI-based variant of ConcurrentTaskScheduler , performing a default lookup for JSR-236's "java:comp/DefaultManagedScheduledExecutorService" in a Jakarta EE environment.
ExecutorConfigurationSupport
Base class for setting up a ExecutorService (typically a ThreadPoolExecutor or ScheduledThreadPoolExecutor ).
ForkJoinPoolFactoryBean
A Spring FactoryBean that builds and exposes a preconfigured ForkJoinPool .
ScheduledExecutorFactoryBean
FactoryBean that sets up a ScheduledExecutorService (by default: a ScheduledThreadPoolExecutor ) and exposes it for bean references.
ScheduledExecutorTask
JavaBean that describes a scheduled executor task, consisting of the Runnable and a delay plus period.
SimpleAsyncTaskScheduler
A simple implementation of Spring's TaskScheduler interface, using a single scheduler thread and executing every scheduled task in an individual separate thread.
ThreadPoolExecutorFactoryBean
JavaBean that allows for configuring a ThreadPoolExecutor in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a bean reference of its native ExecutorService type.
ThreadPoolTaskExecutor
JavaBean that allows for configuring a ThreadPoolExecutor in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a Spring TaskExecutor .
ThreadPoolTaskScheduler
A standard implementation of Spring's TaskScheduler interface, wrapping a native ScheduledThreadPoolExecutor and providing all applicable configuration options for it.
config
@NonNullApi @NonNullFields package org.springframework.scheduling.config Support package for declarative scheduling configuration, with XML schema being the primary configuration format.
Related Packages
org.springframework.scheduling
General exceptions for Spring's scheduling support, independent of any specific scheduling system.
org.springframework.scheduling.annotation
Annotation support for asynchronous method execution.
org.springframework.scheduling.aspectj
AspectJ-based scheduling support.
org.springframework.scheduling.concurrent
Scheduling convenience classes for the java.util.concurrent and jakarta.enterprise.concurrent packages, allowing to set up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring context.
org.springframework.scheduling.quartz
Support classes for the open source scheduler Quartz , allowing to set up Quartz Schedulers, JobDetails and Triggers as beans in a Spring context.
org.springframework.scheduling.support
Generic support classes for scheduling.
Classes
AnnotationDrivenBeanDefinitionParser
Parser for the 'annotation-driven' element of the 'task' namespace.
ContextLifecycleScheduledTaskRegistrar
ScheduledTaskRegistrar subclass which redirects the actual scheduling of tasks to the ContextLifecycleScheduledTaskRegistrar.afterSingletonsInstantiated() callback (as of 4.1.2).
CronTask
TriggerTask implementation defining a Runnable to be executed according to a standard cron expression .
DelayedTask
Task implementation defining a Runnable with an initial delay.
ExecutorBeanDefinitionParser
Parser for the 'executor' element of the 'task' namespace.
FixedDelayTask
Specialization of IntervalTask for fixed-delay semantics.
FixedRateTask
Specialization of IntervalTask for fixed-rate semantics.
IntervalTask
Task implementation defining a Runnable to be executed at a given millisecond interval which may be treated as fixed-rate or fixed-delay depending on context.
OneTimeTask
Task implementation defining a Runnable with an initial delay.
ScheduledTask
A representation of a scheduled task at runtime, used as a return value for scheduling methods.
ScheduledTaskRegistrar
Helper bean for registering tasks with a TaskScheduler , typically using cron expressions.
ScheduledTasksBeanDefinitionParser
Parser for the 'scheduled-tasks' element of the scheduling namespace.
SchedulerBeanDefinitionParser
Parser for the 'scheduler' element of the 'task' namespace.
Task
Holder class defining a Runnable to be executed as a task, typically at a scheduled time or interval.
TaskExecutorFactoryBean
FactoryBean for creating ThreadPoolTaskExecutor instances, primarily used behind the XML task namespace.
TaskManagementConfigUtils
Configuration constants for internal sharing across subpackages.
TaskNamespaceHandler
NamespaceHandler for the 'task' namespace.
TaskSchedulerRouter
A routing implementation of the TaskScheduler interface, delegating to a target scheduler based on an identified qualifier or using a default scheduler otherwise.
TriggerTask
Task implementation defining a Runnable to be executed according to a given Trigger .
Interfaces
ScheduledTaskHolder
Common interface for exposing locally scheduled tasks.
quartz
@NonNullApi @NonNullFields package org.springframework.scheduling.quartz Support classes for the open source scheduler Quartz, allowing to set up Quartz Schedulers, JobDetails and Triggers as beans in a Spring context. Also provides convenience classes for implementing Quartz Jobs.
Related Packages
org.springframework.scheduling
General exceptions for Spring's scheduling support, independent of any specific scheduling system.
org.springframework.scheduling.annotation
Annotation support for asynchronous method execution.
org.springframework.scheduling.aspectj
AspectJ-based scheduling support.
org.springframework.scheduling.concurrent
Scheduling convenience classes for the java.util.concurrent and jakarta.enterprise.concurrent packages, allowing to set up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring context.
org.springframework.scheduling.config
Support package for declarative scheduling configuration, with XML schema being the primary configuration format.
org.springframework.scheduling.support
Generic support classes for scheduling.
Classes
AdaptableJobFactory
JobFactory implementation that supports Runnable objects as well as standard Quartz Job instances.
CronTriggerFactoryBean
A Spring FactoryBean for creating a Quartz CronTrigger instance, supporting bean-style usage for trigger configuration.
DelegatingJob
Simple Quartz Job adapter that delegates to a given Runnable instance.
JobDetailFactoryBean
A Spring FactoryBean for creating a Quartz JobDetail instance, supporting bean-style usage for JobDetail configuration.
LocalDataSourceJobStore
Subclass of Quartz's JobStoreCMT class that delegates to a Spring-managed DataSource instead of using a Quartz-managed JDBC connection pool.
LocalTaskExecutorThreadPool
Quartz ThreadPool adapter that delegates to a Spring-managed Executor instance, specified on SchedulerFactoryBean .
MethodInvokingJobDetailFactoryBean
FactoryBean that exposes a JobDetail object which delegates job execution to a specified (static or non-static) method.
MethodInvokingJobDetailFactoryBean.MethodInvokingJob
Quartz Job implementation that invokes a specified method.
MethodInvokingJobDetailFactoryBean.StatefulMethodInvokingJob
Extension of the MethodInvokingJob, implementing the StatefulJob interface.
QuartzJobBean
Simple implementation of the Quartz Job interface, applying the passed-in JobDataMap and also the SchedulerContext as bean property values.
ResourceLoaderClassLoadHelper
Wrapper that adapts from the Quartz ClassLoadHelper interface onto Spring's ResourceLoader interface.
SchedulerAccessor
Common base class for accessing a Quartz Scheduler, i.e.
SchedulerAccessorBean
Spring bean-style class for accessing a Quartz Scheduler, i.e.
SchedulerFactoryBean
FactoryBean that creates and configures a Quartz Scheduler , manages its lifecycle as part of the Spring application context, and exposes the Scheduler as bean reference for dependency injection.
SimpleThreadPoolTaskExecutor
Subclass of Quartz's SimpleThreadPool that implements Spring's TaskExecutor interface and listens to Spring lifecycle callbacks.
SimpleTriggerFactoryBean
A Spring FactoryBean for creating a Quartz SimpleTrigger instance, supporting bean-style usage for trigger configuration.
SpringBeanJobFactory
Subclass of AdaptableJobFactory that also supports Spring-style dependency injection on bean properties.
Exceptions
JobMethodInvocationFailedException
Unchecked exception that wraps an exception thrown from a target method.
Interfaces
SchedulerContextAware
Callback interface to be implemented by Spring-managed Quartz artifacts that need access to the SchedulerContext (without having natural access to it).
support
@NonNullApi @NonNullFields package org.springframework.scheduling.support Generic support classes for scheduling. Provides a Runnable adapter for Spring's MethodInvoker.
Related Packages
org.springframework.scheduling
General exceptions for Spring's scheduling support, independent of any specific scheduling system.
org.springframework.scheduling.annotation
Annotation support for asynchronous method execution.
org.springframework.scheduling.aspectj
AspectJ-based scheduling support.
org.springframework.scheduling.concurrent
Scheduling convenience classes for the java.util.concurrent and jakarta.enterprise.concurrent packages, allowing to set up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring context.
org.springframework.scheduling.config
Support package for declarative scheduling configuration, with XML schema being the primary configuration format.
org.springframework.scheduling.quartz
Support classes for the open source scheduler Quartz , allowing to set up Quartz Schedulers, JobDetails and Triggers as beans in a Spring context.
Classes
CronExpression
Representation of a crontab expression that can calculate the next time it matches.
CronTrigger
Trigger implementation for cron expressions.
DefaultScheduledTaskObservationConvention
Default implementation for ScheduledTaskObservationConvention .
DelegatingErrorHandlingRunnable
Runnable wrapper that catches any exception or error thrown from its delegate Runnable and allows an ErrorHandler to handle it.
MethodInvokingRunnable
Adapter that implements the Runnable interface as a configurable method invocation based on Spring's MethodInvoker.
NoOpTaskScheduler
A basic, no operation TaskScheduler implementation suitable for disabling scheduling, typically used for test setups.
PeriodicTrigger
A trigger for periodic task execution.
ScheduledMethodRunnable
Variant of MethodInvokingRunnable meant to be used for processing of no-arg scheduled methods.
ScheduledTaskObservationContext
Context that holds information for observation metadata collection during the execution of scheduled tasks .
SimpleTriggerContext
Simple data holder implementation of the TriggerContext interface.
TaskUtils
Utility methods for decorating tasks with error handling.
Interfaces
ScheduledTaskObservationConvention
Interface for an ObservationConvention for scheduled task executions .
Enum Classes
ScheduledTaskObservationDocumentation
Documented KeyValues for the observations on executions of scheduled tasks
ScheduledTaskObservationDocumentation.LowCardinalityKeyNames
scripting
scripting
@NonNullApi @NonNullFields package org.springframework.scripting Core interfaces for Spring's scripting support.
Related Packages
org.springframework.scripting.bsh
Package providing integration of BeanShell (and BeanShell2 ) into Spring's scripting infrastructure.
org.springframework.scripting.config
Support package for Spring's dynamic language machinery, with XML schema being the primary configuration format.
org.springframework.scripting.groovy
Package providing integration of Groovy into Spring's scripting infrastructure.
org.springframework.scripting.support
Support classes for Spring's scripting package.
Exceptions
ScriptCompilationException
Exception to be thrown on script compilation failure.
Interfaces
ScriptEvaluator
Spring's strategy interface for evaluating a script.
ScriptFactory
Script definition interface, encapsulating the configuration of a specific script as well as a factory method for creating the actual scripted Java Object .
ScriptSource
Interface that defines the source of a script.
bsh
@NonNullApi @NonNullFields package org.springframework.scripting.bsh Package providing integration of BeanShell (and BeanShell2) into Spring's scripting infrastructure.
Related Packages
org.springframework.scripting
Core interfaces for Spring's scripting support.
org.springframework.scripting.config
Support package for Spring's dynamic language machinery, with XML schema being the primary configuration format.
org.springframework.scripting.groovy
Package providing integration of Groovy into Spring's scripting infrastructure.
org.springframework.scripting.support
Support classes for Spring's scripting package.
Classes
BshScriptEvaluator
BeanShell-based implementation of Spring's ScriptEvaluator strategy interface.
BshScriptFactory
ScriptFactory implementation for a BeanShell script.
BshScriptUtils
Utility methods for handling BeanShell-scripted objects.
Exceptions
BshScriptUtils.BshExecutionException
Exception to be thrown on script execution failure.
config
@NonNullApi @NonNullFields package org.springframework.scripting.config Support package for Spring's dynamic language machinery, with XML schema being the primary configuration format.
Related Packages
org.springframework.scripting
Core interfaces for Spring's scripting support.
org.springframework.scripting.bsh
Package providing integration of BeanShell (and BeanShell2 ) into Spring's scripting infrastructure.
org.springframework.scripting.groovy
Package providing integration of Groovy into Spring's scripting infrastructure.
org.springframework.scripting.support
Support classes for Spring's scripting package.
Classes
LangNamespaceHandler
NamespaceHandler that supports the wiring of objects backed by dynamic languages such as Groovy, JRuby and BeanShell.
LangNamespaceUtils
Utilities for use with LangNamespaceHandler .
groovy
@NonNullApi @NonNullFields package org.springframework.scripting.groovy Package providing integration of Groovy into Spring's scripting infrastructure.
Related Packages
org.springframework.scripting
Core interfaces for Spring's scripting support.
org.springframework.scripting.bsh
Package providing integration of BeanShell (and BeanShell2 ) into Spring's scripting infrastructure.
org.springframework.scripting.config
Support package for Spring's dynamic language machinery, with XML schema being the primary configuration format.
org.springframework.scripting.support
Support classes for Spring's scripting package.
Interfaces
GroovyObjectCustomizer
Strategy used by GroovyScriptFactory to allow the customization of a created GroovyObject .
Classes
GroovyScriptEvaluator
Groovy-based implementation of Spring's ScriptEvaluator strategy interface.
GroovyScriptFactory
ScriptFactory implementation for a Groovy script.
support
@NonNullApi @NonNullFields package org.springframework.scripting.support Support classes for Spring's scripting package. Provides a ScriptFactoryPostProcessor for turning ScriptFactory definitions into scripted objects.
Related Packages
org.springframework.scripting
Core interfaces for Spring's scripting support.
org.springframework.scripting.bsh
Package providing integration of BeanShell (and BeanShell2 ) into Spring's scripting infrastructure.
org.springframework.scripting.config
Support package for Spring's dynamic language machinery, with XML schema being the primary configuration format.
org.springframework.scripting.groovy
Package providing integration of Groovy into Spring's scripting infrastructure.
Classes
RefreshableScriptTargetSource
Subclass of BeanFactoryRefreshableTargetSource that determines whether a refresh is required through the given ScriptFactory .
ResourceScriptSource
ScriptSource implementation based on Spring's Resource abstraction.
ScriptFactoryPostProcessor
BeanPostProcessor that handles ScriptFactory definitions, replacing each factory with the actual scripted Java object generated by it.
StandardScriptEvaluator
javax.script (JSR-223) based implementation of Spring's ScriptEvaluator strategy interface.
StandardScriptFactory
ScriptFactory implementation based on the JSR-223 script engine abstraction (as included in Java).
StandardScriptUtils
Common operations for dealing with a JSR-223 ScriptEngine .
StaticScriptSource
Static implementation of the ScriptSource interface, encapsulating a given String that contains the script source text.
Exceptions
StandardScriptEvalException
Exception decorating a ScriptException coming out of JSR-223 script evaluation, i.e.
stereotype
@NonNullApi @NonNullFields package org.springframework.stereotype Annotations denoting the roles of types or methods in the overall architecture (at a conceptual, rather than implementation, level). Intended for use by tools and aspects (making an ideal target for pointcuts).
Annotation Interfaces
Component
Indicates that the annotated class is a component .
Controller
Indicates that an annotated class is a "Controller" (e.g.
Indexed
Indicate that the annotated element represents a stereotype for the index.
Repository
Indicates that an annotated class is a "Repository", originally defined by Domain-Driven Design (Evans, 2003) as "a mechanism for encapsulating storage, retrieval, and search behavior which emulates a collection of objects".
Service
Indicates that an annotated class is a "Service", originally defined by Domain-Driven Design (Evans, 2003) as "an operation offered as an interface that stands alone in the model, with no encapsulated state."
test
annotation
@NonNullApi @NonNullFields package org.springframework.test.annotation Support classes for annotation-driven tests.
Annotation Interfaces
Commit
@Commit is a test annotation that is used to indicate that a test-managed transaction should be committed after the test method has completed.
DirtiesContext
Test annotation which indicates that the ApplicationContext associated with a test is dirty and should therefore be closed and removed from the context cache.
IfProfileValue
Test annotation for use with JUnit 4 to indicate whether a test is enabled or disabled for a specific testing profile.
ProfileValueSourceConfiguration
ProfileValueSourceConfiguration is a class-level annotation for use with JUnit 4 which is used to specify what type of ProfileValueSource to use when retrieving profile values configured via @IfProfileValue .
Repeat
Test annotation for use with JUnit 4 to indicate that a test method should be invoked repeatedly.
Rollback
@Rollback is a test annotation that is used to indicate whether a test-managed transaction should be rolled back after the test method has completed.
Timed
Test annotation for use with JUnit 4 to indicate that a test method has to finish execution in a specified time period .
Enum Classes
DirtiesContext.ClassMode
Defines modes which determine how @DirtiesContext is interpreted when used to annotate a test class.
DirtiesContext.HierarchyMode
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 .
DirtiesContext.MethodMode
Defines modes which determine how @DirtiesContext is interpreted when used to annotate a test method.
Interfaces
ProfileValueSource
Strategy interface for retrieving profile values for a given testing environment.
Classes
ProfileValueUtils
General utility methods for working with profile values .
SystemProfileValueSource
Implementation of ProfileValueSource which uses system properties as the underlying source.
TestAnnotationUtils
Collection of utility methods for working with Spring's core testing annotations.
context
context
@NonNullApi @NonNullFields package org.springframework.test.context This package contains the Spring TestContext Framework which provides annotation-driven unit and integration testing support that is agnostic of the actual testing framework in use. The same techniques and annotation-based configuration used in, for example, a JUnit environment can also be applied to tests written with TestNG, etc. In addition to providing generic and extensible testing infrastructure, the Spring TestContext Framework provides out-of-the-box support for Spring-specific integration testing functionality such as context management and caching, dependency injection of test fixtures, and transactional test management with default rollback semantics.
Related Packages
org.springframework.test.context.aot
Ahead-of-time (AOT) support for the Spring TestContext Framework .
org.springframework.test.context.cache
Support for context caching within the Spring TestContext Framework .
org.springframework.test.context.event
Test event support classes for the Spring TestContext Framework .
org.springframework.test.context.jdbc
JDBC support classes for the Spring TestContext Framework , including support for declarative SQL script execution via @Sql .
org.springframework.test.context.junit4
Support classes for integrating the Spring TestContext Framework with JUnit 4.12 or higher.
org.springframework.test.context.support
Support classes for the Spring TestContext Framework .
org.springframework.test.context.testng
Support classes for integrating the Spring TestContext Framework with TestNG.
org.springframework.test.context.transaction
Transactional support classes for the Spring TestContext Framework .
org.springframework.test.context.util
Common utilities used within the Spring TestContext Framework .
org.springframework.test.context.web
Web support classes for the Spring TestContext Framework .
Annotation Interfaces
ActiveProfiles
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.
BootstrapWith
@BootstrapWith defines class-level metadata that is used to determine how to bootstrap the Spring TestContext Framework .
ContextConfiguration
@ContextConfiguration defines class-level metadata that is used to determine how to load and configure an ApplicationContext for integration tests.
ContextCustomizerFactories
@ContextCustomizerFactories defines class-level metadata for configuring which ContextCustomizerFactory implementations should be registered with the Spring TestContext Framework .
ContextHierarchy
@ContextHierarchy is a class-level annotation that is used to define a hierarchy of ApplicationContexts for integration tests.
DynamicPropertySource
Method-level annotation for integration tests that need to add properties with dynamic values to the Environment 's set of PropertySources .
NestedTestConfiguration
@NestedTestConfiguration is a type-level annotation that is used to configure how Spring test configuration annotations are processed within enclosing class hierarchies (i.e., for inner test classes).
TestConstructor
@TestConstructor is a type-level annotation that is used to configure how the parameters of a test class constructor are autowired from components in the test's ApplicationContext .
TestExecutionListeners
TestExecutionListeners defines class-level metadata for configuring which TestExecutionListeners should be registered with a TestContextManager .
TestPropertySource
@TestPropertySource is a class-level annotation that is used to configure the TestPropertySource.locations() of properties files and inlined TestPropertySource.properties() to be added to the Environment 's set of PropertySources for an ApplicationContext for integration tests.
TestPropertySources
@TestPropertySources is a container for one or more @TestPropertySource declarations.
Interfaces
ActiveProfilesResolver
Strategy interface for programmatically resolving which active bean definition profiles should be used when loading an ApplicationContext for a test class.
ApplicationContextFailureProcessor
Strategy for components that process failures related to application contexts within the Spring TestContext Framework .
BootstrapContext
BootstrapContext encapsulates the context in which the Spring TestContext Framework is bootstrapped.
CacheAwareContextLoaderDelegate
A CacheAwareContextLoaderDelegate is responsible for loading and closing application contexts, interacting transparently with a ContextCache behind the scenes.
ContextCustomizer
Strategy interface for customizing application contexts that are created and managed by the Spring TestContext Framework .
ContextCustomizerFactory
Factory for creating ContextCustomizers .
ContextLoader
Strategy interface for loading an ApplicationContext for an integration test managed by the Spring TestContext Framework.
DynamicPropertyRegistry
Registry used with @DynamicPropertySource methods so that they can add properties to the Environment that have dynamically resolved values.
MethodInvoker
MethodInvoker defines a generic API for invoking a Method within the Spring TestContext Framework .
SmartContextLoader
Strategy interface for loading an ApplicationContext for an integration test managed by the Spring TestContext Framework.
TestContext
TestContext encapsulates the context in which a test is executed, agnostic of the actual testing framework in use.
TestContextBootstrapper
TestContextBootstrapper defines the SPI for bootstrapping the Spring TestContext Framework .
TestExecutionListener
TestExecutionListener defines a listener API for reacting to test execution events published by the TestContextManager with which the listener is registered.
Classes
BootstrapUtils
BootstrapUtils is a collection of utility methods to assist with bootstrapping the Spring TestContext Framework .
ContextConfigurationAttributes
ContextConfigurationAttributes encapsulates the context configuration attributes declared via @ContextConfiguration .
MergedContextConfiguration
MergedContextConfiguration encapsulates the merged context configuration declared on a test class and all of its superclasses and enclosing classes via @ContextConfiguration , @ActiveProfiles , and @TestPropertySource .
TestContextAnnotationUtils
TestContextAnnotationUtils is a collection of utility methods that complements the standard support already available in AnnotationUtils and AnnotatedElementUtils , while transparently honoring @NestedTestConfiguration semantics.
TestContextAnnotationUtils.AnnotationDescriptor<T extends Annotation>
Descriptor for an Annotation , including the class on which the annotation is declared as well as the merged annotation instance.
TestContextAnnotationUtils.UntypedAnnotationDescriptor
Untyped extension of TestContextAnnotationUtils.AnnotationDescriptor that is used to describe the declaration of one of several candidate annotation types where the actual annotation type cannot be predetermined.
TestContextManager
TestContextManager is the main entry point into the Spring TestContext Framework .
Enum Classes
ContextCustomizerFactories.MergeMode
Enumeration of modes that dictate whether explicitly declared factories are merged with the default factories when @ContextCustomizerFactories is declared on a class that does not inherit factories from a superclass or enclosing class.
NestedTestConfiguration.EnclosingConfiguration
Enumeration of modes that dictate how test configuration from enclosing classes is processed for inner test classes.
TestConstructor.AutowireMode
Defines autowiring modes for parameters in a test constructor.
TestExecutionListeners.MergeMode
Enumeration of modes that dictate whether explicitly declared listeners are merged with the default listeners when @TestExecutionListeners is declared on a class that does not inherit listeners from a superclass or enclosing class.
Exceptions
ContextLoadException
Exception thrown when an error occurs while a SmartContextLoader attempts to load an ApplicationContext .
aot
@NonNullApi @NonNullFields package org.springframework.test.context.aot Ahead-of-time (AOT) support for the Spring TestContext Framework.
Related Packages
org.springframework.test.context
This package contains the Spring TestContext Framework which provides annotation-driven unit and integration testing support that is agnostic of the actual testing framework in use.
Interfaces
AotContextLoader
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.
AotTestAttributes
Holder for metadata specific to ahead-of-time (AOT) support in the Spring TestContext Framework .
AotTestExecutionListener
AotTestExecutionListener is an extension of the TestExecutionListener SPI that allows a listener to optionally provide ahead-of-time (AOT) support.
TestRuntimeHintsRegistrar
Contract for registering RuntimeHints for integration tests run with the Spring TestContext Framework based on the ClassLoader of the deployment unit.
Classes
AotTestContextInitializers
AotTestContextInitializers provides mappings from test classes to AOT-optimized context initializers.
TestAotProcessor
Filesystem-based ahead-of-time (AOT) processing base implementation that scans the provided classpath roots for Spring integration test classes and then generates AOT artifacts for those test classes in the configured output directories.
TestContextAotGenerator
TestContextAotGenerator generates AOT artifacts for integration tests that depend on support from the Spring TestContext Framework .
Annotation Interfaces
DisabledInAotMode
@DisabledInAotMode signals that an annotated test class is disabled in Spring AOT (ahead-of-time) mode, which means that the ApplicationContext for the test class will not be processed for AOT optimizations at build time.
Exceptions
TestContextAotException
Thrown if an error occurs during AOT build-time processing or AOT run-time execution in the Spring TestContext Framework .
cache
@NonNullApi @NonNullFields package org.springframework.test.context.cache Support for context caching within the Spring TestContext Framework.
Related Packages
org.springframework.test.context
This package contains the Spring TestContext Framework which provides annotation-driven unit and integration testing support that is agnostic of the actual testing framework in use.
Interfaces
ContextCache
ContextCache defines the SPI for caching Spring ApplicationContexts within the Spring TestContext Framework .
Classes
ContextCacheUtils
Collection of utilities for working with context caching.
DefaultCacheAwareContextLoaderDelegate
Default implementation of the CacheAwareContextLoaderDelegate strategy.
DefaultContextCache
Default implementation of the ContextCache API.
event
event
@NonNullApi @NonNullFields package org.springframework.test.context.event Test event support classes for the Spring TestContext Framework.
Related Packages
org.springframework.test.context
This package contains the Spring TestContext Framework which provides annotation-driven unit and integration testing support that is agnostic of the actual testing framework in use.
org.springframework.test.context.event.annotation
Test execution event annotations for the Spring TestContext Framework .
Classes
AfterTestClassEvent
TestContextEvent published by the EventPublishingTestExecutionListener when TestExecutionListener.afterTestClass(TestContext) is invoked.
AfterTestExecutionEvent
TestContextEvent published by the EventPublishingTestExecutionListener when TestExecutionListener.afterTestExecution(TestContext) is invoked.
AfterTestMethodEvent
TestContextEvent published by the EventPublishingTestExecutionListener when TestExecutionListener.afterTestMethod(TestContext) is invoked.
ApplicationEventsHolder
Holder class to expose the application events published during the execution of a test in the form of a thread-bound ApplicationEvents object.
ApplicationEventsTestExecutionListener
TestExecutionListener which provides support for ApplicationEvents .
BeforeTestClassEvent
TestContextEvent published by the EventPublishingTestExecutionListener when TestExecutionListener.beforeTestClass(TestContext) is invoked.
BeforeTestExecutionEvent
TestContextEvent published by the EventPublishingTestExecutionListener when TestExecutionListener.beforeTestExecution(TestContext) is invoked.
BeforeTestMethodEvent
TestContextEvent published by the EventPublishingTestExecutionListener when TestExecutionListener.beforeTestMethod(TestContext) is invoked.
EventPublishingTestExecutionListener
TestExecutionListener that publishes test execution events to the ApplicationContext for the currently executing test.
PrepareTestInstanceEvent
TestContextEvent published by the EventPublishingTestExecutionListener when TestExecutionListener.prepareTestInstance(TestContext) is invoked.
TestContextEvent
Base class for events published by the EventPublishingTestExecutionListener .
Interfaces
ApplicationEvents
ApplicationEvents encapsulates all application events that were fired during the execution of a single test method.
Annotation Interfaces
RecordApplicationEvents
@RecordApplicationEvents is a class-level annotation that is used to instruct the Spring TestContext Framework to record all application events that are published in the ApplicationContext during the execution of a single test, either from the test thread or its descendants.
annotation
@NonNullApi @NonNullFields package org.springframework.test.context.event.annotation Test execution event annotations for the Spring TestContext Framework.
Related Packages
org.springframework.test.context.event
Test event support classes for the Spring TestContext Framework .
Annotation Interfaces
AfterTestClass
@EventListener annotation used to consume an AfterTestClassEvent published by the EventPublishingTestExecutionListener .
AfterTestExecution
@EventListener annotation used to consume an AfterTestExecutionEvent published by the EventPublishingTestExecutionListener .
AfterTestMethod
@EventListener annotation used to consume an AfterTestMethodEvent published by the EventPublishingTestExecutionListener .
BeforeTestClass
@EventListener annotation used to consume a BeforeTestClassEvent published by the EventPublishingTestExecutionListener .
BeforeTestExecution
@EventListener annotation used to consume a BeforeTestExecution published by the EventPublishingTestExecutionListener .
BeforeTestMethod
@EventListener annotation used to consume a BeforeTestMethodEvent published by the EventPublishingTestExecutionListener .
PrepareTestInstance
@EventListener annotation used to consume a PrepareTestInstanceEvent published by the EventPublishingTestExecutionListener .
jdbc
@NonNullApi @NonNullFields package org.springframework.test.context.jdbc JDBC support classes for the Spring TestContext Framework, including support for declarative SQL script execution via @Sql.
Related Packages
org.springframework.test.context
This package contains the Spring TestContext Framework which provides annotation-driven unit and integration testing support that is agnostic of the actual testing framework in use.
Annotation Interfaces
Sql
@Sql is used to annotate a test class or test method to configure SQL Sql.scripts() and Sql.statements() to be executed against a given database during integration tests.
SqlConfig
@SqlConfig defines metadata that is used to determine how to parse and execute SQL scripts configured via the @Sql annotation.
SqlGroup
Container annotation that aggregates several @Sql annotations.
SqlMergeMode
@SqlMergeMode is used to annotate a test class or test method to configure whether method-level @Sql declarations are merged with class-level @Sql declarations.
Enum Classes
Sql.ExecutionPhase
Enumeration of phases that dictate when SQL scripts are executed.
SqlConfig.ErrorMode
Enumeration of modes that dictate how errors are handled while executing SQL statements.
SqlConfig.TransactionMode
Enumeration of modes that dictate whether SQL scripts should be executed within a transaction and what the transaction propagation behavior should be.
SqlMergeMode.MergeMode
Enumeration of modes that dictate whether method-level @Sql declarations are merged with class-level @Sql declarations.
Classes
SqlScriptsTestExecutionListener
TestExecutionListener that provides support for executing SQL scripts and inlined statements configured via the @Sql annotation.
junit
jupiter
jupiter
@NonNullApi @NonNullFields package org.springframework.test.context.junit.jupiter Core support for integrating the Spring TestContext Framework with the JUnit Jupiter extension model in JUnit 5.
Related Packages
org.springframework.test.context.junit.jupiter.web
Web support for integrating the Spring TestContext Framework with the JUnit Jupiter extension model in JUnit 5.
Annotation Interfaces
DisabledIf
@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 .
EnabledIf
@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 .
SpringJUnitConfig
@SpringJUnitConfig is a composed annotation that combines @ExtendWith(SpringExtension.class) from JUnit Jupiter with @ContextConfiguration from the Spring TestContext Framework .
Classes
DisabledIfCondition
DisabledIfCondition is an ExecutionCondition that supports the @DisabledIf annotation when using the Spring TestContext Framework in conjunction with JUnit 5's Jupiter programming model.
EnabledIfCondition
EnabledIfCondition is an ExecutionCondition that supports the @EnabledIf annotation when using the Spring TestContext Framework in conjunction with JUnit 5's Jupiter programming model.
SpringExtension
SpringExtension integrates the Spring TestContext Framework into JUnit 5's Jupiter programming model.
web
@NonNullApi @NonNullFields package org.springframework.test.context.junit.jupiter.web Web support for integrating the Spring TestContext Framework with the JUnit Jupiter extension model in JUnit 5.
Related Packages
org.springframework.test.context.junit.jupiter
Core support for integrating the Spring TestContext Framework with the JUnit Jupiter extension model in JUnit 5.
Annotation Interfaces
SpringJUnitWebConfig
@SpringJUnitWebConfig is a composed annotation that combines @ExtendWith(SpringExtension.class) from JUnit Jupiter with @ContextConfiguration and @WebAppConfiguration from the Spring TestContext Framework .
junit4
junit4
@NonNullApi @NonNullFields package org.springframework.test.context.junit4 Support classes for integrating the Spring TestContext Framework with JUnit 4.12 or higher.
Related Packages
org.springframework.test.context
This package contains the Spring TestContext Framework which provides annotation-driven unit and integration testing support that is agnostic of the actual testing framework in use.
org.springframework.test.context.junit4.rules
Custom JUnit 4 Rules used in the Spring TestContext Framework .
org.springframework.test.context.junit4.statements
Custom JUnit 4 Statements used in the Spring TestContext Framework .
Classes
AbstractJUnit4SpringContextTests
Abstract base test class which integrates the Spring TestContext Framework with explicit ApplicationContext testing support in a JUnit 4 environment.
AbstractTransactionalJUnit4SpringContextTests
Abstract transactional extension of AbstractJUnit4SpringContextTests which adds convenience functionality for JDBC access.
SpringJUnit4ClassRunner
SpringJUnit4ClassRunner is a custom extension of JUnit's BlockJUnit4ClassRunner which provides functionality of the Spring TestContext Framework to standard JUnit tests by means of the TestContextManager and associated support classes and annotations.
SpringRunner
SpringRunner is an alias for the SpringJUnit4ClassRunner .
rules
@NonNullApi @NonNullFields package org.springframework.test.context.junit4.rules Custom JUnit 4 Rules used in the Spring TestContext Framework.
Related Packages
org.springframework.test.context.junit4
Support classes for integrating the Spring TestContext Framework with JUnit 4.12 or higher.
org.springframework.test.context.junit4.statements
Custom JUnit 4 Statements used in the Spring TestContext Framework .
Classes
SpringClassRule
SpringClassRule is a custom JUnit TestRule that supports class-level features of the Spring TestContext Framework in standard JUnit tests by means of the TestContextManager and associated support classes and annotations.
SpringMethodRule
SpringMethodRule is a custom JUnit 4 MethodRule that supports instance-level and method-level features of the Spring TestContext Framework in standard JUnit tests by means of the TestContextManager and associated support classes and annotations.
statements
@NonNullApi @NonNullFields package org.springframework.test.context.junit4.statements Custom JUnit 4 Statements used in the Spring TestContext Framework.
Related Packages
org.springframework.test.context.junit4
Support classes for integrating the Spring TestContext Framework with JUnit 4.12 or higher.
org.springframework.test.context.junit4.rules
Custom JUnit 4 Rules used in the Spring TestContext Framework .
Classes
ProfileValueChecker
ProfileValueChecker is a custom JUnit Statement that checks whether a test class or test method is enabled in the current environment via Spring's @IfProfileValue annotation.
RunAfterTestClassCallbacks
RunAfterTestClassCallbacks is a custom JUnit Statement which allows the Spring TestContext Framework to be plugged into the JUnit execution chain by calling afterTestClass() on the supplied TestContextManager .
RunAfterTestExecutionCallbacks
RunAfterTestExecutionCallbacks is a custom JUnit Statement which allows the Spring TestContext Framework to be plugged into the JUnit 4 execution chain by calling afterTestExecution() on the supplied TestContextManager .
RunAfterTestMethodCallbacks
RunAfterTestMethodCallbacks is a custom JUnit Statement which allows the Spring TestContext Framework to be plugged into the JUnit execution chain by calling afterTestMethod() on the supplied TestContextManager .
RunBeforeTestClassCallbacks
RunBeforeTestClassCallbacks is a custom JUnit Statement which allows the Spring TestContext Framework to be plugged into the JUnit execution chain by calling beforeTestClass() on the supplied TestContextManager .
RunBeforeTestExecutionCallbacks
RunBeforeTestExecutionCallbacks is a custom JUnit Statement which allows the Spring TestContext Framework to be plugged into the JUnit 4 execution chain by calling beforeTestExecution() on the supplied TestContextManager .
RunBeforeTestMethodCallbacks
RunBeforeTestMethodCallbacks is a custom JUnit Statement which allows the Spring TestContext Framework to be plugged into the JUnit execution chain by calling beforeTestMethod() on the supplied TestContextManager .
RunPrepareTestInstanceCallbacks
RunPrepareTestInstanceCallbacks is a custom JUnit Statement which allows the Spring TestContext Framework to be plugged into the JUnit execution chain by calling prepareTestInstance() on the supplied TestContextManager .
SpringFailOnTimeout
SpringFailOnTimeout is a custom JUnit Statement which adds support for Spring's @Timed annotation by throwing an exception if the next statement in the execution chain takes more than the specified number of milliseconds.
SpringRepeat
SpringRepeat is a custom JUnit Statement which adds support for Spring's @Repeat annotation by repeating the test the specified number of times.
support
@NonNullApi @NonNullFields package org.springframework.test.context.support Support classes for the Spring TestContext Framework.
Related Packages
org.springframework.test.context
This package contains the Spring TestContext Framework which provides annotation-driven unit and integration testing support that is agnostic of the actual testing framework in use.
Classes
AbstractContextLoader
Abstract application context loader that provides a basis for all concrete implementations of the ContextLoader SPI.
AbstractDelegatingSmartContextLoader
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.
AbstractDirtiesContextTestExecutionListener
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.
AbstractGenericContextLoader
Abstract, generic extension of AbstractContextLoader that loads a GenericApplicationContext .
AbstractTestContextBootstrapper
Abstract implementation of the TestContextBootstrapper interface which provides most of the behavior required by a bootstrapper.
AbstractTestExecutionListener
Abstract ordered implementation of the TestExecutionListener API.
AnnotationConfigContextLoader
Concrete implementation of AbstractGenericContextLoader that loads bean definitions from component classes.
AnnotationConfigContextLoaderUtils
Utility methods for SmartContextLoaders that deal with component classes (e.g., @Configuration classes).
DefaultActiveProfilesResolver
Default implementation of the ActiveProfilesResolver strategy that resolves active bean definition profiles based solely on profiles configured declaratively via ActiveProfiles.profiles() or ActiveProfiles.value() .
DefaultBootstrapContext
Default implementation of the BootstrapContext interface.
DefaultTestContext
Default implementation of the TestContext interface.
DefaultTestContextBootstrapper
Default implementation of the TestContextBootstrapper SPI.
DelegatingSmartContextLoader
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 .
DependencyInjectionTestExecutionListener
TestExecutionListener which provides support for dependency injection and initialization of test instances.
DirtiesContextBeforeModesTestExecutionListener
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.
DirtiesContextTestExecutionListener
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.
GenericGroovyXmlContextLoader
Concrete implementation of AbstractGenericContextLoader that reads bean definitions from Groovy scripts and XML configuration files.
GenericXmlContextLoader
Concrete implementation of AbstractGenericContextLoader that reads bean definitions from XML resources.
TestConstructorUtils
Utility methods for working with @TestConstructor .
TestPropertySourceUtils
Utility methods for working with @TestPropertySource and adding test PropertySources to the Environment .
Interfaces
PropertyProvider
Strategy for providing named properties — for example, for looking up key-value pairs in a generic fashion.
testng
@NonNullApi @NonNullFields package org.springframework.test.context.testng Support classes for integrating the Spring TestContext Framework with TestNG.
Related Packages
org.springframework.test.context
This package contains the Spring TestContext Framework which provides annotation-driven unit and integration testing support that is agnostic of the actual testing framework in use.
Classes
AbstractTestNGSpringContextTests
Abstract base test class which integrates the Spring TestContext Framework with explicit ApplicationContext testing support in a TestNG environment.
AbstractTransactionalTestNGSpringContextTests
Abstract transactional extension of AbstractTestNGSpringContextTests which adds convenience functionality for JDBC access.
transaction
@NonNullApi @NonNullFields package org.springframework.test.context.transaction Transactional support classes for the Spring TestContext Framework.
Related Packages
org.springframework.test.context
This package contains the Spring TestContext Framework which provides annotation-driven unit and integration testing support that is agnostic of the actual testing framework in use.
Annotation Interfaces
AfterTransaction
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.
BeforeTransaction
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.
Classes
TestContextTransactionUtils
Utility methods for working with transactions and data access related beans within the Spring TestContext Framework .
TestTransaction
TestTransaction provides a collection of static utility methods for programmatic interaction with test-managed transactions within test methods, before methods, and after methods.
TransactionalTestExecutionListener
TestExecutionListener that provides support for executing tests within test-managed transactions by honoring Spring's @Transactional annotation.
util
@NonNullApi @NonNullFields package org.springframework.test.context.util Common utilities used within the Spring TestContext Framework.
Related Packages
org.springframework.test.context
This package contains the Spring TestContext Framework which provides annotation-driven unit and integration testing support that is agnostic of the actual testing framework in use.
Classes
TestContextResourceUtils
Utility methods for working with resources within the Spring TestContext Framework .
TestContextSpringFactoriesUtils
Collection of utilities for working with SpringFactoriesLoader within the Spring TestContext Framework .
web
@NonNullApi @NonNullFields package org.springframework.test.context.web Web support classes for the Spring TestContext Framework.
Related Packages
org.springframework.test.context
This package contains the Spring TestContext Framework which provides annotation-driven unit and integration testing support that is agnostic of the actual testing framework in use.
Classes
AbstractGenericWebContextLoader
Abstract, generic extension of AbstractContextLoader that loads a GenericWebApplicationContext .
AnnotationConfigWebContextLoader
Concrete implementation of AbstractGenericWebContextLoader that loads bean definitions from annotated classes.
GenericGroovyXmlWebContextLoader
Concrete implementation of AbstractGenericWebContextLoader that loads bean definitions from Groovy scripts and XML configuration files.
GenericXmlWebContextLoader
Concrete implementation of AbstractGenericWebContextLoader that loads bean definitions from XML resources.
ServletTestExecutionListener
TestExecutionListener which provides mock Servlet API support to WebApplicationContexts loaded by the Spring TestContext Framework .
WebDelegatingSmartContextLoader
WebDelegatingSmartContextLoader is a concrete implementation of AbstractDelegatingSmartContextLoader that delegates to a GenericXmlWebContextLoader (or a GenericGroovyXmlWebContextLoader if Groovy is present on the classpath) and an AnnotationConfigWebContextLoader .
WebMergedContextConfiguration
WebMergedContextConfiguration encapsulates the merged context configuration declared on a test class and all of its superclasses and enclosing classes via @ContextConfiguration , @WebAppConfiguration , @ActiveProfiles , and @TestPropertySource .
WebTestContextBootstrapper
Web-specific implementation of the TestContextBootstrapper SPI.
Annotation Interfaces
WebAppConfiguration
@WebAppConfiguration is a class-level annotation that is used to declare that the ApplicationContext loaded for an integration test should be a WebApplicationContext .
jdbc
@NonNullApi @NonNullFields package org.springframework.test.jdbc Support classes for tests based on JDBC.
Classes
JdbcTestUtils
JdbcTestUtils is a collection of JDBC related utility functions intended to simplify standard database testing scenarios.
util
@NonNullApi @NonNullFields package org.springframework.test.util General utility classes for use in unit and integration tests.
Classes
AopTestUtils
AopTestUtils is a collection of AOP-related utility methods for use in unit and integration testing scenarios.
AssertionErrors
Test assertions that are independent of any third-party assertion library.
ExceptionCollector
ExceptionCollector is a test utility for executing code blocks, collecting exceptions, and generating a single AssertionError containing any exceptions encountered as suppressed exceptions .
JsonExpectationsHelper
A helper class for assertions on JSON content.
JsonPathExpectationsHelper
A helper class for applying assertions via JSON path expressions.
ReflectionTestUtils
ReflectionTestUtils is a collection of reflection-based utility methods for use in unit and integration testing scenarios.
TestSocketUtils
Simple utility for finding available TCP ports on localhost for use in integration testing scenarios.
XmlExpectationsHelper
A helper class for assertions on XML content.
XpathExpectationsHelper
A helper class for applying assertions via XPath expressions.
Interfaces
ExceptionCollector.Executable
Executable is a functional interface that can be used to implement any generic block of code that potentially throws a Throwable .
web
web
@NonNullApi @NonNullFields package org.springframework.test.web Helper classes for unit tests based on Spring's web support.
Related Packages
org.springframework.test.web.client
Contains client-side REST testing support.
org.springframework.test.web.servlet
Contains server-side support for testing Spring MVC applications.
Classes
ModelAndViewAssert
A collection of assertions intended to simplify testing scenarios dealing with Spring Web MVC ModelAndView objects.
client
client
@NonNullApi @NonNullFields package org.springframework.test.web.client Contains client-side REST testing support. See Also: MockRestServiceServer
Related Packages
org.springframework.test.web
Helper classes for unit tests based on Spring's web support.
org.springframework.test.web.client.match
Contains built-in RequestMatcher implementations.
org.springframework.test.web.client.response
Contains built-in ResponseCreator implementations.
org.springframework.test.web.servlet
Contains server-side support for testing Spring MVC applications.
Classes
AbstractRequestExpectationManager
Base class for RequestExpectationManager implementations responsible for storing expectations and actual requests, and checking for unsatisfied expectations at the end.
AbstractRequestExpectationManager.RequestExpectationGroup
Helper class to manage a group of remaining expectations.
DefaultRequestExpectation
Default implementation of RequestExpectation that simply delegates to the request matchers and the response creator it contains.
DefaultRequestExpectation.RequestCount
Helper class that keeps track of actual vs expected request count.
ExpectedCount
A simple type representing a range for an expected count.
MockMvcClientHttpRequestFactory
A ClientHttpRequestFactory for requests executed via MockMvc .
MockRestServiceServer
Main entry point for client-side REST testing .
SimpleRequestExpectationManager
Simple RequestExpectationManager that matches requests to expectations sequentially, i.e.
UnorderedRequestExpectationManager
RequestExpectationManager that matches requests to expectations regardless of the order of declaration of expected requests.
Interfaces
MockRestServiceServer.MockRestServiceServerBuilder
Builder to create a MockRestServiceServer .
RequestExpectation
An extension of ResponseActions that also implements RequestMatcher and ResponseCreator
RequestExpectationManager
Encapsulates the behavior required to implement MockRestServiceServer including its public API (create expectations + verify/reset) along with an extra method for verifying actual requests.
RequestMatcher
A contract for matching requests to expectations.
ResponseActions
A contract for setting up request expectations and defining a response.
ResponseCreator
A contract for creating a ClientHttpResponse .
match
@NonNullApi @NonNullFields package org.springframework.test.web.client.match Contains built-in RequestMatcher implementations. Use MockRestRequestMatchers to gain access to instances of those implementations.
Related Packages
org.springframework.test.web.client
Contains client-side REST testing support.
org.springframework.test.web.client.response
Contains built-in ResponseCreator implementations.
Classes
ContentRequestMatchers
Factory for request content RequestMatcher 's.
JsonPathRequestMatchers
Factory for assertions on the request content using JsonPath expressions.
MockRestRequestMatchers
Static factory methods for RequestMatcher classes.
XpathRequestMatchers
Factory methods for request content RequestMatcher implementations that use an XPath expression.
response
@NonNullApi @NonNullFields package org.springframework.test.web.client.response Contains built-in ResponseCreator implementations. Use MockRestResponseCreators to gain access to instances of those implementations.
Related Packages
org.springframework.test.web.client
Contains client-side REST testing support.
org.springframework.test.web.client.match
Contains built-in RequestMatcher implementations.
Classes
DefaultResponseCreator
A ResponseCreator with builder-style methods for adding response details.
ExecutingResponseCreator
ResponseCreator that obtains the response by executing the request through a ClientHttpRequestFactory .
MockRestResponseCreators
Static factory methods to obtain a ResponseCreator with a fixed response.
reactive
server
@NonNullApi @NonNullFields package org.springframework.test.web.reactive.server Support for testing Spring WebFlux server endpoints via WebTestClient.
Classes
CookieAssertions
Assertions on cookies of the response.
EntityExchangeResult<T>
ExchangeResult sub-class that exposes the response body fully extracted to a representation of type .
ExchangeResult
Container for request and response details for exchanges performed through WebTestClient .
FluxExchangeResult<T>
ExchangeResult variant with the response body decoded as Flux but not yet consumed.
HeaderAssertions
Assertions on headers of the response.
HttpHandlerConnector
Connector that handles requests by invoking an HttpHandler rather than making actual requests to a network socket.
JsonPathAssertions
JsonPath assertions.
StatusAssertions
Assertions on the response status.
XpathAssertions
XPath assertions for the WebTestClient .
Exceptions
HttpHandlerConnector.FailureAfterResponseCompletedException
Indicates that an error occurred after the server response was completed, via ReactiveHttpOutputMessage.writeWith(org.reactivestreams.Publisher) or ReactiveHttpOutputMessage.setComplete() , and can no longer be changed.
Interfaces
MockServerClientHttpResponse
Simple ClientHttpResponse extension that also exposes a result object from the underlying mock server exchange for further assertions on the state of the server response after the request is performed.
MockServerConfigurer
Contract that frameworks or applications can use to pre-package a set of customizations to a WebTestClient.MockServerSpec and expose that as a shortcut.
WebTestClient
Client for testing web servers that uses WebClient internally to perform requests while also providing a fluent API to verify responses.
WebTestClient.BodyContentSpec
Spec for expectations on the response body content.
WebTestClient.BodySpec<B, S extends WebTestClient.BodySpec<B, S>>
Spec for expectations on the response body decoded to a single Object.
WebTestClient.Builder
Steps for customizing the WebClient used to test with, internally delegating to a WebClient.Builder .
WebTestClient.ControllerSpec
Specification for customizing controller configuration equivalent to, and internally delegating to, a WebFluxConfigurer .
WebTestClient.ListBodySpec<E>
Spec for expectations on the response body decoded to a List.
WebTestClient.MockServerSpec<B extends WebTestClient.MockServerSpec<B>>
Base specification for setting up tests without a server.
WebTestClient.RequestBodySpec
Specification for providing body of a request.
WebTestClient.RequestBodyUriSpec
Specification for providing the body and the URI of a request.
WebTestClient.RequestHeadersSpec<S extends WebTestClient.RequestHeadersSpec<S>>
Specification for adding request headers and performing an exchange.
WebTestClient.RequestHeadersUriSpec<S extends WebTestClient.RequestHeadersSpec<S>>
Specification for providing request headers and the URI of a request.
WebTestClient.ResponseSpec
Chained API for applying assertions to a response.
WebTestClient.ResponseSpec.ResponseSpecConsumer
Consumer of a WebTestClient.ResponseSpec .
WebTestClient.RouterFunctionSpec
Specification for customizing router function configuration.
WebTestClient.UriSpec<S extends WebTestClient.RequestHeadersSpec<?>>
Specification for providing the URI of a request.
WebTestClientConfigurer
Contract to encapsulate customizations to a WebTestClient.Builder .
servlet
servlet
@NonNullApi @NonNullFields package org.springframework.test.web.servlet Contains server-side support for testing Spring MVC applications. See Also: MockMvc
Related Packages
org.springframework.test.web
Helper classes for unit tests based on Spring's web support.
org.springframework.test.web.servlet.client
Support for testing Spring MVC applications via WebTestClient with MockMvc for server request handling.
org.springframework.test.web.servlet.htmlunit
Server-side support for testing Spring MVC applications with MockMvc and HtmlUnit.
org.springframework.test.web.servlet.request
Contains built-in RequestBuilder implementations.
org.springframework.test.web.servlet.result
Contains built-in ResultMatcher and ResultHandler implementations.
org.springframework.test.web.servlet.setup
Contains built-in MockMvcBuilder implementations.
Interfaces
DispatcherServletCustomizer
Strategy interface for customizing DispatcherServlet instances that are managed by MockMvc .
MockMvcBuilder
Builds a MockMvc instance.
MvcResult
Provides access to the result of an executed request.
RequestBuilder
Builds a MockHttpServletRequest .
ResultActions
Allows applying actions, such as expectations, on the result of an executed request.
ResultHandler
A ResultHandler performs a generic action on the result of an executed request — for example, printing debug information.
ResultMatcher
A ResultMatcher matches the result of an executed request against some expectation.
SmartRequestBuilder
Extended variant of a RequestBuilder that applies its org.springframework.test.web.servlet.request.RequestPostProcessors as a separate step from the RequestBuilder.buildRequest(jakarta.servlet.ServletContext) method.
Classes
MockMvc
Main entry point for server-side Spring MVC test support.
MockMvcBuilderSupport
Base class for MockMvc builder implementations, providing the capability to create a MockMvc instance.
client
@NonNullApi @NonNullFields package org.springframework.test.web.servlet.client Support for testing Spring MVC applications via WebTestClient with MockMvc for server request handling.
Related Packages
org.springframework.test.web.servlet
Contains server-side support for testing Spring MVC applications.
org.springframework.test.web.servlet.htmlunit
Server-side support for testing Spring MVC applications with MockMvc and HtmlUnit.
org.springframework.test.web.servlet.request
Contains built-in RequestBuilder implementations.
org.springframework.test.web.servlet.result
Contains built-in ResultMatcher and ResultHandler implementations.
org.springframework.test.web.servlet.setup
Contains built-in MockMvcBuilder implementations.
Classes
MockMvcHttpConnector
Connector that handles requests by invoking a MockMvc rather than making actual requests over HTTP.
Interfaces
MockMvcWebTestClient
The main class for testing Spring MVC applications via WebTestClient with MockMvc for server request handling.
MockMvcWebTestClient.ControllerSpec
Specification for configuring MockMvc to test one or more controllers directly, and a simple facade around StandaloneMockMvcBuilder .
MockMvcWebTestClient.MockMvcServerSpec<B extends MockMvcWebTestClient.MockMvcServerSpec<B>>
Base specification for configuring MockMvc , and a simple facade around ConfigurableMockMvcBuilder .
htmlunit
htmlunit
@NonNullApi @NonNullFields package org.springframework.test.web.servlet.htmlunit Server-side support for testing Spring MVC applications with MockMvc and HtmlUnit. See Also: MockMvc
Related Packages
org.springframework.test.web.servlet
Contains server-side support for testing Spring MVC applications.
org.springframework.test.web.servlet.htmlunit.webdriver
Server-side support for testing Spring MVC applications with MockMvc and the Selenium HtmlUnitDriver .
org.springframework.test.web.servlet.client
Support for testing Spring MVC applications via WebTestClient with MockMvc for server request handling.
org.springframework.test.web.servlet.request
Contains built-in RequestBuilder implementations.
org.springframework.test.web.servlet.result
Contains built-in ResultMatcher and ResultHandler implementations.
org.springframework.test.web.servlet.setup
Contains built-in MockMvcBuilder implementations.
Classes
DelegatingWebConnection
Implementation of WebConnection that allows delegating to various WebConnection implementations.
DelegatingWebConnection.DelegateWebConnection
The delegate web connection.
HostRequestMatcher
A WebRequestMatcher that allows matching on the host and optionally the port of WebRequest#getUrl() .
MockMvcWebClientBuilder
MockMvcWebClientBuilder simplifies the creation of an HtmlUnit WebClient that delegates to a MockMvc instance.
MockMvcWebConnection
MockMvcWebConnection enables MockMvc to transform a WebRequest into a WebResponse .
MockMvcWebConnectionBuilderSupport<T extends MockMvcWebConnectionBuilderSupport<T>>
Support class that simplifies the creation of a WebConnection that uses MockMvc and optionally delegates to a real WebConnection for specific requests.
UrlRegexRequestMatcher
A WebRequestMatcher that allows matching on WebRequest#getUrl().toExternalForm() using a regular expression.
Interfaces
WebRequestMatcher
Strategy for matching on a WebRequest .
webdriver
@NonNullApi @NonNullFields package org.springframework.test.web.servlet.htmlunit.webdriver Server-side support for testing Spring MVC applications with MockMvc and the Selenium HtmlUnitDriver. See Also: MockMvc HtmlUnitDriver
Related Packages
org.springframework.test.web.servlet.htmlunit
Server-side support for testing Spring MVC applications with MockMvc and HtmlUnit.
Classes
MockMvcHtmlUnitDriverBuilder
MockMvcHtmlUnitDriverBuilder simplifies the building of an HtmlUnitDriver that delegates to MockMvc and optionally delegates to an actual connection for specific requests.
WebConnectionHtmlUnitDriver
WebConnectionHtmlUnitDriver enables configuration of the WebConnection for an HtmlUnitDriver instance.
request
@NonNullApi @NonNullFields package org.springframework.test.web.servlet.request Contains built-in RequestBuilder implementations. Use MockMvcRequestBuilders to gain access to instances of those implementations.
Related Packages
org.springframework.test.web.servlet
Contains server-side support for testing Spring MVC applications.
org.springframework.test.web.servlet.client
Support for testing Spring MVC applications via WebTestClient with MockMvc for server request handling.
org.springframework.test.web.servlet.htmlunit
Server-side support for testing Spring MVC applications with MockMvc and HtmlUnit.
org.springframework.test.web.servlet.result
Contains built-in ResultMatcher and ResultHandler implementations.
org.springframework.test.web.servlet.setup
Contains built-in MockMvcBuilder implementations.
Interfaces
ConfigurableSmartRequestBuilder<B extends ConfigurableSmartRequestBuilder<B>>
An extension of SmartRequestBuilder that can be configured with RequestPostProcessors .
RequestPostProcessor
Extension point for applications or 3rd party libraries that wish to further initialize a MockHttpServletRequest instance after it has been built by MockHttpServletRequestBuilder or its subclass MockMultipartHttpServletRequestBuilder .
Classes
MockHttpServletRequestBuilder
Default builder for MockHttpServletRequest required as input to perform requests in MockMvc .
MockMultipartHttpServletRequestBuilder
Default builder for MockMultipartHttpServletRequest .
MockMvcRequestBuilders
Static factory methods for RequestBuilders .
result
@NonNullApi @NonNullFields package org.springframework.test.web.servlet.result Contains built-in ResultMatcher and ResultHandler implementations. Use MockMvcResultMatchers and MockMvcResultHandlers to access instances of those implementations.
Related Packages
org.springframework.test.web.servlet
Contains server-side support for testing Spring MVC applications.
org.springframework.test.web.servlet.client
Support for testing Spring MVC applications via WebTestClient with MockMvc for server request handling.
org.springframework.test.web.servlet.htmlunit
Server-side support for testing Spring MVC applications with MockMvc and HtmlUnit.
org.springframework.test.web.servlet.request
Contains built-in RequestBuilder implementations.
org.springframework.test.web.servlet.setup
Contains built-in MockMvcBuilder implementations.
Classes
ContentResultMatchers
Factory for response content assertions.
CookieResultMatchers
Factory for response cookie assertions.
FlashAttributeResultMatchers
Factory for "output" flash attribute assertions.
HandlerResultMatchers
Factory for assertions on the selected handler or handler method.
HeaderResultMatchers
Factory for response header assertions.
JsonPathResultMatchers
Factory for assertions on the response content using JsonPath expressions.
MockMvcResultHandlers
Static factory methods for ResultHandler -based result actions.
MockMvcResultMatchers
Static factory methods for ResultMatcher -based result actions.
ModelResultMatchers
Factory for assertions on the model.
PrintingResultHandler
Result handler that prints MvcResult details to a given output stream — for example: System.out , System.err , a custom java.io.PrintWriter , etc.
RequestResultMatchers
Factory for assertions on the request.
StatusResultMatchers
Factory for assertions on the response status.
ViewResultMatchers
Factory for assertions on the selected view.
XpathResultMatchers
Factory for assertions on the response content using XPath expressions.
Interfaces
PrintingResultHandler.ResultValuePrinter
A contract for how to actually write result information.
setup
@NonNullApi @NonNullFields package org.springframework.test.web.servlet.setup Contains built-in MockMvcBuilder implementations. Use MockMvcBuilders to access to instances of those implementations.
Related Packages
org.springframework.test.web.servlet
Contains server-side support for testing Spring MVC applications.
org.springframework.test.web.servlet.client
Support for testing Spring MVC applications via WebTestClient with MockMvc for server request handling.
org.springframework.test.web.servlet.htmlunit
Server-side support for testing Spring MVC applications with MockMvc and HtmlUnit.
org.springframework.test.web.servlet.request
Contains built-in RequestBuilder implementations.
org.springframework.test.web.servlet.result
Contains built-in ResultMatcher and ResultHandler implementations.
Classes
AbstractMockMvcBuilder<B extends AbstractMockMvcBuilder<B>>
Abstract implementation of MockMvcBuilder with common methods for configuring filters, default request properties, global expectations and global result actions.
DefaultMockMvcBuilder
A concrete implementation of AbstractMockMvcBuilder that provides the WebApplicationContext supplied to it as a constructor argument.
MockMvcBuilders
The main class to import in order to access all available MockMvcBuilders .
MockMvcConfigurerAdapter
An empty method implementation of MockMvcConfigurer .
SharedHttpSessionConfigurer
MockMvcConfigurer that stores and re-uses the HTTP session across multiple requests performed through the same MockMvc instance.
StandaloneMockMvcBuilder
A MockMvcBuilder that accepts @Controller registrations thus allowing full control over the instantiation and initialization of controllers and their dependencies similar to plain unit tests, and also making it possible to test one controller at a time.
Interfaces
ConfigurableMockMvcBuilder<B extends ConfigurableMockMvcBuilder<B>>
Defines common methods for building a MockMvc .
MockMvcConfigurer
Contract for customizing a ConfigurableMockMvcBuilder in some specific way, e.g.
transaction
transaction
@NonNullApi @NonNullFields package org.springframework.transaction Spring's core transaction management APIs (independent of any specific transaction management system); an exception hierarchy for Spring's transaction infrastructure; and transaction manager, definition, and status interfaces.
Related Packages
org.springframework.transaction.annotation
Spring's support for annotation-based transaction demarcation.
org.springframework.transaction.aspectj
AspectJ-based transaction management support.
org.springframework.transaction.config
Support package for declarative transaction configuration, with XML schema being the primary configuration format.
org.springframework.transaction.event
Spring's support for listening to transaction events.
org.springframework.transaction.interceptor
AOP-based solution for declarative transaction demarcation.
org.springframework.transaction.jta
Transaction SPI implementation for JTA.
org.springframework.transaction.reactive
Support classes for reactive transaction management.
org.springframework.transaction.support
Support classes for the org.springframework.transaction package.
Exceptions
CannotCreateTransactionException
Exception thrown when a transaction can't be created using an underlying transaction API such as JTA.
HeuristicCompletionException
Exception that represents a transaction failure caused by a heuristic decision on the side of the transaction coordinator.
IllegalTransactionStateException
Exception thrown when the existence or non-existence of a transaction amounts to an illegal state according to the transaction propagation behavior that applies.
InvalidIsolationLevelException
Exception that gets thrown when an invalid isolation level is specified, i.e.
InvalidTimeoutException
Exception that gets thrown when an invalid timeout is specified, that is, the specified timeout valid is out of range or the transaction manager implementation doesn't support timeouts.
NestedTransactionNotSupportedException
Exception thrown when attempting to work with a nested transaction but nested transactions are not supported by the underlying backend.
NoTransactionException
Exception thrown when an operation is attempted that relies on an existing transaction (such as setting rollback status) and there is no existing transaction.
TransactionException
Superclass for all transaction exceptions.
TransactionSuspensionNotSupportedException
Exception thrown when attempting to suspend an existing transaction but transaction suspension is not supported by the underlying backend.
TransactionSystemException
Exception thrown when a general transaction system error is encountered, like on commit or rollback.
TransactionTimedOutException
Exception to be thrown when a transaction has timed out.
TransactionUsageException
Superclass for exceptions caused by inappropriate usage of a Spring transaction API.
UnexpectedRollbackException
Thrown when an attempt to commit a transaction resulted in an unexpected rollback.
Interfaces
ConfigurableTransactionManager
Common configuration interface for transaction manager implementations.
PlatformTransactionManager
This is the central interface in Spring's imperative transaction infrastructure.
ReactiveTransaction
Representation of an ongoing ReactiveTransactionManager transaction.
ReactiveTransactionManager
This is the central interface in Spring's reactive transaction infrastructure.
SavepointManager
Interface that specifies an API to programmatically manage transaction savepoints in a generic fashion.
TransactionDefinition
Interface that defines Spring-compliant transaction properties.
TransactionExecution
Common representation of the current state of a transaction.
TransactionExecutionListener
Callback interface for stateless listening to transaction creation/completion steps in a transaction manager.
TransactionManager
Marker interface for Spring transaction manager implementations, either traditional or reactive.
TransactionStatus
Representation of an ongoing PlatformTransactionManager transaction.
annotation
@NonNullApi @NonNullFields package org.springframework.transaction.annotation Spring's support for annotation-based transaction demarcation. Hooked into Spring's transaction interception infrastructure via a special TransactionAttributeSource implementation.
Related Packages
org.springframework.transaction
Spring's core transaction management APIs (independent of any specific transaction management system); an exception hierarchy for Spring's transaction infrastructure; and transaction manager, definition, and status interfaces.
Classes
AbstractTransactionManagementConfiguration
Abstract base @Configuration class providing common structure for enabling Spring's annotation-driven transaction management capability.
AnnotationTransactionAttributeSource
Implementation of the TransactionAttributeSource interface for working with transaction metadata in JDK 1.5+ annotation format.
Ejb3TransactionAnnotationParser
Strategy implementation for parsing EJB3's TransactionAttribute annotation.
JtaTransactionAnnotationParser
Strategy implementation for parsing JTA 1.2's Transactional annotation.
ProxyTransactionManagementConfiguration
@Configuration class that registers the Spring infrastructure beans necessary to enable proxy-based annotation-driven transaction management.
RestrictedTransactionalEventListenerFactory
Extension of TransactionalEventListenerFactory , detecting invalid transaction configuration for transactional event listeners: Transactional only supported with Propagation.REQUIRES_NEW and Propagation.NOT_SUPPORTED .
SpringTransactionAnnotationParser
Strategy implementation for parsing Spring's Transactional annotation.
TransactionManagementConfigurationSelector
Selects which implementation of AbstractTransactionManagementConfiguration should be used based on the value of EnableTransactionManagement.mode() on the importing @Configuration class.
Annotation Interfaces
EnableTransactionManagement
Enables Spring's annotation-driven transaction management capability, similar to the support found in Spring's XML namespace.
Transactional
Describes a transaction attribute on an individual method or on a class.
Enum Classes
Isolation
Enumeration that represents transaction isolation levels for use with the @Transactional annotation, corresponding to the TransactionDefinition interface.
Propagation
Enumeration that represents transaction propagation behaviors for use with the Transactional annotation, corresponding to the TransactionDefinition interface.
Interfaces
TransactionAnnotationParser
Strategy interface for parsing known transaction annotation types.
TransactionManagementConfigurer
Interface to be implemented by @ Configuration classes annotated with @ EnableTransactionManagement that wish to (or need to) explicitly specify the default PlatformTransactionManager bean (or ReactiveTransactionManager bean) to be used for annotation-driven transaction management, as opposed to the default approach of a by-type lookup.
aspectj
@NonNullApi @NonNullFields package org.springframework.transaction.aspectj AspectJ-based transaction management support.
Related Packages
org.springframework.transaction
Spring's core transaction management APIs (independent of any specific transaction management system); an exception hierarchy for Spring's transaction infrastructure; and transaction manager, definition, and status interfaces.
Classes
AspectJJtaTransactionManagementConfiguration
@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.
AspectJTransactionManagementConfiguration
@Configuration class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven transaction management for Spring's own Transactional annotation.
config
@NonNullApi @NonNullFields package org.springframework.transaction.config Support package for declarative transaction configuration, with XML schema being the primary configuration format.
Related Packages
org.springframework.transaction
Spring's core transaction management APIs (independent of any specific transaction management system); an exception hierarchy for Spring's transaction infrastructure; and transaction manager, definition, and status interfaces.
Classes
JtaTransactionManagerBeanDefinitionParser
Parser for the XML configuration element.
JtaTransactionManagerFactoryBean
Deprecated. as of 6.0, in favor of a straight JtaTransactionManager definition
TransactionManagementConfigUtils
Configuration constants for internal sharing across subpackages.
TxNamespaceHandler
NamespaceHandler allowing for the configuration of declarative transaction management using either XML or using annotations.
event
@NonNullApi @NonNullFields package org.springframework.transaction.event Spring's support for listening to transaction events.
Related Packages
org.springframework.transaction
Spring's core transaction management APIs (independent of any specific transaction management system); an exception hierarchy for Spring's transaction infrastructure; and transaction manager, definition, and status interfaces.
Interfaces
TransactionalApplicationListener<E extends ApplicationEvent>
An ApplicationListener that is invoked according to a TransactionPhase .
TransactionalApplicationListener.SynchronizationCallback
Callback to be invoked on synchronization-driven event processing, wrapping the target listener invocation ( TransactionalApplicationListener.processEvent(E) ).
Classes
TransactionalApplicationListenerAdapter<E extends ApplicationEvent>
TransactionalApplicationListener adapter that delegates the processing of an event to a target ApplicationListener instance.
TransactionalApplicationListenerMethodAdapter
GenericApplicationListener adapter that delegates the processing of an event to a TransactionalEventListener annotated method.
TransactionalEventListenerFactory
EventListenerFactory implementation that handles TransactionalEventListener annotated methods.
Annotation Interfaces
TransactionalEventListener
An EventListener that is invoked according to a TransactionPhase .
Enum Classes
TransactionPhase
The phase in which a transactional event listener applies.
interceptor
@NonNullApi @NonNullFields package org.springframework.transaction.interceptor AOP-based solution for declarative transaction demarcation. Builds on the AOP infrastructure in org.springframework.aop.framework. Any POJO can be transactionally advised with Spring. The TransactionFactoryProxyBean can be used to create transactional AOP proxies transparently to code that uses them. The TransactionInterceptor is the AOP Alliance MethodInterceptor that delivers transactional advice, based on the Spring transaction abstraction. This allows declarative transaction management in any environment, even without JTA if an application uses only a single database.
Related Packages
org.springframework.transaction
Spring's core transaction management APIs (independent of any specific transaction management system); an exception hierarchy for Spring's transaction infrastructure; and transaction manager, definition, and status interfaces.
Classes
AbstractFallbackTransactionAttributeSource
Abstract implementation of TransactionAttributeSource that caches attributes for methods and implements a fallback policy: 1.
BeanFactoryTransactionAttributeSourceAdvisor
Advisor driven by a TransactionAttributeSource , used to include a transaction advice bean for methods that are transactional.
CompositeTransactionAttributeSource
Composite TransactionAttributeSource implementation that iterates over a given array of TransactionAttributeSource instances.
DefaultTransactionAttribute
Spring's common transaction attribute implementation.
DelegatingTransactionAttribute
TransactionAttribute implementation that delegates all calls to a given target TransactionAttribute instance.
MatchAlwaysTransactionAttributeSource
Very simple implementation of TransactionAttributeSource which will always return the same TransactionAttribute for all methods fed to it.
MethodMapTransactionAttributeSource
Simple TransactionAttributeSource implementation that allows attributes to be stored per method in a Map .
NameMatchTransactionAttributeSource
Simple TransactionAttributeSource implementation that allows attributes to be matched by registered name.
NoRollbackRuleAttribute
Tag subclass of RollbackRuleAttribute that has the opposite behavior to the RollbackRuleAttribute superclass.
RollbackRuleAttribute
Rule determining whether a given exception should cause a rollback.
RuleBasedTransactionAttribute
TransactionAttribute implementation that works out whether a given exception should cause transaction rollback by applying a number of rollback rules, both positive and negative.
TransactionAspectSupport
Base class for transactional aspects, such as the TransactionInterceptor or an AspectJ aspect.
TransactionAspectSupport.TransactionInfo
Opaque object used to hold transaction information.
TransactionAttributeEditor
PropertyEditor for TransactionAttribute objects.
TransactionAttributeSourceAdvisor
Advisor driven by a TransactionAttributeSource , used to include a TransactionInterceptor only for methods that are transactional.
TransactionAttributeSourceEditor
Property editor that converts a String into a TransactionAttributeSource .
TransactionInterceptor
AOP Alliance MethodInterceptor for declarative transaction management using the common Spring transaction infrastructure ( PlatformTransactionManager / ReactiveTransactionManager ).
TransactionProxyFactoryBean
Proxy factory bean for simplified declarative transaction handling.
Interfaces
TransactionalProxy
A marker interface for manually created transactional proxies.
TransactionAspectSupport.CoroutinesInvocationCallback
Coroutines-supporting extension of the callback interface.
TransactionAspectSupport.InvocationCallback
Simple callback interface for proceeding with the target invocation.
TransactionAttribute
This interface adds a rollbackOn specification to TransactionDefinition .
TransactionAttributeSource
Strategy interface used by TransactionInterceptor for metadata retrieval.
jta
@NonNullApi @NonNullFields package org.springframework.transaction.jta Transaction SPI implementation for JTA.
Related Packages
org.springframework.transaction
Spring's core transaction management APIs (independent of any specific transaction management system); an exception hierarchy for Spring's transaction infrastructure; and transaction manager, definition, and status interfaces.
Classes
JtaAfterCompletionSynchronization
Adapter for a JTA Synchronization, invoking the afterCommit / afterCompletion callbacks of Spring TransactionSynchronization objects callbacks after the outer JTA transaction has completed.
JtaTransactionManager
PlatformTransactionManager implementation for JTA, delegating to a backend JTA provider.
JtaTransactionObject
JTA transaction object, representing a UserTransaction .
ManagedTransactionAdapter
Adapter for a managed JTA Transaction handle, taking a JTA TransactionManager reference and creating a JTA Transaction handle for it.
SimpleTransactionFactory
Default implementation of the TransactionFactory strategy interface, simply wrapping a standard JTA TransactionManager .
SpringJtaSynchronizationAdapter
Adapter that implements the JTA Synchronization interface delegating to an underlying Spring TransactionSynchronization .
UserTransactionAdapter
Adapter for a JTA UserTransaction handle, taking a JTA TransactionManager reference and creating a JTA UserTransaction handle for it.
Interfaces
TransactionFactory
Strategy interface for creating JTA Transaction objects based on specified transactional characteristics.
reactive
@NonNullApi @NonNullFields package org.springframework.transaction.reactive Support classes for reactive transaction management. Provides an abstract base class for reactive transaction manager implementations, and a transactional operator plus callback for transaction demarcation.
Related Packages
org.springframework.transaction
Spring's core transaction management APIs (independent of any specific transaction management system); an exception hierarchy for Spring's transaction infrastructure; and transaction manager, definition, and status interfaces.
Classes
AbstractReactiveTransactionManager
Abstract base class that implements Spring's standard reactive transaction workflow, serving as basis for concrete platform transaction managers.
AbstractReactiveTransactionManager.SuspendedResourcesHolder
Holder for suspended resources.
GenericReactiveTransaction
Default implementation of the ReactiveTransaction interface, used by AbstractReactiveTransactionManager .
ReactiveResourceSynchronization<O, K>
TransactionSynchronization implementation that manages a resource object bound through TransactionSynchronizationManager .
TransactionalEventPublisher
A delegate for publishing transactional events in a reactive setup.
TransactionContext
Mutable transaction context that encapsulates transactional synchronizations and resources in the scope of a single transaction.
TransactionContextManager
Delegate to register and obtain transactional contexts.
TransactionSynchronizationManager
Central delegate that manages resources and transaction synchronizations per subscriber context.
Interfaces
TransactionalOperator
Operator class that simplifies programmatic transaction demarcation and transaction exception handling.
TransactionCallback<T>
Callback interface for reactive transactional code.
TransactionSynchronization
Interface for reactive transaction synchronization callbacks.
support
@NonNullApi @NonNullFields package org.springframework.transaction.support Support classes for the org.springframework.transaction package. Provides an abstract base class for transaction manager implementations, and a template plus callback for transaction demarcation.
Related Packages
org.springframework.transaction
Spring's core transaction management APIs (independent of any specific transaction management system); an exception hierarchy for Spring's transaction infrastructure; and transaction manager, definition, and status interfaces.
Classes
AbstractPlatformTransactionManager
Abstract base class that implements Spring's standard transaction workflow, serving as basis for concrete platform transaction managers like JtaTransactionManager .
AbstractPlatformTransactionManager.SuspendedResourcesHolder
Holder for suspended resources.
AbstractTransactionStatus
Abstract base implementation of the TransactionStatus interface.
DefaultTransactionDefinition
Default implementation of the TransactionDefinition interface, offering bean-style configuration and sensible default values (PROPAGATION_REQUIRED, ISOLATION_DEFAULT, TIMEOUT_DEFAULT, readOnly=false).
DefaultTransactionStatus
Default implementation of the TransactionStatus interface, used by AbstractPlatformTransactionManager .
DelegatingTransactionDefinition
TransactionDefinition implementation that delegates all calls to a given target TransactionDefinition instance.
ResourceHolderSupport
Convenient base class for resource holders.
ResourceHolderSynchronization<H extends ResourceHolder, K>
TransactionSynchronization implementation that manages a ResourceHolder bound through TransactionSynchronizationManager .
SimpleTransactionScope
A simple transaction-backed Scope implementation, delegating to TransactionSynchronizationManager 's resource binding mechanism.
SimpleTransactionStatus
A simple TransactionStatus implementation.
TransactionCallbackWithoutResult
Simple convenience class for TransactionCallback implementation.
TransactionSynchronizationAdapter
Deprecated. as of 5.3, in favor of the default methods on the TransactionSynchronization interface
TransactionSynchronizationManager
Central delegate that manages resources and transaction synchronizations per thread.
TransactionSynchronizationUtils
Utility methods for triggering specific TransactionSynchronization callback methods on all currently registered synchronizations.
TransactionTemplate
Template class that simplifies programmatic transaction demarcation and transaction exception handling.
Interfaces
CallbackPreferringPlatformTransactionManager
Extension of the PlatformTransactionManager interface, exposing a method for executing a given callback within a transaction.
ResourceHolder
Generic interface to be implemented by resource holders.
ResourceTransactionDefinition
Extended variant of TransactionDefinition , indicating a resource transaction and in particular whether the transactional resource is ready for local optimizations.
ResourceTransactionManager
Extension of the PlatformTransactionManager interface, indicating a native resource transaction manager, operating on a single target resource.
SmartTransactionObject
Interface to be implemented by transaction objects that are able to return an internal rollback-only marker, typically from another transaction that has participated and marked it as rollback-only.
TransactionCallback<T>
Callback interface for transactional code.
TransactionOperations
Interface specifying basic transaction execution operations.
TransactionSynchronization
Interface for transaction synchronization callbacks.
ui
ui
@NonNullApi @NonNullFields package org.springframework.ui Generic support for UI layer concepts. Provides a generic ModelMap for model holding.
Related Packages
org.springframework.ui.context
Contains classes defining the application context subinterface for UI applications.
org.springframework.ui.freemarker
Support classes for setting up FreeMarker within a Spring application context.
Classes
ConcurrentModel
Implementation of the Model interface based on a ConcurrentHashMap for use in concurrent scenarios.
ExtendedModelMap
Subclass of ModelMap that implements the Model interface.
ModelMap
Implementation of Map for use when building model data for use with UI tools.
Interfaces
Model
Interface that defines a holder for model attributes.
context
context
@NonNullApi @NonNullFields package org.springframework.ui.context Contains classes defining the application context subinterface for UI applications. The theme feature is added here.
Related Packages
org.springframework.ui
Generic support for UI layer concepts.
org.springframework.ui.context.support
Classes supporting the org.springframework.ui.context package.
org.springframework.ui.freemarker
Support classes for setting up FreeMarker within a Spring application context.
Interfaces
HierarchicalThemeSource
Deprecated. as of 6.0 in favor of using CSS, without direct replacement
Theme
Deprecated. as of 6.0 in favor of using CSS, without direct replacement
ThemeSource
Deprecated. as of 6.0 in favor of using CSS, without direct replacement
support
@NonNullApi @NonNullFields package org.springframework.ui.context.support Classes supporting the org.springframework.ui.context package. Provides support classes for specialized UI contexts, e.g. for web UIs.
Related Packages
org.springframework.ui.context
Contains classes defining the application context subinterface for UI applications.
Classes
DelegatingThemeSource
Deprecated. as of 6.0 in favor of using CSS, without direct replacement
ResourceBundleThemeSource
Deprecated. as of 6.0 in favor of using CSS, without direct replacement
SimpleTheme
Deprecated. as of 6.0 in favor of using CSS, without direct replacement
UiApplicationContextUtils
Deprecated. as of 6.0 in favor of using CSS, without direct replacement
freemarker
@NonNullApi @NonNullFields package org.springframework.ui.freemarker Support classes for setting up FreeMarker within a Spring application context.
Related Packages
org.springframework.ui
Generic support for UI layer concepts.
org.springframework.ui.context
Contains classes defining the application context subinterface for UI applications.
Classes
FreeMarkerConfigurationFactory
Factory that configures a FreeMarker Configuration.
FreeMarkerConfigurationFactoryBean
Factory bean that creates a FreeMarker Configuration and provides it as bean reference.
FreeMarkerTemplateUtils
Utility class for working with FreeMarker.
SpringTemplateLoader
FreeMarker TemplateLoader adapter that loads via a Spring ResourceLoader .
util
util
@NonNullApi @NonNullFields package org.springframework.util Miscellaneous utility classes, such as utilities for working with strings, classes, collections, reflection, etc.
Related Packages
org.springframework.util.backoff
A generic back-off abstraction.
org.springframework.util.comparator
Useful generic java.util.Comparator implementations, such as an invertible comparator and a compound comparator.
org.springframework.util.concurrent
Useful generic java.util.concurrent.Future extensions.
org.springframework.util.function
Useful generic java.util.function helper classes.
org.springframework.util.unit
Useful unit data types.
org.springframework.util.xml
Miscellaneous utility classes for XML parsing and transformation, such as error handlers that log warnings via Commons Logging.
Classes
AlternativeJdkIdGenerator
An IdGenerator that uses SecureRandom for the initial seed and Random thereafter, instead of calling UUID.randomUUID() every time as JdkIdGenerator does.
AntPathMatcher
PathMatcher implementation for Ant-style path patterns.
AntPathMatcher.AntPathStringMatcher
Tests whether a string matches against a pattern via a Pattern .
AntPathMatcher.AntPatternComparator
The default Comparator implementation returned by AntPathMatcher.getPatternComparator(String) .
Assert
Assertion utility class that assists in validating arguments.
AutoPopulatingList<E>
Simple List wrapper class that allows for elements to be automatically populated as they are requested.
Base64Utils
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
ClassUtils
Miscellaneous java.lang.Class utility methods.
CollectionUtils
Miscellaneous collection utility methods.
CommonsLogWriter
java.io.Writer adapter for a Commons Logging Log .
CompositeIterator<E>
Composite iterator that combines multiple other iterators, as registered via CompositeIterator.add(Iterator) .
ConcurrencyThrottleSupport
Support class for throttling concurrent access to a specific resource.
ConcurrentLruCache<K, V>
Simple LRU (Least Recently Used) cache, bounded by a specified cache capacity.
ConcurrentReferenceHashMap<K, V>
A ConcurrentHashMap that uses soft or weak references for both keys and values .
ConcurrentReferenceHashMap.Entry<K, V>
A single map entry.
CustomizableThreadCreator
Simple customizable helper class for creating new Thread instances.
DefaultPropertiesPersister
Default implementation of the PropertiesPersister interface.
DigestUtils
Miscellaneous methods for calculating digests.
ExceptionTypeFilter
An InstanceFilter implementation that handles exception types.
FastByteArrayOutputStream
A speedy alternative to ByteArrayOutputStream .
FileCopyUtils
Simple utility methods for file and stream copying.
FileSystemUtils
Utility methods for working with the file system.
InstanceFilter<T>
A simple instance filter that checks if a given instance match based on a collection of includes and excludes element.
JdkIdGenerator
An IdGenerator that calls UUID.randomUUID() .
LinkedCaseInsensitiveMap<V>
LinkedHashMap variant that stores String keys in a case-insensitive manner, for example for key-based access in a results table.
LinkedMultiValueMap<K, V>
Simple implementation of MultiValueMap that wraps a LinkedHashMap , storing multiple values in an ArrayList .
MethodInvoker
Helper class that allows for specifying a method to invoke in a declarative fashion, be it static or non-static.
MimeType
Represents a MIME Type, as originally defined in RFC 2046 and subsequently used in other Internet protocols including HTTP.
MimeType.SpecificityComparator<T extends MimeType>
Deprecated, for removal: This API element is subject to removal in a future version. As of 6.0, with no direct replacement
MimeTypeUtils
Miscellaneous MimeType utility methods.
MultiValueMapAdapter<K, V>
Adapts a given Map to the MultiValueMap contract.
NumberUtils
Miscellaneous utility methods for number conversion and parsing.
ObjectUtils
Miscellaneous object utility methods.
PatternMatchUtils
Utility methods for simple pattern matching, in particular for Spring's typical xxx* , *xxx , *xxx* , and xxx*yyy pattern styles.
PropertyPlaceholderHelper
Utility class for working with Strings that have placeholder values in them.
ReflectionUtils
Simple utility class for working with the reflection API and handling reflection exceptions.
ResizableByteArrayOutputStream
An extension of ByteArrayOutputStream that: has public ResizableByteArrayOutputStream.grow(int) and ResizableByteArrayOutputStream.resize(int) methods to get more control over the size of the internal buffer has a higher initial capacity (256) by default
ResourceUtils
Utility methods for resolving resource locations to files in the file system.
SerializationUtils
Static utilities for serialization and deserialization using Java Object Serialization .
SimpleIdGenerator
A simple IdGenerator that starts at 1, increments up to Long.MAX_VALUE , and then rolls over.
SimpleRouteMatcher
RouteMatcher that delegates to a PathMatcher .
StopWatch
Simple stop watch, allowing for timing of a number of tasks, exposing total running time and running time for each named task.
StopWatch.TaskInfo
Nested class to hold data about one task executed within the StopWatch .
StreamUtils
Simple utility methods for dealing with streams.
StringUtils
Miscellaneous String utility methods.
SystemPropertyUtils
Helper class for resolving placeholders in texts.
TypeUtils
Utility to work with generic type parameters.
Interfaces
AutoPopulatingList.ElementFactory<E>
Factory interface for creating elements for an index-based access data structure such as a List .
ConcurrentReferenceHashMap.Reference<K, V>
A reference to an ConcurrentReferenceHashMap.Entry contained in the map.
ErrorHandler
A strategy for handling errors.
IdGenerator
Contract for generating universally unique identifiers ( UUIDs ).
MultiValueMap<K, V>
Extension of the Map interface that stores multiple values.
PathMatcher
Strategy interface for String -based path matching.
PropertiesPersister
Strategy interface for persisting java.util.Properties , allowing for pluggable parsing strategies.
PropertyPlaceholderHelper.PlaceholderResolver
Strategy interface used to resolve replacement values for placeholders contained in Strings.
ReflectionUtils.FieldCallback
Callback interface invoked on each field in the hierarchy.
ReflectionUtils.FieldFilter
Callback optionally used to filter fields to be operated on by a field callback.
ReflectionUtils.MethodCallback
Action to take on each method.
ReflectionUtils.MethodFilter
Callback optionally used to filter methods to be operated on by a method callback.
RouteMatcher
Contract for matching routes to patterns.
RouteMatcher.Route
A parsed representation of a route.
StringValueResolver
Simple strategy interface for resolving a String value.
Exceptions
AutoPopulatingList.ElementInstantiationException
Exception to be thrown from ElementFactory.
InvalidMimeTypeException
Exception thrown from MimeTypeUtils.parseMimeType(String) in case of encountering an invalid content type specification String.
Enum Classes
ConcurrentReferenceHashMap.ReferenceType
Various reference types supported by this map.
ConcurrentReferenceHashMap.Restructure
The types of restructuring that can be performed.
backoff
@NonNullApi @NonNullFields package org.springframework.util.backoff A generic back-off abstraction.
Related Packages
org.springframework.util
Miscellaneous utility classes, such as utilities for working with strings, classes, collections, reflection, etc.
org.springframework.util.comparator
Useful generic java.util.Comparator implementations, such as an invertible comparator and a compound comparator.
org.springframework.util.concurrent
Useful generic java.util.concurrent.Future extensions.
org.springframework.util.function
Useful generic java.util.function helper classes.
org.springframework.util.unit
Useful unit data types.
org.springframework.util.xml
Miscellaneous utility classes for XML parsing and transformation, such as error handlers that log warnings via Commons Logging.
Interfaces
BackOff
Provide a BackOffExecution that indicates the rate at which an operation should be retried.
BackOffExecution
Represent a particular back-off execution.
Classes
ExponentialBackOff
Implementation of BackOff that increases the back off period for each retry attempt.
FixedBackOff
A simple BackOff implementation that provides a fixed interval between two attempts and a maximum number of retries.
comparator
@NonNullApi @NonNullFields package org.springframework.util.comparator Useful generic java.util.Comparator implementations, such as an invertible comparator and a compound comparator.
Related Packages
org.springframework.util
Miscellaneous utility classes, such as utilities for working with strings, classes, collections, reflection, etc.
org.springframework.util.backoff
A generic back-off abstraction.
org.springframework.util.concurrent
Useful generic java.util.concurrent.Future extensions.
org.springframework.util.function
Useful generic java.util.function helper classes.
org.springframework.util.unit
Useful unit data types.
org.springframework.util.xml
Miscellaneous utility classes for XML parsing and transformation, such as error handlers that log warnings via Commons Logging.
Classes
BooleanComparator
A Comparator for Boolean objects that can sort either true or false first.
ComparableComparator<T extends Comparable<T>>
Deprecated. as of 6.1 in favor of Comparator.naturalOrder()
Comparators
Convenient entry point with generically typed factory methods for common Spring Comparator variants.
InstanceComparator<T>
Compares objects based on an arbitrary class order.
NullSafeComparator<T>
Deprecated. as of 6.1 in favor of Comparator.nullsLast(java.util.Comparator) and Comparator.nullsFirst(java.util.Comparator)
concurrent
@NonNullApi @NonNullFields package org.springframework.util.concurrent Useful generic java.util.concurrent.Future extensions.
Related Packages
org.springframework.util
Miscellaneous utility classes, such as utilities for working with strings, classes, collections, reflection, etc.
org.springframework.util.backoff
A generic back-off abstraction.
org.springframework.util.comparator
Useful generic java.util.Comparator implementations, such as an invertible comparator and a compound comparator.
org.springframework.util.function
Useful generic java.util.function helper classes.
org.springframework.util.unit
Useful unit data types.
org.springframework.util.xml
Miscellaneous utility classes for XML parsing and transformation, such as error handlers that log warnings via Commons Logging.
Classes
CompletableToListenableFutureAdapter<T>
Deprecated. as of 6.0, with no concrete replacement
FutureAdapter<T, S>
Deprecated. as of 6.0, with no concrete replacement
FutureUtils
Convenience utilities for working with Future and implementations.
ListenableFutureAdapter<T, S>
Deprecated. as of 6.0, in favor of CompletableFuture
ListenableFutureCallbackRegistry<T>
Deprecated. as of 6.0, with no concrete replacement
ListenableFutureTask<T>
Deprecated. as of 6.0, with no concrete replacement
MonoToListenableFutureAdapter<T>
Deprecated. as of 6.0, in favor of Mono.toFuture()
SettableListenableFuture<T>
Deprecated. as of 6.0, in favor of CompletableFuture
Interfaces
FailureCallback
Deprecated. as of 6.0, in favor of CompletableFuture.whenComplete(BiConsumer)
ListenableFuture<T>
Deprecated. as of 6.0, in favor of CompletableFuture
ListenableFutureCallback<T>
Deprecated. as of 6.0, in favor of CompletableFuture.whenComplete(BiConsumer)
SuccessCallback<T>
Deprecated. as of 6.0, in favor of CompletableFuture.whenComplete(BiConsumer)
function
@NonNullApi @NonNullFields package org.springframework.util.function Useful generic java.util.function helper classes.
Related Packages
org.springframework.util
Miscellaneous utility classes, such as utilities for working with strings, classes, collections, reflection, etc.
org.springframework.util.backoff
A generic back-off abstraction.
org.springframework.util.comparator
Useful generic java.util.Comparator implementations, such as an invertible comparator and a compound comparator.
org.springframework.util.concurrent
Useful generic java.util.concurrent.Future extensions.
org.springframework.util.unit
Useful unit data types.
org.springframework.util.xml
Miscellaneous utility classes for XML parsing and transformation, such as error handlers that log warnings via Commons Logging.
Classes
SingletonSupplier<T>
A Supplier decorator that caches a singleton result and makes it available from SingletonSupplier.get() (nullable) and SingletonSupplier.obtain() (null-safe).
SupplierUtils
Convenience utilities for Supplier handling.
Interfaces
ThrowingBiFunction<T, U, R>
A BiFunction that allows invocation of code that throws a checked exception.
ThrowingConsumer<T>
A Consumer that allows invocation of code that throws a checked exception.
ThrowingFunction<T, R>
A Function that allows invocation of code that throws a checked exception.
ThrowingSupplier<T>
A Supplier that allows invocation of code that throws a checked exception.
unit
@NonNullApi @NonNullFields package org.springframework.util.unit Useful unit data types.
Related Packages
org.springframework.util
Miscellaneous utility classes, such as utilities for working with strings, classes, collections, reflection, etc.
org.springframework.util.backoff
A generic back-off abstraction.
org.springframework.util.comparator
Useful generic java.util.Comparator implementations, such as an invertible comparator and a compound comparator.
org.springframework.util.concurrent
Useful generic java.util.concurrent.Future extensions.
org.springframework.util.function
Useful generic java.util.function helper classes.
org.springframework.util.xml
Miscellaneous utility classes for XML parsing and transformation, such as error handlers that log warnings via Commons Logging.
Classes
DataSize
A data size, such as '12MB'.
Enum Classes
DataUnit
A standard set of DataSize units.
xml
@NonNullApi @NonNullFields package org.springframework.util.xml Miscellaneous utility classes for XML parsing and transformation, such as error handlers that log warnings via Commons Logging.
Related Packages
org.springframework.util
Miscellaneous utility classes, such as utilities for working with strings, classes, collections, reflection, etc.
org.springframework.util.backoff
A generic back-off abstraction.
org.springframework.util.comparator
Useful generic java.util.Comparator implementations, such as an invertible comparator and a compound comparator.
org.springframework.util.concurrent
Useful generic java.util.concurrent.Future extensions.
org.springframework.util.function
Useful generic java.util.function helper classes.
org.springframework.util.unit
Useful unit data types.
Classes
DomUtils
Convenience methods for working with the DOM API, in particular for working with DOM Nodes and DOM Elements.
SimpleNamespaceContext
Simple javax.xml.namespace.NamespaceContext implementation.
SimpleSaxErrorHandler
Simple org.xml.sax.ErrorHandler implementation: logs warnings using the given Commons Logging logger instance, and rethrows errors to discontinue the XML transformation.
SimpleTransformErrorListener
Simple javax.xml.transform.ErrorListener implementation: logs warnings using the given Commons Logging logger instance, and rethrows errors to discontinue the XML transformation.
StaxUtils
Convenience methods for working with the StAX API.
TransformerUtils
Contains common behavior relating to Transformers and the javax.xml.transform package in general.
XmlValidationModeDetector
Detects whether an XML stream is using DTD- or XSD-based validation.
validation
validation
@NonNullApi @NonNullFields package org.springframework.validation Provides data binding and validation functionality, for usage in business and/or UI layers.
Related Packages
org.springframework.validation.annotation
Support classes for annotation-based constraint evaluation, e.g.
org.springframework.validation.beanvalidation
Support classes for integrating a JSR-303 Bean Validation provider (such as Hibernate Validator) into a Spring ApplicationContext and in particular with Spring's data binding and validation APIs.
org.springframework.validation.method
Abstractions and support classes for method validation, independent of the underlying validation library.
org.springframework.validation.support
Support classes for handling validation results.
Classes
AbstractBindingResult
Abstract implementation of the BindingResult interface and its super-interface Errors .
AbstractErrors
Abstract implementation of the Errors interface.
AbstractPropertyBindingResult
Abstract base class for BindingResult implementations that work with Spring's PropertyAccessor mechanism.
BeanPropertyBindingResult
Default implementation of the Errors and BindingResult interfaces, for the registration and evaluation of binding errors on JavaBean objects.
BindingResultUtils
Convenience methods for looking up BindingResults in a model Map.
DataBinder
Binder that allows applying property values to a target object via constructor and setter injection, and also supports validation and binding result analysis.
DefaultBindingErrorProcessor
Default BindingErrorProcessor implementation.
DefaultMessageCodesResolver
Default implementation of the MessageCodesResolver interface.
DirectFieldBindingResult
Special implementation of the Errors and BindingResult interfaces, supporting registration and evaluation of binding errors on value objects.
FieldError
Encapsulates a field error, that is, a reason for rejecting a specific field value.
MapBindingResult
Map-based implementation of the BindingResult interface, supporting registration and evaluation of binding errors on Map attributes.
ObjectError
Encapsulates an object error, that is, a global reason for rejecting an object.
SimpleErrors
A simple implementation of the Errors interface, managing global errors and field errors for a top-level target object.
ValidationUtils
Utility class offering convenient methods for invoking a Validator and for rejecting empty fields.
Exceptions
BindException
Thrown when binding errors are considered fatal.
Interfaces
BindingErrorProcessor
Strategy for processing DataBinder 's missing field errors, and for translating a PropertyAccessException to a FieldError .
BindingResult
General interface that represents binding results.
DataBinder.NameResolver
Strategy to determine the name of the value to bind to a method parameter.
DataBinder.ValueResolver
Strategy for constructor binding to look up the values to bind to a given constructor parameter.
Errors
Stores and exposes information about data-binding and validation errors for a specific object.
MessageCodeFormatter
A strategy interface for formatting message codes.
MessageCodesResolver
Strategy interface for building message codes from validation error codes.
SmartValidator
Extended variant of the Validator interface, adding support for validation 'hints'.
Validator
A validator for application-specific objects.
Enum Classes
DefaultMessageCodesResolver.Format
Common message code formats.
annotation
@NonNullApi @NonNullFields package org.springframework.validation.annotation Support classes for annotation-based constraint evaluation, e.g. using a JSR-303 Bean Validation provider. Provides an extended variant of JSR-303's @Valid, supporting the specification of validation groups.
Related Packages
org.springframework.validation
Provides data binding and validation functionality, for usage in business and/or UI layers.
org.springframework.validation.beanvalidation
Support classes for integrating a JSR-303 Bean Validation provider (such as Hibernate Validator) into a Spring ApplicationContext and in particular with Spring's data binding and validation APIs.
org.springframework.validation.method
Abstractions and support classes for method validation, independent of the underlying validation library.
org.springframework.validation.support
Support classes for handling validation results.
Annotation Interfaces
Validated
Variant of JSR-303's Valid , supporting the specification of validation groups.
Classes
ValidationAnnotationUtils
Utility class for handling validation annotations.
beanvalidation
@NonNullApi @NonNullFields package org.springframework.validation.beanvalidation Support classes for integrating a JSR-303 Bean Validation provider (such as Hibernate Validator) into a Spring ApplicationContext and in particular with Spring's data binding and validation APIs. The central class is LocalValidatorFactoryBean which defines a shared ValidatorFactory/Validator setup for availability to other Spring components.
Related Packages
org.springframework.validation
Provides data binding and validation functionality, for usage in business and/or UI layers.
org.springframework.validation.annotation
Support classes for annotation-based constraint evaluation, e.g.
org.springframework.validation.method
Abstractions and support classes for method validation, independent of the underlying validation library.
org.springframework.validation.support
Support classes for handling validation results.
Classes
BeanValidationPostProcessor
Simple BeanPostProcessor that checks JSR-303 constraint annotations in Spring-managed beans, throwing an initialization exception in case of constraint violations right before calling the bean's init method (if any).
CustomValidatorBean
Configurable bean class that exposes a specific JSR-303 Validator through its original interface as well as through the Spring Validator interface.
LocaleContextMessageInterpolator
Delegates to a target MessageInterpolator implementation but enforces Spring's managed Locale.
LocalValidatorFactoryBean
This is the central class for jakarta.validation (JSR-303) setup in a Spring application context: It bootstraps a jakarta.validation.ValidationFactory and exposes it through the Spring Validator interface as well as through the JSR-303 Validator interface and the ValidatorFactory interface itself.
MessageSourceResourceBundleLocator
Implementation of Hibernate Validator 4.3/5.x's ResourceBundleLocator interface, exposing a Spring MessageSource as localized MessageSourceResourceBundle .
MethodValidationAdapter
MethodValidator that uses a Bean Validation Validator for validation, and adapts ConstraintViolation s to MethodValidationResult .
MethodValidationInterceptor
An AOP Alliance MethodInterceptor implementation that delegates to a JSR-303 provider for performing method-level validation on annotated methods.
MethodValidationPostProcessor
A convenient BeanPostProcessor implementation that delegates to a JSR-303 provider for performing method-level validation on annotated methods.
OptionalValidatorFactoryBean
LocalValidatorFactoryBean subclass that simply turns Validator calls into no-ops in case of no Bean Validation provider being available.
SpringConstraintValidatorFactory
JSR-303 ConstraintValidatorFactory implementation that delegates to a Spring BeanFactory for creating autowired ConstraintValidator instances.
SpringValidatorAdapter
Adapter that takes a JSR-303 javax.validator.Validator and exposes it as a Spring Validator while also exposing the original JSR-303 Validator interface itself.
Interfaces
MethodValidationAdapter.ObjectNameResolver
Strategy to resolve the name of an @Valid method parameter to use for its BindingResult .
method
@NonNullApi @NonNullFields package org.springframework.validation.method Abstractions and support classes for method validation, independent of the underlying validation library. The main abstractions: MethodValidator to apply method validation, and return or handle the results. MethodValidationResult and related types to represent the results. MethodValidationException to expose method validation results.
Related Packages
org.springframework.validation
Provides data binding and validation functionality, for usage in business and/or UI layers.
org.springframework.validation.annotation
Support classes for annotation-based constraint evaluation, e.g.
org.springframework.validation.beanvalidation
Support classes for integrating a JSR-303 Bean Validation provider (such as Hibernate Validator) into a Spring ApplicationContext and in particular with Spring's data binding and validation APIs.
org.springframework.validation.support
Support classes for handling validation results.
Exceptions
MethodValidationException
Exception that is a MethodValidationResult .
Interfaces
MethodValidationResult
Container for method validation results with validation errors from the underlying library adapted to MessageSourceResolvable s and grouped by method parameter as ParameterValidationResult .
MethodValidator
Contract to apply method validation and handle the results.
Classes
ParameterErrors
Extension of ParameterValidationResult created for Object method parameters or return values with nested errors on their properties.
ParameterValidationResult
Store and expose the results of method validation for a method parameter.
support
@NonNullApi @NonNullFields package org.springframework.validation.support Support classes for handling validation results.
Related Packages
org.springframework.validation
Provides data binding and validation functionality, for usage in business and/or UI layers.
org.springframework.validation.annotation
Support classes for annotation-based constraint evaluation, e.g.
org.springframework.validation.beanvalidation
Support classes for integrating a JSR-303 Bean Validation provider (such as Hibernate Validator) into a Spring ApplicationContext and in particular with Spring's data binding and validation APIs.
org.springframework.validation.method
Abstractions and support classes for method validation, independent of the underlying validation library.
Classes
BindingAwareConcurrentModel
Subclass of ConcurrentModel that automatically removes the BindingResult object when its corresponding target attribute is replaced through regular Map operations.
BindingAwareModelMap
Subclass of ExtendedModelMap that automatically removes a BindingResult object if the corresponding target attribute gets replaced through regular Map operations.
web
web
@NonNullApi @NonNullFields package org.springframework.web Common, generic interfaces that define minimal boundary points between Spring's web infrastructure and other framework modules.
Related Packages
org.springframework.web.accept
This package contains classes used to determine the requested the media types in a request.
org.springframework.web.bind
Provides web-specific data binding functionality.
org.springframework.web.client
Core package of the client-side web support.
org.springframework.web.context
Contains a variant of the application context interface for web applications, and the ContextLoaderListener that bootstraps a root web application context.
org.springframework.web.cors
Support for CORS (Cross-Origin Resource Sharing), based on a common CorsProcessor strategy.
org.springframework.web.filter
Provides generic filter base classes allowing for bean-style configuration.
org.springframework.web.jsf
Support classes for integrating a JSF web layer with a Spring service layer which is hosted in a Spring root WebApplicationContext.
org.springframework.web.method
Common infrastructure for handler method processing, as used by Spring MVC's org.springframework.web.servlet.mvc.method package.
org.springframework.web.multipart
Multipart resolution framework for handling file uploads.
org.springframework.web.reactive
Top-level package for the spring-webflux module that contains DispatcherHandler , the main entry point for WebFlux server endpoint processing including key contracts used to map requests to handlers, invoke them, and process the result.
org.springframework.web.server
Core interfaces and classes for Spring's generic, reactive web support.
org.springframework.web.servlet
Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.
org.springframework.web.socket
Common abstractions and Spring configuration support for WebSocket applications.
org.springframework.web.util
Miscellaneous web utility classes, such as HTML escaping and cookie handling.
Interfaces
ErrorResponse
Representation of a complete RFC 7807 error response including status, headers, and an RFC 7807 formatted ProblemDetail body.
ErrorResponse.Builder
Builder for an ErrorResponse .
HttpRequestHandler
Plain handler interface for components that process HTTP requests, analogous to a Servlet.
WebApplicationInitializer
Interface to be implemented in Servlet environments in order to configure the ServletContext programmatically -- as opposed to (or possibly in conjunction with) the traditional web.xml -based approach.
Exceptions
ErrorResponseException
RuntimeException that implements ErrorResponse to expose an HTTP status, response headers, and a body formatted as an RFC 7807 ProblemDetail .
HttpMediaTypeException
Abstract base for exceptions related to media types.
HttpMediaTypeNotAcceptableException
Exception thrown when the request handler cannot generate a response that is acceptable by the client.
HttpMediaTypeNotSupportedException
Exception thrown when a client POSTs, PUTs, or PATCHes content of a type not supported by request handler.
HttpRequestMethodNotSupportedException
Exception thrown when a request handler does not support a specific request method.
HttpSessionRequiredException
Exception thrown when an HTTP request handler requires a pre-existing session.
Classes
SpringServletContainerInitializer
A Spring-provided ServletContainerInitializer designed to support code-based configuration of the servlet container using Spring's WebApplicationInitializer SPI as opposed to (or possibly in combination with) the traditional web.xml -based approach.
accept
This package contains classes used to determine the requested the media types in a request.
bind
bind
@NonNullApi @NonNullFields package org.springframework.web.bind Provides web-specific data binding functionality.
Related Packages
org.springframework.web
Common, generic interfaces that define minimal boundary points between Spring's web infrastructure and other framework modules.
org.springframework.web.bind.annotation
Annotations for binding requests to controllers and handler methods as well as for binding request parameters to method arguments.
org.springframework.web.bind.support
Support classes for web data binding.
Classes
EscapedErrors
Errors wrapper that adds automatic HTML escaping to the wrapped instance, for convenient usage in HTML views.
ServletRequestDataBinder
Special DataBinder to perform data binding from servlet request parameters to JavaBeans, including support for multipart files.
ServletRequestDataBinder.ServletRequestValueResolver
Resolver that looks up values to bind in a ServletRequest .
ServletRequestParameterPropertyValues
PropertyValues implementation created from parameters in a ServletRequest.
ServletRequestUtils
Parameter extraction methods, for an approach distinct from data binding, in which parameters of specific types are required.
WebDataBinder
Special DataBinder for data binding from web request parameters to JavaBean objects.
Exceptions
MethodArgumentNotValidException
Exception to be thrown when validation on an argument annotated with @Valid fails.
MissingMatrixVariableException
ServletRequestBindingException subclass that indicates that a matrix variable expected in the method parameters of an @RequestMapping method is not present among the matrix variables extracted from the URL.
MissingPathVariableException
ServletRequestBindingException subclass that indicates that a path variable expected in the method parameters of an @RequestMapping method is not present among the URI variables extracted from the URL.
MissingRequestCookieException
ServletRequestBindingException subclass that indicates that a request cookie expected in the method parameters of an @RequestMapping method is not present.
MissingRequestHeaderException
ServletRequestBindingException subclass that indicates that a request header expected in the method parameters of an @RequestMapping method is not present.
MissingRequestValueException
Base class for ServletRequestBindingException exceptions that could not bind because the request value is required but is either missing or otherwise resolves to null after conversion.
MissingServletRequestParameterException
ServletRequestBindingException subclass that indicates a missing parameter.
ServletRequestBindingException
Fatal binding exception, thrown when we want to treat binding exceptions as unrecoverable.
UnsatisfiedServletRequestParameterException
ServletRequestBindingException subclass that indicates an unsatisfied parameter condition, as typically expressed using an @RequestMapping annotation at the @Controller type level.
annotation
@NonNullApi @NonNullFields package org.springframework.web.bind.annotation Annotations for binding requests to controllers and handler methods as well as for binding request parameters to method arguments.
Related Packages
org.springframework.web.bind
Provides web-specific data binding functionality.
org.springframework.web.bind.support
Support classes for web data binding.
Annotation Interfaces
BindParam
Annotation to bind values from a web request such as request parameters or path variables to fields of a Java object.
ControllerAdvice
Specialization of @Component for classes that declare @ExceptionHandler , @InitBinder , or @ModelAttribute methods to be shared across multiple @Controller classes.
CookieValue
Annotation to indicate that a method parameter is bound to an HTTP cookie.
CrossOrigin
Annotation for permitting cross-origin requests on specific handler classes and/or handler methods.
DeleteMapping
Annotation for mapping HTTP DELETE requests onto specific handler methods.
ExceptionHandler
Annotation for handling exceptions in specific handler classes and/or handler methods.
GetMapping
Annotation for mapping HTTP GET requests onto specific handler methods.
InitBinder
Annotation that identifies methods that initialize the WebDataBinder which will be used for populating command and form object arguments of annotated handler methods.
Mapping
Meta annotation that indicates a web mapping annotation.
MatrixVariable
Annotation which indicates that a method parameter should be bound to a name-value pair within a path segment.
ModelAttribute
Annotation that binds a method parameter or method return value to a named model attribute, exposed to a web view.
PatchMapping
Annotation for mapping HTTP PATCH requests onto specific handler methods.
PathVariable
Annotation which indicates that a method parameter should be bound to a URI template variable.
PostMapping
Annotation for mapping HTTP POST requests onto specific handler methods.
PutMapping
Annotation for mapping HTTP PUT requests onto specific handler methods.
RequestAttribute
Annotation to bind a method parameter to a request attribute.
RequestBody
Annotation indicating a method parameter should be bound to the body of the web request.
RequestHeader
Annotation which indicates that a method parameter should be bound to a web request header.
RequestMapping
Annotation for mapping web requests onto methods in request-handling classes with flexible method signatures.
RequestParam
Annotation which indicates that a method parameter should be bound to a web request parameter.
RequestPart
Annotation that can be used to associate the part of a "multipart/form-data" request with a method argument.
ResponseBody
Annotation that indicates a method return value should be bound to the web response body.
ResponseStatus
Marks a method or exception class with the status ResponseStatus.code() and ResponseStatus.reason() that should be returned.
RestController
A convenience annotation that is itself annotated with @Controller and @ResponseBody .
RestControllerAdvice
A convenience annotation that is itself annotated with @ControllerAdvice and @ResponseBody .
SessionAttribute
Annotation to bind a method parameter to a session attribute.
SessionAttributes
Annotation that indicates the session attributes that a specific handler uses.
Enum Classes
RequestMethod
Enumeration of HTTP request methods.
Interfaces
ValueConstants
Common value constants shared between bind annotations.
support
@NonNullApi @NonNullFields package org.springframework.web.bind.support Support classes for web data binding.
Related Packages
org.springframework.web.bind
Provides web-specific data binding functionality.
org.springframework.web.bind.annotation
Annotations for binding requests to controllers and handler methods as well as for binding request parameters to method arguments.
Classes
BindParamNameResolver
DataBinder.NameResolver that determines the bind value name from a @BindParam method parameter annotation.
ConfigurableWebBindingInitializer
Convenient WebBindingInitializer for declarative configuration in a Spring application context.
DefaultDataBinderFactory
Create a WebRequestDataBinder instance and initialize it with a WebBindingInitializer .
DefaultSessionAttributeStore
Default implementation of the SessionAttributeStore interface, storing the attributes in the WebRequest session (i.e.
SimpleSessionStatus
Simple implementation of the SessionStatus interface, keeping the complete flag as an instance variable.
SpringWebConstraintValidatorFactory
JSR-303 ConstraintValidatorFactory implementation that delegates to the current Spring WebApplicationContext for creating autowired ConstraintValidator instances.
WebExchangeDataBinder
Specialized DataBinder to perform data binding from URL query parameters or form data in the request data to Java objects.
WebRequestDataBinder
Special DataBinder to perform data binding from web request parameters to JavaBeans, including support for multipart files.
Interfaces
SessionAttributeStore
Strategy interface for storing model attributes in a backend session.
SessionStatus
Simple interface that can be injected into handler methods, allowing them to signal that their session processing is complete.
WebArgumentResolver
SPI for resolving custom arguments for a specific handler method parameter.
WebBindingInitializer
Callback interface for initializing a WebDataBinder for performing data binding in the context of a specific web request.
WebDataBinderFactory
A factory for creating a WebDataBinder instance for a named target object.
Exceptions
WebExchangeBindException
ServerWebInputException subclass that indicates a data binding or validation failure.
client
client
@NonNullApi @NonNullFields package org.springframework.web.client Core package of the client-side web support. Provides the RestTemplate and RestClient.
Related Packages
org.springframework.web
Common, generic interfaces that define minimal boundary points between Spring's web infrastructure and other framework modules.
org.springframework.web.client.support
Classes supporting the org.springframework.web.client package.
Classes
DefaultResponseErrorHandler
Spring's default implementation of the ResponseErrorHandler interface.
ExtractingResponseErrorHandler
Implementation of ResponseErrorHandler that uses HttpMessageConverters to convert HTTP error responses to RestClientExceptions .
HttpMessageConverterExtractor<T>
Response extractor that uses the given entity converters to convert the response into a type T .
RestTemplate
Synchronous client to perform HTTP requests, exposing a simple, template method API over underlying HTTP client libraries such as the JDK HttpURLConnection , Apache HttpComponents, and others.
Exceptions
HttpClientErrorException
Exception thrown when an HTTP 4xx is received.
HttpClientErrorException.BadRequest
HttpClientErrorException for status HTTP 400 Bad Request.
HttpClientErrorException.Conflict
HttpClientErrorException for status HTTP 409 Conflict.
HttpClientErrorException.Forbidden
HttpClientErrorException for status HTTP 403 Forbidden.
HttpClientErrorException.Gone
HttpClientErrorException for status HTTP 410 Gone.
HttpClientErrorException.MethodNotAllowed
HttpClientErrorException for status HTTP 405 Method Not Allowed.
HttpClientErrorException.NotAcceptable
HttpClientErrorException for status HTTP 406 Not Acceptable.
HttpClientErrorException.NotFound
HttpClientErrorException for status HTTP 404 Not Found.
HttpClientErrorException.TooManyRequests
HttpClientErrorException for status HTTP 429 Too Many Requests.
HttpClientErrorException.Unauthorized
HttpClientErrorException for status HTTP 401 Unauthorized.
HttpClientErrorException.UnprocessableEntity
HttpClientErrorException for status HTTP 422 Unprocessable Entity.
HttpClientErrorException.UnsupportedMediaType
HttpClientErrorException for status HTTP 415 Unsupported Media Type.
HttpServerErrorException
Exception thrown when an HTTP 5xx is received.
HttpServerErrorException.BadGateway
HttpServerErrorException for HTTP status 502 Bad Gateway.
HttpServerErrorException.GatewayTimeout
HttpServerErrorException for status HTTP 504 Gateway Timeout.
HttpServerErrorException.InternalServerError
HttpServerErrorException for status HTTP 500 Internal Server Error.
HttpServerErrorException.NotImplemented
HttpServerErrorException for status HTTP 501 Not Implemented.
HttpServerErrorException.ServiceUnavailable
HttpServerErrorException for status HTTP 503 Service Unavailable.
HttpStatusCodeException
Abstract base class for exceptions based on an HttpStatusCode .
ResourceAccessException
Exception thrown when an I/O error occurs.
RestClientException
Base class for exceptions thrown by RestTemplate in case a request fails because of a server error response, as determined via ResponseErrorHandler.hasError(ClientHttpResponse) , failure to decode the response, or a low level I/O error.
RestClientResponseException
Common base class for exceptions that contain actual HTTP response data.
UnknownContentTypeException
Raised when no suitable HttpMessageConverter could be found to extract the response.
UnknownHttpStatusCodeException
Exception thrown when an unknown (or custom) HTTP status code is received.
Interfaces
RequestCallback
Callback interface for code that operates on a ClientHttpRequest .
ResponseErrorHandler
Strategy interface used by the RestTemplate to determine whether a particular response has an error or not.
ResponseExtractor<T>
Generic callback interface used by RestTemplate 's retrieval methods.
RestClient
Client to perform HTTP requests, exposing a fluent, synchronous API over underlying HTTP client libraries such as the JDK HttpClient , Apache HttpComponents, and others.
RestClient.Builder
A mutable builder for creating a RestClient .
RestClient.RequestBodySpec
Contract for specifying request headers and body leading up to the exchange.
RestClient.RequestBodyUriSpec
Contract for specifying request headers, body and URI for a request.
RestClient.RequestHeadersSpec<S extends RestClient.RequestHeadersSpec<S>>
Contract for specifying request headers leading up to the exchange.
RestClient.RequestHeadersSpec.ConvertibleClientHttpResponse
Extension of ClientHttpResponse that can convert the body.
RestClient.RequestHeadersSpec.ExchangeFunction<T>
Defines the contract for RestClient.RequestHeadersSpec.exchange(ExchangeFunction) .
RestClient.RequestHeadersUriSpec<S extends RestClient.RequestHeadersSpec<S>>
Contract for specifying request headers and URI for a request.
RestClient.ResponseSpec
Contract for specifying response operations following the exchange.
RestClient.ResponseSpec.ErrorHandler
Used in RestClient.ResponseSpec.onStatus(Predicate, ErrorHandler) .
RestClient.UriSpec<S extends RestClient.RequestHeadersSpec<?>>
Contract for specifying the URI for a request.
RestOperations
Interface specifying a basic set of RESTful operations.
support
@NonNullApi @NonNullFields package org.springframework.web.client.support Classes supporting the org.springframework.web.client package. Contains a base class for RestTemplate usage.
Related Packages
org.springframework.web.client
Core package of the client-side web support.
Classes
RestClientAdapter
HttpExchangeAdapter that enables an HttpServiceProxyFactory to use RestClient for request execution.
RestGatewaySupport
Convenient superclass for application classes that need REST access.
RestTemplateAdapter
HttpExchangeAdapter that enables an HttpServiceProxyFactory to use RestTemplate for request execution.
context
context
@NonNullApi @NonNullFields package org.springframework.web.context Contains a variant of the application context interface for web applications, and the ContextLoaderListener that bootstraps a root web application context.
Related Packages
org.springframework.web
Common, generic interfaces that define minimal boundary points between Spring's web infrastructure and other framework modules.
org.springframework.web.context.annotation
Provides convenience annotations for web scopes.
org.springframework.web.context.request
Support for generic request context holding, in particular for scoping of application objects per HTTP request or HTTP session.
org.springframework.web.context.support
Classes supporting the org.springframework.web.context package, such as WebApplicationContext implementations and various utility classes.
Classes
AbstractContextLoaderInitializer
Convenient base class for WebApplicationInitializer implementations that register a ContextLoaderListener in the servlet context.
ContextCleanupListener
Web application listener that cleans up remaining disposable attributes in the ServletContext, i.e.
ContextLoader
Performs the actual initialization work for the root application context.
ContextLoaderListener
Bootstrap listener to start up and shut down Spring's root WebApplicationContext .
Interfaces
ConfigurableWebApplicationContext
Interface to be implemented by configurable web application contexts.
ConfigurableWebEnvironment
Specialization of ConfigurableEnvironment allowing initialization of servlet-related PropertySource objects at the earliest moment that the ServletContext and (optionally) ServletConfig become available.
ServletConfigAware
Interface to be implemented by any object that wishes to be notified of the ServletConfig (typically determined by the WebApplicationContext ) that it runs in.
ServletContextAware
Interface to be implemented by any object that wishes to be notified of the ServletContext (typically determined by the WebApplicationContext ) that it runs in.
WebApplicationContext
Interface to provide configuration for a web application.
annotation
@NonNullApi @NonNullFields package org.springframework.web.context.annotation Provides convenience annotations for web scopes.
Related Packages
org.springframework.web.context
Contains a variant of the application context interface for web applications, and the ContextLoaderListener that bootstraps a root web application context.
org.springframework.web.context.request
Support for generic request context holding, in particular for scoping of application objects per HTTP request or HTTP session.
org.springframework.web.context.support
Classes supporting the org.springframework.web.context package, such as WebApplicationContext implementations and various utility classes.
Annotation Interfaces
ApplicationScope
@ApplicationScope is a specialization of @Scope for a component whose lifecycle is bound to the current web application.
RequestScope
@RequestScope is a specialization of @Scope for a component whose lifecycle is bound to the current web request.
SessionScope
@SessionScope is a specialization of @Scope for a component whose lifecycle is bound to the current web session.
request
request
Support for generic request context holding, in particular for scoping of application objects per HTTP request or HTTP session.
async
@NonNullApi @NonNullFields package org.springframework.web.context.request.async Support for asynchronous request processing.
Related Packages
org.springframework.web.context.request
Support for generic request context holding, in particular for scoping of application objects per HTTP request or HTTP session.
Exceptions
AsyncRequestNotUsableException
Raised when the response for an asynchronous request becomes unusable as indicated by a write failure, or a Servlet container error notification, or after the async request has completed.
AsyncRequestTimeoutException
Exception to be thrown when an async request times out.
Interfaces
AsyncWebRequest
Extends NativeWebRequest with methods for asynchronous request processing.
CallableProcessingInterceptor
Intercepts concurrent request handling, where the concurrent result is obtained by executing a Callable on behalf of the application with an AsyncTaskExecutor .
DeferredResult.DeferredResultHandler
Handles a DeferredResult value when set.
DeferredResultProcessingInterceptor
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.
Classes
DeferredResult<T>
DeferredResult provides an alternative to using a Callable for asynchronous request processing.
StandardServletAsyncWebRequest
A Servlet implementation of AsyncWebRequest .
TimeoutCallableProcessingInterceptor
Sends a 503 (SERVICE_UNAVAILABLE) in case of a timeout if the response is not already committed.
TimeoutDeferredResultProcessingInterceptor
Sends a 503 (SERVICE_UNAVAILABLE) in case of a timeout if the response is not already committed.
WebAsyncManager
The central class for managing asynchronous request processing, mainly intended as an SPI and not typically used directly by application classes.
WebAsyncTask<V>
Holder for a Callable , a timeout value, and a task executor.
WebAsyncUtils
Utility methods related to processing asynchronous web requests.
support
@NonNullApi @NonNullFields package org.springframework.web.context.support Classes supporting the org.springframework.web.context package, such as WebApplicationContext implementations and various utility classes.
Related Packages
org.springframework.web.context
Contains a variant of the application context interface for web applications, and the ContextLoaderListener that bootstraps a root web application context.
org.springframework.web.context.annotation
Provides convenience annotations for web scopes.
org.springframework.web.context.request
Support for generic request context holding, in particular for scoping of application objects per HTTP request or HTTP session.
Classes
AbstractRefreshableWebApplicationContext
AbstractRefreshableApplicationContext subclass which implements the ConfigurableWebApplicationContext interface for web environments.
AnnotationConfigWebApplicationContext
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.
ContextExposingHttpServletRequest
HttpServletRequest decorator that makes all Spring beans in a given WebApplicationContext accessible as request attributes, through lazy checking once an attribute gets accessed.
GenericWebApplicationContext
Subclass of GenericApplicationContext , suitable for web environments.
GroovyWebApplicationContext
WebApplicationContext implementation which takes its configuration from Groovy bean definition scripts and/or XML files, as understood by a GroovyBeanDefinitionReader .
HttpRequestHandlerServlet
Simple HttpServlet that delegates to an HttpRequestHandler bean defined in Spring's root web application context.
RequestHandledEvent
Event raised when a request is handled within an ApplicationContext.
ServletConfigPropertySource
PropertySource that reads init parameters from a ServletConfig object.
ServletContextAttributeExporter
Exporter that takes Spring-defined objects and exposes them as ServletContext attributes.
ServletContextAttributeFactoryBean
FactoryBean that fetches a specific, existing ServletContext attribute.
ServletContextAwareProcessor
BeanPostProcessor implementation that passes the ServletContext to beans that implement the ServletContextAware interface.
ServletContextParameterFactoryBean
FactoryBean that retrieves a specific ServletContext init parameter (that is, a "context-param" defined in web.xml ).
ServletContextPropertySource
PropertySource that reads init parameters from a ServletContext object.
ServletContextResource
Resource implementation for ServletContext resources, interpreting relative paths within the web application root directory.
ServletContextResourceLoader
ResourceLoader implementation that resolves paths as ServletContext resources, for use outside a WebApplicationContext (for example, in an HttpServletBean or GenericFilterBean subclass).
ServletContextResourcePatternResolver
ServletContext-aware subclass of PathMatchingResourcePatternResolver , able to find matching resources below the web application root directory via ServletContext.getResourcePaths(java.lang.String) .
ServletContextScope
Scope wrapper for a ServletContext, i.e.
ServletRequestHandledEvent
Servlet-specific subclass of RequestHandledEvent, adding servlet-specific context information.
SpringBeanAutowiringSupport
Convenient base class for self-autowiring classes that gets constructed within a Spring-based web application.
StandardServletEnvironment
Environment implementation to be used by Servlet -based web applications.
StaticWebApplicationContext
Static WebApplicationContext implementation for testing.
WebApplicationContextUtils
Convenience methods for retrieving the root WebApplicationContext for a given ServletContext .
WebApplicationObjectSupport
Convenient superclass for application objects running in a WebApplicationContext .
XmlWebApplicationContext
WebApplicationContext implementation which takes its configuration from XML documents, understood by an XmlBeanDefinitionReader .
cors
cors
@NonNullApi @NonNullFields package org.springframework.web.cors Support for CORS (Cross-Origin Resource Sharing), based on a common CorsProcessor strategy.
Related Packages
org.springframework.web
Common, generic interfaces that define minimal boundary points between Spring's web infrastructure and other framework modules.
org.springframework.web.cors.reactive
Reactive support for CORS (Cross-Origin Resource Sharing), based on a common CorsProcessor strategy.
Classes
CorsConfiguration
A container for CORS configuration along with methods to check against the actual origin, HTTP methods, and headers of a given request.
CorsUtils
Utility class for CORS request handling based on the CORS W3C recommendation .
DefaultCorsProcessor
The default implementation of CorsProcessor , as defined by the CORS W3C recommendation .
UrlBasedCorsConfigurationSource
CorsConfigurationSource that uses URL path patterns to select the CorsConfiguration for a request.
Interfaces
CorsConfigurationSource
Interface to be implemented by classes (usually HTTP request handlers) that provides a CorsConfiguration instance based on the provided request.
CorsProcessor
A strategy that takes a request and a CorsConfiguration and updates the response.
reactive
@NonNullApi @NonNullFields package org.springframework.web.cors.reactive Reactive support for CORS (Cross-Origin Resource Sharing), based on a common CorsProcessor strategy.
Related Packages
org.springframework.web.cors
Support for CORS (Cross-Origin Resource Sharing), based on a common CorsProcessor strategy.
Interfaces
CorsConfigurationSource
Interface to be implemented by classes (usually HTTP request handlers) that provides a CorsConfiguration instance based on the provided reactive request.
CorsProcessor
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 .
PreFlightRequestHandler
Handler for CORS pre-flight requests.
Classes
CorsUtils
Utility class for CORS reactive request handling based on the CORS W3C recommendation .
CorsWebFilter
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.
DefaultCorsProcessor
The default implementation of CorsProcessor , as defined by the CORS W3C recommendation .
PreFlightRequestWebFilter
WebFilter that handles pre-flight requests through a PreFlightRequestHandler and bypasses the rest of the chain.
UrlBasedCorsConfigurationSource
CorsConfigurationSource that uses URL patterns to select the CorsConfiguration for a request.
filter
filter
@NonNullApi @NonNullFields package org.springframework.web.filter Provides generic filter base classes allowing for bean-style configuration.
Related Packages
org.springframework.web
Common, generic interfaces that define minimal boundary points between Spring's web infrastructure and other framework modules.
org.springframework.web.filter.reactive
WebFilter implementations for use in reactive web applications.
Classes
AbstractRequestLoggingFilter
Base class for Filter s that perform logging operations before and after a request is processed.
CharacterEncodingFilter
Servlet Filter that allows one to specify a character encoding for requests.
CommonsRequestLoggingFilter
Simple request logging filter that writes the request URI (and optionally the query string) to the Commons Log.
CompositeFilter
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.
CorsFilter
Filter to handle CORS pre-flight requests and intercept CORS simple and actual requests with a CorsProcessor , and to update the response, e.g.
DelegatingFilterProxy
Proxy for a standard Servlet Filter, delegating to a Spring-managed bean that implements the Filter interface.
FormContentFilter
Filter that parses form data for HTTP PUT, PATCH, and DELETE requests and exposes it as Servlet request parameters.
ForwardedHeaderFilter
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) .
GenericFilterBean
Simple base implementation of Filter which treats its config parameters ( init-param entries within the filter tag in web.xml ) as bean properties.
HiddenHttpMethodFilter
Filter that converts posted method parameters into HTTP methods, retrievable via HttpServletRequest.getMethod() .
OncePerRequestFilter
Filter base class that aims to guarantee a single execution per request dispatch, on any servlet container.
RelativeRedirectFilter
Overrides HttpServletResponse.sendRedirect(String) and handles it by setting the HTTP status and "Location" headers, which keeps the Servlet container from re-writing relative redirect URLs into absolute ones.
RequestContextFilter
Servlet Filter that exposes the request to the current thread, through both LocaleContextHolder and RequestContextHolder .
ServerHttpObservationFilter
Filter that creates observations for HTTP exchanges.
ServletContextRequestLoggingFilter
Simple request logging filter that writes the request URI (and optionally the query string) to the ServletContext log.
ServletRequestPathFilter
Filter that parses and caches a RequestPath that can then be accessed via ServletRequestPathUtils.getParsedRequestPath(jakarta.servlet.ServletRequest) .
ShallowEtagHeaderFilter
Filter that generates an ETag value based on the content on the response.
reactive
@NonNullApi @NonNullFields package org.springframework.web.filter.reactive WebFilter implementations for use in reactive web applications.
Related Packages
org.springframework.web.filter
Provides generic filter base classes allowing for bean-style configuration.
Classes
HiddenHttpMethodFilter
Reactive WebFilter that converts posted method parameters into HTTP methods, retrievable via HttpRequest.getMethod() .
ServerHttpObservationFilter
Deprecated, for removal: This API element is subject to removal in a future version. since 6.1 in favor of WebHttpHandlerBuilder .
ServerWebExchangeContextFilter
Inserts an attribute in the Reactor Context that makes the current ServerWebExchange available under the attribute name ServerWebExchangeContextFilter.EXCHANGE_CONTEXT_ATTRIBUTE .
jsf
jsf
@NonNullApi @NonNullFields package org.springframework.web.jsf Support classes for integrating a JSF web layer with a Spring service layer which is hosted in a Spring root WebApplicationContext. Supports easy access to beans in the Spring root WebApplicationContext from JSF EL expressions, for example in property values of JSF-managed beans.
Related Packages
org.springframework.web
Common, generic interfaces that define minimal boundary points between Spring's web infrastructure and other framework modules.
org.springframework.web.jsf.el
ELResolvers for integrating a JSF web layer with a Spring service layer which is hosted in a Spring root WebApplicationContext.
Classes
DecoratingNavigationHandler
Base class for JSF NavigationHandler implementations that want to be capable of decorating an original NavigationHandler.
DelegatingNavigationHandlerProxy
JSF NavigationHandler implementation that delegates to a NavigationHandler bean obtained from the Spring root WebApplicationContext.
DelegatingPhaseListenerMulticaster
JSF PhaseListener implementation that delegates to one or more Spring-managed PhaseListener beans coming from the Spring root WebApplicationContext.
FacesContextUtils
Convenience methods to retrieve Spring's root WebApplicationContext for a given JSF FacesContext .
el
@NonNullApi @NonNullFields package org.springframework.web.jsf.el ELResolvers for integrating a JSF web layer with a Spring service layer which is hosted in a Spring root WebApplicationContext.
Related Packages
org.springframework.web.jsf
Support classes for integrating a JSF web layer with a Spring service layer which is hosted in a Spring root WebApplicationContext.
Classes
SpringBeanFacesELResolver
JSF ELResolver that delegates to the Spring root WebApplicationContext , resolving name references to Spring-defined beans.
WebApplicationContextFacesELResolver
Special JSF ELResolver that exposes the Spring WebApplicationContext instance under a variable named "webApplicationContext".
method
method
@NonNullApi @NonNullFields package org.springframework.web.method Common infrastructure for handler method processing, as used by Spring MVC's org.springframework.web.servlet.mvc.method package.
Related Packages
org.springframework.web
Common, generic interfaces that define minimal boundary points between Spring's web infrastructure and other framework modules.
org.springframework.web.method.annotation
Support classes for annotation-based handler method processing.
org.springframework.web.method.support
Generic support classes for handler method processing.
Classes
ControllerAdviceBean
Encapsulates information about an @ControllerAdvice Spring-managed bean without necessarily requiring it to be instantiated.
HandlerMethod
Encapsulates information about a handler method consisting of a method and a bean .
HandlerTypePredicate
A Predicate to match request handling component types if any of the following selectors match: Base packages -- for selecting handlers by their package.
HandlerTypePredicate.Builder
A HandlerTypePredicate builder.
annotation
@NonNullApi @NonNullFields package org.springframework.web.method.annotation Support classes for annotation-based handler method processing.
Related Packages
org.springframework.web.method
Common infrastructure for handler method processing, as used by Spring MVC's org.springframework.web.servlet.mvc.method package.
org.springframework.web.method.support
Generic support classes for handler method processing.
Classes
AbstractCookieValueMethodArgumentResolver
A base abstract class to resolve method arguments annotated with @CookieValue .
AbstractNamedValueMethodArgumentResolver
Abstract base class for resolving method arguments from a named value.
AbstractNamedValueMethodArgumentResolver.NamedValueInfo
Represents the information about a named value, including name, whether it's required and a default value.
AbstractWebArgumentResolverAdapter
An abstract base class adapting a WebArgumentResolver to the HandlerMethodArgumentResolver contract.
ErrorsMethodArgumentResolver
Resolves Errors method arguments.
ExceptionHandlerMethodResolver
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 .
ExpressionValueMethodArgumentResolver
Resolves method arguments annotated with @Value .
HandlerMethodValidator
MethodValidator that uses Bean Validation to validate @RequestMapping method arguments.
InitBinderDataBinderFactory
Adds initialization to a WebDataBinder via @InitBinder methods.
MapMethodProcessor
Resolves Map method arguments and handles Map return values.
ModelAttributeMethodProcessor
Resolve @ModelAttribute annotated method arguments and handle return values from @ModelAttribute annotated methods.
ModelFactory
Assist with initialization of the Model before controller method invocation and with updates to it after the invocation.
ModelMethodProcessor
Resolves Model arguments and handles Model return values.
RequestHeaderMapMethodArgumentResolver
Resolves Map method arguments annotated with @RequestHeader .
RequestHeaderMethodArgumentResolver
Resolves method arguments annotated with @RequestHeader except for Map arguments.
RequestParamMapMethodArgumentResolver
Resolves Map method arguments annotated with an @ RequestParam where the annotation does not specify a request parameter name.
RequestParamMethodArgumentResolver
Resolves method arguments annotated with @ RequestParam , arguments of type MultipartFile in conjunction with Spring's MultipartResolver abstraction, and arguments of type jakarta.servlet.http.Part in conjunction with Servlet multipart requests.
SessionAttributesHandler
Manages controller-specific session attributes declared via @SessionAttributes .
SessionStatusMethodArgumentResolver
Resolves a SessionStatus argument by obtaining it from the ModelAndViewContainer .
Exceptions
HandlerMethodValidationException
ResponseStatusException that is also MethodValidationResult .
MethodArgumentConversionNotSupportedException
A ConversionNotSupportedException raised while resolving a method argument.
MethodArgumentTypeMismatchException
A TypeMismatchException raised while resolving a controller method argument.
Interfaces
HandlerMethodValidationException.Visitor
Contract to handle validation results with callbacks by controller method parameter type, with HandlerMethodValidationException.Visitor.other(org.springframework.validation.method.ParameterValidationResult) serving as the fallthrough.
support
@NonNullApi @NonNullFields package org.springframework.web.method.support Generic support classes for handler method processing.
Related Packages
org.springframework.web.method
Common infrastructure for handler method processing, as used by Spring MVC's org.springframework.web.servlet.mvc.method package.
org.springframework.web.method.annotation
Support classes for annotation-based handler method processing.
Interfaces
AsyncHandlerMethodReturnValueHandler
A return value handler that supports async types.
HandlerMethodArgumentResolver
Strategy interface for resolving method parameters into argument values in the context of a given request.
HandlerMethodReturnValueHandler
Strategy interface to handle the value returned from the invocation of a handler method.
UriComponentsContributor
Strategy for contributing to the building of a UriComponents by looking at a method parameter and an argument value and deciding what part of the target URL should be updated.
Classes
CompositeUriComponentsContributor
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.
HandlerMethodArgumentResolverComposite
Resolves method parameters by delegating to a list of registered HandlerMethodArgumentResolvers .
HandlerMethodReturnValueHandlerComposite
Handles method return values by delegating to a list of registered HandlerMethodReturnValueHandlers .
InvocableHandlerMethod
Extension of HandlerMethod that invokes the underlying method with argument values resolved from the current HTTP request through a list of HandlerMethodArgumentResolver .
ModelAndViewContainer
Records model and view related decisions made by HandlerMethodArgumentResolvers and HandlerMethodReturnValueHandlers during the course of invocation of a controller method.
multipart
multipart
@NonNullApi @NonNullFields package org.springframework.web.multipart Multipart resolution framework for handling file uploads. Provides a MultipartResolver strategy interface, and a generic extension of the HttpServletRequest interface for accessing multipart files in web application code.
Related Packages
org.springframework.web
Common, generic interfaces that define minimal boundary points between Spring's web infrastructure and other framework modules.
org.springframework.web.multipart.support
Support classes for the multipart resolution framework.
Exceptions
MaxUploadSizeExceededException
MultipartException subclass thrown when an upload exceeds the maximum upload size allowed.
MultipartException
Exception thrown when multipart resolution fails.
Interfaces
MultipartFile
A representation of an uploaded file received in a multipart request.
MultipartHttpServletRequest
Provides additional methods for dealing with multipart content within a servlet request, allowing to access uploaded files.
MultipartRequest
This interface defines the multipart request access operations that are exposed for actual multipart requests.
MultipartResolver
A strategy interface for multipart file upload resolution in accordance with RFC 1867 .
support
@NonNullApi @NonNullFields package org.springframework.web.multipart.support Support classes for the multipart resolution framework. Contains property editors for multipart files, and a Servlet filter for multipart handling without Spring's Web MVC.
Related Packages
org.springframework.web.multipart
Multipart resolution framework for handling file uploads.
Classes
AbstractMultipartHttpServletRequest
Abstract base implementation of the MultipartHttpServletRequest interface.
ByteArrayMultipartFileEditor
Custom PropertyEditor for converting MultipartFiles to byte arrays.
DefaultMultipartHttpServletRequest
Default implementation of the MultipartHttpServletRequest interface.
MultipartFilter
Servlet Filter that resolves multipart requests via a MultipartResolver .
MultipartResolutionDelegate
A common delegate for HandlerMethodArgumentResolver implementations which need to resolve MultipartFile and Part arguments.
RequestPartServletServerHttpRequest
ServerHttpRequest implementation that accesses one part of a multipart request.
StandardMultipartHttpServletRequest
Spring MultipartHttpServletRequest adapter, wrapping a Servlet HttpServletRequest and its Part objects.
StandardServletMultipartResolver
Standard implementation of the MultipartResolver interface, based on the Servlet Part API.
StandardServletPartUtils
Utility methods for standard Servlet Part handling.
StringMultipartFileEditor
Custom PropertyEditor for converting MultipartFiles to Strings.
Exceptions
MissingServletRequestPartException
Signals the part of a "multipart/form-data" request, identified by name could not be found.
reactive
reactive
Top-level package for the spring-webflux module that contains DispatcherHandler , the main entry point for WebFlux server endpoint processing including key contracts used to map requests to handlers, invoke them, and process the result.
accept
@NonNullApi @NonNullFields package org.springframework.web.reactive.accept RequestedContentTypeResolver strategy and implementations to resolve the requested content type for a given request.
Related Packages
org.springframework.web.reactive
Top-level package for the spring-webflux module that contains DispatcherHandler , the main entry point for WebFlux server endpoint processing including key contracts used to map requests to handlers, invoke them, and process the result.
Classes
FixedContentTypeResolver
Resolver that always resolves to a fixed list of media types.
HeaderContentTypeResolver
Resolver that looks at the 'Accept' header of the request.
ParameterContentTypeResolver
Resolver that checks a query parameter and uses it to look up a matching MediaType.
RequestedContentTypeResolverBuilder
Builder for a composite RequestedContentTypeResolver that delegates to other resolvers each implementing a different strategy to determine the requested content type -- e.g.
RequestedContentTypeResolverBuilder.ParameterResolverConfigurer
Helper to create and configure ParameterContentTypeResolver .
Interfaces
RequestedContentTypeResolver
Strategy to resolve the requested media types for a ServerWebExchange .
config
@NonNullApi @NonNullFields package org.springframework.web.reactive.config Spring WebFlux configuration infrastructure.
Related Packages
org.springframework.web.reactive
Top-level package for the spring-webflux module that contains DispatcherHandler , the main entry point for WebFlux server endpoint processing including key contracts used to map requests to handlers, invoke them, and process the result.
Classes
BlockingExecutionConfigurer
Helps to configure options related to blocking execution in WebFlux.
CorsRegistration
Assists with the creation of a CorsConfiguration instance for a given URL path pattern.
CorsRegistry
Assists with the registration of global, URL pattern based CorsConfiguration mappings.
DelegatingWebFluxConfiguration
A subclass of WebFluxConfigurationSupport that detects and delegates to all beans of type WebFluxConfigurer allowing them to customize the configuration provided by WebFluxConfigurationSupport .
PathMatchConfigurer
Assist with configuring HandlerMapping 's with path matching options.
ResourceChainRegistration
Assists with the registration of resource resolvers and transformers.
ResourceHandlerRegistration
Assist with creating and configuring a static resources handler.
ResourceHandlerRegistry
Stores registrations of resource handlers for serving static resources such as images, css files and others through Spring WebFlux including setting cache headers optimized for efficient loading in a web browser.
UrlBasedViewResolverRegistration
Assist with configuring properties of a UrlBasedViewResolver .
ViewResolverRegistry
Assist with the configuration of a chain of ViewResolver 's supporting different template mechanisms.
WebFluxConfigurationSupport
The main class for Spring WebFlux configuration.
WebFluxConfigurerComposite
A WebFluxConfigurer that delegates to one or more others.
Annotation Interfaces
EnableWebFlux
Adding this annotation to an @Configuration class imports the Spring WebFlux configuration from WebFluxConfigurationSupport that enables use of annotated controllers and functional endpoints.
Interfaces
WebFluxConfigurer
Defines callback methods to customize the configuration for WebFlux applications enabled via @EnableWebFlux .
function
function
@NonNullApi @NonNullFields package org.springframework.web.reactive.function Provides a foundation for both the reactive client and server subpackages.
Related Packages
org.springframework.web.reactive
Top-level package for the spring-webflux module that contains DispatcherHandler , the main entry point for WebFlux server endpoint processing including key contracts used to map requests to handlers, invoke them, and process the result.
org.springframework.web.reactive.function.client
Provides a reactive WebClient that builds on top of the org.springframework.http.client.reactive reactive HTTP adapter layer.
org.springframework.web.reactive.function.server
Provides the types that make up Spring's functional web framework for Reactive environments.
Interfaces
BodyExtractor<T, M extends ReactiveHttpInputMessage>
A function that can extract data from a ReactiveHttpInputMessage body.
BodyExtractor.Context
Defines the context used during the extraction.
BodyInserter<T, M extends ReactiveHttpOutputMessage>
A combination of functions that can populate a ReactiveHttpOutputMessage body.
BodyInserter.Context
Defines the context used during the insertion.
BodyInserters.FormInserter<T>
Extension of BodyInserter that allows for adding form data or multipart form data.
BodyInserters.MultipartInserter
Extension of BodyInserters.FormInserter that allows for adding asynchronous parts.
Classes
BodyExtractors
Static factory methods for BodyExtractor implementations.
BodyInserters
Static factory methods for BodyInserter implementations.
Exceptions
UnsupportedMediaTypeException
Exception thrown to indicate that a Content-Type is not supported.
client
client
@NonNullApi @NonNullFields package org.springframework.web.reactive.function.client Provides a reactive WebClient that builds on top of the org.springframework.http.client.reactive reactive HTTP adapter layer.
Related Packages
org.springframework.web.reactive.function
Provides a foundation for both the reactive client and server subpackages.
org.springframework.web.reactive.function.client.support
Classes supporting the org.springframework.web.reactive.function.client package.
org.springframework.web.reactive.function.server
Provides the types that make up Spring's functional web framework for Reactive environments.
Enum Classes
ClientHttpObservationDocumentation
Documented KeyValues for the HTTP client observations.
ClientHttpObservationDocumentation.HighCardinalityKeyNames
ClientHttpObservationDocumentation.LowCardinalityKeyNames
Interfaces
ClientRequest
Represents a typed, immutable, client-side HTTP request, as executed by the ExchangeFunction .
ClientRequest.Builder
Defines a builder for a request.
ClientRequestObservationConvention
Interface for an ObservationConvention related to HTTP client exchange observations .
ClientResponse
Represents an HTTP response, as returned by WebClient and also ExchangeFunction .
ClientResponse.Builder
Defines a builder for a response.
ClientResponse.Headers
Represents the headers of the HTTP response.
ExchangeFilterFunction
Represents a function that filters an exchange function .
ExchangeFunction
Represents a function that exchanges a request for a (delayed) ClientResponse .
ExchangeStrategies
Provides strategies for use in an ExchangeFunction .
ExchangeStrategies.Builder
A mutable builder for an ExchangeStrategies .
WebClient
Non-blocking, reactive client to perform HTTP requests, exposing a fluent, reactive API over underlying HTTP client libraries such as Reactor Netty.
WebClient.Builder
A mutable builder for creating a WebClient .
WebClient.RequestBodySpec
Contract for specifying request headers and body leading up to the exchange.
WebClient.RequestBodyUriSpec
Contract for specifying request headers, body and URI for a request.
WebClient.RequestHeadersSpec<S extends WebClient.RequestHeadersSpec<S>>
Contract for specifying request headers leading up to the exchange.
WebClient.RequestHeadersUriSpec<S extends WebClient.RequestHeadersSpec<S>>
Contract for specifying request headers and URI for a request.
WebClient.ResponseSpec
Contract for specifying response operations following the exchange.
WebClient.UriSpec<S extends WebClient.RequestHeadersSpec<?>>
Contract for specifying the URI for a request.
Classes
ClientRequestObservationContext
Context that holds information for metadata collection during the HTTP client exchange observations .
DefaultClientRequestObservationConvention
Default implementation for a ClientRequestObservationConvention , extracting information from the ClientRequestObservationContext .
ExchangeFilterFunctions
Static factory methods providing access to built-in implementations of ExchangeFilterFunction for basic authentication, error handling, etc.
ExchangeFilterFunctions.Credentials
Deprecated. as of Spring 5.1 in favor of using HttpHeaders.setBasicAuth(String, String) while building the request.
ExchangeFunctions
Static factory methods to create an ExchangeFunction .
Exceptions
UnknownHttpStatusCodeException
Exception thrown when an unknown (or custom) HTTP status code is received.
WebClientException
Abstract base class for exception published by WebClient in case of errors.
WebClientRequestException
Exceptions that contain actual HTTP request data.
WebClientResponseException
Exceptions that contain actual HTTP response data.
WebClientResponseException.BadGateway
WebClientResponseException for HTTP status 502 Bad Gateway.
WebClientResponseException.BadRequest
WebClientResponseException for status HTTP 400 Bad Request.
WebClientResponseException.Conflict
WebClientResponseException for status HTTP 409 Conflict.
WebClientResponseException.Forbidden
WebClientResponseException for status HTTP 403 Forbidden.
WebClientResponseException.GatewayTimeout
WebClientResponseException for status HTTP 504 Gateway Timeout.
WebClientResponseException.Gone
WebClientResponseException for status HTTP 410 Gone.
WebClientResponseException.InternalServerError
WebClientResponseException for status HTTP 500 Internal Server Error.
WebClientResponseException.MethodNotAllowed
WebClientResponseException for status HTTP 405 Method Not Allowed.
WebClientResponseException.NotAcceptable
WebClientResponseException for status HTTP 406 Not Acceptable.
WebClientResponseException.NotFound
WebClientResponseException for status HTTP 404 Not Found.
WebClientResponseException.NotImplemented
WebClientResponseException for status HTTP 501 Not Implemented.
WebClientResponseException.ServiceUnavailable
WebClientResponseException for status HTTP 503 Service Unavailable.
WebClientResponseException.TooManyRequests
WebClientResponseException for status HTTP 429 Too Many Requests.
WebClientResponseException.Unauthorized
WebClientResponseException for status HTTP 401 Unauthorized.
WebClientResponseException.UnprocessableEntity
WebClientResponseException for status HTTP 422 Unprocessable Entity.
WebClientResponseException.UnsupportedMediaType
WebClientResponseException for status HTTP 415 Unsupported Media Type.
support
@NonNullApi @NonNullFields package org.springframework.web.reactive.function.client.support Classes supporting the org.springframework.web.reactive.function.client package. Contains a ClientResponse wrapper to adapt a request.
Related Packages
org.springframework.web.reactive.function.client
Provides a reactive WebClient that builds on top of the org.springframework.http.client.reactive reactive HTTP adapter layer.
Classes
ClientResponseWrapper
Implementation of the ClientResponse interface that can be subclassed to adapt the request in a exchange filter function .
ClientResponseWrapper.HeadersWrapper
Implementation of the Headers interface that can be subclassed to adapt the headers in a exchange filter function .
WebClientAdapter
ReactorHttpExchangeAdapter that enables an HttpServiceProxyFactory to use WebClient for request execution.
server
server
@NonNullApi @NonNullFields package org.springframework.web.reactive.function.server Provides the types that make up Spring's functional web framework for Reactive environments.
Related Packages
org.springframework.web.reactive.function
Provides a foundation for both the reactive client and server subpackages.
org.springframework.web.reactive.function.server.support
Classes supporting the org.springframework.web.reactive.function.server package.
org.springframework.web.reactive.function.client
Provides a reactive WebClient that builds on top of the org.springframework.http.client.reactive reactive HTTP adapter layer.
Interfaces
EntityResponse<T>
Entity-specific subtype of ServerResponse that exposes entity data.
EntityResponse.Builder<T>
Defines a builder for EntityResponse .
HandlerFilterFunction<T extends ServerResponse, R extends ServerResponse>
Represents a function that filters a handler function .
HandlerFunction<T extends ServerResponse>
Represents a function that handles a request .
HandlerStrategies
Defines the strategies to be used for processing HandlerFunctions .
HandlerStrategies.Builder
A mutable builder for a HandlerStrategies .
RenderingResponse
Rendering-specific subtype of ServerResponse that exposes model and template data.
RenderingResponse.Builder
Defines a builder for RenderingResponse .
RequestPredicate
Represents a function that evaluates on a given ServerRequest .
RequestPredicates.Visitor
Receives notifications from the logical structure of request predicates.
RouterFunction<T extends ServerResponse>
Represents a function that routes to a handler function .
RouterFunctions.Builder
Represents a discoverable builder for router functions.
RouterFunctions.Visitor
Receives notifications from the logical structure of router functions.
ServerRequest
Represents a server-side HTTP request, as handled by a HandlerFunction .
ServerRequest.Builder
Defines a builder for a request.
ServerRequest.Headers
Represents the headers of the HTTP request.
ServerResponse
Represents a typed server-side HTTP response, as returned by a handler function or filter function .
ServerResponse.BodyBuilder
Defines a builder that adds a body to the response.
ServerResponse.Context
Defines the context used during the ServerResponse.writeTo(ServerWebExchange, Context) .
ServerResponse.HeadersBuilder<B extends ServerResponse.HeadersBuilder<B>>
Defines a builder that adds headers to the response.
Classes
RequestPredicates
Implementations of RequestPredicate that implement various useful request matching operations, such as matching based on path, HTTP method, etc.
RouterFunctions
Central entry point to Spring's functional web framework. Exposes routing functionality, such as to create a RouterFunction using a discoverable builder-style API, to create a RouterFunction given a RequestPredicate and HandlerFunction , and to do further subrouting on an existing routing function.
support
@NonNullApi @NonNullFields package org.springframework.web.reactive.function.server.support Classes supporting the org.springframework.web.reactive.function.server package. Contains a HandlerAdapter that supports HandlerFunctions, a HandlerResultHandler that supports ServerResponses, and a ServerRequest wrapper to adapt a request.
Related Packages
org.springframework.web.reactive.function.server
Provides the types that make up Spring's functional web framework for Reactive environments.
Classes
HandlerFunctionAdapter
HandlerAdapter implementation that supports HandlerFunctions .
RouterFunctionMapping
HandlerMapping implementation that supports RouterFunctions .
ServerRequestWrapper
Implementation of the ServerRequest interface that can be subclassed to adapt the request in a handler filter function .
ServerRequestWrapper.HeadersWrapper
Implementation of the Headers interface that can be subclassed to adapt the headers in a handler filter function .
ServerResponseResultHandler
HandlerResultHandler implementation that supports ServerResponses .
handler
@NonNullApi @NonNullFields package org.springframework.web.reactive.handler Provides HandlerMapping implementations including abstract base classes.
Related Packages
org.springframework.web.reactive
Top-level package for the spring-webflux module that contains DispatcherHandler , the main entry point for WebFlux server endpoint processing including key contracts used to map requests to handlers, invoke them, and process the result.
Classes
AbstractHandlerMapping
Abstract base class for HandlerMapping implementations.
AbstractUrlHandlerMapping
Abstract base class for URL-mapped HandlerMapping implementations.
SimpleUrlHandlerMapping
Implementation of the HandlerMapping interface to map from URLs to request handler beans.
WebFluxResponseStatusExceptionHandler
Common WebFlux exception handler that detects instances of ResponseStatusException (inherited from the base class) as well as exceptions annotated with @ResponseStatus by determining the HTTP status for them and updating the status of the response accordingly.
resource
@NonNullApi @NonNullFields package org.springframework.web.reactive.resource Support classes for serving static resources.
Related Packages
org.springframework.web.reactive
Top-level package for the spring-webflux module that contains DispatcherHandler , the main entry point for WebFlux server endpoint processing including key contracts used to map requests to handlers, invoke them, and process the result.
Classes
AbstractFileNameVersionStrategy
Abstract base class for filename suffix based VersionStrategy implementations, e.g.
AbstractPrefixVersionStrategy
Abstract base class for VersionStrategy implementations that insert a prefix into the URL path, e.g.
AbstractResourceResolver
Base ResourceResolver providing consistent logging.
CachingResourceResolver
A ResourceResolver that resolves resources from a Cache or otherwise delegates to the resolver chain and caches the result.
CachingResourceTransformer
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.
ContentVersionStrategy
A VersionStrategy that calculates a Hex MD5 hash from the content of the resource and appends it to the file name, e.g.
CssLinkResourceTransformer
A ResourceTransformer implementation that modifies links in a CSS file to match the public URL paths that should be exposed to clients (e.g.
CssLinkResourceTransformer.AbstractLinkParser
Abstract base class for CssLinkResourceTransformer.LinkParser implementations.
EncodedResourceResolver
Resolver that delegates to the chain, and if a resource is found, it then attempts to find an encoded (e.g.
FixedVersionStrategy
A VersionStrategy that relies on a fixed version applied as a request path prefix, e.g.
PathResourceResolver
A simple ResourceResolver that tries to find a resource under the given locations matching to the request path.
ResourceTransformerSupport
A base class for a ResourceTransformer with an optional helper method for resolving public links within a transformed resource.
ResourceUrlProvider
A central component to use to obtain the public URL path that clients should use to access a static resource.
ResourceWebHandler
HttpRequestHandler that serves static resources in an optimized way according to the guidelines of Page Speed, YSlow, etc.
TransformedResource
An extension of ByteArrayResource that a ResourceTransformer can use to represent an original resource preserving all other information except the content.
VersionResourceResolver
Resolves request paths containing a version string that can be used as part of an HTTP caching strategy in which a resource is cached with a date in the distant future (e.g.
WebJarsResourceResolver
A ResourceResolver that delegates to the chain to locate a resource and then attempts to find a matching versioned resource contained in a WebJar JAR file.
Interfaces
CssLinkResourceTransformer.LinkParser
Extract content chunks that represent links.
HttpResource
Extended interface for a Resource to be written to an HTTP response.
ResourceResolver
A strategy for resolving a request to a server-side resource.
ResourceResolverChain
A contract for invoking a chain of ResourceResolvers where each resolver is given a reference to the chain allowing it to delegate when necessary.
ResourceTransformer
An abstraction for transforming the content of a resource.
ResourceTransformerChain
A contract for invoking a chain of ResourceTransformers where each resolver is given a reference to the chain allowing it to delegate when necessary.
VersionStrategy
A strategy to determine the version of a static resource and to apply and/or extract it from the URL path.
Exceptions
NoResourceFoundException
Raised when ResourceWebHandler is mapped to the request but can not find a matching resource.
result
result
@NonNullApi @NonNullFields package org.springframework.web.reactive.result Support for various programming model styles including the invocation of different types of handlers, e.g. annotated controller vs simple WebHandler, including the handling of handler result values, e.g. @ResponseBody, view resolution, and so on.
Related Packages
org.springframework.web.reactive
Top-level package for the spring-webflux module that contains DispatcherHandler , the main entry point for WebFlux server endpoint processing including key contracts used to map requests to handlers, invoke them, and process the result.
org.springframework.web.reactive.result.condition
RequestCondition and implementations for matching requests based on different criteria.
org.springframework.web.reactive.result.method
Infrastructure for handler method processing.
org.springframework.web.reactive.result.view
Support for result handling through view resolution.
Classes
HandlerResultHandlerSupport
Base class for HandlerResultHandler with support for content negotiation and access to a ReactiveAdapter registry.
SimpleHandlerAdapter
HandlerAdapter that allows using the plain WebHandler contract with the generic DispatcherHandler .
condition
@NonNullApi @NonNullFields package org.springframework.web.reactive.result.condition RequestCondition and implementations for matching requests based on different criteria.
Related Packages
org.springframework.web.reactive.result
Support for various programming model styles including the invocation of different types of handlers, e.g.
org.springframework.web.reactive.result.method
Infrastructure for handler method processing.
org.springframework.web.reactive.result.view
Support for result handling through view resolution.
Classes
AbstractRequestCondition<T extends AbstractRequestCondition<T>>
A base class for RequestCondition types providing implementations of AbstractRequestCondition.equals(Object) , AbstractRequestCondition.hashCode() , and AbstractRequestCondition.toString() .
CompositeRequestCondition
Implements the RequestCondition contract by delegating to multiple RequestCondition types and using a logical conjunction ( ' && ' ) to ensure all conditions match a given request.
ConsumesRequestCondition
A logical disjunction (' || ') request condition to match a request's 'Content-Type' header to a list of media type expressions.
HeadersRequestCondition
A logical conjunction ( ' && ' ) request condition that matches a request against a set of header expressions with syntax defined in RequestMapping.headers() .
ParamsRequestCondition
A logical conjunction ( ' && ' ) request condition that matches a request against a set parameter expressions with syntax defined in RequestMapping.params() .
PatternsRequestCondition
A logical disjunction (' || ') request condition that matches a request against a set of URL path patterns.
ProducesRequestCondition
A logical disjunction (' || ') request condition to match a request's 'Accept' header to a list of media type expressions.
RequestConditionHolder
A holder for a RequestCondition useful when the type of the request condition is not known ahead of time, e.g.
RequestMethodsRequestCondition
A logical disjunction (' || ') request condition that matches a request against a set of RequestMethods .
Interfaces
MediaTypeExpression
A contract for media type expressions (e.g.
NameValueExpression<T>
A contract for "name!=value" style expression used to specify request parameters and request header conditions in @RequestMapping .
RequestCondition<T>
Contract for request mapping conditions.
method
method
@NonNullApi @NonNullFields package org.springframework.web.reactive.result.method Infrastructure for handler method processing.
Related Packages
org.springframework.web.reactive.result
Support for various programming model styles including the invocation of different types of handlers, e.g.
org.springframework.web.reactive.result.method.annotation
Infrastructure for annotation-based handler method processing.
org.springframework.web.reactive.result.condition
RequestCondition and implementations for matching requests based on different criteria.
org.springframework.web.reactive.result.view
Support for result handling through view resolution.
Classes
AbstractHandlerMethodMapping<T>
Abstract base class for HandlerMapping implementations that define a mapping between a request and a HandlerMethod .
HandlerMethodArgumentResolverSupport
Base class for HandlerMethodArgumentResolver implementations with access to a ReactiveAdapterRegistry and methods to check for method parameter support.
InvocableHandlerMethod
Extension of HandlerMethod that invokes the underlying method with argument values resolved from the current HTTP request through a list of HandlerMethodArgumentResolver .
RequestMappingInfo
Request mapping information.
RequestMappingInfo.BuilderConfiguration
Container for configuration options used for request mapping purposes.
RequestMappingInfoHandlerMapping
Abstract base class for classes for which RequestMappingInfo defines the mapping between a request and a handler method.
SyncInvocableHandlerMethod
Extension of HandlerMethod that invokes the underlying method via InvocableHandlerMethod but uses sync argument resolvers only and thus can return directly a HandlerResult with no async wrappers.
Interfaces
HandlerMethodArgumentResolver
Strategy to resolve the argument value for a method parameter in the context of the current HTTP request.
RequestMappingInfo.Builder
Defines a builder for creating a RequestMappingInfo.
SyncHandlerMethodArgumentResolver
An extension of HandlerMethodArgumentResolver for implementations that are synchronous in nature and do not block to resolve values.
annotation
@NonNullApi @NonNullFields package org.springframework.web.reactive.result.method.annotation Infrastructure for annotation-based handler method processing.
Related Packages
org.springframework.web.reactive.result.method
Infrastructure for handler method processing.
Classes
AbstractMessageReaderArgumentResolver
Abstract base class for argument resolvers that resolve method arguments by reading the request body with an HttpMessageReader .
AbstractMessageWriterResultHandler
Abstract base class for result handlers that handle return values by writing to the response with HttpMessageWriter .
AbstractNamedValueArgumentResolver
Abstract base class for resolving method arguments from a named value.
AbstractNamedValueArgumentResolver.NamedValueInfo
Represents the information about a named value, including name, whether it's required and a default value.
AbstractNamedValueSyncArgumentResolver
An extension of AbstractNamedValueArgumentResolver for named value resolvers that are synchronous and yet non-blocking.
ArgumentResolverConfigurer
Helps to configure resolvers for Controller method arguments.
ContinuationHandlerMethodArgumentResolver
No-op resolver for method arguments of type Continuation .
CookieValueMethodArgumentResolver
Resolve method arguments annotated with @CookieValue .
ErrorsMethodArgumentResolver
Resolve Errors or BindingResult method arguments.
ExpressionValueMethodArgumentResolver
Resolves method arguments annotated with @Value .
HttpEntityMethodArgumentResolver
Resolves method arguments of type HttpEntity or RequestEntity by reading the body of the request through a compatible HttpMessageReader .
MatrixVariableMapMethodArgumentResolver
Resolves arguments of type Map annotated with @MatrixVariable where the annotation does not specify a name.
MatrixVariableMethodArgumentResolver
Resolves arguments annotated with @MatrixVariable .
ModelAttributeMethodArgumentResolver
Resolve @ModelAttribute annotated method arguments.
ModelMethodArgumentResolver
Resolver for a controller method argument of type Model that can also be resolved as a Map .
PathVariableMapMethodArgumentResolver
Resolver for Map method arguments annotated with @PathVariable where the annotation does not specify a path variable name.
PathVariableMethodArgumentResolver
Resolves method arguments annotated with @ PathVariable .
PrincipalMethodArgumentResolver
Resolves method argument value of type Principal .
RequestAttributeMethodArgumentResolver
Resolves method arguments annotated with an @ RequestAttribute .
RequestBodyMethodArgumentResolver
Resolves method arguments annotated with @RequestBody by reading the body of the request through a compatible HttpMessageReader .
RequestHeaderMapMethodArgumentResolver
Resolves Map method arguments annotated with @RequestHeader .
RequestHeaderMethodArgumentResolver
Resolves method arguments annotated with @RequestHeader except for Map arguments.
RequestMappingHandlerAdapter
Supports the invocation of @RequestMapping handler methods.
RequestMappingHandlerMapping
An extension of RequestMappingInfoHandlerMapping that creates RequestMappingInfo instances from type-level and method-level @RequestMapping and @HttpExchange annotations.
RequestParamMapMethodArgumentResolver
Resolver for Map method arguments annotated with @RequestParam where the annotation does not specify a request parameter name.
RequestParamMethodArgumentResolver
Resolver for method arguments annotated with @ RequestParam from URI query string parameters.
RequestPartMethodArgumentResolver
Resolver for @RequestPart arguments where the named part is decoded much like an @RequestBody argument but based on the content of an individual part instead.
ResponseBodyResultHandler
HandlerResultHandler that handles return values from methods annotated with @ResponseBody writing to the body of the request or response with an HttpMessageWriter .
ResponseEntityExceptionHandler
A class with an @ExceptionHandler method that handles all Spring WebFlux raised exceptions by returning a ResponseEntity with RFC 7807 formatted error details in the body.
ResponseEntityResultHandler
Handles return values of type HttpEntity , ResponseEntity , HttpHeaders , ErrorResponse , and ProblemDetail .
ServerWebExchangeMethodArgumentResolver
Resolves ServerWebExchange-related method argument values of the following types: ServerWebExchange ServerHttpRequest ServerHttpResponse HttpMethod Locale TimeZone ZoneId UriBuilder or UriComponentsBuilder -- for building URL's relative to the current request
SessionAttributeMethodArgumentResolver
Resolves method arguments annotated with an @ SessionAttribute .
SessionStatusMethodArgumentResolver
Resolver for a SessionStatus argument obtaining it from the BindingContext .
WebSessionMethodArgumentResolver
Resolves method argument value of type WebSession .
view
view
@NonNullApi @NonNullFields package org.springframework.web.reactive.result.view Support for result handling through view resolution.
Related Packages
org.springframework.web.reactive.result
Support for various programming model styles including the invocation of different types of handlers, e.g.
org.springframework.web.reactive.result.view.freemarker
Support classes for the integration of FreeMarker as Spring web view technology.
org.springframework.web.reactive.result.view.script
Support classes for views based on the JSR-223 script engine abstraction (as included in Java 6+), e.g.
org.springframework.web.reactive.result.condition
RequestCondition and implementations for matching requests based on different criteria.
org.springframework.web.reactive.result.method
Infrastructure for handler method processing.
Classes
AbstractUrlBasedView
Abstract base class for URL-based views.
AbstractView
Base class for View implementations.
BindStatus
Simple adapter to expose the bind status of a field or object.
HttpMessageWriterView
View that writes model attribute(s) with an HttpMessageWriter .
RedirectView
View that redirects to an absolute or context relative URL.
RequestContext
Context holder for request-specific state, like the MessageSource to use, current locale, binding errors, etc.
UrlBasedViewResolver
A ViewResolver that allows direct resolution of symbolic view names to URLs without explicit mapping definitions.
ViewResolutionResultHandler
HandlerResultHandler that encapsulates the view resolution algorithm supporting the following return types: Void , void , or no value -- default view name String -- view name unless @ModelAttribute -annotated View -- View to render with Model -- attributes to add to the model Map -- attributes to add to the model Rendering -- use case driven API for view resolution @ModelAttribute -- attribute for the model Non-simple value -- attribute for the model
ViewResolverSupport
Base class for ViewResolver implementations with shared properties.
Interfaces
Rendering
Public API for HTML rendering.
Rendering.Builder<B extends Rendering.Builder<B>>
Defines a builder for Rendering .
Rendering.RedirectBuilder
Extends Rendering.Builder with extra options for redirect scenarios.
RequestDataValueProcessor
A contract for inspecting and potentially modifying request data values such as URL query parameters or form field values before they are rendered by a view or before a redirect.
View
Contract to render HandlerResult to the HTTP response.
ViewResolver
Contract to resolve a view name to a View instance.
freemarker
@NonNullApi @NonNullFields package org.springframework.web.reactive.result.view.freemarker Support classes for the integration of FreeMarker as Spring web view technology. Contains a View implementation for FreeMarker templates.
Related Packages
org.springframework.web.reactive.result.view
Support for result handling through view resolution.
org.springframework.web.reactive.result.view.script
Support classes for views based on the JSR-223 script engine abstraction (as included in Java 6+), e.g.
Interfaces
FreeMarkerConfig
Interface to be implemented by objects that configure and manage a FreeMarker Configuration object in a web environment.
Classes
FreeMarkerConfigurer
Configures FreeMarker for web usage via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties.
FreeMarkerView
A View implementation that uses the FreeMarker template engine.
FreeMarkerViewResolver
A ViewResolver for resolving FreeMarkerView instances, i.e.
script
@NonNullApi @NonNullFields package org.springframework.web.reactive.result.view.script Support classes for views based on the JSR-223 script engine abstraction (as included in Java 6+), e.g. using JavaScript via Nashorn on JDK 8. Contains a View implementation for scripted templates.
Related Packages
org.springframework.web.reactive.result.view
Support for result handling through view resolution.
org.springframework.web.reactive.result.view.freemarker
Support classes for the integration of FreeMarker as Spring web view technology.
Classes
RenderingContext
Context passed to ScriptTemplateView render function in order to make the application context, the locale, the template loader and the url available on scripting side.
ScriptTemplateConfigurer
An implementation of the Spring WebFlux ScriptTemplateConfig for creating a ScriptEngine for use in a web application.
ScriptTemplateView
An AbstractUrlBasedView subclass designed to run any template library based on a JSR-223 script engine.
ScriptTemplateViewResolver
Convenience subclass of UrlBasedViewResolver that supports ScriptTemplateView and custom subclasses of it.
Interfaces
ScriptTemplateConfig
Interface to be implemented by objects that configure and manage a JSR-223 ScriptEngine for automatic lookup in a web environment.
socket
socket
@NonNullApi @NonNullFields package org.springframework.web.reactive.socket Abstractions and support classes for reactive WebSocket interactions.
Related Packages
org.springframework.web.reactive
Top-level package for the spring-webflux module that contains DispatcherHandler , the main entry point for WebFlux server endpoint processing including key contracts used to map requests to handlers, invoke them, and process the result.
org.springframework.web.reactive.socket.adapter
Classes adapting Spring's Reactive WebSocket API to and from WebSocket runtimes.
org.springframework.web.reactive.socket.client
Client support for WebSocket interactions.
org.springframework.web.reactive.socket.server
Server support for WebSocket interactions.
Classes
CloseStatus
Representation of WebSocket "close" status codes and reasons.
HandshakeInfo
Simple container of information related to the handshake request that started the WebSocketSession session.
WebSocketMessage
Representation of a WebSocket message.
Interfaces
WebSocketHandler
Handler for a WebSocket session.
WebSocketSession
Represents a WebSocket session.
Enum Classes
WebSocketMessage.Type
WebSocket message types.
adapter
@NonNullApi @NonNullFields package org.springframework.web.reactive.socket.adapter Classes adapting Spring's Reactive WebSocket API to and from WebSocket runtimes.
Related Packages
org.springframework.web.reactive.socket
Abstractions and support classes for reactive WebSocket interactions.
org.springframework.web.reactive.socket.client
Client support for WebSocket interactions.
org.springframework.web.reactive.socket.server
Server support for WebSocket interactions.
Classes
AbstractListenerWebSocketSession<T>
Base class for WebSocketSession implementations that bridge between event-listener WebSocket APIs (e.g.
AbstractWebSocketSession<T>
Convenient base class for WebSocketSession implementations that holds common fields and exposes accessors.
ContextWebSocketHandler
WebSocketHandler decorator that enriches the context of the target handler.
JettyWebSocketHandlerAdapter
Jetty @WebSocket handler that delegates events to a reactive WebSocketHandler and its session.
JettyWebSocketSession
Spring WebSocketSession implementation that adapts to a Jetty WebSocket Session .
Netty5WebSocketSessionSupport<T>
Base class for Netty-based WebSocketSession adapters that provides convenience methods to convert Netty WebSocketFrames to and from WebSocketMessages .
NettyWebSocketSessionSupport<T>
Base class for Netty-based WebSocketSession adapters that provides convenience methods to convert Netty WebSocketFrames to and from WebSocketMessages .
ReactorNetty2WebSocketSession
WebSocketSession implementation for use with the Reactor Netty's (Netty 5) NettyInbound and NettyOutbound .
ReactorNetty2WebSocketSession.WebSocketConnection
Simple container for NettyInbound and NettyOutbound .
ReactorNettyWebSocketSession
WebSocketSession implementation for use with the Reactor Netty's NettyInbound and NettyOutbound .
ReactorNettyWebSocketSession.WebSocketConnection
Simple container for NettyInbound and NettyOutbound .
StandardWebSocketHandlerAdapter
Adapter for the Jakarta WebSocket API (JSR-356) that delegates events to a reactive WebSocketHandler and its session.
StandardWebSocketSession
Spring WebSocketSession adapter for a standard Java (JSR 356) Session .
TomcatWebSocketSession
Spring WebSocketSession adapter for Tomcat's Session .
UndertowWebSocketHandlerAdapter
Undertow WebSocketConnectionCallback implementation that adapts and delegates to a Spring WebSocketHandler .
UndertowWebSocketSession
Spring WebSocketSession implementation that adapts to an Undertow WebSocketChannel .
client
@NonNullApi @NonNullFields package org.springframework.web.reactive.socket.client Client support for WebSocket interactions.
Related Packages
org.springframework.web.reactive.socket
Abstractions and support classes for reactive WebSocket interactions.
org.springframework.web.reactive.socket.adapter
Classes adapting Spring's Reactive WebSocket API to and from WebSocket runtimes.
org.springframework.web.reactive.socket.server
Server support for WebSocket interactions.
Classes
ReactorNetty2WebSocketClient
WebSocketClient implementation for use with Reactor Netty for Netty 5.
ReactorNettyWebSocketClient
WebSocketClient implementation for use with Reactor Netty.
StandardWebSocketClient
WebSocketClient implementation for use with the Jakarta WebSocket API.
TomcatWebSocketClient
WebSocketClient implementation for use with Tomcat, based on the Jakarta WebSocket API.
UndertowWebSocketClient
Undertow based implementation of WebSocketClient .
Interfaces
WebSocketClient
Contract for reactive-style handling of a WebSocket session.
server
server
@NonNullApi @NonNullFields package org.springframework.web.reactive.socket.server Server support for WebSocket interactions.
Related Packages
org.springframework.web.reactive.socket
Abstractions and support classes for reactive WebSocket interactions.
org.springframework.web.reactive.socket.server.support
Server-side support classes for WebSocket requests.
org.springframework.web.reactive.socket.server.upgrade
Holds implementations of RequestUpgradeStrategy .
org.springframework.web.reactive.socket.adapter
Classes adapting Spring's Reactive WebSocket API to and from WebSocket runtimes.
org.springframework.web.reactive.socket.client
Client support for WebSocket interactions.
Interfaces
RequestUpgradeStrategy
A strategy for upgrading an HTTP request to a WebSocket session depending on the underlying network runtime.
WebSocketService
A service to delegate WebSocket-related HTTP requests to.
support
@NonNullApi @NonNullFields package org.springframework.web.reactive.socket.server.support Server-side support classes for WebSocket requests.
Related Packages
org.springframework.web.reactive.socket.server
Server support for WebSocket interactions.
org.springframework.web.reactive.socket.server.upgrade
Holds implementations of RequestUpgradeStrategy .
Classes
HandshakeWebSocketService
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.
WebSocketHandlerAdapter
HandlerAdapter that allows DispatcherHandler to support handlers of type WebSocketHandler with such handlers mapped to URL patterns via SimpleUrlHandlerMapping .
WebSocketUpgradeHandlerPredicate
A predicate for use with AbstractUrlHandlerMapping.setHandlerPredicate(java.util.function.BiPredicate) to ensure only WebSocket handshake requests are matched to handlers of type WebSocketHandler .
upgrade
@NonNullApi @NonNullFields package org.springframework.web.reactive.socket.server.upgrade Holds implementations of RequestUpgradeStrategy.
Related Packages
org.springframework.web.reactive.socket.server
Server support for WebSocket interactions.
org.springframework.web.reactive.socket.server.support
Server-side support classes for WebSocket requests.
Classes
JettyRequestUpgradeStrategy
A WebSocket RequestUpgradeStrategy for Jetty 11.
ReactorNetty2RequestUpgradeStrategy
A WebSocket RequestUpgradeStrategy for Reactor Netty for Netty 5.
ReactorNettyRequestUpgradeStrategy
A WebSocket RequestUpgradeStrategy for Reactor Netty.
StandardWebSocketUpgradeStrategy
A WebSocket RequestUpgradeStrategy for the Jakarta WebSocket API 2.1+.
TomcatRequestUpgradeStrategy
A WebSocket RequestUpgradeStrategy for Apache Tomcat.
UndertowRequestUpgradeStrategy
A WebSocket RequestUpgradeStrategy for Undertow.
server
server
@NonNullApi @NonNullFields package org.springframework.web.server Core interfaces and classes for Spring's generic, reactive web support. Builds on top of the org.springframework.http.client.reactive reactive HTTP adapter layer, providing additional constructs such as WebHandler, WebFilter, WebSession among others.
Related Packages
org.springframework.web
Common, generic interfaces that define minimal boundary points between Spring's web infrastructure and other framework modules.
org.springframework.web.server.adapter
Implementations to adapt to the underlying org.springframework.http.client.reactive reactive HTTP adapter and HttpHandler .
org.springframework.web.server.handler
Provides common WebHandler implementations and a WebHandlerDecorator .
org.springframework.web.server.i18n
Locale related support classes.
org.springframework.web.server.session
Auxiliary interfaces and implementation classes for WebSession support.
Exceptions
MethodNotAllowedException
Exception for errors that fit response status 405 (method not allowed).
MissingRequestValueException
ServerWebInputException subclass that indicates a missing request value such as a request header, cookie value, query parameter, etc.
NotAcceptableStatusException
Exception for errors that fit response status 406 (not acceptable).
ResponseStatusException
Subclass of ErrorResponseException that accepts a "reason", and by default maps that to the "detail" of the ProblemDetail .
ServerErrorException
Exception for an HttpStatus.INTERNAL_SERVER_ERROR that exposes extra information about a controller method that failed, or a controller method argument that could not be resolved.
ServerWebInputException
Exception for errors that fit response status 400 (bad request) for use in Spring Web applications.
UnsatisfiedRequestParameterException
ServerWebInputException subclass that indicates an unsatisfied parameter condition, as typically expressed using an @RequestMapping annotation at the @Controller type level.
UnsupportedMediaTypeStatusException
Exception for errors that fit response status 415 (unsupported media type).
Interfaces
ServerWebExchange
Contract for an HTTP request-response interaction.
ServerWebExchange.Builder
Builder for mutating an existing ServerWebExchange .
WebExceptionHandler
Contract for handling exceptions during web server exchange processing.
WebFilter
Contract for interception-style, chained processing of Web requests that may be used to implement cross-cutting, application-agnostic requirements such as security, timeouts, and others.
WebFilterChain
Contract to allow a WebFilter to delegate to the next in the chain.
WebHandler
Contract to handle a web request.
WebSession
Main contract for using a server-side session that provides access to session attributes across HTTP requests.
Classes
ServerWebExchangeDecorator
A convenient base class for classes that need to wrap another ServerWebExchange .
adapter
@NonNullApi @NonNullFields package org.springframework.web.server.adapter Implementations to adapt to the underlying org.springframework.http.client.reactive reactive HTTP adapter and HttpHandler.
Related Packages
org.springframework.web.server
Core interfaces and classes for Spring's generic, reactive web support.
org.springframework.web.server.handler
Provides common WebHandler implementations and a WebHandlerDecorator .
org.springframework.web.server.i18n
Locale related support classes.
org.springframework.web.server.session
Auxiliary interfaces and implementation classes for WebSession support.
Classes
AbstractReactiveWebInitializer
Base class for a WebApplicationInitializer that installs a Spring Reactive Web Application on a Servlet container.
DefaultServerWebExchange
Default implementation of ServerWebExchange .
ForwardedHeaderTransformer
Extract values from "Forwarded" and "X-Forwarded-*" headers to override the request URI (i.e.
HttpWebHandlerAdapter
Default adapter of WebHandler to the HttpHandler contract.
WebHttpHandlerBuilder
This builder has two purposes:
WebHttpHandlerBuilder.SpringWebBlockHoundIntegration
BlockHoundIntegration for spring-web classes.
handler
@NonNullApi @NonNullFields package org.springframework.web.server.handler Provides common WebHandler implementations and a WebHandlerDecorator.
Related Packages
org.springframework.web.server
Core interfaces and classes for Spring's generic, reactive web support.
org.springframework.web.server.adapter
Implementations to adapt to the underlying org.springframework.http.client.reactive reactive HTTP adapter and HttpHandler .
org.springframework.web.server.i18n
Locale related support classes.
org.springframework.web.server.session
Auxiliary interfaces and implementation classes for WebSession support.
Classes
DefaultWebFilterChain
Default implementation of WebFilterChain .
ExceptionHandlingWebHandler
WebHandler decorator that invokes one or more WebExceptionHandlers after the delegate WebHandler .
FilteringWebHandler
WebHandlerDecorator that invokes a chain of WebFilters before invoking the delegate WebHandler .
ResponseStatusExceptionHandler
Handle ResponseStatusException by setting the response status.
WebHandlerDecorator
WebHandler that decorates and delegates to another WebHandler .
i18n
@NonNullApi @NonNullFields package org.springframework.web.server.i18n Locale related support classes. Provides standard LocaleContextResolver implementations.
Related Packages
org.springframework.web.server
Core interfaces and classes for Spring's generic, reactive web support.
org.springframework.web.server.adapter
Implementations to adapt to the underlying org.springframework.http.client.reactive reactive HTTP adapter and HttpHandler .
org.springframework.web.server.handler
Provides common WebHandler implementations and a WebHandlerDecorator .
org.springframework.web.server.session
Auxiliary interfaces and implementation classes for WebSession support.
Classes
AcceptHeaderLocaleContextResolver
LocaleContextResolver implementation that looks for a match between locales in the Accept-Language header and a list of configured supported locales.
FixedLocaleContextResolver
LocaleContextResolver implementation that always returns a fixed locale and optionally time zone.
Interfaces
LocaleContextResolver
Interface for web-based locale context resolution strategies that allows for both locale context resolution via the request and locale context modification via the HTTP exchange.
session
@NonNullApi @NonNullFields package org.springframework.web.server.session Auxiliary interfaces and implementation classes for WebSession support.
Related Packages
org.springframework.web.server
Core interfaces and classes for Spring's generic, reactive web support.
org.springframework.web.server.adapter
Implementations to adapt to the underlying org.springframework.http.client.reactive reactive HTTP adapter and HttpHandler .
org.springframework.web.server.handler
Provides common WebHandler implementations and a WebHandlerDecorator .
org.springframework.web.server.i18n
Locale related support classes.
Classes
CookieWebSessionIdResolver
Cookie-based WebSessionIdResolver .
DefaultWebSessionManager
Default implementation of WebSessionManager delegating to a WebSessionIdResolver for session id resolution and to a WebSessionStore .
HeaderWebSessionIdResolver
Request and response header-based WebSessionIdResolver .
InMemoryWebSessionStore
Simple Map-based storage for WebSession instances.
Interfaces
WebSessionIdResolver
Contract for session ID resolution strategies.
WebSessionManager
Main class for access to the WebSession for an HTTP request.
WebSessionStore
Strategy for WebSession persistence.
service
annotation
@NonNullApi @NonNullFields package org.springframework.web.service.annotation Annotations for declaring HTTP service request methods.
Annotation Interfaces
DeleteExchange
Shortcut for @HttpExchange for HTTP DELETE requests.
GetExchange
Shortcut for @HttpExchange for HTTP GET requests.
HttpExchange
Annotation to declare a method on an HTTP service interface as an HTTP endpoint.
PatchExchange
Shortcut for @HttpExchange for HTTP PATCH requests.
PostExchange
Shortcut for @HttpExchange for HTTP POST requests.
PutExchange
Shortcut for @HttpExchange for HTTP PUT requests.
invoker
@NonNullApi @NonNullFields package org.springframework.web.service.invoker Support for creating a client proxy for an HTTP service annotated with HttpExchange methods.
Classes
AbstractNamedValueArgumentResolver
Base class for arguments that resolve to a named request value such as a request header, path variable, cookie, and others.
AbstractNamedValueArgumentResolver.NamedValueInfo
Info about a request value, typically extracted from a method parameter annotation.
AbstractReactorHttpExchangeAdapter
Convenient base class for a ReactorHttpExchangeAdapter implementation adapting to the synchronous HttpExchangeAdapter contract.
CookieValueArgumentResolver
HttpServiceArgumentResolver for @CookieValue annotated arguments.
HttpMethodArgumentResolver
HttpServiceArgumentResolver that resolves the target request's HTTP method from an HttpMethod argument.
HttpRequestValues
Container for HTTP request values extracted from an @HttpExchange -annotated method and argument values passed to it.
HttpRequestValues.Builder
Builder for HttpRequestValues .
HttpServiceProxyFactory
Factory to create a client proxy from an HTTP service interface with @HttpExchange methods.
HttpServiceProxyFactory.Builder
Builder to create an HttpServiceProxyFactory .
PathVariableArgumentResolver
HttpServiceArgumentResolver for @PathVariable annotated arguments.
ReactiveHttpRequestValues
HttpRequestValues extension for use with ReactorHttpExchangeAdapter .
ReactiveHttpRequestValues.Builder
Builder for ReactiveHttpRequestValues .
RequestAttributeArgumentResolver
HttpServiceArgumentResolver for @RequestAttribute annotated arguments.
RequestBodyArgumentResolver
HttpServiceArgumentResolver for @RequestBody annotated arguments.
RequestHeaderArgumentResolver
HttpServiceArgumentResolver for @RequestHeader annotated arguments.
RequestParamArgumentResolver
HttpServiceArgumentResolver for @RequestParam annotated arguments.
RequestPartArgumentResolver
HttpServiceArgumentResolver for @RequestPart annotated arguments.
UriBuilderFactoryArgumentResolver
An HttpServiceArgumentResolver that uses the provided UriBuilderFactory to expand the UriTemplate .
UrlArgumentResolver
HttpServiceArgumentResolver that resolves the URL for the request from a URI argument.
Interfaces
HttpClientAdapter
Deprecated, for removal: This API element is subject to removal in a future version. in favor of ReactorHttpExchangeAdapter
HttpExchangeAdapter
Contract to abstract an HTTP client from HttpServiceProxyFactory and make it pluggable.
HttpServiceArgumentResolver
Resolve an argument from an @HttpExchange -annotated method to one or more HTTP request values.
ReactorHttpExchangeAdapter
Contract to abstract a reactive, HTTP client from HttpServiceProxyFactory and make it pluggable.
servlet
servlet
@NonNullApi @NonNullFields package org.springframework.web.servlet Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework. This package and related packages are discussed in Chapters 12 and 13 of Expert One-On-One J2EE Design and Development by Rod Johnson (Wrox, 2002).
Related Packages
org.springframework.web
Common, generic interfaces that define minimal boundary points between Spring's web infrastructure and other framework modules.
org.springframework.web.servlet.config
Defines the XML configuration namespace for Spring MVC.
org.springframework.web.servlet.function
Provides the types that make up Spring's functional web framework for Servlet environments.
org.springframework.web.servlet.handler
Provides standard HandlerMapping implementations, including abstract base classes for custom implementations.
org.springframework.web.servlet.i18n
Locale support classes for Spring's web MVC framework.
org.springframework.web.servlet.mvc
Standard controller implementations for the Servlet MVC framework that comes with Spring.
org.springframework.web.servlet.resource
Support classes for serving static resources.
org.springframework.web.servlet.support
Support classes for Spring's web MVC framework.
org.springframework.web.servlet.tags
This package contains Spring's JSP standard tag library for JSP 2.0+.
org.springframework.web.servlet.theme
Theme support classes for Spring's web MVC framework.
org.springframework.web.servlet.view
Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.
Interfaces
AsyncHandlerInterceptor
Extends HandlerInterceptor with a callback method invoked after the start of asynchronous request handling.
FlashMapManager
A strategy interface for retrieving and saving FlashMap instances.
HandlerAdapter
MVC framework SPI, allowing parameterization of the core MVC workflow.
HandlerExceptionResolver
Interface to be implemented by objects that can resolve exceptions thrown during handler mapping or execution, in the typical case to error views.
HandlerInterceptor
Workflow interface that allows for customized handler execution chains.
HandlerMapping
Interface to be implemented by objects that define a mapping between requests and handler objects.
LocaleContextResolver
Extension of LocaleResolver that adds support for a rich locale context (potentially including locale and time zone information).
LocaleResolver
Interface for web-based locale resolution strategies that allows for both locale resolution via the request and locale modification via request and response.
RequestToViewNameTranslator
Strategy interface for translating an incoming HttpServletRequest into a logical view name when no view name is explicitly supplied.
SmartView
Provides additional information about a View such as whether it performs redirects.
ThemeResolver
Deprecated. as of 6.0 in favor of using CSS, without direct replacement
View
MVC View for a web interaction.
ViewResolver
Interface to be implemented by objects that can resolve views by name.
Classes
DispatcherServlet
Central dispatcher for HTTP request handlers/controllers, e.g.
FlashMap
A FlashMap provides a way for one request to store attributes intended for use in another.
FrameworkServlet
Base servlet for Spring's web framework.
HandlerExecutionChain
Handler execution chain, consisting of handler object and any handler interceptors.
HttpServletBean
Simple extension of HttpServlet which treats its config parameters ( init-param entries within the servlet tag in web.xml ) as bean properties.
ModelAndView
Holder for both Model and View in the web MVC framework.
Exceptions
ModelAndViewDefiningException
Exception to be thrown on error conditions that should forward to a specific view with a specific model.
NoHandlerFoundException
Thrown when the DispatcherServlet can't find a handler for a request, which may be handled with a configured HandlerExceptionResolver .
config
config
@NonNullApi @NonNullFields package org.springframework.web.servlet.config Defines the XML configuration namespace for Spring MVC.
Related Packages
org.springframework.web.servlet
Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.
org.springframework.web.servlet.config.annotation
Annotation-based setup for Spring MVC.
Classes
CorsBeanDefinitionParser
BeanDefinitionParser that parses a cors element in order to set the CORS configuration in the various {AbstractHandlerMapping} beans created by AnnotationDrivenBeanDefinitionParser , ResourcesBeanDefinitionParser and ViewControllerBeanDefinitionParser .
FreeMarkerConfigurerBeanDefinitionParser
Parse the MVC namespace element and register FreeMarkerConfigurer bean.
GroovyMarkupConfigurerBeanDefinitionParser
Parse the MVC namespace element and register a GroovyConfigurer bean.
MvcNamespaceHandler
NamespaceHandler for Spring MVC configuration namespace.
MvcNamespaceUtils
Convenience methods for use in MVC namespace BeanDefinitionParsers.
ScriptTemplateConfigurerBeanDefinitionParser
Parse the MVC namespace element and register a ScriptTemplateConfigurer bean.
ViewResolversBeanDefinitionParser
Parses the view-resolvers MVC namespace element and registers ViewResolver bean definitions.
annotation
@NonNullApi @NonNullFields package org.springframework.web.servlet.config.annotation Annotation-based setup for Spring MVC.
Related Packages
org.springframework.web.servlet.config
Defines the XML configuration namespace for Spring MVC.
Classes
AsyncSupportConfigurer
Helps with configuring options for asynchronous request processing.
ContentNegotiationConfigurer
Creates a ContentNegotiationManager and configures it with one or more ContentNegotiationStrategy instances.
CorsRegistration
Assists with the creation of a CorsConfiguration instance for a given URL path pattern.
CorsRegistry
Assists with the registration of global, URL pattern based CorsConfiguration mappings.
DefaultServletHandlerConfigurer
Configures a request handler for serving static resources by forwarding the request to the Servlet container's "default" Servlet.
DelegatingWebMvcConfiguration
A subclass of WebMvcConfigurationSupport that detects and delegates to all beans of type WebMvcConfigurer allowing them to customize the configuration provided by WebMvcConfigurationSupport .
InterceptorRegistration
Assists with the creation of a MappedInterceptor .
InterceptorRegistry
Helps with configuring a list of mapped interceptors.
PathMatchConfigurer
Configure path matching options.
RedirectViewControllerRegistration
Assist with the registration of a single redirect view controller.
ResourceChainRegistration
Assists with the registration of resource resolvers and transformers.
ResourceHandlerRegistration
Encapsulates information required to create a resource handler.
ResourceHandlerRegistry
Stores registrations of resource handlers for serving static resources such as images, css files and others through Spring MVC including setting cache headers optimized for efficient loading in a web browser.
UrlBasedViewResolverRegistration
Assist with configuring a UrlBasedViewResolver .
ViewControllerRegistration
Assist with the registration of a single view controller.
ViewControllerRegistry
Assists with the registration of simple automated controllers pre-configured with status code and/or a view.
ViewResolverRegistry
Assist with the configuration of a chain of ViewResolver instances.
WebMvcConfigurationSupport
This is the main class providing the configuration behind the MVC Java config.
Annotation Interfaces
EnableWebMvc
Adding this annotation to an @Configuration class imports the Spring MVC configuration from WebMvcConfigurationSupport , e.g.:
Interfaces
WebMvcConfigurer
Defines callback methods to customize the Java-based configuration for Spring MVC enabled via @EnableWebMvc .
function
function
@NonNullApi @NonNullFields package org.springframework.web.servlet.function Provides the types that make up Spring's functional web framework for Servlet environments.
Related Packages
org.springframework.web.servlet
Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.
org.springframework.web.servlet.function.support
Classes supporting the org.springframework.web.servlet.function package.
Interfaces
AsyncServerResponse
Asynchronous subtype of ServerResponse that exposes the future response.
EntityResponse<T>
Entity-specific subtype of ServerResponse that exposes entity data.
EntityResponse.Builder<T>
Defines a builder for EntityResponse .
HandlerFilterFunction<T extends ServerResponse, R extends ServerResponse>
Represents a function that filters a handler function .
HandlerFunction<T extends ServerResponse>
Represents a function that handles a request .
RenderingResponse
Rendering-specific subtype of ServerResponse that exposes model and template data.
RenderingResponse.Builder
Defines a builder for RenderingResponse .
RequestPredicate
Represents a function that evaluates on a given ServerRequest .
RequestPredicates.Visitor
Receives notifications from the logical structure of request predicates.
RouterFunction<T extends ServerResponse>
Represents a function that routes to a handler function .
RouterFunctions.Builder
Represents a discoverable builder for router functions.
RouterFunctions.Visitor
Receives notifications from the logical structure of router functions.
ServerRequest
Represents a server-side HTTP request, as handled by a HandlerFunction .
ServerRequest.Builder
Defines a builder for a request.
ServerRequest.Headers
Represents the headers of the HTTP request.
ServerResponse
Represents a typed server-side HTTP response, as returned by a handler function or filter function .
ServerResponse.BodyBuilder
Defines a builder that adds a body to the response.
ServerResponse.Context
Defines the context used during the ServerResponse.writeTo(HttpServletRequest, HttpServletResponse, Context) .
ServerResponse.HeadersBuilder<B extends ServerResponse.HeadersBuilder<B>>
Defines a builder that adds headers to the response.
ServerResponse.HeadersBuilder.WriteFunction
Defines the contract for ServerResponse.HeadersBuilder.build(WriteFunction) .
ServerResponse.SseBuilder
Defines a builder for a body that sends server-sent events.
Classes
RequestPredicates
Implementations of RequestPredicate that implement various useful request matching operations, such as matching based on path, HTTP method, etc.
RouterFunctions
Central entry point to Spring's functional web framework. Exposes routing functionality, such as to create a RouterFunction using a discoverable builder-style API, to create a RouterFunction given a RequestPredicate and HandlerFunction , and to do further subrouting on an existing routing function.
support
@NonNullApi @NonNullFields package org.springframework.web.servlet.function.support Classes supporting the org.springframework.web.servlet.function package. Contains a HandlerAdapter that supports HandlerFunctions, and a HandlerMapping that supports RouterFunctions.
Related Packages
org.springframework.web.servlet.function
Provides the types that make up Spring's functional web framework for Servlet environments.
Classes
HandlerFunctionAdapter
HandlerAdapter implementation that supports HandlerFunction s.
RouterFunctionMapping
HandlerMapping implementation that supports RouterFunctions .
handler
@NonNullApi @NonNullFields package org.springframework.web.servlet.handler Provides standard HandlerMapping implementations, including abstract base classes for custom implementations.
Related Packages
org.springframework.web.servlet
Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.
Classes
AbstractDetectingUrlHandlerMapping
Abstract implementation of the HandlerMapping interface, detecting URL mappings for handler beans through introspection of all defined beans in the application context.
AbstractHandlerExceptionResolver
Abstract base class for HandlerExceptionResolver implementations.
AbstractHandlerMapping
Abstract base class for HandlerMapping implementations.
AbstractHandlerMethodExceptionResolver
Abstract base class for HandlerExceptionResolver implementations that support handling exceptions from handlers of type HandlerMethod .
AbstractHandlerMethodMapping<T>
Abstract base class for HandlerMapping implementations that define a mapping between a request and a HandlerMethod .
AbstractUrlHandlerMapping
Abstract base class for URL-mapped HandlerMapping implementations.
BeanNameUrlHandlerMapping
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.
ConversionServiceExposingInterceptor
Interceptor that places the configured ConversionService in request scope so it's available during request processing.
DispatcherServletWebRequest
ServletWebRequest subclass that is aware of DispatcherServlet 's request context, such as the Locale determined by the configured LocaleResolver .
HandlerExceptionResolverComposite
A HandlerExceptionResolver that delegates to a list of other HandlerExceptionResolvers .
HandlerMappingIntrospector
Helper class to get information from the HandlerMapping that would serve a specific request.
HandlerMappingIntrospector.CachedResult
Container for a MatchableHandlerMapping and CorsConfiguration for a given request matched by dispatcher type and requestURI.
MappedInterceptor
Wraps a HandlerInterceptor and uses URL patterns to determine whether it applies to a given request.
RequestMatchResult
Container for the result from request pattern matching via MatchableHandlerMapping with a method to further extract URI template variables from the pattern.
SimpleMappingExceptionResolver
HandlerExceptionResolver implementation that allows for mapping exception class names to view names, either for a set of given handlers or for all handlers in the DispatcherServlet.
SimpleServletHandlerAdapter
Adapter to use the Servlet interface with the generic DispatcherServlet.
SimpleServletPostProcessor
BeanPostProcessor that applies initialization and destruction callbacks to beans that implement the Servlet interface.
SimpleUrlHandlerMapping
Implementation of the HandlerMapping interface that maps from URLs to request handler beans.
UserRoleAuthorizationInterceptor
Interceptor that checks the authorization of the current user via the user's roles, as evaluated by HttpServletRequest's isUserInRole method.
WebRequestHandlerInterceptorAdapter
Adapter that implements the Servlet HandlerInterceptor interface and wraps an underlying WebRequestInterceptor.
Interfaces
HandlerMethodMappingNamingStrategy<T>
A strategy for assigning a name to a handler method's mapping.
MatchableHandlerMapping
Additional interface that a HandlerMapping can implement to expose a request matching API aligned with its internal request matching configuration and implementation.
i18n
@NonNullApi @NonNullFields package org.springframework.web.servlet.i18n Locale support classes for Spring's web MVC framework. Provides standard LocaleResolver implementations, and a HandlerInterceptor for locale changes.
Related Packages
org.springframework.web.servlet
Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.
Classes
AbstractLocaleContextResolver
Abstract base class for LocaleContextResolver implementations.
AbstractLocaleResolver
Abstract base class for LocaleResolver implementations.
AcceptHeaderLocaleResolver
LocaleResolver implementation that looks for a match between locales in the Accept-Language header and a list of configured supported locales.
CookieLocaleResolver
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.
FixedLocaleResolver
LocaleResolver implementation that always returns a fixed default locale and optionally time zone.
LocaleChangeInterceptor
Interceptor that allows for changing the current locale on every request, via a configurable request parameter (default parameter name: "locale").
SessionLocaleResolver
LocaleResolver implementation that uses a locale attribute in the user's session in case of a custom setting, with a fallback to the configured default locale, the request's Accept-Language header, or the default locale for the server.
mvc
mvc
@NonNullApi @NonNullFields package org.springframework.web.servlet.mvc Standard controller implementations for the Servlet MVC framework that comes with Spring. Provides various controller styles, including an annotation-based model.
Related Packages
org.springframework.web.servlet
Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.
org.springframework.web.servlet.mvc.annotation
Support package for annotation-based Servlet MVC controllers.
org.springframework.web.servlet.mvc.condition
Common MVC logic for matching incoming requests based on conditions.
org.springframework.web.servlet.mvc.method
Servlet-based infrastructure for handler method processing, building on the org.springframework.web.method package.
org.springframework.web.servlet.mvc.support
Support package for MVC controllers.
Classes
AbstractController
Convenient superclass for controller implementations, using the Template Method design pattern.
AbstractUrlViewController
Abstract base class for Controllers that return a view name based on the request URL.
HttpRequestHandlerAdapter
Adapter to use the plain HttpRequestHandler interface with the generic DispatcherServlet .
ParameterizableViewController
Trivial controller that always returns a pre-configured view and optionally sets the response status code.
ServletForwardingController
Spring Controller implementation that forwards to a named servlet, i.e.
ServletWrappingController
Spring Controller implementation that wraps a servlet instance which it manages internally.
SimpleControllerHandlerAdapter
Adapter to use the plain Controller workflow interface with the generic DispatcherServlet .
UrlFilenameViewController
Simple Controller implementation that transforms the virtual path of a URL into a view name and returns that view.
WebContentInterceptor
Handler interceptor that checks the request for supported methods and a required session and prepares the response by applying the configured cache settings.
Interfaces
Controller
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.
LastModified
Deprecated. as of 5.3.9 in favor of using the checkNotModified methods in WebRequest , or from an annotated controller method, returning a ResponseEntity with an "ETag" and/or "Last-Modified" headers set.
annotation
@NonNullApi @NonNullFields package org.springframework.web.servlet.mvc.annotation Support package for annotation-based Servlet MVC controllers.
Related Packages
org.springframework.web.servlet.mvc
Standard controller implementations for the Servlet MVC framework that comes with Spring.
org.springframework.web.servlet.mvc.condition
Common MVC logic for matching incoming requests based on conditions.
org.springframework.web.servlet.mvc.method
Servlet-based infrastructure for handler method processing, building on the org.springframework.web.method package.
org.springframework.web.servlet.mvc.support
Support package for MVC controllers.
Interfaces
ModelAndViewResolver
SPI for resolving custom return values from a specific handler method.
Classes
ResponseStatusExceptionResolver
A HandlerExceptionResolver that uses the @ResponseStatus annotation to map exceptions to HTTP status codes.
condition
@NonNullApi @NonNullFields package org.springframework.web.servlet.mvc.condition Common MVC logic for matching incoming requests based on conditions.
Related Packages
org.springframework.web.servlet.mvc
Standard controller implementations for the Servlet MVC framework that comes with Spring.
org.springframework.web.servlet.mvc.annotation
Support package for annotation-based Servlet MVC controllers.
org.springframework.web.servlet.mvc.method
Servlet-based infrastructure for handler method processing, building on the org.springframework.web.method package.
org.springframework.web.servlet.mvc.support
Support package for MVC controllers.
Classes
AbstractRequestCondition<T extends AbstractRequestCondition<T>>
A base class for RequestCondition types providing implementations of AbstractRequestCondition.equals(Object) , AbstractRequestCondition.hashCode() , and AbstractRequestCondition.toString() .
CompositeRequestCondition
Implements the RequestCondition contract by delegating to multiple RequestCondition types and using a logical conjunction ( ' && ' ) to ensure all conditions match a given request.
ConsumesRequestCondition
A logical disjunction (' || ') request condition to match a request's 'Content-Type' header to a list of media type expressions.
HeadersRequestCondition
A logical conjunction ( ' && ' ) request condition that matches a request against a set of header expressions with syntax defined in RequestMapping.headers() .
ParamsRequestCondition
A logical conjunction ( ' && ' ) request condition that matches a request against a set parameter expressions with syntax defined in RequestMapping.params() .
PathPatternsRequestCondition
A logical disjunction (' || ') request condition that matches a request against a set of URL path patterns.
PatternsRequestCondition
A logical disjunction (' || ') request condition that matches a request against a set of URL path patterns.
ProducesRequestCondition
A logical disjunction (' || ') request condition to match a request's 'Accept' header to a list of media type expressions.
RequestConditionHolder
A holder for a RequestCondition useful when the type of the request condition is not known ahead of time, e.g.
RequestMethodsRequestCondition
A logical disjunction (' || ') request condition that matches a request against a set of RequestMethods .
Interfaces
MediaTypeExpression
A contract for media type expressions (e.g.
NameValueExpression<T>
A contract for "name!=value" style expression used to specify request parameters and request header conditions in @RequestMapping .
RequestCondition<T>
Contract for request mapping conditions.
method
method
@NonNullApi @NonNullFields package org.springframework.web.servlet.mvc.method Servlet-based infrastructure for handler method processing, building on the org.springframework.web.method package.
Related Packages
org.springframework.web.servlet.mvc
Standard controller implementations for the Servlet MVC framework that comes with Spring.
org.springframework.web.servlet.mvc.method.annotation
MVC infrastructure for annotation-based handler method processing, building on the org.springframework.web.method.annotation package.
org.springframework.web.servlet.mvc.annotation
Support package for annotation-based Servlet MVC controllers.
org.springframework.web.servlet.mvc.condition
Common MVC logic for matching incoming requests based on conditions.
org.springframework.web.servlet.mvc.support
Support package for MVC controllers.
Classes
AbstractHandlerMethodAdapter
Abstract base class for HandlerAdapter implementations that support handlers of type HandlerMethod .
RequestMappingInfo
Request mapping information.
RequestMappingInfo.BuilderConfiguration
Container for configuration options used for request mapping purposes.
RequestMappingInfoHandlerMapping
Abstract base class for classes for which RequestMappingInfo defines the mapping between a request and a handler method.
RequestMappingInfoHandlerMethodMappingNamingStrategy
A HandlerMethodMappingNamingStrategy for RequestMappingInfo -based handler method mappings.
Interfaces
RequestMappingInfo.Builder
Defines a builder for creating a RequestMappingInfo.
annotation
@NonNullApi @NonNullFields package org.springframework.web.servlet.mvc.method.annotation MVC infrastructure for annotation-based handler method processing, building on the org.springframework.web.method.annotation package. Entry points are RequestMappingHandlerMapping and RequestMappingHandlerAdapter.
Related Packages
org.springframework.web.servlet.mvc.method
Servlet-based infrastructure for handler method processing, building on the org.springframework.web.method package.
Classes
AbstractMappingJacksonResponseBodyAdvice
A convenient base class for ResponseBodyAdvice implementations that customize the response before JSON serialization with AbstractJackson2HttpMessageConverter 's concrete subclasses.
AbstractMessageConverterMethodArgumentResolver
A base class for resolving method argument values by reading from the body of a request with HttpMessageConverters .
AbstractMessageConverterMethodProcessor
Extends AbstractMessageConverterMethodArgumentResolver with the ability to handle method return values by writing to the response with HttpMessageConverters .
AsyncTaskMethodReturnValueHandler
Handles return values of type WebAsyncTask .
CallableMethodReturnValueHandler
Handles return values of type Callable .
ContinuationHandlerMethodArgumentResolver
No-op resolver for method arguments of type Continuation .
DeferredResultMethodReturnValueHandler
Handler for return values of type DeferredResult , ListenableFuture , and CompletionStage .
ExceptionHandlerExceptionResolver
An AbstractHandlerMethodExceptionResolver that resolves exceptions through @ExceptionHandler methods.
ExtendedServletRequestDataBinder
Subclass of ServletRequestDataBinder that adds URI template variables to the values used for data binding.
HttpEntityMethodProcessor
Resolves HttpEntity and RequestEntity method argument values, as well as return values of type HttpEntity , ResponseEntity , ErrorResponse and ProblemDetail .
HttpHeadersReturnValueHandler
Handles HttpHeaders return values.
JsonViewRequestBodyAdvice
A RequestBodyAdvice implementation that adds support for Jackson's @JsonView annotation declared on a Spring MVC @HttpEntity or @RequestBody method parameter.
JsonViewResponseBodyAdvice
A ResponseBodyAdvice implementation that adds support for Jackson's @JsonView annotation declared on a Spring MVC @RequestMapping or @ExceptionHandler method.
MatrixVariableMapMethodArgumentResolver
Resolves arguments of type Map annotated with @MatrixVariable where the annotation does not specify a name.
MatrixVariableMethodArgumentResolver
Resolves arguments annotated with @MatrixVariable .
ModelAndViewMethodReturnValueHandler
Handles return values of type ModelAndView copying view and model information to the ModelAndViewContainer .
ModelAndViewResolverMethodReturnValueHandler
This return value handler is intended to be ordered after all others as it attempts to handle _any_ return value type (i.e.
MvcUriComponentsBuilder
Creates instances of UriComponentsBuilder by pointing to @RequestMapping methods on Spring MVC controllers.
MvcUriComponentsBuilder.MethodArgumentBuilder
Builder class to create URLs for method arguments.
PathVariableMapMethodArgumentResolver
Resolves Map method arguments annotated with @PathVariable where the annotation does not specify a path variable name.
PathVariableMethodArgumentResolver
Resolves method arguments annotated with an @ PathVariable .
PrincipalMethodArgumentResolver
Resolves an argument of type Principal , similar to ServletRequestMethodArgumentResolver but irrespective of whether the argument is annotated or not.
RedirectAttributesMethodArgumentResolver
Resolves method arguments of type RedirectAttributes .
RequestAttributeMethodArgumentResolver
Resolves method arguments annotated with an @ RequestAttribute .
RequestBodyAdviceAdapter
A convenient starting point for implementing RequestBodyAdvice with default method implementations.
RequestMappingHandlerAdapter
Extension of AbstractHandlerMethodAdapter that supports @RequestMapping annotated HandlerMethods .
RequestMappingHandlerMapping
Creates RequestMappingInfo instances from type-level and method-level @RequestMapping and @HttpExchange annotations in @Controller classes.
RequestPartMethodArgumentResolver
Resolves the following method arguments: Annotated with @ RequestPart Of type MultipartFile in conjunction with Spring's MultipartResolver abstraction Of type jakarta.servlet.http.Part in conjunction with Servlet multipart requests
RequestResponseBodyMethodProcessor
Resolves method arguments annotated with @RequestBody and handles return values from methods annotated with @ResponseBody by reading and writing to the body of the request or response with an HttpMessageConverter .
ResponseBodyEmitter
A controller method return value type for asynchronous request processing where one or more objects are written to the response.
ResponseBodyEmitter.DataWithMediaType
A simple holder of data to be written along with a MediaType hint for selecting a message converter to write with.
ResponseBodyEmitterReturnValueHandler
Handler for return values of type ResponseBodyEmitter and subclasses such as SseEmitter including the same types wrapped with ResponseEntity .
ResponseEntityExceptionHandler
A class with an @ExceptionHandler method that handles all Spring MVC raised exceptions by returning a ResponseEntity with RFC 7807 formatted error details in the body.
ServletCookieValueMethodArgumentResolver
An AbstractCookieValueMethodArgumentResolver that resolves cookie values from an HttpServletRequest .
ServletInvocableHandlerMethod
Extends InvocableHandlerMethod with the ability to handle return values through a registered HandlerMethodReturnValueHandler and also supports setting the response status based on a method-level @ResponseStatus annotation.
ServletModelAttributeMethodProcessor
A Servlet-specific ModelAttributeMethodProcessor that applies data binding through a WebDataBinder of type ServletRequestDataBinder .
ServletRequestDataBinderFactory
Creates a ServletRequestDataBinder .
ServletRequestMethodArgumentResolver
Resolves servlet backed request-related method arguments.
ServletResponseMethodArgumentResolver
Resolves servlet backed response-related method arguments.
ServletWebArgumentResolverAdapter
A Servlet-specific AbstractWebArgumentResolverAdapter that creates a NativeWebRequest from ServletRequestAttributes .
SessionAttributeMethodArgumentResolver
Resolves method arguments annotated with an @ SessionAttribute .
SseEmitter
A specialization of ResponseBodyEmitter for sending Server-Sent Events .
StreamingResponseBodyReturnValueHandler
Supports return values of type StreamingResponseBody and also ResponseEntity .
UriComponentsBuilderMethodArgumentResolver
Resolvers argument values of type UriComponentsBuilder .
ViewMethodReturnValueHandler
Handles return values that are of type View .
ViewNameMethodReturnValueHandler
Handles return values of types void and String interpreting them as view name reference.
Interfaces
MvcUriComponentsBuilder.MethodInvocationInfo
Method invocation information.
RequestBodyAdvice
Allows customizing the request before its body is read and converted into an Object and also allows for processing of the resulting Object before it is passed into a controller method as an @RequestBody or an HttpEntity method argument.
ResponseBodyAdvice<T>
Allows customizing the response after the execution of an @ResponseBody or a ResponseEntity controller method but before the body is written with an HttpMessageConverter .
SseEmitter.SseEventBuilder
A builder for an SSE event.
StreamingResponseBody
A controller method return value type for asynchronous request processing where the application can write directly to the response OutputStream without holding up the Servlet container thread.
support
@NonNullApi @NonNullFields package org.springframework.web.servlet.mvc.support Support package for MVC controllers. Contains a special HandlerMapping for controller conventions.
Related Packages
org.springframework.web.servlet.mvc
Standard controller implementations for the Servlet MVC framework that comes with Spring.
org.springframework.web.servlet.mvc.annotation
Support package for annotation-based Servlet MVC controllers.
org.springframework.web.servlet.mvc.condition
Common MVC logic for matching incoming requests based on conditions.
org.springframework.web.servlet.mvc.method
Servlet-based infrastructure for handler method processing, building on the org.springframework.web.method package.
Classes
DefaultHandlerExceptionResolver
The default implementation of the HandlerExceptionResolver interface, resolving standard Spring MVC exceptions and translating them to corresponding HTTP status codes.
RedirectAttributesModelMap
A ModelMap implementation of RedirectAttributes that formats values as Strings using a DataBinder .
Interfaces
RedirectAttributes
A specialization of the Model interface that controllers can use to select attributes for a redirect scenario.
resource
@NonNullApi @NonNullFields package org.springframework.web.servlet.resource Support classes for serving static resources.
Related Packages
org.springframework.web.servlet
Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.
Classes
AbstractResourceResolver
Base class for ResourceResolver implementations.
AbstractVersionStrategy
Abstract base class for VersionStrategy implementations.
AbstractVersionStrategy.FileNameVersionPathStrategy
File name-based VersionPathStrategy , e.g.
AbstractVersionStrategy.PrefixVersionPathStrategy
A prefix-based VersionPathStrategy , e.g.
CachingResourceResolver
A ResourceResolver that resolves resources from a Cache or otherwise delegates to the resolver chain and saves the result in the cache.
CachingResourceTransformer
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.
ContentVersionStrategy
A VersionStrategy that calculates a Hex MD5 hash from the content of the resource and appends it to the file name, e.g.
CssLinkResourceTransformer
A ResourceTransformer implementation that modifies links in a CSS file to match the public URL paths that should be exposed to clients (e.g.
CssLinkResourceTransformer.AbstractLinkParser
Abstract base class for CssLinkResourceTransformer.LinkParser implementations.
DefaultServletHttpRequestHandler
An HttpRequestHandler for serving static files using the Servlet container's "default" Servlet.
EncodedResourceResolver
Resolver that delegates to the chain, and if a resource is found, it then attempts to find an encoded (e.g.
FixedVersionStrategy
A VersionStrategy that relies on a fixed version applied as a request path prefix, e.g.
PathResourceResolver
A simple ResourceResolver that tries to find a resource under the given locations matching to the request path.
ResourceHttpRequestHandler
HttpRequestHandler that serves static resources in an optimized way according to the guidelines of Page Speed, YSlow, etc.
ResourceTransformerSupport
A base class for a ResourceTransformer with an optional helper method for resolving public links within a transformed resource.
ResourceUrlEncodingFilter
A filter that wraps the HttpServletResponse and overrides its encodeURL method in order to translate internal resource request URLs into public URL paths for external use.
ResourceUrlProvider
A central component to use to obtain the public URL path that clients should use to access a static resource.
ResourceUrlProviderExposingInterceptor
An interceptor that exposes the ResourceUrlProvider instance it is configured with as a request attribute.
TransformedResource
An extension of ByteArrayResource that a ResourceTransformer can use to represent an original resource preserving all other information except the content.
VersionResourceResolver
Resolves request paths containing a version string that can be used as part of an HTTP caching strategy in which a resource is cached with a date in the distant future (e.g.
WebJarsResourceResolver
A ResourceResolver that delegates to the chain to locate a resource and then attempts to find a matching versioned resource contained in a WebJar JAR file.
Interfaces
CssLinkResourceTransformer.LinkParser
Extract content chunks that represent links.
HttpResource
Extended interface for a Resource to be written to an HTTP response.
ResourceResolver
A strategy for resolving a request to a server-side resource.
ResourceResolverChain
A contract for invoking a chain of ResourceResolvers where each resolver is given a reference to the chain allowing it to delegate when necessary.
ResourceTransformer
An abstraction for transforming the content of a resource.
ResourceTransformerChain
A contract for invoking a chain of ResourceTransformers where each resolver is given a reference to the chain allowing it to delegate when necessary.
VersionPathStrategy
A strategy for extracting and embedding a resource version in its URL path.
VersionStrategy
An extension of VersionPathStrategy that adds a method to determine the actual version of a Resource .
Exceptions
NoResourceFoundException
Raised when ResourceHttpRequestHandler can not find a resource.
support
@NonNullApi @NonNullFields package org.springframework.web.servlet.support Support classes for Spring's web MVC framework. Provides easy evaluation of the request context in views, and miscellaneous HandlerInterceptor implementations.
Related Packages
org.springframework.web.servlet
Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.
Classes
AbstractAnnotationConfigDispatcherServletInitializer
WebApplicationInitializer to register a DispatcherServlet and use Java-based Spring configuration.
AbstractDispatcherServletInitializer
Base class for WebApplicationInitializer implementations that register a DispatcherServlet in the servlet context.
AbstractFlashMapManager
A base class for FlashMapManager implementations.
BindStatus
Simple adapter to expose the bind status of a field or object.
JspAwareRequestContext
JSP-aware (and JSTL-aware) subclass of RequestContext, allowing for population of the context from a jakarta.servlet.jsp.PageContext .
JstlUtils
Helper class for preparing JSTL views, in particular for exposing a JSTL localization context.
RequestContext
Context holder for request-specific state, like current web application context, current locale, current theme, and potential binding errors.
RequestContextUtils
Utility class for easy access to request-specific state which has been set by the DispatcherServlet .
ServletUriComponentsBuilder
UriComponentsBuilder with additional static factory methods to create links based on the current HttpServletRequest.
SessionFlashMapManager
Store and retrieve FlashMap instances to and from the HTTP session.
WebContentGenerator
Convenient superclass for any kind of web content generator, like AbstractController and WebContentInterceptor .
Interfaces
RequestDataValueProcessor
A contract for inspecting and potentially modifying request data values such as URL query parameters or form field values before they are rendered by a view or before a redirect.
tags
tags
@NonNullApi @NonNullFields package org.springframework.web.servlet.tags This package contains Spring's JSP standard tag library for JSP 2.0+. Supports JSP view implementations within Spring's Web MVC framework. For more details on each tag, see the list of tags below with links to individual tag classes, or check the spring.tld file: The argument tag The bind tag The hasBindErrors tag The escapeBody tag The eval tag The htmlEscape tag The message tag The nestedPath tag The param tag The theme tag The transform tag The url tag Please note that the various tags generated by this form tag library are compliant with https://www.w3.org/TR/xhtml1/ and attendant https://www.w3.org/TR/xhtml1/dtds.html#a_dtd_XHTML-1.0-Strict.
Related Packages
org.springframework.web.servlet
Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.
org.springframework.web.servlet.tags.form
Spring's form tag library for JSP views in Spring's Web MVC framework.
Interfaces
ArgumentAware
Allows implementing tag to utilize nested spring:argument tags.
EditorAwareTag
Interface to be implemented by JSP tags that expose a PropertyEditor for a property that they are currently bound to.
ParamAware
Allows implementing tag to utilize nested spring:param tags.
Classes
ArgumentTag
The tag is based on the JSTL fmt:param tag.
BindErrorsTag
This tag provides an Errors instance in case of bind errors.
BindTag
The tag supports evaluation of binding errors for a certain bean or bean property.
EscapeBodyTag
The tag is used to escape its enclosed body content, applying HTML escaping and/or JavaScript escaping.
EvalTag
The tag evaluates a Spring expression (SpEL) and either prints the result or assigns it to a variable.
HtmlEscapeTag
The tag sets default HTML escape value for the current page.
HtmlEscapingAwareTag
Superclass for tags that output content that might get HTML-escaped.
MessageTag
The tag looks up a message in the scope of this page.
NestedPathTag
The tag supports and assists with nested beans or bean properties in the model.
Param
Bean used to pass name-value pair parameters from a ParamTag to a ParamAware tag.
ParamTag
The tag collects name-value parameters and passes them to a ParamAware ancestor in the tag hierarchy.
RequestContextAwareTag
Superclass for all tags that require a RequestContext .
ThemeTag
Deprecated. as of 6.0, with no direct replacement
TransformTag
The tag provides transformation for reference data values from controllers and other objects inside a spring:bind tag (or a data-bound form element tag from Spring's form tag library).
UrlTag
The tag creates URLs.
form
@NonNullApi @NonNullFields package org.springframework.web.servlet.tags.form Spring's form tag library for JSP views in Spring's Web MVC framework. For more details on each tag, see the list of tags below with links to individual tag classes, or check the spring-form.tld file: The button tag The checkbox tag The checkboxes tag The errors tag The form tag The hidden tag The input tag The label tag The option tag The options tag The password tag The radiobutton tag The radiobuttons tag The select tag The textarea tag
Related Packages
org.springframework.web.servlet.tags
This package contains Spring's JSP standard tag library for JSP 2.0+.
Classes
AbstractCheckedElementTag
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 '.
AbstractDataBoundFormElementTag
Base tag for all data-binding aware JSP form tags.
AbstractFormTag
Base class for all JSP form tags.
AbstractHtmlElementBodyTag
Convenient superclass for many html tags that render content using the databinding features of the AbstractHtmlElementTag .
AbstractHtmlElementTag
Base class for databinding-aware JSP tags that render HTML element.
AbstractHtmlInputElementTag
Base class for databinding-aware JSP tags that render HTML form input element.
AbstractMultiCheckedElementTag
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 '.
AbstractSingleCheckedElementTag
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 '.
ButtonTag
The tag renders a form field label in an HTML 'button' tag.
CheckboxesTag
The tag renders multiple HTML 'input' tags with type 'checkbox'.
CheckboxTag
The tag renders an HTML 'input' tag with type 'checkbox'.
ErrorsTag
The tag renders field errors in an HTML 'span' tag.
FormTag
The tag renders an HTML 'form' tag and exposes a binding path to inner tags for binding.
HiddenInputTag
The tag renders an HTML 'input' tag with type 'hidden' using the bound value.
InputTag
The tag renders an HTML 'input' tag with type 'text' using the bound value.
LabelTag
The tag renders a form field label in an HTML 'label' tag.
OptionsTag
The tag renders a list of HTML 'option' tags.
OptionTag
The tag renders a single HTML 'option'.
PasswordInputTag
The tag renders an HTML 'input' tag with type 'password' using the bound value.
RadioButtonsTag
The tag renders multiple HTML 'input' tags with type 'radio'.
RadioButtonTag
The tag renders an HTML 'input' tag with type 'radio'.
SelectTag
The tag renders an HTML 'select' element.
TagWriter
Utility class for writing HTML content to a Writer instance.
TextareaTag
The tag renders an HTML 'textarea'.
theme
@NonNullApi @NonNullFields package org.springframework.web.servlet.theme Theme support classes for Spring's web MVC framework. Provides standard ThemeResolver implementations, and a HandlerInterceptor for theme changes. If you don't provide a bean of one of these classes as themeResolver, a FixedThemeResolver will be provided with the default theme name 'theme'. If you use a defined FixedThemeResolver, you will able to use another theme name for default, but the users will stick on this theme. With a CookieThemeResolver or SessionThemeResolver, you can allow the user to change his current theme. Generally, you will put in the themes resource bundles the paths of CSS files, images and HTML constructs. For retrieving themes data, you can either use the spring:theme tag in JSP or access via the RequestContext for other view technologies. The pagedlist demo application uses themes
Related Packages
org.springframework.web.servlet
Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.
Classes
AbstractThemeResolver
Deprecated. as of 6.0 in favor of using CSS, without direct replacement
CookieThemeResolver
Deprecated. as of 6.0 in favor of using CSS, without direct replacement
FixedThemeResolver
Deprecated. as of 6.0 in favor of using CSS, without direct replacement
SessionThemeResolver
Deprecated. as of 6.0 in favor of using CSS, without direct replacement
ThemeChangeInterceptor
Deprecated. as of 6.0 in favor of using CSS, without direct replacement
view
view
@NonNullApi @NonNullFields package org.springframework.web.servlet.view Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations. Application developers don't usually need to implement views, as the framework provides standard views for JSPs, FreeMarker, XSLT, etc. However, the ability to implement custom views easily by subclassing the AbstractView class in this package can be very helpful if an application has unusual view requirements.
Related Packages
org.springframework.web.servlet
Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.
org.springframework.web.servlet.view.document
Support classes for document generation, providing View implementations for PDF and Excel.
org.springframework.web.servlet.view.feed
Support classes for feed generation, providing View implementations for Atom and RSS.
org.springframework.web.servlet.view.freemarker
Support classes for the integration of FreeMarker as Spring web view technology.
org.springframework.web.servlet.view.groovy
Support classes for the integration of Groovy Templates as Spring web view technology.
org.springframework.web.servlet.view.json
Support classes for providing a View implementation based on JSON serialization.
org.springframework.web.servlet.view.script
Support classes for views based on the JSR-223 script engine abstraction (as included in Java 6+), e.g.
org.springframework.web.servlet.view.xml
Support classes for providing a View implementation based on XML Marshalling.
org.springframework.web.servlet.view.xslt
Support classes for XSLT, providing a View implementation for XSLT stylesheets.
Classes
AbstractCachingViewResolver
Convenient base class for ViewResolver implementations.
AbstractTemplateView
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.
AbstractTemplateViewResolver
Abstract base class for template view resolvers, in particular for FreeMarker views.
AbstractUrlBasedView
Abstract base class for URL-based views.
AbstractView
Abstract base class for View implementations.
BeanNameViewResolver
A simple implementation of ViewResolver that interprets a view name as a bean name in the current application context, i.e.
ContentNegotiatingViewResolver
Implementation of ViewResolver that resolves a view based on the request file name or Accept header.
DefaultRequestToViewNameTranslator
RequestToViewNameTranslator that simply transforms the URI of the incoming request into a view name.
InternalResourceView
Wrapper for a JSP or other resource within the same web application.
InternalResourceViewResolver
Convenient subclass of UrlBasedViewResolver that supports InternalResourceView (i.e.
JstlView
Specialization of InternalResourceView for JSTL pages, i.e.
RedirectView
View that redirects to an absolute, context relative, or current request relative URL.
ResourceBundleViewResolver
Deprecated. as of 5.3, in favor of Spring's common view resolver variants and/or custom resolver implementations
UrlBasedViewResolver
Simple implementation of the ViewResolver interface, allowing for direct resolution of symbolic view names to URLs, without explicit mapping definitions.
ViewResolverComposite
A ViewResolver that delegates to others.
XmlViewResolver
Deprecated. as of 5.3, in favor of Spring's common view resolver variants and/or custom resolver implementations
Interfaces
AbstractCachingViewResolver.CacheFilter
Filter that determines if view should be cached.
document
@NonNullApi @NonNullFields package org.springframework.web.servlet.view.document Support classes for document generation, providing View implementations for PDF and Excel.
Related Packages
org.springframework.web.servlet.view
Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.
Classes
AbstractPdfStamperView
Abstract superclass for PDF views that operate on an existing document with an AcroForm.
AbstractPdfView
Abstract superclass for PDF views.
AbstractXlsView
Convenient superclass for Excel document views in traditional XLS format.
AbstractXlsxStreamingView
Convenient superclass for Excel document views in the Office 2007 XLSX format, using POI's streaming variant.
AbstractXlsxView
Convenient superclass for Excel document views in the Office 2007 XLSX format (as supported by POI-OOXML).
feed
@NonNullApi @NonNullFields package org.springframework.web.servlet.view.feed Support classes for feed generation, providing View implementations for Atom and RSS. Based on the ROME tools project.
Related Packages
org.springframework.web.servlet.view
Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.
Classes
AbstractAtomFeedView
Abstract superclass for Atom Feed views, using the ROME package.
AbstractFeedView<T extends com.rometools.rome.feed.WireFeed>
Abstract base class for Atom and RSS Feed views, using the ROME package.
AbstractRssFeedView
Abstract superclass for RSS Feed views, using the ROME package.
freemarker
@NonNullApi @NonNullFields package org.springframework.web.servlet.view.freemarker Support classes for the integration of FreeMarker as Spring web view technology. Contains a View implementation for FreeMarker templates.
Related Packages
org.springframework.web.servlet.view
Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.
Interfaces
FreeMarkerConfig
Interface to be implemented by objects that configure and manage a FreeMarker Configuration object in a web environment.
Classes
FreeMarkerConfigurer
JavaBean to configure FreeMarker for web usage, via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties.
FreeMarkerView
View using the FreeMarker template engine.
FreeMarkerViewResolver
Convenience subclass of UrlBasedViewResolver that supports FreeMarkerView (i.e.
groovy
@NonNullApi @NonNullFields package org.springframework.web.servlet.view.groovy Support classes for the integration of Groovy Templates as Spring web view technology. Contains a View implementation for Groovy templates.
Related Packages
org.springframework.web.servlet.view
Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.
Interfaces
GroovyMarkupConfig
Interface to be implemented by objects that configure and manage a Groovy MarkupTemplateEngine for automatic lookup in a web environment.
Classes
GroovyMarkupConfigurer
An extension of Groovy's TemplateConfiguration and an implementation of Spring MVC's GroovyMarkupConfig for creating a MarkupTemplateEngine for use in a web application.
GroovyMarkupView
An AbstractTemplateView subclass based on Groovy XML/XHTML markup templates.
GroovyMarkupViewResolver
Convenience subclass of AbstractTemplateViewResolver that supports GroovyMarkupView (i.e.
json
@NonNullApi @NonNullFields package org.springframework.web.servlet.view.json Support classes for providing a View implementation based on JSON serialization.
Related Packages
org.springframework.web.servlet.view
Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.
Classes
AbstractJackson2View
Abstract base class for Jackson based and content type independent AbstractView implementations.
MappingJackson2JsonView
Spring MVC View that renders JSON content by serializing the model for the current request using Jackson 2's ObjectMapper .
script
@NonNullApi @NonNullFields package org.springframework.web.servlet.view.script Support classes for views based on the JSR-223 script engine abstraction (as included in Java 6+), e.g. using JavaScript via Nashorn on JDK 8. Contains a View implementation for scripted templates.
Related Packages
org.springframework.web.servlet.view
Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.
Classes
RenderingContext
Context passed to ScriptTemplateView render function in order to make the application context, the locale, the template loader and the url available on scripting side.
ScriptTemplateConfigurer
An implementation of Spring MVC's ScriptTemplateConfig for creating a ScriptEngine for use in a web application.
ScriptTemplateView
An AbstractUrlBasedView subclass designed to run any template library based on a JSR-223 script engine.
ScriptTemplateViewResolver
Convenience subclass of UrlBasedViewResolver that supports ScriptTemplateView and custom subclasses of it.
Interfaces
ScriptTemplateConfig
Interface to be implemented by objects that configure and manage a JSR-223 ScriptEngine for automatic lookup in a web environment.
xml
@NonNullApi @NonNullFields package org.springframework.web.servlet.view.xml Support classes for providing a View implementation based on XML Marshalling.
Related Packages
org.springframework.web.servlet.view
Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.
Classes
MappingJackson2XmlView
Spring MVC View that renders XML content by serializing the model for the current request using Jackson 2's XmlMapper .
MarshallingView
Spring-MVC View that allows for response context to be rendered as the result of marshalling by a Marshaller .
xslt
@NonNullApi @NonNullFields package org.springframework.web.servlet.view.xslt Support classes for XSLT, providing a View implementation for XSLT stylesheets.
Related Packages
org.springframework.web.servlet.view
Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.
Classes
XsltView
XSLT-driven View that allows for response context to be rendered as the result of an XSLT transformation.
XsltViewResolver
ViewResolver implementation that resolves instances of XsltView by translating the supplied view name into the URL of the XSLT stylesheet.
socket
socket
@NonNullApi @NonNullFields package org.springframework.web.socket Common abstractions and Spring configuration support for WebSocket applications.
Related Packages
org.springframework.web
Common, generic interfaces that define minimal boundary points between Spring's web infrastructure and other framework modules.
org.springframework.web.socket.adapter
Classes adapting Spring's WebSocket API to and from WebSocket providers.
org.springframework.web.socket.client
Client-side abstractions for WebSocket applications.
org.springframework.web.socket.config
Configuration support for WebSocket request handling.
org.springframework.web.socket.handler
Convenient WebSocketHandler implementations and decorators.
org.springframework.web.socket.messaging
WebSocket integration for Spring's messaging module.
org.springframework.web.socket.server
Server-side abstractions for WebSocket interactions.
org.springframework.web.socket.sockjs
Top-level SockJS types.
Classes
AbstractWebSocketMessage<T>
A message that can be handled or sent on a WebSocket connection.
BinaryMessage
A binary WebSocket message.
CloseStatus
Represents a WebSocket close status code and reason.
PingMessage
A WebSocket ping message.
PongMessage
A WebSocket pong message.
TextMessage
A text WebSocket message.
WebSocketExtension
Represents a WebSocket extension as defined in the RFC 6455.
WebSocketHttpHeaders
An HttpHeaders variant that adds support for the HTTP headers defined by the WebSocket specification RFC 6455.
Interfaces
SubProtocolCapable
An interface for WebSocket handlers that support sub-protocols as defined in RFC 6455.
WebSocketHandler
A handler for WebSocket messages and lifecycle events.
WebSocketMessage<T>
A message that can be handled or sent on a WebSocket connection.
WebSocketSession
A WebSocket session abstraction.
adapter
adapter
@NonNullApi @NonNullFields package org.springframework.web.socket.adapter Classes adapting Spring's WebSocket API to and from WebSocket providers.
Related Packages
org.springframework.web.socket
Common abstractions and Spring configuration support for WebSocket applications.
org.springframework.web.socket.adapter.jetty
Adapter classes for the Jetty WebSocket API.
org.springframework.web.socket.adapter.standard
Adapter classes for the standard Jakarta WebSocket API.
Classes
AbstractWebSocketSession<T>
An abstract base class for implementations of WebSocketSession .
Interfaces
NativeWebSocketSession
A WebSocketSession that exposes the underlying, native WebSocketSession through a getter.
jetty
@NonNullApi @NonNullFields package org.springframework.web.socket.adapter.jetty Adapter classes for the Jetty WebSocket API.
Related Packages
org.springframework.web.socket.adapter
Classes adapting Spring's WebSocket API to and from WebSocket providers.
org.springframework.web.socket.adapter.standard
Adapter classes for the standard Jakarta WebSocket API.
Classes
JettyWebSocketHandlerAdapter
Adapts WebSocketHandler to the Jetty WebSocket API.
JettyWebSocketSession
A WebSocketSession for use with the Jetty WebSocket API.
WebSocketToJettyExtensionConfigAdapter
Adapter class to convert a WebSocketExtension to a Jetty ExtensionConfig .
standard
@NonNullApi @NonNullFields package org.springframework.web.socket.adapter.standard Adapter classes for the standard Jakarta WebSocket API.
Related Packages
org.springframework.web.socket.adapter
Classes adapting Spring's WebSocket API to and from WebSocket providers.
org.springframework.web.socket.adapter.jetty
Adapter classes for the Jetty WebSocket API.
Classes
ConvertingEncoderDecoderSupport<T, M>
Base class that can be used to implement a standard Encoder and/or Decoder .
ConvertingEncoderDecoderSupport.BinaryDecoder<T>
A binary jakarta.websocket.Encoder that delegates to Spring's conversion service.
ConvertingEncoderDecoderSupport.BinaryEncoder<T>
A binary jakarta.websocket.Encoder that delegates to Spring's conversion service.
ConvertingEncoderDecoderSupport.TextDecoder<T>
A Text jakarta.websocket.Encoder that delegates to Spring's conversion service.
ConvertingEncoderDecoderSupport.TextEncoder<T>
A text jakarta.websocket.Encoder that delegates to Spring's conversion service.
StandardToWebSocketExtensionAdapter
A subclass of WebSocketExtension that can be constructed from a Extension .
StandardWebSocketHandlerAdapter
Adapts a WebSocketHandler to the standard WebSocket for Java API.
StandardWebSocketSession
A WebSocketSession for use with the standard WebSocket for Java API.
WebSocketToStandardExtensionAdapter
Adapt an instance of WebSocketExtension to the Extension interface.
client
client
@NonNullApi @NonNullFields package org.springframework.web.socket.client Client-side abstractions for WebSocket applications.
Related Packages
org.springframework.web.socket
Common abstractions and Spring configuration support for WebSocket applications.
org.springframework.web.socket.client.standard
Client-side classes for use with standard Jakarta WebSocket endpoints.
Classes
AbstractWebSocketClient
Abstract base class for WebSocketClient implementations.
ConnectionManagerSupport
Base class for a connection manager that automates the process of connecting to a WebSocket server with the Spring ApplicationContext lifecycle.
WebSocketConnectionManager
WebSocket connection manager that connects to the server via WebSocketClient and handles the session with a WebSocketHandler .
Interfaces
WebSocketClient
Contract for initiating a WebSocket request.
standard
@NonNullApi @NonNullFields package org.springframework.web.socket.client.standard Client-side classes for use with standard Jakarta WebSocket endpoints.
Related Packages
org.springframework.web.socket.client
Client-side abstractions for WebSocket applications.
Classes
AnnotatedEndpointConnectionManager
WebSocket connection manager that connects to the server via WebSocketContainer and handles the session with an @ClientEndpoint endpoint.
EndpointConnectionManager
WebSocket connection manager that connects to the server via WebSocketContainer and handles the session with an Endpoint .
StandardWebSocketClient
A WebSocketClient based on the standard Jakarta WebSocket API.
WebSocketContainerFactoryBean
A FactoryBean for creating and configuring a WebSocketContainer through Spring XML configuration.
config
config
@NonNullApi @NonNullFields package org.springframework.web.socket.config Configuration support for WebSocket request handling.
Related Packages
org.springframework.web.socket
Common abstractions and Spring configuration support for WebSocket applications.
org.springframework.web.socket.config.annotation
Support for annotation-based WebSocket setup in configuration classes.
Classes
WebSocketMessageBrokerStats
A central class for aggregating information about internal state and counters from key infrastructure components of the setup that comes with @EnableWebSocketMessageBroker for Java config and for XML.
WebSocketNamespaceHandler
NamespaceHandler for Spring WebSocket configuration namespace.
annotation
@NonNullApi @NonNullFields package org.springframework.web.socket.config.annotation Support for annotation-based WebSocket setup in configuration classes.
Related Packages
org.springframework.web.socket.config
Configuration support for WebSocket request handling.
Classes
AbstractWebSocketHandlerRegistration<M>
Base class for WebSocketHandlerRegistrations that gathers all the configuration options but allows subclasses to put together the actual HTTP request mappings.
DelegatingWebSocketConfiguration
A variation of WebSocketConfigurationSupport that detects implementations of WebSocketConfigurer in Spring configuration and invokes them in order to configure WebSocket request handling.
DelegatingWebSocketMessageBrokerConfiguration
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 .
ServletWebSocketHandlerRegistration
A helper class for configuring WebSocketHandler request handling including SockJS fallback options.
ServletWebSocketHandlerRegistry
WebSocketHandlerRegistry with Spring MVC handler mappings for the handshake requests.
SockJsServiceRegistration
A helper class for configuring SockJS fallback options for use with an EnableWebSocket and WebSocketConfigurer setup.
WebMvcStompEndpointRegistry
A registry for STOMP over WebSocket endpoints that maps the endpoints with a HandlerMapping for use in Spring MVC.
WebMvcStompWebSocketEndpointRegistration
An abstract base class for configuring STOMP over WebSocket/SockJS endpoints.
WebSocketConfigurationSupport
Configuration support for WebSocket request handling.
WebSocketMessageBrokerConfigurationSupport
Extends AbstractMessageBrokerConfiguration and adds configuration for receiving and responding to STOMP messages from WebSocket clients.
WebSocketTransportRegistration
Configure the processing of messages received from and sent to WebSocket clients.
Annotation Interfaces
EnableWebSocket
Add this annotation to an @Configuration class to configure processing WebSocket requests.
EnableWebSocketMessageBroker
Add this annotation to an @Configuration class to enable broker-backed messaging over WebSocket using a higher-level messaging sub-protocol.
Interfaces
StompEndpointRegistry
A contract for registering STOMP over WebSocket endpoints.
StompWebSocketEndpointRegistration
A contract for configuring a STOMP over WebSocket endpoint.
WebSocketConfigurer
Defines callback methods to configure the WebSocket request handling via @EnableWebSocket .
WebSocketHandlerRegistration
Provides methods for configuring a WebSocket handler.
WebSocketHandlerRegistry
Provides methods for configuring WebSocketHandler request mappings.
WebSocketMessageBrokerConfigurer
Defines methods for configuring message handling with simple messaging protocols (e.g.
handler
@NonNullApi @NonNullFields package org.springframework.web.socket.handler Convenient WebSocketHandler implementations and decorators.
Related Packages
org.springframework.web.socket
Common abstractions and Spring configuration support for WebSocket applications.
Classes
AbstractWebSocketHandler
A convenient base class for WebSocketHandler implementation with empty methods.
BeanCreatingHandlerProvider<T>
Instantiates a target handler through a Spring BeanFactory and also provides an equivalent destroy method.
BinaryWebSocketHandler
A convenient base class for WebSocketHandler implementations that process binary messages only.
ConcurrentWebSocketSessionDecorator
Wrap a WebSocketSession to guarantee only one thread can send messages at a time.
ExceptionWebSocketHandlerDecorator
An exception handling WebSocketHandlerDecorator .
LoggingWebSocketHandlerDecorator
A WebSocketHandlerDecorator that adds logging to WebSocket lifecycle events.
PerConnectionWebSocketHandler
A WebSocketHandler that initializes and destroys a WebSocketHandler instance for each WebSocket connection and delegates all other methods to it.
TextWebSocketHandler
A convenient base class for WebSocketHandler implementations that process text messages only.
WebSocketHandlerDecorator
Wraps another WebSocketHandler instance and delegates to it.
WebSocketSessionDecorator
Wraps another WebSocketSession instance and delegates to it.
Enum Classes
ConcurrentWebSocketSessionDecorator.OverflowStrategy
Enum for options of what to do when the buffer fills up.
Exceptions
SessionLimitExceededException
Raised when a WebSocket session has exceeded limits it has been configured for, e.g.
Interfaces
WebSocketHandlerDecoratorFactory
A factory for applying decorators to a WebSocketHandler.
messaging
@NonNullApi @NonNullFields package org.springframework.web.socket.messaging WebSocket integration for Spring's messaging module.
Related Packages
org.springframework.web.socket
Common abstractions and Spring configuration support for WebSocket applications.
Classes
AbstractSubProtocolEvent
A base class for events for a message received from a WebSocket client and parsed into a higher-level sub-protocol (e.g.
DefaultSimpUserRegistry
A default implementation of SimpUserRegistry that relies on AbstractSubProtocolEvent application context events to keep track of connected users and their subscriptions.
SessionConnectedEvent
A connected event represents the server response to a client's connect request.
SessionConnectEvent
Event raised when a new WebSocket client using a Simple Messaging Protocol (e.g.
SessionDisconnectEvent
Event raised when the session of a WebSocket client using a Simple Messaging Protocol (e.g.
SessionSubscribeEvent
Event raised when a new WebSocket client using a Simple Messaging Protocol (e.g.
SessionUnsubscribeEvent
Event raised when a new WebSocket client using a Simple Messaging Protocol (e.g.
StompSubProtocolErrorHandler
A SubProtocolErrorHandler for use with STOMP.
StompSubProtocolHandler
A SubProtocolHandler for STOMP that supports versions 1.0, 1.1, and 1.2 of the STOMP specification.
SubProtocolWebSocketHandler
An implementation of WebSocketHandler that delegates incoming WebSocket messages to a SubProtocolHandler along with a MessageChannel to which the sub-protocol handler can send messages from WebSocket clients to the application.
WebSocketAnnotationMethodMessageHandler
A subclass of SimpAnnotationMethodMessageHandler to provide support for ControllerAdvice with global @MessageExceptionHandler methods.
WebSocketStompClient
A STOMP over WebSocket client that connects using an implementation of WebSocketClient including SockJsClient .
Interfaces
StompSubProtocolHandler.Stats
Contract for access to session counters.
SubProtocolErrorHandler<P>
A contract for handling sub-protocol errors sent to clients.
SubProtocolHandler
A contract for handling WebSocket messages as part of a higher level protocol, referred to as "sub-protocol" in the WebSocket RFC specification.
SubProtocolWebSocketHandler.Stats
Contract for access to session counters.
server
server
@NonNullApi @NonNullFields package org.springframework.web.socket.server Server-side abstractions for WebSocket interactions.
Related Packages
org.springframework.web.socket
Common abstractions and Spring configuration support for WebSocket applications.
org.springframework.web.socket.server.jetty
Server-side support for the Jetty WebSocket API.
org.springframework.web.socket.server.standard
Server-side classes for use with standard JSR-356 WebSocket endpoints.
org.springframework.web.socket.server.support
Server-side support classes including container-specific strategies for upgrading a request.
Exceptions
HandshakeFailureException
Thrown when handshake processing failed to complete due to an internal, unrecoverable error.
Interfaces
HandshakeHandler
Contract for processing a WebSocket handshake request.
HandshakeInterceptor
Interceptor for WebSocket handshake requests.
RequestUpgradeStrategy
A server-specific strategy for performing the actual upgrade to a WebSocket exchange.
jetty
@NonNullApi @NonNullFields package org.springframework.web.socket.server.jetty Server-side support for the Jetty WebSocket API.
Related Packages
org.springframework.web.socket.server
Server-side abstractions for WebSocket interactions.
org.springframework.web.socket.server.standard
Server-side classes for use with standard JSR-356 WebSocket endpoints.
org.springframework.web.socket.server.support
Server-side support classes including container-specific strategies for upgrading a request.
Classes
JettyRequestUpgradeStrategy
A RequestUpgradeStrategy for Jetty 11.
standard
@NonNullApi @NonNullFields package org.springframework.web.socket.server.standard Server-side classes for use with standard JSR-356 WebSocket endpoints.
Related Packages
org.springframework.web.socket.server
Server-side abstractions for WebSocket interactions.
org.springframework.web.socket.server.jetty
Server-side support for the Jetty WebSocket API.
org.springframework.web.socket.server.support
Server-side support classes including container-specific strategies for upgrading a request.
Classes
AbstractStandardUpgradeStrategy
A base class for RequestUpgradeStrategy implementations that build on the standard WebSocket API for Java (JSR-356).
AbstractTyrusRequestUpgradeStrategy
A base class for RequestUpgradeStrategy implementations on top of JSR-356 based servers which include Tyrus as their WebSocket engine.
GlassFishRequestUpgradeStrategy
A WebSocket RequestUpgradeStrategy for Oracle's GlassFish 4.1 and higher.
ServerEndpointExporter
Detects beans of type ServerEndpointConfig and registers with the standard Jakarta WebSocket runtime.
ServerEndpointRegistration
An implementation of ServerEndpointConfig for use in Spring-based applications.
ServletServerContainerFactoryBean
A FactoryBean for configuring ServerContainer .
SpringConfigurator
A ServerEndpointConfig.Configurator for initializing ServerEndpoint -annotated classes through Spring.
StandardWebSocketUpgradeStrategy
A WebSocket RequestUpgradeStrategy for the Jakarta WebSocket API 2.1+.
TomcatRequestUpgradeStrategy
A WebSocket RequestUpgradeStrategy for Apache Tomcat.
UndertowRequestUpgradeStrategy
A WebSocket RequestUpgradeStrategy for WildFly and its underlying Undertow web server.
WebLogicRequestUpgradeStrategy
A WebSocket RequestUpgradeStrategy for Oracle's WebLogic.
WebSphereRequestUpgradeStrategy
WebSphere support for upgrading an HttpServletRequest during a WebSocket handshake.
support
@NonNullApi @NonNullFields package org.springframework.web.socket.server.support Server-side support classes including container-specific strategies for upgrading a request.
Related Packages
org.springframework.web.socket.server
Server-side abstractions for WebSocket interactions.
org.springframework.web.socket.server.jetty
Server-side support for the Jetty WebSocket API.
org.springframework.web.socket.server.standard
Server-side classes for use with standard JSR-356 WebSocket endpoints.
Classes
AbstractHandshakeHandler
A base class for HandshakeHandler implementations, independent of the Servlet API.
DefaultHandshakeHandler
A default HandshakeHandler implementation, extending AbstractHandshakeHandler with Servlet-specific initialization support.
HandshakeInterceptorChain
A helper class that assists with invoking a list of handshake interceptors.
HttpSessionHandshakeInterceptor
An interceptor to copy information from the HTTP session to the "handshake attributes" map to be made available via WebSocketSession.getAttributes() .
OriginHandshakeInterceptor
An interceptor to check request Origin header value against a collection of allowed origins.
WebSocketHandlerMapping
Extension of SimpleUrlHandlerMapping with support for more precise mapping of WebSocket handshake requests to handlers of type WebSocketHttpRequestHandler .
WebSocketHttpRequestHandler
A HttpRequestHandler for processing WebSocket handshake requests.
sockjs
sockjs
@NonNullApi @NonNullFields package org.springframework.web.socket.sockjs Top-level SockJS types.
Related Packages
org.springframework.web.socket
Common abstractions and Spring configuration support for WebSocket applications.
org.springframework.web.socket.sockjs.client
SockJS client implementation of WebSocketClient .
org.springframework.web.socket.sockjs.frame
Support classes for creating SockJS frames including the encoding and decoding of SockJS message frames.
org.springframework.web.socket.sockjs.support
Support classes for SockJS including an AbstractSockJsService implementation.
org.springframework.web.socket.sockjs.transport
Server-side support for SockJS transports including TransportHandler implementations for processing incoming requests, their session counterparts for sending messages over the various transports, and DefaultSockJsService .
Exceptions
SockJsException
Base class for exceptions raised while processing SockJS HTTP requests.
SockJsMessageDeliveryException
An exception thrown when a message frame was successfully received over an HTTP POST and parsed but one or more of the messages it contained could not be delivered to the WebSocketHandler either because the handler failed or because the connection got closed.
SockJsTransportFailureException
Indicates a serious failure that occurred in the SockJS implementation as opposed to in user code (e.g.
Interfaces
SockJsService
The main entry point for processing HTTP requests from SockJS clients.
client
@NonNullApi @NonNullFields package org.springframework.web.socket.sockjs.client SockJS client implementation of WebSocketClient.
Related Packages
org.springframework.web.socket.sockjs
Top-level SockJS types.
org.springframework.web.socket.sockjs.frame
Support classes for creating SockJS frames including the encoding and decoding of SockJS message frames.
org.springframework.web.socket.sockjs.support
Support classes for SockJS including an AbstractSockJsService implementation.
org.springframework.web.socket.sockjs.transport
Server-side support for SockJS transports including TransportHandler implementations for processing incoming requests, their session counterparts for sending messages over the various transports, and DefaultSockJsService .
Classes
AbstractClientSockJsSession
Base class for SockJS client implementations of WebSocketSession .
AbstractXhrTransport
Abstract base class for XHR transport implementations to extend.
JettyXhrTransport
An XHR transport based on Jetty's HttpClient .
RestTemplateXhrTransport
An XhrTransport implementation that uses a RestTemplate .
SockJsClient
A SockJS implementation of WebSocketClient with fallback alternatives that simulate a WebSocket interaction through plain HTTP streaming and long polling techniques.
SockJsUrlInfo
Container for the base URL of a SockJS endpoint with additional helper methods to derive related SockJS URLs: specifically, the info and transport URLs.
UndertowXhrTransport
An XHR transport based on Undertow's UndertowClient .
WebSocketClientSockJsSession
An extension of AbstractClientSockJsSession wrapping and delegating to an actual WebSocket session.
WebSocketTransport
A SockJS Transport that uses a WebSocketClient .
XhrClientSockJsSession
An extension of AbstractClientSockJsSession for use with HTTP transports simulating a WebSocket session.
Interfaces
InfoReceiver
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.
Transport
A client-side implementation for a SockJS transport.
TransportRequest
Exposes information, typically to Transport and session implementations, about a request to connect to a SockJS server endpoint over a given transport.
XhrTransport
A SockJS Transport that uses HTTP requests to simulate a WebSocket interaction.
frame
@NonNullApi @NonNullFields package org.springframework.web.socket.sockjs.frame Support classes for creating SockJS frames including the encoding and decoding of SockJS message frames.
Related Packages
org.springframework.web.socket.sockjs
Top-level SockJS types.
org.springframework.web.socket.sockjs.client
SockJS client implementation of WebSocketClient .
org.springframework.web.socket.sockjs.support
Support classes for SockJS including an AbstractSockJsService implementation.
org.springframework.web.socket.sockjs.transport
Server-side support for SockJS transports including TransportHandler implementations for processing incoming requests, their session counterparts for sending messages over the various transports, and DefaultSockJsService .
Classes
AbstractSockJsMessageCodec
A base class for SockJS message codec that provides an implementation of AbstractSockJsMessageCodec.encode(String[]) .
DefaultSockJsFrameFormat
A default implementation of SockJsFrameFormat that relies on String.format(String, Object...) ..
Jackson2SockJsMessageCodec
A Jackson 2.x codec for encoding and decoding SockJS messages.
SockJsFrame
Represents a SockJS frame.
Interfaces
SockJsFrameFormat
Applies a transport-specific format to the content of a SockJS frame resulting in a content that can be written out.
SockJsMessageCodec
Encode and decode messages to and from a SockJS message frame, essentially an array of JSON-encoded messages.
Enum Classes
SockJsFrameType
SockJS frame types.
support
@NonNullApi @NonNullFields package org.springframework.web.socket.sockjs.support Support classes for SockJS including an AbstractSockJsService implementation.
Related Packages
org.springframework.web.socket.sockjs
Top-level SockJS types.
org.springframework.web.socket.sockjs.client
SockJS client implementation of WebSocketClient .
org.springframework.web.socket.sockjs.frame
Support classes for creating SockJS frames including the encoding and decoding of SockJS message frames.
org.springframework.web.socket.sockjs.transport
Server-side support for SockJS transports including TransportHandler implementations for processing incoming requests, their session counterparts for sending messages over the various transports, and DefaultSockJsService .
Classes
AbstractSockJsService
An abstract base class for SockJsService implementations that provides SockJS path resolution and handling of static SockJS requests (e.g.
SockJsHttpRequestHandler
An HttpRequestHandler that allows mapping a SockJsService to requests in a Servlet container.
transport
transport
@NonNullApi @NonNullFields package org.springframework.web.socket.sockjs.transport Server-side support for SockJS transports including TransportHandler implementations for processing incoming requests, their session counterparts for sending messages over the various transports, and DefaultSockJsService.
Related Packages
org.springframework.web.socket.sockjs
Top-level SockJS types.
org.springframework.web.socket.sockjs.transport.handler
TransportHandler implementation classes as well as a concrete SockJsService .
org.springframework.web.socket.sockjs.transport.session
SockJS specific implementations of WebSocketSession .
org.springframework.web.socket.sockjs.client
SockJS client implementation of WebSocketClient .
org.springframework.web.socket.sockjs.frame
Support classes for creating SockJS frames including the encoding and decoding of SockJS message frames.
org.springframework.web.socket.sockjs.support
Support classes for SockJS including an AbstractSockJsService implementation.
Interfaces
SockJsServiceConfig
Provides transport handling code with access to the SockJsService configuration options they need to have access to.
SockJsSession
SockJS extension of Spring's standard WebSocketSession .
SockJsSessionFactory
A factory for creating a SockJS session.
TransportHandler
Handle a SockJS session URL, i.e.
Classes
TransportHandlingSockJsService
A basic implementation of SockJsService with support for SPI-based transport handling and session management.
Enum Classes
TransportType
SockJS transport types.
handler
@NonNullApi @NonNullFields package org.springframework.web.socket.sockjs.transport.handler TransportHandler implementation classes as well as a concrete SockJsService.
Related Packages
org.springframework.web.socket.sockjs.transport
Server-side support for SockJS transports including TransportHandler implementations for processing incoming requests, their session counterparts for sending messages over the various transports, and DefaultSockJsService .
org.springframework.web.socket.sockjs.transport.session
SockJS specific implementations of WebSocketSession .
Classes
AbstractHttpReceivingTransportHandler
Base class for HTTP transport handlers that receive messages via HTTP POST.
AbstractHttpSendingTransportHandler
Base class for HTTP transport handlers that push messages to connected clients.
AbstractTransportHandler
Common base class for TransportHandler implementations.
DefaultSockJsService
A default implementation of SockJsService with all default TransportHandler implementations pre-registered.
EventSourceTransportHandler
A TransportHandler for sending messages via Server-Sent Events: https://dev.w3.org/html5/eventsource/ .
HtmlFileTransportHandler
An HTTP TransportHandler that uses a famous browser document.domain technique.
SockJsWebSocketHandler
An implementation of WebSocketHandler that adds SockJS messages frames, sends SockJS heartbeat messages, and delegates lifecycle events and messages to a target WebSocketHandler .
WebSocketTransportHandler
WebSocket-based TransportHandler .
XhrPollingTransportHandler
A TransportHandler based on XHR (long) polling.
XhrReceivingTransportHandler
A TransportHandler that receives messages over HTTP.
XhrStreamingTransportHandler
A TransportHandler that sends messages over an HTTP streaming request.
session
@NonNullApi @NonNullFields package org.springframework.web.socket.sockjs.transport.session SockJS specific implementations of WebSocketSession.
Related Packages
org.springframework.web.socket.sockjs.transport
Server-side support for SockJS transports including TransportHandler implementations for processing incoming requests, their session counterparts for sending messages over the various transports, and DefaultSockJsService .
org.springframework.web.socket.sockjs.transport.handler
TransportHandler implementation classes as well as a concrete SockJsService .
Classes
AbstractHttpSockJsSession
An abstract base class for use with HTTP transport SockJS sessions.
AbstractSockJsSession
An abstract base class for SockJS sessions implementing SockJsSession .
PollingSockJsSession
A SockJS session for use with polling HTTP transports.
StreamingSockJsSession
A SockJS session for use with streaming HTTP transports.
WebSocketServerSockJsSession
A SockJS session for use with the WebSocket transport.
util
util
@NonNullApi @NonNullFields package org.springframework.web.util Miscellaneous web utility classes, such as HTML escaping and cookie handling.
Related Packages
org.springframework.web
Common, generic interfaces that define minimal boundary points between Spring's web infrastructure and other framework modules.
org.springframework.web.util.pattern
Dedicated support for matching HTTP request paths.
Classes
BindErrorUtils
Utility methods to resolve a list of MessageSourceResolvable s, and optionally join them.
ContentCachingRequestWrapper
HttpServletRequest wrapper that caches all content read from the input stream and reader , and allows this content to be retrieved via a byte array .
ContentCachingResponseWrapper
HttpServletResponse wrapper that caches all content written to the output stream and writer , and allows this content to be retrieved via a byte array .
CookieGenerator
Deprecated. as of 6.0 in favor of ResponseCookie
DefaultUriBuilderFactory
UriBuilderFactory that relies on UriComponentsBuilder for the actual building of the URI.
DisconnectedClientHelper
Utility methods to assist with identifying and logging exceptions that indicate the client has gone away.
ForwardedHeaderUtils
Utility class to assist with processing "Forwarded" and "X-Forwarded-*" headers.
HtmlUtils
Utility class for HTML escaping.
HttpSessionMutexListener
Servlet HttpSessionListener that automatically exposes the session mutex when an HttpSession gets created.
IntrospectorCleanupListener
Listener that flushes the JDK's JavaBeans Introspector cache on web app shutdown.
JavaScriptUtils
Utility class for JavaScript escaping.
ServletContextPropertyUtils
Helper class for resolving placeholders in texts.
ServletRequestPathUtils
Utility class to assist with preparation and access to the lookup path for request mapping purposes.
TagUtils
Utility class for tag library related code, exposing functionality such as translating Strings to web scopes.
UriComponents
Represents an immutable collection of URI components, mapping component type to String values.
UriComponentsBuilder
Builder for UriComponents .
UriTemplate
Representation of a URI template that can be expanded with URI variables via UriTemplate.expand(Map) , UriTemplate.expand(Object[]) , or matched to a URL via UriTemplate.match(String) .
UriUtils
Utility methods for URI encoding and decoding based on RFC 3986.
UrlPathHelper
Helper class for URL path matching.
WebAppRootListener
Listener that sets a system property to the web application root directory.
WebUtils
Miscellaneous utilities for web applications.
Enum Classes
DefaultUriBuilderFactory.EncodingMode
Enum to represent multiple URI encoding strategies.
Exceptions
NestedServletException
Deprecated. as of 6.0, in favor of standard ServletException nesting
Interfaces
UriBuilder
Builder-style methods to prepare and expand a URI template with variables.
UriBuilderFactory
Factory to create UriBuilder instances with shared configuration such as a base URI, an encoding mode strategy, and others across all URI builder instances created through a factory.
UriComponents.UriTemplateVariables
Defines the contract for URI Template variables.
UriTemplateHandler
Defines methods for expanding a URI template with variables.
pattern
@NonNullApi @NonNullFields package org.springframework.web.util.pattern Dedicated support for matching HTTP request paths. PathPatternParser is used to parse URI path patterns into org.springframework.web.util.pattern.PathPatterns that can then be used for matching purposes at request time.
Related Packages
org.springframework.web.util
Miscellaneous web utility classes, such as HTML escaping and cookie handling.
Classes
PathPattern
Representation of a parsed path pattern.
PathPattern.PathMatchInfo
Holder for URI variables and path parameters (matrix variables) extracted based on the pattern for a given matched path.
PathPattern.PathRemainingMatchInfo
Holder for the result of a match on the start of a pattern.
PathPatternParser
Parser for URI path patterns producing PathPattern instances that can then be matched to requests.
PathPatternRouteMatcher
RouteMatcher built on PathPatternParser that uses PathContainer and PathPattern as parsed representations of routes and patterns.
Exceptions
PatternParseException
Exception that is thrown when there is a problem with the pattern being parsed.
Enum Classes
PatternParseException.PatternMessage
The messages that can be included in a PatternParseException when there is a parse failure.
beans
beans
@NonNullApi @NonNullFields package org.springframework.beans This package contains interfaces and classes for manipulating Java beans. It is used by most other Spring packages. A BeanWrapper object may be used to set and get bean properties, singly or in bulk. The classes in this package are discussed in Chapter 11 of Expert One-On-One J2EE Design and Development by Rod Johnson (Wrox, 2002).
Related Packages
org.springframework.beans.factory
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
org.springframework.beans.propertyeditors
Properties editors used to convert from String values to object types such as java.util.Properties.
org.springframework.beans.support
Classes supporting the org.springframework.beans package, such as utility classes for sorting and holding lists of beans.
Classes
AbstractNestablePropertyAccessor
A basic ConfigurablePropertyAccessor that provides the necessary infrastructure for all typical use cases.
AbstractNestablePropertyAccessor.PropertyHandler
A handler for a specific property.
AbstractNestablePropertyAccessor.PropertyTokenHolder
Holder class used to store property tokens.
AbstractPropertyAccessor
Abstract implementation of the PropertyAccessor interface.
BeanMetadataAttribute
Holder for a key-value style attribute that is part of a bean definition.
BeanMetadataAttributeAccessor
Extension of AttributeAccessorSupport , holding attributes as BeanMetadataAttribute objects in order to keep track of the definition source.
BeanUtils
Static convenience methods for JavaBeans: for instantiating beans, checking bean property types, copying bean properties, etc.
BeanWrapperImpl
Default BeanWrapper implementation that should be sufficient for all typical use cases.
CachedIntrospectionResults
Internal class that caches JavaBeans PropertyDescriptor information for a Java class.
DirectFieldAccessor
ConfigurablePropertyAccessor implementation that directly accesses instance fields.
ExtendedBeanInfoFactory
Extension of StandardBeanInfoFactory that supports "non-standard" JavaBeans setter methods through introspection by Spring's (package-visible) ExtendedBeanInfo implementation.
MutablePropertyValues
The default implementation of the PropertyValues interface.
PropertyAccessorFactory
Simple factory facade for obtaining PropertyAccessor instances, in particular for BeanWrapper instances.
PropertyAccessorUtils
Utility methods for classes that perform bean property access according to the PropertyAccessor interface.
PropertyEditorRegistrySupport
Base implementation of the PropertyEditorRegistry interface.
PropertyMatches
Helper class for calculating property matches, according to a configurable distance.
PropertyValue
Object to hold information and value for an individual bean property.
PropertyValuesEditor
Editor for a PropertyValues object.
SimpleTypeConverter
Simple implementation of the TypeConverter interface that does not operate on a specific target object.
StandardBeanInfoFactory
BeanInfoFactory implementation that performs standard Introspector inspection.
TypeConverterSupport
Base implementation of the TypeConverter interface, using a package-private delegate.
Interfaces
BeanInfoFactory
Strategy interface for creating BeanInfo instances for Spring beans.
BeanMetadataElement
Interface to be implemented by bean metadata elements that carry a configuration source object.
BeanWrapper
The central interface of Spring's low-level JavaBeans infrastructure.
ConfigurablePropertyAccessor
Interface that encapsulates configuration methods for a PropertyAccessor.
Mergeable
Interface representing an object whose value set can be merged with that of a parent object.
PropertyAccessor
Common interface for classes that can access named properties (such as bean properties of an object or fields in an object).
PropertyEditorRegistrar
Interface for strategies that register custom property editors with a property editor registry .
PropertyEditorRegistry
Encapsulates methods for registering JavaBeans PropertyEditors .
PropertyValues
Holder containing one or more PropertyValue objects, typically comprising one update for a specific target bean.
TypeConverter
Interface that defines type conversion methods.
Exceptions
BeanInstantiationException
Exception thrown when instantiation of a bean failed.
BeansException
Abstract superclass for all exceptions thrown in the beans package and subpackages.
ConversionNotSupportedException
Exception thrown when no suitable editor or converter can be found for a bean property.
FatalBeanException
Thrown on an unrecoverable problem encountered in the beans packages or sub-packages, e.g.
InvalidPropertyException
Exception thrown when referring to an invalid bean property.
MethodInvocationException
Thrown when a bean property getter or setter method throws an exception, analogous to an InvocationTargetException.
NotReadablePropertyException
Exception thrown on an attempt to get the value of a property that isn't readable, because there's no getter method.
NotWritablePropertyException
Exception thrown on an attempt to set the value of a property that is not writable (typically because there is no setter method).
NullValueInNestedPathException
Exception thrown when navigation of a valid nested property path encounters a NullPointerException.
PropertyAccessException
Superclass for exceptions related to a property access, such as type mismatch or invocation target exception.
PropertyBatchUpdateException
Combined exception, composed of individual PropertyAccessException instances.
TypeMismatchException
Exception thrown on a type mismatch when trying to set a bean property.
factory
factory
@NonNullApi @NonNullFields package org.springframework.beans.factory The core package implementing Spring's lightweight Inversion of Control (IoC) container. Provides an alternative to the Singleton and Prototype design patterns, including a consistent approach to configuration management. Builds on the org.springframework.beans package. This package and related packages are discussed in Chapter 11 of Expert One-On-One J2EE Design and Development by Rod Johnson (Wrox, 2002).
Related Packages
org.springframework.beans
This package contains interfaces and classes for manipulating Java beans.
org.springframework.beans.factory.annotation
Support package for annotation-driven bean configuration.
org.springframework.beans.factory.aot
AOT support for bean factories.
org.springframework.beans.factory.aspectj
AspectJ-based dependency injection support.
org.springframework.beans.factory.config
SPI interfaces and configuration-related convenience classes for bean factories.
org.springframework.beans.factory.groovy
Support package for Groovy-based bean definitions.
org.springframework.beans.factory.parsing
Support infrastructure for bean definition parsing.
org.springframework.beans.factory.serviceloader
Support package for the Java ServiceLoader facility.
org.springframework.beans.factory.support
Classes supporting the org.springframework.beans.factory package.
org.springframework.beans.factory.wiring
Mechanism to determine bean wiring metadata from a bean instance.
org.springframework.beans.factory.xml
Contains an abstract XML-based BeanFactory implementation, including a standard "spring-beans" XSD.
Interfaces
Aware
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.
BeanClassLoaderAware
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.
BeanFactory
The root interface for accessing a Spring bean container.
BeanFactoryAware
Interface to be implemented by beans that wish to be aware of their owning BeanFactory .
BeanNameAware
Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean
Interface to be implemented by beans that want to release resources on destruction.
FactoryBean<T>
Interface to be implemented by objects used within a BeanFactory which are themselves factories for individual objects.
HierarchicalBeanFactory
Sub-interface implemented by bean factories that can be part of a hierarchy.
InitializingBean
Interface to be implemented by beans that need to react once all their properties have been set by a BeanFactory : e.g.
ListableBeanFactory
Extension of the BeanFactory interface to be implemented by bean factories that can enumerate all their bean instances, rather than attempting bean lookup by name one by one as requested by clients.
NamedBean
Counterpart of BeanNameAware .
ObjectFactory<T>
Defines a factory which can return an Object instance (possibly shared or independent) when invoked.
ObjectProvider<T>
A variant of ObjectFactory designed specifically for injection points, allowing for programmatic optionality and lenient not-unique handling.
SmartFactoryBean<T>
Extension of the FactoryBean interface.
SmartInitializingSingleton
Callback interface triggered at the end of the singleton pre-instantiation phase during BeanFactory bootstrap.
Exceptions
BeanCreationException
Exception thrown when a BeanFactory encounters an error when attempting to create a bean from a bean definition.
BeanCreationNotAllowedException
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).
BeanCurrentlyInCreationException
Exception thrown in case of a reference to a bean that's currently in creation.
BeanDefinitionStoreException
Exception thrown when a BeanFactory encounters an invalid bean definition: e.g.
BeanExpressionException
Exception that indicates an expression evaluation attempt having failed.
BeanInitializationException
Exception that a bean implementation is suggested to throw if its own factory-aware initialization code fails.
BeanIsAbstractException
Exception thrown when a bean instance has been requested for a bean definition which has been marked as abstract.
BeanIsNotAFactoryException
Exception thrown when a bean is not a factory, but a user tries to get at the factory for the given bean name.
BeanNotOfRequiredTypeException
Thrown when a bean doesn't match the expected type.
CannotLoadBeanClassException
Exception thrown when the BeanFactory cannot load the specified class of a given bean.
FactoryBeanNotInitializedException
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.
NoSuchBeanDefinitionException
Exception thrown when a BeanFactory is asked for a bean instance for which it cannot find a definition.
NoUniqueBeanDefinitionException
Exception thrown when a BeanFactory is asked for a bean instance for which multiple matching candidates have been found when only one matching bean was expected.
UnsatisfiedDependencyException
Exception thrown when a bean depends on other beans or simple properties that were not specified in the bean factory definition, although dependency checking was enabled.
Classes
BeanFactoryUtils
Convenience methods operating on bean factories, in particular on the ListableBeanFactory interface.
InjectionPoint
A simple descriptor for an injection point, pointing to a method/constructor parameter or a field.
annotation
@NonNullApi @NonNullFields package org.springframework.beans.factory.annotation Support package for annotation-driven bean configuration.
Related Packages
org.springframework.beans.factory
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
Interfaces
AnnotatedBeanDefinition
Extended BeanDefinition interface that exposes AnnotationMetadata about its bean class - without requiring the class to be loaded yet.
Classes
AnnotatedGenericBeanDefinition
Extension of the GenericBeanDefinition class, adding support for annotation metadata exposed through the AnnotatedBeanDefinition interface.
AnnotationBeanWiringInfoResolver
BeanWiringInfoResolver that uses the Configurable annotation to identify which classes need autowiring.
AutowiredAnnotationBeanPostProcessor
BeanPostProcessor implementation that autowires annotated fields, setter methods, and arbitrary config methods.
BeanFactoryAnnotationUtils
Convenience methods performing bean lookups related to Spring-specific annotations, for example Spring's @Qualifier annotation.
CustomAutowireConfigurer
A BeanFactoryPostProcessor implementation that allows for convenient registration of custom autowire qualifier types.
InitDestroyAnnotationBeanPostProcessor
BeanPostProcessor implementation that invokes annotated init and destroy methods.
InjectionMetadata
Internal class for managing injection metadata.
InjectionMetadata.InjectedElement
A single injected element.
ParameterResolutionDelegate
Public delegate for resolving autowirable parameters on externally managed constructors and methods.
QualifierAnnotationAutowireCandidateResolver
AutowireCandidateResolver implementation that matches bean definition qualifiers against qualifier annotations on the field or parameter to be autowired.
Enum Classes
Autowire
Enumeration determining autowiring status: that is, whether a bean should have its dependencies automatically injected by the Spring container using setter injection.
Annotation Interfaces
Autowired
Marks a constructor, field, setter method, or config method as to be autowired by Spring's dependency injection facilities.
Configurable
Marks a class as being eligible for Spring-driven configuration.
Lookup
An annotation that indicates 'lookup' methods, to be overridden by the container to redirect them back to the BeanFactory for a getBean call.
Qualifier
This annotation may be used on a field or parameter as a qualifier for candidate beans when autowiring.
Value
Annotation used at the field or method/constructor parameter level that indicates a default value expression for the annotated element.
aot
@NonNullApi @NonNullFields package org.springframework.beans.factory.aot AOT support for bean factories.
Related Packages
org.springframework.beans.factory
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
Classes
AotServices<T>
A collection of AOT services that can be loaded from a SpringFactoriesLoader or obtained from a ListableBeanFactory .
AotServices.Loader
Loader class used to actually load the services.
AutowiredArgumentsCodeGenerator
Code generator to apply AutowiredArguments .
AutowiredFieldValueResolver
Resolver used to support the autowiring of fields.
AutowiredMethodArgumentsResolver
Resolver used to support the autowiring of methods.
BeanInstanceSupplier<T>
Specialized InstanceSupplier that provides the factory Method used to instantiate the underlying bean instance, if any.
BeanRegistrationCodeFragmentsDecorator
A BeanRegistrationCodeFragments decorator implementation.
InstanceSupplierCodeGenerator
Default code generator to create an InstanceSupplier , usually in the form of a BeanInstanceSupplier that retains the executable that is used to instantiate the bean.
Enum Classes
AotServices.Source
Sources from which services were obtained.
Interfaces
AutowiredArguments
Resolved arguments to be autowired.
BeanFactoryInitializationAotContribution
AOT contribution from a BeanFactoryInitializationAotProcessor used to initialize a bean factory.
BeanFactoryInitializationAotProcessor
AOT processor that makes bean factory initialization contributions by processing ConfigurableListableBeanFactory instances.
BeanFactoryInitializationCode
Interface that can be used to configure the code that will be generated to perform bean factory initialization.
BeanRegistrationAotContribution
AOT contribution from a BeanRegistrationAotProcessor used to register a single bean definition.
BeanRegistrationAotProcessor
AOT processor that makes bean registration contributions by processing RegisteredBean instances.
BeanRegistrationCode
Interface that can be used to configure the code that will be generated to perform registration of a single bean.
BeanRegistrationCodeFragments
Generate the various fragments of code needed to register a bean.
BeanRegistrationExcludeFilter
Filter that can be used to exclude AOT processing of a RegisteredBean .
BeanRegistrationsCode
Interface that can be used to configure the code that will be generated to register beans.
aspectj
@NonNullApi @NonNullFields package org.springframework.beans.factory.aspectj AspectJ-based dependency injection support.
Related Packages
org.springframework.beans.factory
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
Interfaces
ConfigurableObject
Marker interface for domain objects that need DI through aspects.
config
@NonNullApi @NonNullFields package org.springframework.beans.factory.config SPI interfaces and configuration-related convenience classes for bean factories.
Related Packages
org.springframework.beans.factory
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
Classes
AbstractFactoryBean<T>
Simple template superclass for FactoryBean implementations that creates a singleton or a prototype object, depending on a flag.
AutowiredPropertyMarker
Simple marker class for an individually autowired property value, to be added to BeanDefinition.getPropertyValues() for a specific bean property.
BeanDefinitionHolder
Holder for a BeanDefinition with name and aliases.
BeanDefinitionVisitor
Visitor class for traversing BeanDefinition objects, in particular the property values and constructor argument values contained in them, resolving bean metadata values.
BeanExpressionContext
Context object for evaluating an expression within a bean definition.
ConstructorArgumentValues
Holder for constructor argument values, typically as part of a bean definition.
ConstructorArgumentValues.ValueHolder
Holder for a constructor argument value, with an optional type attribute indicating the target type of the actual constructor argument.
CustomEditorConfigurer
BeanFactoryPostProcessor implementation that allows for convenient registration of custom property editors .
CustomScopeConfigurer
Simple BeanFactoryPostProcessor implementation that registers custom Scope(s) with the containing ConfigurableBeanFactory .
DependencyDescriptor
Descriptor for a specific dependency that is about to be injected.
DeprecatedBeanWarner
Bean factory post processor that logs a warning for @Deprecated beans.
EmbeddedValueResolver
StringValueResolver adapter for resolving placeholders and expressions against a ConfigurableBeanFactory .
FieldRetrievingFactoryBean
FactoryBean which retrieves a static or non-static field value.
ListFactoryBean
Simple factory for shared List instances.
MapFactoryBean
Simple factory for shared Map instances.
MethodInvokingBean
Simple method invoker bean: just invoking a target method, not expecting a result to expose to the container (in contrast to MethodInvokingFactoryBean ).
MethodInvokingFactoryBean
FactoryBean which returns a value which is the result of a static or instance method invocation.
NamedBeanHolder<T>
A simple holder for a given bean name plus bean instance.
ObjectFactoryCreatingFactoryBean
A FactoryBean implementation that returns a value which is an ObjectFactory that in turn returns a bean sourced from a BeanFactory .
PlaceholderConfigurerSupport
Abstract base class for property resource configurers that resolve placeholders in bean definition property values.
PreferencesPlaceholderConfigurer
Deprecated. as of 5.2, along with PropertyPlaceholderConfigurer
PropertiesFactoryBean
Allows for making a properties file from a classpath location available as Properties instance in a bean factory.
PropertyOverrideConfigurer
Property resource configurer that overrides bean property values in an application context definition.
PropertyPathFactoryBean
FactoryBean that evaluates a property path on a given target object.
PropertyPlaceholderConfigurer
Deprecated. as of 5.2; use org.springframework.context.support.PropertySourcesPlaceholderConfigurer instead which is more flexible through taking advantage of the Environment and PropertySource mechanisms.
PropertyResourceConfigurer
Allows for configuration of individual bean property values from a property resource, i.e.
ProviderCreatingFactoryBean
A FactoryBean implementation that returns a value which is a JSR-330 Provider that in turn returns a bean sourced from a BeanFactory .
RuntimeBeanNameReference
Immutable placeholder class used for a property value object when it's a reference to another bean name in the factory, to be resolved at runtime.
RuntimeBeanReference
Immutable placeholder class used for a property value object when it's a reference to another bean in the factory, to be resolved at runtime.
ServiceLocatorFactoryBean
A FactoryBean implementation that takes an interface which must have one or more methods with the signatures MyType xxx() or MyType xxx(MyIdType id) (typically, MyService getService() or MyService getService(String id) ) and creates a dynamic proxy which implements that interface, delegating to an underlying BeanFactory .
SetFactoryBean
Simple factory for shared Set instances.
TypedStringValue
Holder for a typed String value.
YamlMapFactoryBean
Factory for a Map that reads from a YAML source, preserving the YAML-declared value types and their structure.
YamlProcessor
Base class for YAML factories.
YamlPropertiesFactoryBean
Factory for Properties that reads from a YAML source, exposing a flat structure of String property values.
Interfaces
AutowireCapableBeanFactory
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.
BeanDefinition
A BeanDefinition describes a bean instance, which has property values, constructor argument values, and further information supplied by concrete implementations.
BeanDefinitionCustomizer
Callback for customizing a given bean definition.
BeanExpressionResolver
Strategy interface for resolving a value by evaluating it as an expression, if applicable.
BeanFactoryPostProcessor
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.
BeanPostProcessor
Factory hook that allows for custom modification of new bean instances — for example, checking for marker interfaces or wrapping beans with proxies.
BeanReference
Interface that exposes a reference to a bean name in an abstract fashion.
ConfigurableBeanFactory
Configuration interface to be implemented by most bean factories.
ConfigurableListableBeanFactory
Configuration interface to be implemented by most listable bean factories.
DestructionAwareBeanPostProcessor
Subinterface of BeanPostProcessor that adds a before-destruction callback.
InstantiationAwareBeanPostProcessor
Subinterface of BeanPostProcessor that adds a before-instantiation callback, and a callback after instantiation but before explicit properties are set or autowiring occurs.
Scope
Strategy interface used by a ConfigurableBeanFactory , representing a target scope to hold bean instances in.
SingletonBeanRegistry
Interface that defines a registry for shared bean instances.
SmartInstantiationAwareBeanPostProcessor
Extension of the InstantiationAwareBeanPostProcessor interface, adding a callback for predicting the eventual type of a processed bean.
YamlProcessor.DocumentMatcher
Strategy interface used to test if properties match.
YamlProcessor.MatchCallback
Callback interface used to process the YAML parsing results.
Enum Classes
YamlProcessor.MatchStatus
Status returned from YamlProcessor.DocumentMatcher.matches(java.util.Properties) .
YamlProcessor.ResolutionMethod
Method to use for resolving resources.
groovy
@NonNullApi @NonNullFields package org.springframework.beans.factory.groovy Support package for Groovy-based bean definitions.
Related Packages
org.springframework.beans.factory
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
Classes
GroovyBeanDefinitionReader
A Groovy-based reader for Spring bean definitions: like a Groovy builder, but more of a DSL for Spring configuration.
parsing
@NonNullApi @NonNullFields package org.springframework.beans.factory.parsing Support infrastructure for bean definition parsing.
Related Packages
org.springframework.beans.factory
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
Classes
AbstractComponentDefinition
Base implementation of ComponentDefinition that provides a basic implementation of AbstractComponentDefinition.getDescription() which delegates to ComponentDefinition.getName() .
AliasDefinition
Representation of an alias that has been registered during the parsing process.
BeanComponentDefinition
ComponentDefinition based on a standard BeanDefinition, exposing the given bean definition as well as inner bean definitions and bean references for the given bean.
BeanEntry
ParseState entry representing a bean definition.
CompositeComponentDefinition
ComponentDefinition implementation that holds one or more nested ComponentDefinition instances, aggregating them into a named group of components.
ConstructorArgumentEntry
ParseState entry representing a (possibly indexed) constructor argument.
EmptyReaderEventListener
Empty implementation of the ReaderEventListener interface, providing no-op implementations of all callback methods.
FailFastProblemReporter
Simple ProblemReporter implementation that exhibits fail-fast behavior when errors are encountered.
ImportDefinition
Representation of an import that has been processed during the parsing process.
Location
Class that models an arbitrary location in a resource .
NullSourceExtractor
Simple implementation of SourceExtractor that returns null as the source metadata.
ParseState
Simple ArrayDeque -based structure for tracking the logical position during a parsing process.
PassThroughSourceExtractor
Simple SourceExtractor implementation that just passes the candidate source metadata object through for attachment.
Problem
Represents a problem with a bean definition configuration.
PropertyEntry
ParseState entry representing a JavaBean property.
QualifierEntry
ParseState entry representing an autowire candidate qualifier.
ReaderContext
Context that gets passed along a bean definition reading process, encapsulating all relevant configuration as well as state.
Exceptions
BeanDefinitionParsingException
Exception thrown when a bean definition reader encounters an error during the parsing process.
Interfaces
ComponentDefinition
Interface that describes the logical view of a set of BeanDefinitions and BeanReferences as presented in some configuration context.
DefaultsDefinition
Marker interface for a defaults definition, extending BeanMetadataElement to inherit source exposure.
ParseState.Entry
Marker interface for entries into the ParseState .
ProblemReporter
SPI interface allowing tools and other external processes to handle errors and warnings reported during bean definition parsing.
ReaderEventListener
Interface that receives callbacks for component, alias and import registrations during a bean definition reading process.
SourceExtractor
Simple strategy allowing tools to control how source metadata is attached to the bean definition metadata.
serviceloader
@NonNullApi @NonNullFields package org.springframework.beans.factory.serviceloader Support package for the Java ServiceLoader facility.
Related Packages
org.springframework.beans.factory
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
Classes
AbstractServiceLoaderBasedFactoryBean
Abstract base class for FactoryBeans operating on the JDK 1.6 ServiceLoader facility.
ServiceFactoryBean
FactoryBean that exposes the 'primary' service for the configured service class, obtained through the JDK 1.6 ServiceLoader facility.
ServiceListFactoryBean
FactoryBean that exposes all services for the configured service class, represented as a List of service objects, obtained through the JDK 1.6 ServiceLoader facility.
ServiceLoaderFactoryBean
FactoryBean that exposes the JDK 1.6 ServiceLoader for the configured service class.
support
@NonNullApi @NonNullFields package org.springframework.beans.factory.support Classes supporting the org.springframework.beans.factory package. Contains abstract base classes for BeanFactory implementations.
Related Packages
org.springframework.beans.factory
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
Classes
AbstractAutowireCapableBeanFactory
Abstract bean factory superclass that implements default bean creation, with the full capabilities specified by the RootBeanDefinition class.
AbstractBeanDefinition
Base class for concrete, full-fledged BeanDefinition classes, factoring out common properties of GenericBeanDefinition , RootBeanDefinition , and ChildBeanDefinition .
AbstractBeanDefinitionReader
Abstract base class for bean definition readers which implement the BeanDefinitionReader interface.
AbstractBeanFactory
Abstract base class for BeanFactory implementations, providing the full capabilities of the ConfigurableBeanFactory SPI.
AutowireCandidateQualifier
Qualifier for resolving autowire candidates.
BeanDefinitionBuilder
Programmatic means of constructing BeanDefinitions using the builder pattern.
BeanDefinitionDefaults
A simple holder for BeanDefinition property defaults.
BeanDefinitionReaderUtils
Utility methods that are useful for bean definition reader implementations.
BeanDefinitionValueResolver
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.
CglibSubclassingInstantiationStrategy
Default object instantiation strategy for use in BeanFactories.
ChildBeanDefinition
Bean definition for beans which inherit settings from their parent.
DefaultBeanNameGenerator
Default implementation of the BeanNameGenerator interface, delegating to BeanDefinitionReaderUtils.generateBeanName(BeanDefinition, BeanDefinitionRegistry) .
DefaultListableBeanFactory
Spring's default implementation of the ConfigurableListableBeanFactory and BeanDefinitionRegistry interfaces: a full-fledged bean factory based on bean definition metadata, extensible through post-processors.
DefaultSingletonBeanRegistry
Generic registry for shared bean instances, implementing the SingletonBeanRegistry .
FactoryBeanRegistrySupport
Support base class for singleton registries which need to handle FactoryBean instances, integrated with DefaultSingletonBeanRegistry 's singleton management.
GenericBeanDefinition
GenericBeanDefinition is a one-stop shop for declarative bean definition purposes.
GenericTypeAwareAutowireCandidateResolver
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.
LookupOverride
Represents an override of a method that looks up an object in the same IoC context, either by bean name or by bean type (based on the declared method return type).
ManagedArray
Tag collection class used to hold managed array elements, which may include runtime bean references (to be resolved into bean objects).
ManagedList<E>
Tag collection class used to hold managed List elements, which may include runtime bean references (to be resolved into bean objects).
ManagedMap<K, V>
Tag collection class used to hold managed Map values, which may include runtime bean references (to be resolved into bean objects).
ManagedProperties
Tag class which represents a Spring-managed Properties instance that supports merging of parent/child definitions.
ManagedSet<E>
Tag collection class used to hold managed Set values, which may include runtime bean references (to be resolved into bean objects).
MethodOverride
Object representing the override of a method on a managed object by the IoC container.
MethodOverrides
Set of method overrides, determining which, if any, methods on a managed object the Spring IoC container will override at runtime.
PropertiesBeanDefinitionReader
Deprecated. as of 5.3, in favor of Spring's common bean definition formats and/or custom reader implementations
RegisteredBean
A RegisteredBean represents a bean that has been registered with a BeanFactory , but has not necessarily been instantiated.
ReplaceOverride
Extension of MethodOverride that represents an arbitrary override of a method by the IoC container.
RootBeanDefinition
A root bean definition represents the merged bean definition at runtime that backs a specific bean in a Spring BeanFactory.
SimpleAutowireCandidateResolver
AutowireCandidateResolver implementation to use when no annotation support is available.
SimpleBeanDefinitionRegistry
Simple implementation of the BeanDefinitionRegistry interface.
SimpleInstantiationStrategy
Simple object instantiation strategy for use in a BeanFactory.
StaticListableBeanFactory
Static BeanFactory implementation which allows one to register existing singleton instances programmatically.
Interfaces
AutowireCandidateResolver
Strategy interface for determining whether a specific bean definition qualifies as an autowire candidate for a specific dependency.
BeanDefinitionReader
Simple interface for bean definition readers that specifies load methods with Resource and String location parameters.
BeanDefinitionRegistry
Interface for registries that hold bean definitions, for example RootBeanDefinition and ChildBeanDefinition instances.
BeanDefinitionRegistryPostProcessor
Extension to the standard BeanFactoryPostProcessor SPI, allowing for the registration of further bean definitions before regular BeanFactoryPostProcessor detection kicks in.
BeanNameGenerator
Strategy interface for generating bean names for bean definitions.
InstanceSupplier<T>
Specialized Supplier that can be set on a BeanDefinition when details about the registered bean are needed to supply the instance.
InstantiationStrategy
Interface responsible for creating instances corresponding to a root bean definition.
MergedBeanDefinitionPostProcessor
Post-processor callback interface for merged bean definitions at runtime.
MethodReplacer
Interface to be implemented by classes that can reimplement any method on an IoC-managed object: the Method Injection form of Dependency Injection.
Exceptions
BeanDefinitionOverrideException
Subclass of BeanDefinitionStoreException indicating an invalid override attempt: typically registering a new definition for the same bean name while DefaultListableBeanFactory.isAllowBeanDefinitionOverriding() is false .
BeanDefinitionValidationException
Exception thrown when the validation of a bean definition failed.
ScopeNotActiveException
A subclass of BeanCreationException which indicates that the target scope is not active, e.g.
wiring
@NonNullApi @NonNullFields package org.springframework.beans.factory.wiring Mechanism to determine bean wiring metadata from a bean instance. Foundation for aspect-driven bean configuration.
Related Packages
org.springframework.beans.factory
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
Classes
BeanConfigurerSupport
Convenient base class for bean configurers that can perform Dependency Injection on objects (however they may be created).
BeanWiringInfo
Holder for bean wiring metadata information about a particular class.
ClassNameBeanWiringInfoResolver
Simple default implementation of the BeanWiringInfoResolver interface, looking for a bean with the same name as the fully-qualified class name.
Interfaces
BeanWiringInfoResolver
Strategy interface to be implemented by objects than can resolve bean name information, given a newly instantiated bean object.
xml
@NonNullApi @NonNullFields package org.springframework.beans.factory.xml Contains an abstract XML-based BeanFactory implementation, including a standard "spring-beans" XSD.
Related Packages
org.springframework.beans.factory
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
Classes
AbstractBeanDefinitionParser
Abstract BeanDefinitionParser implementation providing a number of convenience methods and a template method that subclasses must override to provide the actual parsing logic.
AbstractSimpleBeanDefinitionParser
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.
AbstractSingleBeanDefinitionParser
Base class for those BeanDefinitionParser implementations that need to parse and define just a single BeanDefinition .
BeanDefinitionParserDelegate
Stateful delegate class used to parse XML bean definitions.
BeansDtdResolver
EntityResolver implementation for the Spring beans DTD, to load the DTD from the Spring class path (or JAR file).
DefaultBeanDefinitionDocumentReader
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).
DefaultDocumentLoader
Spring's default DocumentLoader implementation.
DefaultNamespaceHandlerResolver
Default implementation of the NamespaceHandlerResolver interface.
DelegatingEntityResolver
EntityResolver implementation that delegates to a BeansDtdResolver and a PluggableSchemaResolver for DTDs and XML schemas, respectively.
DocumentDefaultsDefinition
Simple JavaBean that holds the defaults specified at the level in a standard Spring XML bean definition document: default-lazy-init , default-autowire , etc.
NamespaceHandlerSupport
Support class for implementing custom NamespaceHandlers .
ParserContext
Context that gets passed along a bean definition parsing process, encapsulating all relevant configuration as well as state.
PluggableSchemaResolver
EntityResolver implementation that attempts to resolve schema URLs into local classpath resources using a set of mappings files.
ResourceEntityResolver
EntityResolver implementation that tries to resolve entity references through a ResourceLoader (usually, relative to the resource base of an ApplicationContext ), if applicable.
SimpleConstructorNamespaceHandler
Simple NamespaceHandler implementation that maps custom attributes directly through to bean properties.
SimplePropertyNamespaceHandler
Simple NamespaceHandler implementation that maps custom attributes directly through to bean properties.
UtilNamespaceHandler
NamespaceHandler for the util namespace.
XmlBeanDefinitionReader
Bean definition reader for XML bean definitions.
XmlReaderContext
Extension of ReaderContext , specific to use with an XmlBeanDefinitionReader .
Interfaces
BeanDefinitionDecorator
Interface used by the DefaultBeanDefinitionDocumentReader to handle custom, nested (directly under a ) tags.
BeanDefinitionDocumentReader
SPI for parsing an XML document that contains Spring bean definitions.
BeanDefinitionParser
Interface used by the DefaultBeanDefinitionDocumentReader to handle custom, top-level (directly under ) tags.
DocumentLoader
Strategy interface for loading an XML Document .
NamespaceHandler
Base interface used by the DefaultBeanDefinitionDocumentReader for handling custom namespaces in a Spring XML configuration file.
NamespaceHandlerResolver
Used by the DefaultBeanDefinitionDocumentReader to locate a NamespaceHandler implementation for a particular namespace URI.
Exceptions
XmlBeanDefinitionStoreException
XML-specific BeanDefinitionStoreException subclass that wraps a SAXException , typically a SAXParseException which contains information about the error location.
propertyeditors
@NonNullApi @NonNullFields package org.springframework.beans.propertyeditors Properties editors used to convert from String values to object types such as java.util.Properties. Some of these editors are registered automatically by BeanWrapperImpl. "CustomXxxEditor" classes are intended for manual registration in specific binding processes, as they are localized or the like.
Related Packages
org.springframework.beans
This package contains interfaces and classes for manipulating Java beans.
org.springframework.beans.factory
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
org.springframework.beans.support
Classes supporting the org.springframework.beans package, such as utility classes for sorting and holding lists of beans.
Classes
ByteArrayPropertyEditor
Editor for byte arrays.
CharacterEditor
Editor for a Character , to populate a property of type Character or char from a String value.
CharArrayPropertyEditor
Editor for char arrays.
CharsetEditor
Editor for java.nio.charset.Charset , translating charset String representations into Charset objects and back.
ClassArrayEditor
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.
ClassEditor
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.
CurrencyEditor
Editor for java.util.Currency , translating currency codes into Currency objects.
CustomBooleanEditor
Property editor for Boolean/boolean properties.
CustomCollectionEditor
Property editor for Collections, converting any source Collection to a given target Collection type.
CustomDateEditor
Property editor for java.util.Date , supporting a custom java.text.DateFormat .
CustomMapEditor
Property editor for Maps, converting any source Map to a given target Map type.
CustomNumberEditor
Property editor for any Number subclass such as Short, Integer, Long, BigInteger, Float, Double, BigDecimal.
FileEditor
Editor for java.io.File , to directly populate a File property from a Spring resource location.
InputSourceEditor
Editor for org.xml.sax.InputSource , converting from a Spring resource location String to a SAX InputSource object.
InputStreamEditor
One-way PropertyEditor which can convert from a text String to a java.io.InputStream , interpreting the given String as a Spring resource location (e.g.
LocaleEditor
Editor for java.util.Locale , to directly populate a Locale property.
PathEditor
Editor for java.nio.file.Path , to directly populate a Path property instead of using a String property as bridge.
PatternEditor
Editor for java.util.regex.Pattern , to directly populate a Pattern property.
PropertiesEditor
Custom PropertyEditor for Properties objects.
ReaderEditor
One-way PropertyEditor which can convert from a text String to a java.io.Reader , interpreting the given String as a Spring resource location (e.g.
ResourceBundleEditor
PropertyEditor implementation for standard JDK ResourceBundles .
StringArrayPropertyEditor
Custom PropertyEditor for String arrays.
StringTrimmerEditor
Property editor that trims Strings.
TimeZoneEditor
Editor for java.util.TimeZone , translating timezone IDs into TimeZone objects.
URIEditor
Editor for java.net.URI , to directly populate a URI property instead of using a String property as bridge.
URLEditor
Editor for java.net.URL , to directly populate a URL property instead of using a String property as bridge.
UUIDEditor
Editor for java.util.UUID , translating UUID String representations into UUID objects and back.
ZoneIdEditor
Editor for java.time.ZoneId , translating zone ID Strings into ZoneId objects.
support
@NonNullApi @NonNullFields package org.springframework.beans.support Classes supporting the org.springframework.beans package, such as utility classes for sorting and holding lists of beans.
Related Packages
org.springframework.beans
This package contains interfaces and classes for manipulating Java beans.
org.springframework.beans.factory
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
org.springframework.beans.propertyeditors
Properties editors used to convert from String values to object types such as java.util.Properties.
Classes
ArgumentConvertingMethodInvoker
Subclass of MethodInvoker that tries to convert the given arguments for the actual target method via a TypeConverter .
MutableSortDefinition
Mutable implementation of the SortDefinition interface.
PagedListHolder<E>
PagedListHolder is a simple state holder for handling lists of objects, separating them into pages.
PropertyComparator<T>
PropertyComparator performs a comparison of two beans, evaluating the specified bean property via a BeanWrapper.
ResourceEditorRegistrar
PropertyEditorRegistrar implementation that populates a given PropertyEditorRegistry (typically a BeanWrapper used for bean creation within an ApplicationContext ) with resource editors.
Interfaces
SortDefinition
Definition for sorting bean instances by a property.