| 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 |
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
|
| 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.annotation |
Annotations and supporting classes for declarative cache management.
|
| org.springframework.cache.aspectj | |
| org.springframework.cache.concurrent |
Implementation package for
java.util.concurrent based caches. |
| org.springframework.cache.ehcache |
Support classes for the open source cache
EhCache 2.x,
allowing to set up an EhCache CacheManager and Caches
as beans in a Spring context.
|
| 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.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.
|
| 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 |
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.ejb.access |
This package contains classes that allow easy access to EJBs.
|
| org.springframework.format.datetime |
Formatters for
java.util.Date properties. |
| org.springframework.format.datetime.joda |
Integration with Joda-Time for formatting Joda date and time types as well as standard JDK Date types.
|
| org.springframework.format.datetime.standard |
Integration with the JSR-310
java.time package in JDK 8. |
| org.springframework.format.number |
Formatters for
java.lang.Number properties. |
| org.springframework.format.number.money |
Integration with the JSR-354
javax.money package. |
| org.springframework.format.support |
Support classes for the formatting package,
providing common implementations as well as adapters.
|
| org.springframework.http.converter.json |
Provides HttpMessageConverter implementations for handling JSON.
|
| org.springframework.jca.context |
Integration package that allows for deploying a Spring application context
as a JCA 1.7 compliant RAR file.
|
| org.springframework.jca.endpoint |
This package provides a facility for generic JCA message endpoint management.
|
| org.springframework.jca.work |
Convenience classes for scheduling based on the JCA WorkManager facility,
as supported within ResourceAdapters.
|
| 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.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.
|
| org.springframework.jms.remoting |
Remoting classes for transparent Java-to-Java remoting via a JMS provider.
|
| 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.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.export.annotation |
Java 5 annotations for MBean exposure.
|
| org.springframework.jmx.export.assembler |
Provides a strategy for MBeanInfo assembly.
|
| org.springframework.jmx.export.notification |
Provides supporting infrastructure to allow Spring-created MBeans
to send JMX notifications.
|
| org.springframework.jmx.support |
Contains support classes for connecting to local and remote
MBeanServers
and for exposing an MBeanServer to remote clients. |
| 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.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.
|
| org.springframework.messaging.rsocket.annotation.support |
Support classes for working with annotated RSocket stream handling methods.
|
| 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.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.orm.hibernate5 |
Package providing integration of
Hibernate 5.x
with Spring concepts.
|
| 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.
|
| 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.oxm.jaxb |
Package providing integration of JAXB
with Spring's O/X Mapping support.
|
| org.springframework.oxm.xstream |
Package providing integration of XStream
with Spring's O/X Mapping support.
|
| org.springframework.r2dbc.connection.lookup |
Provides a strategy for looking up R2DBC ConnectionFactories by name.
|
| org.springframework.remoting.caucho |
This package provides remoting classes for Caucho's Hessian protocol:
a proxy factory for accessing Hessian services, and an exporter for
making beans available to Hessian clients.
|
| org.springframework.remoting.httpinvoker |
Remoting classes for transparent Java-to-Java remoting via HTTP invokers.
|
| 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.remoting.rmi |
Remoting classes for conventional RMI and transparent remoting via
RMI invokers.
|
| org.springframework.remoting.support |
Generic support classes for remoting implementations.
|
| org.springframework.scheduling.annotation |
Java 5 annotation for asynchronous method execution.
|
| org.springframework.scheduling.aspectj | |
| org.springframework.scheduling.concurrent |
Scheduling convenience classes for the
java.util.concurrent
and javax.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.
|
| 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.
|
| org.springframework.test.context.junit4 |
Support classes for integrating the Spring TestContext Framework
with JUnit 4.12 or higher.
|
| org.springframework.test.context.testng |
Support classes for integrating the Spring TestContext Framework
with TestNG.
|
| org.springframework.transaction.annotation |
Spring's support for annotation-based transaction demarcation.
|
| org.springframework.transaction.aspectj | |
| org.springframework.transaction.interceptor |
AOP-based solution for declarative transaction demarcation.
|
| 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.
|
| 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.accept |
This package contains classes used to determine the requested the media types in a request.
|
| 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.async |
Support for asynchronous request processing.
|
| org.springframework.web.context.support |
Classes supporting the
org.springframework.web.context package,
such as WebApplicationContext implementations and various utility classes. |
| org.springframework.web.filter |
Provides generic filter base classes allowing for bean-style configuration.
|
| org.springframework.web.multipart.commons |
MultipartResolver implementation for
Apache Commons FileUpload.
|
| org.springframework.web.multipart.support |
Support classes for the multipart resolution framework.
|
| 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.config |
Spring WebFlux configuration infrastructure.
|
| org.springframework.web.reactive.function.server.support |
Classes supporting the
org.springframework.web.reactive.function.server package. |
| org.springframework.web.reactive.handler |
Provides HandlerMapping implementations including abstract base classes.
|
| org.springframework.web.reactive.result.method |
Infrastructure for handler method processing.
|
| org.springframework.web.reactive.result.method.annotation |
Infrastructure for annotation-based handler method processing.
|
| 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.
|
| 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.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.
|
| org.springframework.web.servlet.handler |
Provides standard HandlerMapping implementations,
including abstract base classes for custom implementations.
|
| 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.method.annotation |
MVC infrastructure for annotation-based handler method processing, building on the
org.springframework.web.method.annotation package. |
| 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.view |
Provides standard View and ViewResolver implementations,
including abstract base classes for custom implementations.
|
| 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.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.tiles3 |
Support classes for the integration of
Tiles 3
(the standalone version of Tiles) as Spring web view technology.
|
| 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.
|
| org.springframework.web.socket.client.standard |
Client-side classes for use with standard Java WebSocket endpoints.
|
| org.springframework.web.socket.config.annotation |
Support for annotation-based WebSocket setup in configuration classes.
|
| 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.jetty |
Server-side support for the Jetty 9+ 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.
|
| org.springframework.web.socket.sockjs.support |
Support classes for SockJS including an
AbstractSockJsService
implementation. |
| org.springframework.web.socket.sockjs.transport.handler |
TransportHandler
implementation classes as well as a concrete
SockJsService. |
| 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 |
AbstractAdvisingBeanPostProcessor
Base class for
BeanPostProcessor implementations that apply a
Spring AOP Advisor to specific beans. |
class |
AbstractSingletonProxyFactoryBean
Convenient superclass for
FactoryBean types that produce singleton-scoped
proxy objects. |
class |
ProxyFactoryBean
FactoryBean implementation that builds an
AOP proxy based on beans in Spring BeanFactory. |
class |
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. |
| 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 | Interface and Description |
|---|---|
interface |
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. |
interface |
BeanFactoryAware
Interface to be implemented by beans that wish to be aware of their
owning
BeanFactory. |
interface |
BeanNameAware
Interface to be implemented by beans that want to be aware of their
bean name in a bean factory.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AutowiredAnnotationBeanPostProcessor
BeanPostProcessor
implementation that autowires annotated fields, setter methods, and arbitrary
config methods. |
class |
CustomAutowireConfigurer
A
BeanFactoryPostProcessor
implementation that allows for convenient registration of custom autowire
qualifier types. |
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 |
CustomScopeConfigurer
Simple
BeanFactoryPostProcessor implementation that registers
custom Scope(s) with the containing ConfigurableBeanFactory. |
class |
FieldRetrievingFactoryBean
FactoryBean which retrieves a static or non-static field value. |
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 |
AbstractCachingConfiguration
Abstract base
@Configuration class providing common structure
for enabling Spring's annotation-driven cache management capability. |
class |
ProxyCachingConfiguration
@Configuration class that registers the Spring infrastructure beans necessary
to enable proxy-based annotation-driven cache management. |
| Modifier and Type | Class and Description |
|---|---|
class |
AspectJCachingConfiguration
@Configuration class that registers the Spring infrastructure beans
necessary to enable AspectJ-based annotation-driven cache management. |
class |
AspectJJCacheConfiguration
@Configuration class that registers the Spring infrastructure beans necessary
to enable AspectJ-based annotation-driven cache management for standard JSR-107
annotations. |
| Modifier and Type | Class and Description |
|---|---|
class |
ConcurrentMapCacheFactoryBean
FactoryBean for easy configuration of a ConcurrentMapCache
when used within a Spring container. |
class |
ConcurrentMapCacheManager
CacheManager implementation that lazily builds ConcurrentMapCache
instances for each ConcurrentMapCacheManager.getCache(java.lang.String) request. |
| Modifier and Type | Class and Description |
|---|---|
class |
EhCacheFactoryBean
FactoryBean that creates a named EhCache Cache instance
(or a decorator that implements the Ehcache interface),
representing a cache region within an EhCache CacheManager. |
| 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 |
JCacheManagerFactoryBean
FactoryBean for a JCache javax.cache.CacheManager,
obtaining a pre-defined CacheManager by name through the standard
JCache javax.cache.Caching class. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractJCacheConfiguration
Abstract JSR-107 specific
@Configuration class providing common
structure for enabling JSR-107 annotation-driven cache management capability. |
class |
ProxyJCacheConfiguration
@Configuration class that registers the Spring infrastructure beans necessary
to enable proxy-based annotation-driven JSR-107 cache management. |
| 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 | Interface and Description |
|---|---|
interface |
ApplicationContextAware
Interface to be implemented by any object that wishes to be notified
of the
ApplicationContext that it runs in. |
interface |
ApplicationEventPublisherAware
Interface to be implemented by any object that wishes to be notified
of the ApplicationEventPublisher (typically the ApplicationContext)
that it runs in.
|
interface |
ApplicationStartupAware
Interface to be implemented by any object that wishes to be notified
of the
ApplicationStartup that it runs with. |
interface |
EmbeddedValueResolverAware
Interface to be implemented by any object that wishes to be notified of a
StringValueResolver for the resolution of embedded definition values. |
interface |
EnvironmentAware
Interface to be implemented by any bean that wishes to be notified
of the
Environment that it runs in. |
interface |
MessageSourceAware
Interface to be implemented by any object that wishes to be notified
of the MessageSource (typically the ApplicationContext) that it runs in.
|
interface |
ResourceLoaderAware
Interface to be implemented by any object that wishes to be notified of the
ResourceLoader (typically the ApplicationContext) that it runs in. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
ImportAware
Interface to be implemented by any @
Configuration class that wishes
to be injected with the AnnotationMetadata of the @Configuration
class that imported it. |
| Modifier and Type | Class and Description |
|---|---|
class |
ClassPathBeanDefinitionScanner
A bean definition scanner that detects bean candidates on the classpath,
registering corresponding bean definitions with a given registry (
BeanFactory
or ApplicationContext). |
class |
ClassPathScanningCandidateComponentProvider
A component provider that provides candidate components from a base package.
|
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 |
ConfigurationClassPostProcessor
BeanFactoryPostProcessor used for bootstrapping processing of
@Configuration classes. |
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 |
LoadTimeWeavingConfiguration
@Configuration class that registers a LoadTimeWeaver bean. |
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 |
EventListenerMethodProcessor
Registers
EventListener methods as individual ApplicationListener instances. |
class |
EventPublicationInterceptor
Interceptor that publishes an
ApplicationEvent to all ApplicationListeners
registered with an ApplicationEventPublisher after each
successful method invocation. |
class |
SimpleApplicationEventMulticaster
Simple implementation of the
ApplicationEventMulticaster interface. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractRefreshableConfigApplicationContext
AbstractRefreshableApplicationContext subclass that adds common handling
of specified config locations. |
class |
AbstractXmlApplicationContext
Convenient base class for
ApplicationContext
implementations, drawing configuration from XML documents containing bean definitions
understood by an XmlBeanDefinitionReader. |
class |
ApplicationObjectSupport
Convenient superclass for application objects that want to be aware of
the application context, e.g.
|
class |
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.
|
class |
DefaultLifecycleProcessor
Default implementation of the
LifecycleProcessor strategy. |
class |
EmbeddedValueResolutionSupport
Convenient base class for components with a need for embedded value resolution
(i.e.
|
class |
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.
|
class |
LiveBeansView
Deprecated.
as of 5.3, in favor of using Spring Boot actuators for such needs
|
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. |
class |
ReloadableResourceBundleMessageSource
Spring-specific
MessageSource implementation
that accesses resource bundles using specified basenames, participating in the
Spring ApplicationContext's resource loading. |
class |
ResourceBundleMessageSource
MessageSource implementation that
accesses resource bundles using specified basenames. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
LoadTimeWeaverAware
Interface to be implemented by any object that wishes to be notified
of the application context's default
LoadTimeWeaver. |
| Modifier and Type | Class and Description |
|---|---|
class |
AspectJWeavingEnabler
Post-processor that registers AspectJ's
ClassPreProcessorAgentAdapter
with the Spring application context's default
LoadTimeWeaver. |
class |
DefaultContextLoadTimeWeaver
Default
LoadTimeWeaver bean for use in an application context,
decorating an automatically detected internal LoadTimeWeaver. |
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 |
LocalStatelessSessionProxyFactoryBean
Convenient
FactoryBean for local Stateless Session Bean (SLSB) proxies. |
class |
SimpleRemoteStatelessSessionProxyFactoryBean
Convenient
FactoryBean for remote SLSB proxies. |
| Modifier and Type | Class and Description |
|---|---|
class |
DateTimeFormatAnnotationFormatterFactory
Formats fields annotated with the
DateTimeFormat annotation using a DateFormatter. |
| Modifier and Type | Class and Description |
|---|---|
class |
JodaDateTimeFormatAnnotationFormatterFactory
Deprecated.
as of 5.3, in favor of standard JSR-310 support
|
| Modifier and Type | Class and Description |
|---|---|
class |
Jsr310DateTimeFormatAnnotationFormatterFactory
Formats fields annotated with the
DateTimeFormat annotation using the
JSR-310 java.time package in JDK 8. |
| Modifier and Type | Class and Description |
|---|---|
class |
NumberFormatAnnotationFormatterFactory
Formats fields annotated with the
NumberFormat annotation. |
| Modifier and Type | Class and Description |
|---|---|
class |
Jsr354NumberFormatAnnotationFormatterFactory
Formats
MonetaryAmount fields annotated
with Spring's common NumberFormat annotation. |
| Modifier and Type | Class and Description |
|---|---|
class |
DefaultFormattingConversionService
A specialization of
FormattingConversionService configured by default with
converters and formatters appropriate for most applications. |
class |
FormattingConversionService
A
ConversionService implementation
designed to be configured as a FormatterRegistry. |
class |
FormattingConversionServiceFactoryBean
A factory providing convenient access to a
FormattingConversionService
configured with converters and formatters for common types such as numbers and
datetimes. |
| Modifier and Type | Class and Description |
|---|---|
class |
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. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
BootstrapContextAware
Interface to be implemented by any object that wishes to be
notified of the BootstrapContext (typically determined by the
ResourceAdapterApplicationContext) that it runs in. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractMessageEndpointFactory
Abstract base implementation of the JCA 1.7
MessageEndpointFactory interface,
providing transaction management capabilities as well as ClassLoader
exposure for endpoint invocations. |
class |
GenericMessageEndpointFactory
Generic implementation of the JCA 1.7
MessageEndpointFactory interface,
providing transaction management capabilities for any kind of message
listener object (e.g. |
| Modifier and Type | Class and Description |
|---|---|
class |
WorkManagerTaskExecutor
TaskExecutor implementation
that delegates to a JCA 1.7 WorkManager, implementing the
WorkManager interface. |
| 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 |
JmsListenerEndpointRegistry
Creates the necessary
MessageListenerContainer instances for the
registered endpoints. |
class |
MethodJmsListenerEndpoint
A
JmsListenerEndpoint providing the method to invoke to process
an incoming message for this endpoint. |
| Modifier and Type | Class and Description |
|---|---|
class |
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).
|
class |
AbstractMessageListenerContainer
Abstract base class for Spring message listener container implementations.
|
class |
AbstractPollingMessageListenerContainer
Base class for listener container implementations which are based on polling.
|
class |
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). |
class |
SimpleMessageListenerContainer
Message listener container that uses the plain JMS client API's
MessageConsumer.setMessageListener() method to
create concurrent MessageConsumers for the specified listeners. |
| Modifier and Type | Class and Description |
|---|---|
class |
JmsMessageEndpointFactory
JMS-specific implementation of the JCA 1.7
MessageEndpointFactory interface,
providing transaction management capabilities for a JMS listener object
(e.g. |
class |
JmsMessageEndpointManager
Extension of the generic JCA 1.5
GenericMessageEndpointManager,
adding JMS-specific support for ActivationSpec configuration. |
| Modifier and Type | Class and Description |
|---|---|
class |
JmsInvokerProxyFactoryBean
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
class |
JmsInvokerServiceExporter
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
| Modifier and Type | Class and Description |
|---|---|
class |
MappingJackson2MessageConverter
Message converter that uses Jackson 2.x to convert messages to and from JSON.
|
| Modifier and Type | Class and Description |
|---|---|
class |
BeanFactoryDestinationResolver
DestinationResolver implementation based on a Spring BeanFactory. |
| Modifier and Type | Class and Description |
|---|---|
class |
MBeanClientInterceptor
MethodInterceptor that routes calls to an
MBean running on the supplied MBeanServerConnection. |
class |
MBeanProxyFactoryBean
Creates a proxy to a managed resource running either locally or remotely.
|
| 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 |
InterfaceBasedMBeanInfoAssembler
Subclass of
AbstractReflectiveMBeanInfoAssembler that allows for
the management interface of a bean to be defined using arbitrary interfaces. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
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. |
| Modifier and Type | Class and Description |
|---|---|
class |
MBeanServerConnectionFactoryBean
FactoryBean that creates a JMX 1.2 MBeanServerConnection
to a remote MBeanServer exposed via a JMXServerConnector. |
| 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 |
MessageMappingMessageHandler
Extension of
AbstractMethodMessageHandler for reactive, non-blocking
handling of messages via @MessageMapping methods. |
| 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 |
AbstractMethodMessageHandler<T>
Abstract base class for HandlerMethod-based message handling.
|
| Modifier and Type | Class and Description |
|---|---|
class |
RSocketMessageHandler
Extension of
MessageMappingMessageHandler for handling RSocket
requests with @ConnectMapping and
@MessageMapping methods. |
| Modifier and Type | Class and Description |
|---|---|
class |
SimpAnnotationMethodMessageHandler
A handler for messages delegating to
@MessageMapping
and @SubscribeMapping annotated methods. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractBrokerMessageHandler
Abstract base class for a
MessageHandler that broker messages to
registered subscribers. |
class |
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. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractMessageBrokerConfiguration
Provides essential configuration for handling messages with simple messaging
protocols such as STOMP.
|
| Modifier and Type | Class and Description |
|---|---|
class |
StompBrokerRelayMessageHandler
A
MessageHandler that handles messages by
forwarding them to a STOMP broker. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractMessageChannel
Abstract base class for
MessageChannel implementations. |
class |
AbstractSubscribableChannel
Abstract base class for
SubscribableChannel implementations. |
class |
ExecutorSubscribableChannel
A
SubscribableChannel that sends messages to each of its subscribers. |
| 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 |
OpenSessionInViewFilter
Servlet Filter that binds a Hibernate Session to the thread for the entire
processing of the request.
|
| 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 |
DefaultPersistenceUnitManager
Default implementation of the
PersistenceUnitManager interface. |
| Modifier and Type | Class and Description |
|---|---|
class |
OpenEntityManagerInViewFilter
Servlet Filter that binds a JPA EntityManager to the thread for the
entire processing of the request.
|
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 |
Jaxb2Marshaller
Implementation of the
GenericMarshaller interface for JAXB 2.2. |
| Modifier and Type | Class and Description |
|---|---|
class |
XStreamMarshaller
Implementation of the
Marshaller interface for XStream. |
| Modifier and Type | Class and Description |
|---|---|
class |
BeanFactoryConnectionFactoryLookup
ConnectionFactoryLookup implementation based on a
Spring BeanFactory. |
| Modifier and Type | Class and Description |
|---|---|
class |
HessianClientInterceptor
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
class |
HessianExporter
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
class |
HessianProxyFactoryBean
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
class |
HessianServiceExporter
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
class |
SimpleHessianServiceExporter
Deprecated.
as of Spring Framework 5.1, in favor of
HessianServiceExporter |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractHttpInvokerRequestExecutor
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
class |
HttpComponentsHttpInvokerRequestExecutor
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
class |
HttpInvokerClientInterceptor
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
class |
HttpInvokerProxyFactoryBean
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
class |
HttpInvokerServiceExporter
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
class |
SimpleHttpInvokerRequestExecutor
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
class |
SimpleHttpInvokerServiceExporter
Deprecated.
as of Spring Framework 5.1, in favor of
HttpInvokerServiceExporter |
| 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 |
JaxWsPortClientInterceptor
MethodInterceptor for accessing a
specific port of a JAX-WS service. |
class |
JaxWsPortProxyFactoryBean
FactoryBean for a specific port of a
JAX-WS service. |
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 |
JndiRmiProxyFactoryBean
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
class |
JndiRmiServiceExporter
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
class |
RemoteInvocationSerializingExporter
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
class |
RmiBasedExporter
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
class |
RmiClientInterceptor
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
class |
RmiProxyFactoryBean
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
class |
RmiServiceExporter
Deprecated.
as of 5.3 (phasing out serialization-based remoting)
|
| Modifier and Type | Class and Description |
|---|---|
class |
RemoteAccessor
Abstract base class for classes that access a remote service.
|
class |
RemoteExporter
Abstract base class for classes that export a remote service.
|
class |
RemoteInvocationBasedAccessor
Abstract base class for remote service accessors that are based
on serialization of
RemoteInvocation objects. |
class |
RemoteInvocationBasedExporter
Abstract base class for remote service exporters that are based
on deserialization of
RemoteInvocation objects. |
class |
RemotingSupport
Generic support base class for remote accessor and exporters,
providing common bean ClassLoader handling.
|
class |
UrlBasedRemoteAccessor
Abstract base class for classes that access remote services via URLs.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractAsyncConfiguration
Abstract base
Configuration class providing common structure for enabling
Spring's asynchronous method execution capability. |
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 |
ProxyAsyncConfiguration
@Configuration class that registers the Spring infrastructure beans necessary
to enable proxy-based asynchronous method execution. |
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 |
AspectJAsyncConfiguration
@Configuration class that registers the Spring infrastructure beans necessary
to enable AspectJ-based asynchronous method execution. |
| Modifier and Type | Class and Description |
|---|---|
class |
ExecutorConfigurationSupport
Base class for setting up a
ExecutorService
(typically a ThreadPoolExecutor or
ScheduledThreadPoolExecutor). |
class |
ScheduledExecutorFactoryBean
FactoryBean that sets up
a ScheduledExecutorService
(by default: a ScheduledThreadPoolExecutor)
and exposes it for bean references. |
class |
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. |
class |
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. |
class |
ThreadPoolTaskScheduler
Implementation of Spring's
TaskScheduler interface, wrapping
a native ScheduledThreadPoolExecutor. |
| Modifier and Type | Class and Description |
|---|---|
class |
TaskExecutorFactoryBean
FactoryBean for creating ThreadPoolTaskExecutor instances,
primarily used behind the XML task namespace. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
SchedulerContextAware
Callback interface to be implemented by Spring-managed
Quartz artifacts that need access to the SchedulerContext
(without having natural access to it).
|
| Modifier and Type | Class and Description |
|---|---|
class |
CronTriggerFactoryBean
A Spring
FactoryBean for creating a Quartz CronTrigger
instance, supporting bean-style usage for trigger configuration. |
class |
JobDetailFactoryBean
A Spring
FactoryBean for creating a Quartz JobDetail
instance, supporting bean-style usage for JobDetail configuration. |
class |
MethodInvokingJobDetailFactoryBean
FactoryBean that exposes a
JobDetail object which delegates job execution to a
specified (static or non-static) method. |
class |
SchedulerAccessor
Common base class for accessing a Quartz Scheduler, i.e.
|
class |
SchedulerAccessorBean
Spring bean-style class for accessing a Quartz Scheduler, i.e.
|
class |
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. |
class |
SimpleTriggerFactoryBean
A Spring
FactoryBean for creating a Quartz SimpleTrigger
instance, supporting bean-style usage for trigger configuration. |
class |
SpringBeanJobFactory
Subclass of
AdaptableJobFactory that also supports Spring-style
dependency injection on bean properties. |
| Modifier and Type | Class and Description |
|---|---|
class |
MethodInvokingRunnable
Adapter that implements the
Runnable interface as a configurable
method invocation based on Spring's MethodInvoker. |
| Modifier and Type | Class and Description |
|---|---|
class |
BshScriptEvaluator
BeanShell-based implementation of Spring's
ScriptEvaluator strategy interface. |
class |
BshScriptFactory
ScriptFactory implementation
for a BeanShell script. |
| Modifier and Type | Class and Description |
|---|---|
class |
GroovyScriptEvaluator
Groovy-based implementation of Spring's
ScriptEvaluator strategy interface. |
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. |
class |
StandardScriptEvaluator
javax.script (JSR-223) based implementation of Spring's ScriptEvaluator
strategy interface. |
class |
StandardScriptFactory
ScriptFactory implementation based
on the JSR-223 script engine abstraction (as included in Java 6+). |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractJUnit4SpringContextTests
Abstract base test class which integrates the Spring TestContext
Framework with explicit
ApplicationContext testing support
in a JUnit 4 environment. |
class |
AbstractTransactionalJUnit4SpringContextTests
Abstract transactional extension of
AbstractJUnit4SpringContextTests which adds convenience functionality
for JDBC access. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractTestNGSpringContextTests
Abstract base test class which integrates the Spring TestContext Framework
with explicit
ApplicationContext testing support in a TestNG
environment. |
class |
AbstractTransactionalTestNGSpringContextTests
Abstract transactional extension of
AbstractTestNGSpringContextTests which adds convenience functionality
for JDBC access. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractTransactionManagementConfiguration
Abstract base
@Configuration class providing common structure for enabling
Spring's annotation-driven transaction management capability. |
class |
AnnotationTransactionAttributeSource
Implementation of the
TransactionAttributeSource
interface for working with transaction metadata in JDK 1.5+ annotation format. |
class |
ProxyTransactionManagementConfiguration
@Configuration class that registers the Spring infrastructure beans
necessary to enable proxy-based annotation-driven transaction management. |
| Modifier and Type | Class and Description |
|---|---|
class |
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. |
class |
AspectJTransactionManagementConfiguration
@Configuration class that registers the Spring infrastructure beans necessary
to enable AspectJ-based annotation-driven transaction management for Spring's own
Transactional annotation. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractFallbackTransactionAttributeSource
Abstract implementation of
TransactionAttributeSource that caches
attributes for methods and implements a fallback policy: 1. |
class |
BeanFactoryTransactionAttributeSourceAdvisor
Advisor driven by a
TransactionAttributeSource, used to include
a transaction advice bean for methods that are transactional. |
class |
MethodMapTransactionAttributeSource
Simple
TransactionAttributeSource implementation that
allows attributes to be stored per method in a Map. |
class |
NameMatchTransactionAttributeSource
Simple
TransactionAttributeSource implementation that
allows attributes to be matched by registered name. |
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 |
ResourceBundleThemeSource
ThemeSource implementation that looks up an individual
ResourceBundle per theme. |
| Modifier and Type | Class and Description |
|---|---|
class |
FreeMarkerConfigurationFactoryBean
Factory bean that creates a FreeMarker Configuration and provides it as
bean reference.
|
| Modifier and Type | Class and Description |
|---|---|
class |
LocalValidatorFactoryBean
This is the central class for
javax.validation (JSR-303) setup in a Spring
application context: It bootstraps a javax.validation.ValidationFactory and
exposes it through the Spring Validator interface
as well as through the JSR-303 Validator interface and the
ValidatorFactory interface itself. |
class |
MethodValidationPostProcessor
A convenient
BeanPostProcessor implementation that delegates to a
JSR-303 provider for performing method-level validation on annotated methods. |
class |
OptionalValidatorFactoryBean
LocalValidatorFactoryBean subclass that simply turns
Validator calls into no-ops
in case of no Bean Validation provider being available. |
| Modifier and Type | Class and Description |
|---|---|
class |
ContentNegotiationManagerFactoryBean
Factory to create a
ContentNegotiationManager and configure it with
ContentNegotiationStrategy instances. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
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. |
interface |
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. |
| 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 |
AbstractRefreshableWebApplicationContext
AbstractRefreshableApplicationContext
subclass which implements the
ConfigurableWebApplicationContext
interface for web environments. |
class |
AnnotationConfigWebApplicationContext
WebApplicationContext
implementation which accepts component classes as input — in particular
@Configuration-annotated
classes, but also plain @Component
classes and JSR-330 compliant classes using javax.inject annotations. |
class |
GroovyWebApplicationContext
WebApplicationContext implementation which takes
its configuration from Groovy bean definition scripts and/or XML files, as understood by
a GroovyBeanDefinitionReader. |
class |
ServletContextAttributeExporter
Exporter that takes Spring-defined objects and exposes them as
ServletContext attributes.
|
class |
ServletContextAttributeFactoryBean
FactoryBean that fetches a specific, existing ServletContext attribute. |
class |
ServletContextLiveBeansView
Deprecated.
as of 5.3, in favor of using Spring Boot actuators for such needs
|
class |
ServletContextParameterFactoryBean
FactoryBean that retrieves a specific ServletContext init parameter
(that is, a "context-param" defined in web.xml). |
class |
WebApplicationObjectSupport
Convenient superclass for application objects running in a
WebApplicationContext. |
class |
XmlWebApplicationContext
WebApplicationContext implementation
which takes its configuration from XML documents, understood by an
XmlBeanDefinitionReader. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractRequestLoggingFilter
Base class for
Filters that perform logging operations before and after a request
is processed. |
class |
CharacterEncodingFilter
Servlet Filter that allows one to specify a character encoding for requests.
|
class |
CommonsRequestLoggingFilter
Simple request logging filter that writes the request URI
(and optionally the query string) to the Commons Log.
|
class |
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. |
class |
DelegatingFilterProxy
Proxy for a standard Servlet Filter, delegating to a Spring-managed bean that
implements the Filter interface.
|
class |
FormContentFilter
Filter that parses form data for HTTP PUT, PATCH, and DELETE requests
and exposes it as Servlet request parameters. |
class |
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). |
class |
GenericFilterBean
Simple base implementation of
Filter which treats
its config parameters (init-param entries within the
filter tag in web.xml) as bean properties. |
class |
HiddenHttpMethodFilter
Filter that converts posted method parameters into HTTP methods,
retrievable via HttpServletRequest.getMethod(). |
class |
HttpPutFormContentFilter
Deprecated.
as of 5.1 in favor of
FormContentFilter which is the same
but also handles DELETE. |
class |
OncePerRequestFilter
Filter base class that aims to guarantee a single execution per request
dispatch, on any servlet container.
|
class |
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. |
class |
RequestContextFilter
Servlet Filter that exposes the request to the current thread,
through both
LocaleContextHolder and
RequestContextHolder. |
class |
ServletContextRequestLoggingFilter
Simple request logging filter that writes the request URI
(and optionally the query string) to the ServletContext log.
|
class |
ShallowEtagHeaderFilter
Filter that generates an ETag value based on the
content on the response. |
| Modifier and Type | Class and Description |
|---|---|
class |
CommonsMultipartResolver
Servlet-based
MultipartResolver implementation for
Apache Commons FileUpload
1.2 or above. |
| Modifier and Type | Class and Description |
|---|---|
class |
MultipartFilter
Servlet Filter that resolves multipart requests via a
MultipartResolver. |
| Modifier and Type | Class and Description |
|---|---|
class |
DispatcherHandler
Central dispatcher for HTTP request handlers/controllers.
|
| Modifier and Type | Class and Description |
|---|---|
class |
DelegatingWebFluxConfiguration
A subclass of
WebFluxConfigurationSupport that detects and delegates
to all beans of type WebFluxConfigurer allowing them to customize the
configuration provided by WebFluxConfigurationSupport. |
class |
WebFluxConfigurationSupport
The main class for Spring WebFlux configuration.
|
| Modifier and Type | Class and Description |
|---|---|
class |
RouterFunctionMapping
HandlerMapping implementation that supports RouterFunctions. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractHandlerMapping
Abstract base class for
HandlerMapping
implementations. |
class |
AbstractUrlHandlerMapping
Abstract base class for URL-mapped
HandlerMapping implementations. |
class |
SimpleUrlHandlerMapping
Implementation of the
HandlerMapping
interface to map from URLs to request handler beans. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractHandlerMethodMapping<T>
Abstract base class for
HandlerMapping implementations that define
a mapping between a request and a HandlerMethod. |
class |
RequestMappingInfoHandlerMapping
Abstract base class for classes for which
RequestMappingInfo defines
the mapping between a request and a handler method. |
| Modifier and Type | Class and Description |
|---|---|
class |
RequestMappingHandlerAdapter
Supports the invocation of
@RequestMapping
handler methods. |
class |
RequestMappingHandlerMapping
An extension of
RequestMappingInfoHandlerMapping that creates
RequestMappingInfo instances from class-level and method-level
@RequestMapping annotations. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractUrlBasedView
Abstract base class for URL-based views.
|
class |
AbstractView
Base class for
View implementations. |
class |
RedirectView
View that redirects to an absolute or context relative URL.
|
class |
UrlBasedViewResolver
A
ViewResolver that allows direct resolution of symbolic view names
to URLs without explicit mapping definitions. |
| Modifier and Type | Class and Description |
|---|---|
class |
FreeMarkerConfigurer
Configures FreeMarker for web usage via the "configLocation" and/or
"freemarkerSettings" and/or "templateLoaderPath" properties.
|
class |
FreeMarkerView
A
View implementation that uses the FreeMarker template engine. |
class |
FreeMarkerViewResolver
A
ViewResolver for resolving FreeMarkerView instances, i.e. |
| Modifier and Type | Class and Description |
|---|---|
class |
ScriptTemplateView
An
AbstractUrlBasedView subclass designed to run any template library
based on a JSR-223 script engine. |
class |
ScriptTemplateViewResolver
Convenience subclass of
UrlBasedViewResolver that supports
ScriptTemplateView and custom subclasses of it. |
| Modifier and Type | Class and Description |
|---|---|
class |
DispatcherServlet
Central dispatcher for HTTP request handlers/controllers, e.g.
|
class |
FrameworkServlet
Base servlet for Spring's web framework.
|
class |
HttpServletBean
Simple extension of
HttpServlet which treats
its config parameters (init-param entries within the
servlet tag in web.xml) as bean properties. |
| Modifier and Type | Class and Description |
|---|---|
class |
DelegatingWebMvcConfiguration
A subclass of
WebMvcConfigurationSupport that detects and delegates
to all beans of type WebMvcConfigurer allowing them to customize the
configuration provided by WebMvcConfigurationSupport. |
class |
WebMvcConfigurationSupport
This is the main class providing the configuration behind the MVC Java config.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractDetectingUrlHandlerMapping
Abstract implementation of the
HandlerMapping
interface, detecting URL mappings for handler beans through introspection of all
defined beans in the application context. |
class |
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. |
class |
HandlerMappingIntrospector
Helper class to get information from the
HandlerMapping that would
serve a specific request. |
class |
SimpleServletPostProcessor
BeanPostProcessor
that applies initialization and destruction callbacks to beans that
implement the Servlet interface. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractController
Convenient superclass for controller implementations, using the Template Method
design pattern.
|
class |
AbstractUrlViewController
Abstract base class for
Controllers that return a view name
based on the request URL. |
class |
ParameterizableViewController
Trivial controller that always returns a pre-configured view and optionally
sets the response status code.
|
class |
ServletForwardingController
Spring Controller implementation that forwards to a named servlet,
i.e.
|
class |
ServletWrappingController
Spring Controller implementation that wraps a servlet instance which it manages
internally.
|
class |
UrlFilenameViewController
Simple
Controller implementation that transforms the virtual
path of a URL into a view name and returns that view. |
class |
WebContentInterceptor
Handler interceptor that checks the request for supported methods and a
required session and prepares the response by applying the configured
cache settings.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ResponseStatusExceptionResolver
A
HandlerExceptionResolver that uses the @ResponseStatus
annotation to map exceptions to HTTP status codes. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractHandlerMethodAdapter
Abstract base class for
HandlerAdapter implementations that support
handlers of type HandlerMethod. |
| Modifier and Type | Class and Description |
|---|---|
class |
ExceptionHandlerExceptionResolver
An
AbstractHandlerMethodExceptionResolver that resolves exceptions
through @ExceptionHandler methods. |
| Modifier and Type | Class and Description |
|---|---|
class |
DefaultServletHttpRequestHandler
An
HttpRequestHandler for serving static files using the Servlet container's "default" Servlet. |
class |
ResourceHttpRequestHandler
HttpRequestHandler that serves static resources in an optimized way
according to the guidelines of Page Speed, YSlow, etc. |
class |
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. |
| Modifier and Type | Class and Description |
|---|---|
class |
WebContentGenerator
Convenient superclass for any kind of web content generator,
like
AbstractController
and WebContentInterceptor. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractCachingViewResolver
Convenient base class for
ViewResolver
implementations. |
class |
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.
|
class |
AbstractTemplateViewResolver
Abstract base class for template view resolvers, in particular for FreeMarker views.
|
class |
BeanNameViewResolver
A simple implementation of
ViewResolver
that interprets a view name as a bean name in the current application context,
i.e. |
class |
ContentNegotiatingViewResolver
Implementation of
ViewResolver that resolves a view based on the request file name
or Accept header. |
class |
InternalResourceView
Wrapper for a JSP or other resource within the same web application.
|
class |
InternalResourceViewResolver
Convenient subclass of
UrlBasedViewResolver that supports
InternalResourceView (i.e. |
class |
JstlView
Specialization of
InternalResourceView for JSTL pages,
i.e. |
class |
ResourceBundleViewResolver
Deprecated.
as of 5.3, in favor of Spring's common view resolver variants
and/or custom resolver implementations
|
class |
ViewResolverComposite
A
ViewResolver that delegates to others. |
class |
XmlViewResolver
Deprecated.
as of 5.3, in favor of Spring's common view resolver variants
and/or custom resolver implementations
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractPdfStamperView
Abstract superclass for PDF views that operate on an existing
document with an AcroForm.
|
class |
AbstractPdfView
Abstract superclass for PDF views.
|
class |
AbstractXlsView
Convenient superclass for Excel document views in traditional XLS format.
|
class |
AbstractXlsxStreamingView
Convenient superclass for Excel document views in the Office 2007 XLSX format,
using POI's streaming variant.
|
class |
AbstractXlsxView
Convenient superclass for Excel document views in the Office 2007 XLSX format
(as supported by POI-OOXML).
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractAtomFeedView
Abstract superclass for Atom Feed views, using the
ROME package.
|
class |
AbstractFeedView<T extends com.rometools.rome.feed.WireFeed>
Abstract base class for Atom and RSS Feed views, using the
ROME package.
|
class |
AbstractRssFeedView
Abstract superclass for RSS Feed views, using the
ROME package.
|
| Modifier and Type | Class and Description |
|---|---|
class |
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. |
class |
GroovyMarkupView
An
AbstractTemplateView subclass based on Groovy XML/XHTML markup templates. |
class |
GroovyMarkupViewResolver
Convenience subclass of @link AbstractTemplateViewResolver} that supports
GroovyMarkupView (i.e. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractJackson2View
Abstract base class for Jackson based and content type independent
AbstractView implementations. |
class |
MappingJackson2JsonView
Spring MVC
View that renders JSON content by serializing the model for the current request
using Jackson 2's ObjectMapper. |
| Modifier and Type | Class and Description |
|---|---|
class |
TilesConfigurer
Helper class to configure Tiles 3.x for the Spring Framework.
|
class |
TilesView
View implementation that renders
through the Tiles Request API. |
class |
TilesViewResolver
Convenience subclass of
UrlBasedViewResolver that supports
TilesView (i.e. |
| Modifier and Type | Class and Description |
|---|---|
class |
MappingJackson2XmlView
Spring MVC
View that renders XML content by serializing the model for the current request
using Jackson 2's XmlMapper. |
class |
MarshallingView
Spring-MVC
View that allows for response context to be rendered as the result
of marshalling by a Marshaller. |
| Modifier and Type | Class and Description |
|---|---|
class |
XsltView
XSLT-driven View that allows for response context to be rendered as the
result of an XSLT transformation.
|
class |
XsltViewResolver
ViewResolver implementation that
resolves instances of XsltView by translating the supplied view name
into the URL of the XSLT stylesheet. |
| 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 |
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. |
class |
WebSocketMessageBrokerConfigurationSupport
Extends
AbstractMessageBrokerConfiguration and adds configuration for
receiving and responding to STOMP messages from WebSocket clients. |
| 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 |
StompSubProtocolHandler
A
SubProtocolHandler for STOMP that supports versions 1.0, 1.1, and 1.2
of the STOMP specification. |
class |
WebSocketAnnotationMethodMessageHandler
A sub-class of
SimpAnnotationMethodMessageHandler to provide support
for ControllerAdvice with global @MessageExceptionHandler methods. |
| Modifier and Type | Class and Description |
|---|---|
class |
JettyRequestUpgradeStrategy
A
RequestUpgradeStrategy for use with Jetty 9.4. |
| Modifier and Type | Class and Description |
|---|---|
class |
ServerEndpointExporter
Detects beans of type
ServerEndpointConfig and registers
with the standard Java WebSocket runtime. |
class |
ServerEndpointRegistration
An implementation of
ServerEndpointConfig for use in
Spring-based applications. |
class |
ServletServerContainerFactoryBean
A
FactoryBean for configuring ServerContainer. |
| Modifier and Type | Class and Description |
|---|---|
class |
DefaultHandshakeHandler
A default
HandshakeHandler implementation,
extending AbstractHandshakeHandler with Servlet-specific initialization support. |
class |
WebSocketHandlerMapping
An extension of
SimpleUrlHandlerMapping that is also a
SmartLifecycle container and propagates start and stop calls to any
handlers that implement Lifecycle. |
class |
WebSocketHttpRequestHandler
A
HttpRequestHandler for processing WebSocket handshake requests. |
| Modifier and Type | Class and Description |
|---|---|
class |
SockJsHttpRequestHandler
An
HttpRequestHandler that allows mapping a SockJsService to requests
in a Servlet container. |
| Modifier and Type | Class and Description |
|---|---|
class |
DefaultSockJsService
A default implementation of
SockJsService
with all default TransportHandler implementations pre-registered. |
class |
WebSocketTransportHandler
WebSocket-based
TransportHandler. |