| Package | Description |
|---|---|
| org.springframework.aop.aspectj |
AspectJ integration package.
|
| 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.
|
| 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.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.
|
| org.springframework.aop.framework.autoproxy.target | |
| 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 | |
| org.springframework.beans.factory.annotation |
Support package for annotation-driven bean configuration.
|
| org.springframework.beans.factory.config |
SPI interfaces and configuration-related convenience classes for bean factories.
|
| org.springframework.beans.factory.serviceloader |
Support package for the Java 6 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.cache.interceptor |
AOP-based solution for declarative caching demarcation.
|
| org.springframework.cache.jcache.interceptor |
AOP-based solution for declarative caching demarcation using JSR-107 annotations.
|
| 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.event |
Support classes for application events, like standard context events.
|
| 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. |
| org.springframework.dao.annotation |
Annotation support for DAOs.
|
| org.springframework.dao.support |
Support classes for DAO implementations,
providing miscellaneous utility methods.
|
| org.springframework.jdbc.config |
Defines the Spring JDBC configuration namespace.
|
| org.springframework.jdbc.datasource.lookup |
Provides a strategy for looking up JDBC DataSources by name.
|
| 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.support.destination |
Support classes for Spring's JMS framework.
|
| org.springframework.jmx.export |
This package provides declarative creation and registration of
Spring-managed beans as JMX MBeans.
|
| org.springframework.jmx.export.annotation |
Java 5 annotations for MBean exposure.
|
| 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.
|
| org.springframework.messaging.core |
Defines interfaces and implementation classes for messaging templates.
|
| org.springframework.messaging.handler.annotation.support |
Support classes for working with annotated message-handling methods.
|
| 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.
|
| 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.r2dbc.connection.lookup |
Provides a strategy for looking up R2DBC ConnectionFactories by name.
|
| org.springframework.remoting.jaxws |
Remoting classes for Web Services via JAX-WS (the successor of JAX-RPC),
as included in Java 6 and Java EE 5.
|
| org.springframework.scheduling.annotation |
Java 5 annotation for asynchronous method execution.
|
| 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.scripting.groovy |
Package providing integration of
Groovy
into Spring's scripting infrastructure.
|
| org.springframework.scripting.support |
Support classes for Spring's scripting package.
|
| org.springframework.transaction.interceptor |
AOP-based solution for declarative transaction demarcation.
|
| 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.web.context.request.async |
Support for asynchronous request processing.
|
| 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.socket.client.standard |
Client-side classes for use with standard Java WebSocket endpoints.
|
| org.springframework.web.socket.handler |
Convenient
WebSocketHandler
implementations and decorators. |
| org.springframework.web.socket.server.standard |
Server-side classes for use with standard JSR-356 WebSocket endpoints.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AspectJExpressionPointcut
Spring
Pointcut implementation
that uses the AspectJ weaver to evaluate a pointcut expression. |
class |
AspectJExpressionPointcutAdvisor
Spring AOP Advisor that can be used for any AspectJ pointcut expression.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AnnotationAwareAspectJAutoProxyCreator
AspectJAwareAdvisorAutoProxyCreator subclass that processes all AspectJ
annotation aspects in the current application context, as well as Spring Advisors. |
| Modifier and Type | Class and Description |
|---|---|
class |
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. |
| Modifier and Type | Class and Description |
|---|---|
class |
MethodLocatingFactoryBean
FactoryBean implementation that locates a Method on a specified bean. |
class |
SimpleBeanFactoryAwareAspectInstanceFactory
Implementation of
AspectInstanceFactory that locates the aspect from the
BeanFactory using a configured bean name. |
| Modifier and Type | Class and Description |
|---|---|
class |
ProxyFactoryBean
FactoryBean implementation that builds an
AOP proxy based on beans in Spring BeanFactory. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractAdvisorAutoProxyCreator
Generic auto proxy creator that builds AOP proxies for specific beans
based on detected Advisors for each bean.
|
class |
AbstractAutoProxyCreator
BeanPostProcessor implementation
that wraps each eligible bean with an AOP proxy, delegating to specified interceptors
before invoking the bean itself. |
class |
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). |
class |
BeanNameAutoProxyCreator
Auto proxy creator that identifies beans to proxy via a list of names.
|
class |
DefaultAdvisorAutoProxyCreator
BeanPostProcessor implementation that creates AOP proxies based on all
candidate Advisors in the current BeanFactory. |
class |
InfrastructureAdvisorAutoProxyCreator
Auto-proxy creator that considers infrastructure Advisor beans only,
ignoring any application-defined Advisors.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractBeanFactoryBasedTargetSourceCreator
Convenient superclass for
TargetSourceCreator
implementations that require creating multiple instances of a prototype bean. |
class |
LazyInitTargetSourceCreator
TargetSourceCreator that enforces a LazyInitTargetSource for
each bean that is defined as "lazy-init". |
class |
QuickTargetSourceCreator
Convenient TargetSourceCreator using bean name prefixes to create one of three
well-known TargetSource types:
: CommonsPool2TargetSource
% ThreadLocalTargetSource
! PrototypeTargetSource
|
| Modifier and Type | Class and Description |
|---|---|
class |
AsyncExecutionAspectSupport
Base class for asynchronous method execution aspects, such as
org.springframework.scheduling.annotation.AnnotationAsyncExecutionInterceptor
or org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect. |
class |
AsyncExecutionInterceptor
AOP Alliance
MethodInterceptor that processes method invocations
asynchronously, using a given AsyncTaskExecutor. |
| Modifier and Type | Class and Description |
|---|---|
class |
ScopedProxyFactoryBean
Convenient proxy factory bean for scoped objects.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractBeanFactoryPointcutAdvisor
Abstract BeanFactory-based PointcutAdvisor that allows for any Advice
to be configured as reference to an Advice bean in a BeanFactory.
|
class |
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.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractBeanFactoryBasedTargetSource
Base class for
TargetSource implementations
that are based on a Spring BeanFactory,
delegating to Spring-managed bean instances. |
class |
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. |
class |
AbstractPrototypeBasedTargetSource
Base class for dynamic
TargetSource implementations
that create new prototype bean instances to support a pooling or
new-instance-per-invocation strategy. |
class |
CommonsPool2TargetSource
TargetSource implementation that holds
objects in a configurable Apache Commons2 Pool. |
class |
LazyInitTargetSource
TargetSource that lazily accesses a
singleton bean from a BeanFactory. |
class |
PrototypeTargetSource
TargetSource implementation that
creates a new instance of the target bean for each request,
destroying each instance on release (after each request). |
class |
SimpleBeanTargetSource
Simple
TargetSource implementation,
freshly obtaining the specified target bean from its containing
Spring BeanFactory. |
class |
ThreadLocalTargetSource
Alternative to an object pool.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AutowiredAnnotationBeanPostProcessor
BeanPostProcessor
implementation that autowires annotated fields, setter methods, and arbitrary
config methods. |
class |
QualifierAnnotationAutowireCandidateResolver
AutowireCandidateResolver implementation that matches bean definition qualifiers
against qualifier annotations on the field or parameter to be autowired. |
class |
RequiredAnnotationBeanPostProcessor
Deprecated.
as of 5.1, in favor of using constructor injection for required settings
(or a custom
InitializingBean implementation) |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractFactoryBean<T>
Simple template superclass for
FactoryBean implementations that
creates a singleton or a prototype object, depending on a flag. |
class |
ListFactoryBean
Simple factory for shared List instances.
|
class |
MapFactoryBean
Simple factory for shared Map instances.
|
class |
MethodInvokingBean
Simple method invoker bean: just invoking a target method, not expecting a result
to expose to the container (in contrast to
MethodInvokingFactoryBean). |
class |
MethodInvokingFactoryBean
FactoryBean which returns a value which is the result of a static or instance
method invocation. |
class |
ObjectFactoryCreatingFactoryBean
A
FactoryBean implementation that
returns a value which is an ObjectFactory
that in turn returns a bean sourced from a BeanFactory. |
class |
PlaceholderConfigurerSupport
Abstract base class for property resource configurers that resolve placeholders
in bean definition property values.
|
class |
PreferencesPlaceholderConfigurer
Deprecated.
as of 5.2, along with
PropertyPlaceholderConfigurer |
class |
PropertyPathFactoryBean
FactoryBean that evaluates a property path on a given target object. |
class |
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. |
class |
ProviderCreatingFactoryBean
A
FactoryBean implementation that
returns a value which is a JSR-330 Provider that in turn
returns a bean sourced from a BeanFactory. |
class |
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. |
class |
SetFactoryBean
Simple factory for shared Set instances.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractServiceLoaderBasedFactoryBean
Abstract base class for FactoryBeans operating on the
JDK 1.6
ServiceLoader facility. |
class |
ServiceFactoryBean
FactoryBean that exposes the
'primary' service for the configured service class, obtained through
the JDK 1.6 ServiceLoader facility. |
class |
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. |
class |
ServiceLoaderFactoryBean
FactoryBean that exposes the
JDK 1.6 ServiceLoader for the configured service class. |
| Modifier and Type | Class and Description |
|---|---|
class |
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. |
| Modifier and Type | Class and Description |
|---|---|
class |
BeanConfigurerSupport
Convenient base class for bean configurers that can perform Dependency Injection
on objects (however they may be created).
|
| Modifier and Type | Class and Description |
|---|---|
class |
BeanFactoryCacheOperationSourceAdvisor
Advisor driven by a
CacheOperationSource, used to include a
cache advice bean for methods that are cacheable. |
class |
CacheAspectSupport
Base class for caching aspects, such as the
CacheInterceptor or an
AspectJ aspect. |
class |
CacheInterceptor
AOP Alliance MethodInterceptor for declarative cache
management using the common Spring caching infrastructure
(
Cache). |
class |
CacheProxyFactoryBean
Proxy factory bean for simplified declarative caching handling.
|
| Modifier and Type | Class and Description |
|---|---|
class |
BeanFactoryJCacheOperationSourceAdvisor
Advisor driven by a
JCacheOperationSource, used to include a
cache advice bean for methods that are cacheable. |
class |
DefaultJCacheOperationSource
The default
JCacheOperationSource implementation delegating
default operations to configurable services with sensible defaults
when not present. |
| Modifier and Type | Class and Description |
|---|---|
class |
CommonAnnotationBeanPostProcessor
BeanPostProcessor implementation
that supports common Java annotations out of the box, in particular the JSR-250
annotations in the javax.annotation package. |
class |
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. |
class |
MBeanExportConfiguration
@Configuration class that registers a AnnotationMBeanExporter bean. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractApplicationEventMulticaster
Abstract implementation of the
ApplicationEventMulticaster interface,
providing the basic listener registration facility. |
class |
SimpleApplicationEventMulticaster
Simple implementation of the
ApplicationEventMulticaster interface. |
| Modifier and Type | Class and Description |
|---|---|
class |
DefaultLifecycleProcessor
Default implementation of the
LifecycleProcessor strategy. |
class |
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. |
| Modifier and Type | Class and Description |
|---|---|
class |
LoadTimeWeaverAwareProcessor
BeanPostProcessor
implementation that passes the context's default LoadTimeWeaver
to beans that implement the LoadTimeWeaverAware interface. |
| Modifier and Type | Class and Description |
|---|---|
class |
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). |
| Modifier and Type | Class and Description |
|---|---|
class |
PersistenceExceptionTranslationInterceptor
AOP Alliance MethodInterceptor that provides persistence exception translation
based on a given PersistenceExceptionTranslator.
|
| Modifier and Type | Class and Description |
|---|---|
class |
SortedResourcesFactoryBean
FactoryBean implementation that takes a list of location Strings
and creates a sorted array of Resource instances. |
| Modifier and Type | Class and Description |
|---|---|
class |
BeanFactoryDataSourceLookup
DataSourceLookup implementation based on a Spring BeanFactory. |
| Modifier and Type | Class and Description |
|---|---|
class |
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. |
| Modifier and Type | Class and Description |
|---|---|
class |
JmsListenerEndpointRegistrar
Helper bean for registering
JmsListenerEndpoint with a JmsListenerEndpointRegistry. |
class |
MethodJmsListenerEndpoint
A
JmsListenerEndpoint providing the method to invoke to process
an incoming message for this endpoint. |
| Modifier and Type | Class and Description |
|---|---|
class |
BeanFactoryDestinationResolver
DestinationResolver implementation based on a Spring BeanFactory. |
| Modifier and Type | Class and Description |
|---|---|
class |
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. |
| Modifier and Type | Class and Description |
|---|---|
class |
AnnotationJmxAttributeSource
Implementation of the
JmxAttributeSource interface that
reads annotations and exposes the corresponding attributes. |
class |
AnnotationMBeanExporter
Convenient subclass of Spring's standard
MBeanExporter,
activating Java 5 annotation usage for JMX exposure of Spring beans:
ManagedResource, ManagedAttribute, ManagedOperation, etc. |
| Modifier and Type | Class and Description |
|---|---|
class |
JndiObjectFactoryBean
FactoryBean that looks up a
JNDI object. |
| Modifier and Type | Class and Description |
|---|---|
class |
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. |
class |
GenericMessagingTemplate
A messaging template that resolves destinations names to
MessageChannel's
to send and receive messages from. |
| Modifier and Type | Class and Description |
|---|---|
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. |
| Modifier and Type | Class and Description |
|---|---|
class |
HibernateTransactionManager
PlatformTransactionManager
implementation for a single Hibernate SessionFactory. |
class |
LocalSessionFactoryBean
FactoryBean that creates a Hibernate SessionFactory. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractEntityManagerFactoryBean
Abstract
FactoryBean that creates
a local JPA EntityManagerFactory instance within
a Spring application context. |
class |
EntityManagerFactoryAccessor
Base class for any class that needs to access a JPA
EntityManagerFactory,
usually in order to obtain a JPA EntityManager. |
class |
JpaTransactionManager
PlatformTransactionManager implementation
for a single JPA EntityManagerFactory. |
class |
LocalContainerEntityManagerFactoryBean
FactoryBean that creates a JPA
EntityManagerFactory according to JPA's standard
container bootstrap contract. |
class |
LocalEntityManagerFactoryBean
FactoryBean that creates a JPA
EntityManagerFactory according to JPA's standard
standalone bootstrap contract. |
| Modifier and Type | Class and Description |
|---|---|
class |
OpenEntityManagerInViewInterceptor
Spring web request interceptor that binds a JPA EntityManager to the
thread for the entire processing of the request.
|
class |
PersistenceAnnotationBeanPostProcessor
BeanPostProcessor that processes
PersistenceUnit
and PersistenceContext annotations, for injection of
the corresponding JPA resources EntityManagerFactory
and EntityManager. |
class |
SharedEntityManagerBean
FactoryBean that exposes a shared JPA EntityManager
reference for a given EntityManagerFactory. |
| Modifier and Type | Class and Description |
|---|---|
class |
HibernateJpaSessionFactoryBean
Deprecated.
as of Spring Framework 4.3.12 against Hibernate 5.2, in favor of a custom solution
based on
EntityManagerFactory.unwrap(java.lang.Class<T>) with explicit qualifiers and/or primary markers |
| Modifier and Type | Class and Description |
|---|---|
class |
BeanFactoryConnectionFactoryLookup
ConnectionFactoryLookup implementation based on a
Spring BeanFactory. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractJaxWsServiceExporter
Abstract exporter for JAX-WS services, autodetecting annotated service beans
(through the JAX-WS
WebService annotation). |
class |
SimpleHttpServerJaxWsServiceExporter
Deprecated.
as of Spring Framework 5.1, in favor of
SimpleJaxWsServiceExporter |
class |
SimpleJaxWsServiceExporter
Simple exporter for JAX-WS services, autodetecting annotated service beans
(through the JAX-WS
WebService annotation) and exporting
them with a configured base address (by default "http://localhost:8080/")
using the JAX-WS provider's built-in publication support. |
| Modifier and Type | Class and Description |
|---|---|
class |
AnnotationAsyncExecutionInterceptor
Specialization of
AsyncExecutionInterceptor that delegates method execution to
an Executor based on the Async annotation. |
class |
AsyncAnnotationAdvisor
Advisor that activates asynchronous method execution through the
Async
annotation. |
class |
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 of the target's interfaces). |
class |
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. |
| Modifier and Type | Class and Description |
|---|---|
class |
MethodInvokingJobDetailFactoryBean
FactoryBean that exposes a
JobDetail object which delegates job execution to a
specified (static or non-static) method. |
class |
SchedulerAccessorBean
Spring bean-style class for accessing a Quartz Scheduler, i.e.
|
| Modifier and Type | Class and Description |
|---|---|
class |
GroovyScriptFactory
ScriptFactory implementation
for a Groovy script. |
| Modifier and Type | Class and Description |
|---|---|
class |
ScriptFactoryPostProcessor
BeanPostProcessor that
handles ScriptFactory definitions,
replacing each factory with the actual scripted Java object generated by it. |
| Modifier and Type | Class and Description |
|---|---|
class |
BeanFactoryTransactionAttributeSourceAdvisor
Advisor driven by a
TransactionAttributeSource, used to include
a transaction advice bean for methods that are transactional. |
class |
TransactionAspectSupport
Base class for transactional aspects, such as the
TransactionInterceptor
or an AspectJ aspect. |
class |
TransactionInterceptor
AOP Alliance MethodInterceptor for declarative transaction
management using the common Spring transaction infrastructure
(
PlatformTransactionManager/
ReactiveTransactionManager). |
class |
TransactionProxyFactoryBean
Proxy factory bean for simplified declarative transaction handling.
|
| Modifier and Type | Class and Description |
|---|---|
class |
MethodValidationPostProcessor
A convenient
BeanPostProcessor implementation that delegates to a
JSR-303 provider for performing method-level validation on annotated methods. |
| Modifier and Type | Class and Description |
|---|---|
class |
WebAsyncTask<V>
Holder for a
Callable, a timeout value, and a task executor. |
| Modifier and Type | Class and Description |
|---|---|
class |
RequestMappingHandlerAdapter
|
| Modifier and Type | Class and Description |
|---|---|
class |
AnnotatedEndpointConnectionManager
A WebSocket connection manager that is given a URI, a
ClientEndpoint-annotated endpoint, connects to a
WebSocket server through the ConnectionManagerSupport.start() and ConnectionManagerSupport.stop() methods. |
class |
EndpointConnectionManager
A WebSocket connection manager that is given a URI, an
Endpoint, connects to a
WebSocket server through the ConnectionManagerSupport.start() and ConnectionManagerSupport.stop() methods. |
| Modifier and Type | Class and Description |
|---|---|
class |
BeanCreatingHandlerProvider<T>
Instantiates a target handler through a Spring
BeanFactory and also provides
an equivalent destroy method. |
class |
PerConnectionWebSocketHandler
A
WebSocketHandler that initializes and destroys a WebSocketHandler
instance for each WebSocket connection and delegates all other methods to it. |
| Modifier and Type | Class and Description |
|---|---|
class |
ServerEndpointRegistration
An implementation of
ServerEndpointConfig for use in
Spring-based applications. |