Package | Description |
---|---|
org.springframework.aop.framework |
Package containing Spring's basic AOP infrastructure, compliant with the
AOP Alliance interfaces.
|
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.wiring |
Mechanism to determine bean wiring metadata from a bean instance.
|
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.interceptor |
AOP-based solution for declarative caching demarcation using JSR-107 annotations.
|
org.springframework.cache.support |
Support classes for the org.springframework.cache package.
|
org.springframework.cache.transaction |
Transaction-aware decorators for the org.springframework.cache package.
|
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.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.joda |
Integration with Joda-Time for formatting Joda date and time types as well as standard JDK Date types.
|
org.springframework.format.support |
Support classes for the formatting package,
providing common implementations as well as adapters.
|
org.springframework.http.client |
Contains an abstraction over client-side HTTP.
|
org.springframework.http.client.support |
This package provides generic HTTP support classes,
to be used by higher-level classes like RestTemplate.
|
org.springframework.http.converter.json |
Provides HttpMessageConverter implementations for handling JSON.
|
org.springframework.jca.cci.connection |
Provides a utility class for easy ConnectionFactory access,
a PlatformTransactionManager for local CCI transactions,
and various simple ConnectionFactory proxies/adapters.
|
org.springframework.jca.cci.core.support |
Classes supporting the
org.springframework.jca.cci.core package. |
org.springframework.jca.cci.object |
The classes in this package represent EIS operations as threadsafe,
reusable objects.
|
org.springframework.jca.endpoint |
This package provides a facility for generic JCA message endpoint management.
|
org.springframework.jca.support |
Provides generic support classes for JCA usage within Spring,
mainly for local setup of a JCA ResourceAdapter and/or ConnectionFactory.
|
org.springframework.jdbc.config |
Defines the Spring JDBC configuration namespace.
|
org.springframework.jdbc.core |
Provides the core JDBC framework, based on JdbcTemplate
and its associated callback interfaces and helper objects.
|
org.springframework.jdbc.core.namedparam |
JdbcTemplate variant with named parameter support.
|
org.springframework.jdbc.core.support |
Classes supporting the
org.springframework.jdbc.core package. |
org.springframework.jdbc.datasource |
Provides a utility class for easy DataSource access,
a PlatformTransactionManager for a single DataSource,
and various simple DataSource implementations.
|
org.springframework.jdbc.datasource.embedded |
Provides extensible support for creating embedded database instances.
|
org.springframework.jdbc.datasource.init |
Provides extensible support for initializing databases through scripts.
|
org.springframework.jdbc.datasource.lookup |
Provides a strategy for looking up JDBC DataSources by name.
|
org.springframework.jdbc.object |
The classes in this package represent RDBMS queries, updates,
and stored procedures as threadsafe, reusable objects.
|
org.springframework.jdbc.support |
Support classes for the JDBC framework, used by the classes in the
jdbc.core and jdbc.object packages.
|
org.springframework.jdbc.support.incrementer |
Provides a support framework for incrementing database table values
via sequences, with implementations for various databases.
|
org.springframework.jms.config |
Support package for declarative messaging configuration,
with Java configuration and XML schema support.
|
org.springframework.jms.connection |
Provides a PlatformTransactionManager implementation for a single
JMS ConnectionFactory, and a SingleConnectionFactory adapter.
|
org.springframework.jms.core |
Core package of the JMS support.
|
org.springframework.jms.core.support |
Classes supporting the
org.springframework.jms.core package. |
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 |
This package provides generic JMS support classes,
to be used by higher-level classes like JmsTemplate.
|
org.springframework.jms.support.converter |
Provides a MessageConverter abstraction to convert
between Java objects and JMS messages.
|
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.naming |
Provides a strategy for ObjectName creation.
|
org.springframework.jmx.support |
Contains support classes for connecting to local and remote
MBeanServer s
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.mail.javamail |
JavaMail support for Spring's mail infrastructure.
|
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.messaging.handler.invocation |
Common infrastructure for invoking message handler methods.
|
org.springframework.messaging.simp.annotation.support |
Support classes for handling messages from simple messaging protocols
(like STOMP).
|
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.oxm.castor |
Package providing integration of Castor
within Spring's O/X Mapping support.
|
org.springframework.oxm.jaxb |
Package providing integration of JAXB
with Spring's O/X Mapping support.
|
org.springframework.oxm.jibx |
Package providing integration of JiBX
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.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.commonj |
Convenience classes for scheduling based on the CommonJ WorkManager/TimerManager
facility, as supported by IBM WebSphere 6.0+ and BEA WebLogic 9.0+.
|
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.transaction.interceptor |
AOP-based solution for declarative transaction demarcation.
|
org.springframework.transaction.jta |
Transaction SPI implementation for JTA.
|
org.springframework.transaction.support |
Support classes for the org.springframework.transaction 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.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.support |
Support classes for the multipart resolution framework.
|
org.springframework.web.reactive.function.server.support |
Classes supporting the
org.springframework.web.reactive.function.server package. |
org.springframework.web.reactive.resource |
Support classes for serving static resources.
|
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.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.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.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.groovy |
Support classes for the integration of
Groovy Templates as Spring web view technology.
|
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.xslt |
Support classes for XSLT,
providing a View implementation for XSLT stylesheets.
|
org.springframework.web.socket.messaging |
WebSocket integration for Spring's messaging module.
|
org.springframework.web.socket.server.standard |
Server-side classes for use with standard JSR-356 WebSocket endpoints.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractSingletonProxyFactoryBean
Convenient superclass for
FactoryBean types that produce singleton-scoped
proxy objects. |
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 |
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 |
PreferencesPlaceholderConfigurer
Subclass of PropertyPlaceholderConfigurer that supports JDK 1.4's
Preferences API (
java.util.prefs ). |
class |
PropertiesFactoryBean
Allows for making a properties file from a classpath location available
as Properties instance in a bean factory.
|
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.
|
class |
YamlMapFactoryBean
Factory for a
Map that reads from a YAML source, preserving the
YAML-declared value types and their structure. |
class |
YamlPropertiesFactoryBean
Factory for
Properties that reads from a YAML source,
exposing a flat structure of String property values. |
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 |
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 |
ConcurrentMapCacheFactoryBean
FactoryBean for easy configuration of a ConcurrentMapCache
when used within a Spring container. |
Modifier and Type | Class and Description |
---|---|
class |
EhCacheCacheManager
CacheManager backed by an EhCache
CacheManager . |
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 . |
class |
EhCacheManagerFactoryBean
FactoryBean that exposes an EhCache CacheManager
instance (independent or shared), configured from a specified config location. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractCacheResolver
A base
CacheResolver implementation that requires the concrete
implementation to provide the collection of cache name(s) based on the
invocation context. |
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.
|
class |
NamedCacheResolver
A
CacheResolver that forces the resolution to a configurable
collection of name(s) against a given CacheManager . |
class |
SimpleCacheResolver
A simple
CacheResolver that resolves the Cache instance(s)
based on a configurable CacheManager and the name of the
cache(s) as provided by getCacheNames() |
Modifier and Type | Class and Description |
---|---|
class |
JCacheCacheManager
CacheManager implementation
backed by a JCache CacheManager . |
class |
JCacheManagerFactoryBean
FactoryBean for a JCache CacheManager ,
obtaining a pre-defined CacheManager by name through the standard
JCache Caching class. |
Modifier and Type | Class and Description |
---|---|
class |
DefaultJCacheOperationSource
The default
JCacheOperationSource implementation delegating
default operations to configurable services with sensible defaults
when not present. |
class |
JCacheAspectSupport
Base class for JSR-107 caching aspects, such as the
JCacheInterceptor
or an AspectJ aspect. |
class |
JCacheInterceptor
AOP Alliance MethodInterceptor for declarative cache
management using JSR-107 caching annotations.
|
class |
SimpleExceptionCacheResolver
A simple
CacheResolver that resolves the exception cache
based on a configurable CacheManager and the name of the
cache: CacheResultOperation.getExceptionCacheName() |
Modifier and Type | Class and Description |
---|---|
class |
AbstractCacheManager
Abstract base class implementing the common
CacheManager methods. |
class |
CompositeCacheManager
Composite
CacheManager implementation that iterates over
a given collection of delegate CacheManager instances. |
class |
SimpleCacheManager
Simple cache manager working against a given collection of caches.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractTransactionSupportingCacheManager
Base class for CacheManager implementations that want to support built-in
awareness of Spring-managed transactions.
|
class |
TransactionAwareCacheManagerProxy
Proxy for a target
CacheManager , exposing transaction-aware Cache objects
which synchronize their Cache.put(java.lang.Object, java.lang.Object) operations with Spring-managed transactions
(through Spring's TransactionSynchronizationManager ,
performing the actual cache put operation only in the after-commit phase of a successful transaction. |
Modifier and Type | Class and Description |
---|---|
class |
EventPublicationInterceptor
Interceptor that publishes an
ApplicationEvent to all ApplicationListeners
registered with an ApplicationEventPublisher after each
successful method invocation. |
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 |
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 |
ConversionServiceFactoryBean
A factory providing convenient access to a ConversionService configured with
converters appropriate for most environments.
|
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.
|
Modifier and Type | Class and Description |
---|---|
class |
DaoSupport
Generic base class for DAOs, defining template methods for DAO initialization.
|
class |
PersistenceExceptionTranslationInterceptor
AOP Alliance MethodInterceptor that provides persistence exception translation
based on a given PersistenceExceptionTranslator.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractRemoteSlsbInvokerInterceptor
Base class for interceptors proxying remote Stateless Session Beans.
|
class |
AbstractSlsbInvokerInterceptor
Base class for AOP interceptors invoking local or remote Stateless Session Beans.
|
class |
LocalSlsbInvokerInterceptor
Invoker for a local Stateless Session Bean.
|
class |
LocalStatelessSessionProxyFactoryBean
Convenient
FactoryBean for local Stateless Session Bean (SLSB) proxies. |
class |
SimpleRemoteSlsbInvokerInterceptor
Basic invoker for a remote Stateless Session Bean.
|
class |
SimpleRemoteStatelessSessionProxyFactoryBean
Convenient
FactoryBean for remote SLSB proxies. |
Modifier and Type | Class and Description |
---|---|
class |
DateTimeFormatterFactoryBean
FactoryBean that creates a Joda-Time DateTimeFormatter . |
Modifier and Type | Class and Description |
---|---|
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 |
HttpComponentsAsyncClientHttpRequestFactory
Deprecated.
as of Spring 5.0, with no direct replacement
|
class |
Netty4ClientHttpRequestFactory
Deprecated.
as of Spring 5.0, in favor of
ReactorClientHttpConnector |
Modifier and Type | Class and Description |
---|---|
class |
ProxyFactoryBean
FactoryBean that creates a java.net.Proxy . |
Modifier and Type | Class and Description |
---|---|
class |
GsonFactoryBean
A
FactoryBean for creating a Google Gson 2.x Gson instance. |
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 | Class and Description |
---|---|
class |
CciLocalTransactionManager
PlatformTransactionManager implementation
that manages local transactions for a single CCI ConnectionFactory. |
class |
ConnectionSpecConnectionFactoryAdapter
An adapter for a target CCI
ConnectionFactory ,
applying the given ConnectionSpec to every standard getConnection()
call, that is, implicitly invoking getConnection(ConnectionSpec)
on the target. |
class |
TransactionAwareConnectionFactoryProxy
Proxy for a target CCI
ConnectionFactory , adding
awareness of Spring-managed transactions. |
Modifier and Type | Class and Description |
---|---|
class |
CciDaoSupport
Convenient super class for CCI-based data access objects.
|
Modifier and Type | Class and Description |
---|---|
class |
EisOperation
Base class for EIS operation objects that work with the CCI API.
|
class |
MappingCommAreaOperation
EIS operation object for access to COMMAREA records.
|
class |
MappingRecordOperation
EIS operation object that expects mapped input and output objects,
converting to and from CCI Records.
|
class |
SimpleRecordOperation
EIS operation object that accepts a passed-in CCI input Record
and returns a corresponding CCI output Record.
|
Modifier and Type | Class and Description |
---|---|
class |
GenericMessageEndpointManager
Generic bean that manages JCA 1.7 message endpoints within a Spring
application context, activating and deactivating the endpoint as part
of the application context's lifecycle.
|
Modifier and Type | Class and Description |
---|---|
class |
LocalConnectionFactoryBean
FactoryBean that creates
a local JCA connection factory in "non-managed" mode (as defined by the
Java Connector Architecture specification). |
class |
ResourceAdapterFactoryBean
FactoryBean that bootstraps
the specified JCA 1.7 ResourceAdapter ,
starting it with a local BootstrapContext
and exposing it for bean references. |
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 |
JdbcTemplate
This is the central class in the JDBC core package.
It simplifies the use of JDBC and helps to avoid common errors.
|
Modifier and Type | Class and Description |
---|---|
class |
NamedParameterJdbcDaoSupport
Extension of JdbcDaoSupport that exposes a NamedParameterJdbcTemplate as well.
|
Modifier and Type | Class and Description |
---|---|
class |
JdbcDaoSupport
Convenient super class for JDBC-based data access objects.
|
Modifier and Type | Class and Description |
---|---|
class |
DataSourceTransactionManager
PlatformTransactionManager
implementation for a single JDBC DataSource . |
class |
DelegatingDataSource
JDBC
DataSource implementation that delegates all calls
to a given target DataSource . |
class |
IsolationLevelDataSourceAdapter
An adapter for a target
DataSource , applying the current
Spring transaction's isolation level (and potentially specified user credentials)
to every getConnection call. |
class |
LazyConnectionDataSourceProxy
Proxy for a target DataSource, fetching actual JDBC Connections lazily,
i.e.
|
class |
TransactionAwareDataSourceProxy
Proxy for a target JDBC
DataSource , adding awareness of
Spring-managed transactions. |
class |
UserCredentialsDataSourceAdapter
An adapter for a target JDBC
DataSource , applying the specified
user credentials to every standard getConnection() call, implicitly
invoking getConnection(username, password) on the target. |
class |
WebSphereDataSourceAdapter
DataSource implementation that delegates all calls to a WebSphere
target DataSource , typically obtained from JNDI, applying a current
isolation level and/or current user credentials to every Connection obtained
from it. |
Modifier and Type | Class and Description |
---|---|
class |
EmbeddedDatabaseFactoryBean
A subclass of
EmbeddedDatabaseFactory that implements FactoryBean
for registration as a Spring bean. |
Modifier and Type | Class and Description |
---|---|
class |
DataSourceInitializer
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractRoutingDataSource
Abstract
DataSource implementation that routes AbstractRoutingDataSource.getConnection()
calls to one of various target DataSources based on a lookup key. |
class |
IsolationLevelDataSourceRouter
DataSource that routes to one of various target DataSources based on the
current transaction isolation level.
|
Modifier and Type | Class and Description |
---|---|
class |
BatchSqlUpdate
SqlUpdate subclass that performs batch update operations.
|
class |
GenericSqlQuery<T>
|
class |
GenericStoredProcedure
Concrete implementation making it possible to define the RDBMS stored procedures
in an application context without writing a custom Java implementation class.
|
class |
MappingSqlQuery<T>
Reusable query in which concrete subclasses must implement the abstract
mapRow(ResultSet, int) method to convert each row of the JDBC ResultSet
into an object.
|
class |
MappingSqlQueryWithParameters<T>
Reusable RDBMS query in which concrete subclasses must implement
the abstract mapRow(ResultSet, int) method to map each row of
the JDBC ResultSet into an object.
|
class |
RdbmsOperation
An "RDBMS operation" is a multi-threaded, reusable object representing a query,
update, or stored procedure call.
|
class |
SqlCall
RdbmsOperation using a JdbcTemplate and representing a SQL-based
call such as a stored procedure or a stored function.
|
class |
SqlFunction<T>
SQL "function" wrapper for a query that returns a single row of results.
|
class |
SqlOperation
Operation object representing a SQL-based operation such as a query or update,
as opposed to a stored procedure.
|
class |
SqlQuery<T>
Reusable operation object representing a SQL query.
|
class |
SqlUpdate
Reusable operation object representing a SQL update.
|
class |
StoredProcedure
Superclass for object abstractions of RDBMS stored procedures.
|
class |
UpdatableSqlQuery<T>
Reusable RDBMS query in which concrete subclasses must implement
the abstract updateRow(ResultSet, int, context) method to update each
row of the JDBC ResultSet and optionally map contents into an object.
|
Modifier and Type | Class and Description |
---|---|
class |
CustomSQLExceptionTranslatorRegistrar
Registry for custom
SQLExceptionTranslator instances for specific databases. |
class |
DatabaseStartupValidator
Bean that checks if a database has already started up.
|
class |
JdbcAccessor
Base class for
JdbcTemplate and
other JDBC-accessing DAO helpers, defining common properties such as
DataSource and exception translator. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractColumnMaxValueIncrementer
Abstract base class for
DataFieldMaxValueIncrementer implementations that use
a column in a custom sequence table. |
class |
AbstractDataFieldMaxValueIncrementer
Base implementation of
DataFieldMaxValueIncrementer that delegates
to a single AbstractDataFieldMaxValueIncrementer.getNextKey() template method that returns a long . |
class |
AbstractIdentityColumnMaxValueIncrementer
Abstract base class for
DataFieldMaxValueIncrementer implementations
which are based on identity columns in a sequence-like table. |
class |
AbstractSequenceMaxValueIncrementer
Abstract base class for
DataFieldMaxValueIncrementer implementations that use
a database sequence. |
class |
Db2LuwMaxValueIncrementer
DataFieldMaxValueIncrementer that retrieves the next value
of a given sequence on DB2 LUW (for Linux, Unix and Windows). |
class |
Db2MainframeMaxValueIncrementer
DataFieldMaxValueIncrementer that retrieves the next value
of a given sequence on DB2 for the mainframe (z/OS, DB2/390, DB2/400). |
class |
DB2MainframeSequenceMaxValueIncrementer
Deprecated.
in favor of the differently named
Db2MainframeMaxValueIncrementer |
class |
DB2SequenceMaxValueIncrementer
Deprecated.
in favor of the specifically named
Db2LuwMaxValueIncrementer |
class |
DerbyMaxValueIncrementer
DataFieldMaxValueIncrementer that increments the maximum value of a given Derby table
with the equivalent of an auto-increment column. |
class |
H2SequenceMaxValueIncrementer
DataFieldMaxValueIncrementer that retrieves the next value
of a given H2 sequence. |
class |
HanaSequenceMaxValueIncrementer
DataFieldMaxValueIncrementer that retrieves the next value
of a given SAP HANA sequence. |
class |
HsqlMaxValueIncrementer
DataFieldMaxValueIncrementer that increments the maximum value of a given HSQL table
with the equivalent of an auto-increment column. |
class |
HsqlSequenceMaxValueIncrementer
DataFieldMaxValueIncrementer that retrieves the next value
of a given HSQL sequence. |
class |
MySQLMaxValueIncrementer
DataFieldMaxValueIncrementer that increments the maximum value of a given MySQL table
with the equivalent of an auto-increment column. |
class |
OracleSequenceMaxValueIncrementer
DataFieldMaxValueIncrementer that retrieves the next value
of a given Oracle sequence. |
class |
PostgreSQLSequenceMaxValueIncrementer
Deprecated.
in favor of the differently named
PostgresSequenceMaxValueIncrementer |
class |
PostgresSequenceMaxValueIncrementer
DataFieldMaxValueIncrementer that retrieves the next value
of a given PostgreSQL sequence. |
class |
SqlServerMaxValueIncrementer
DataFieldMaxValueIncrementer that increments the maximum value of a given SQL Server table
with the equivalent of an auto-increment column. |
class |
SybaseAnywhereMaxValueIncrementer
DataFieldMaxValueIncrementer that increments the maximum value of a given Sybase table
with the equivalent of an auto-increment column. |
class |
SybaseMaxValueIncrementer
DataFieldMaxValueIncrementer that increments the maximum value of a given Sybase table
with the equivalent of an auto-increment column. |
Modifier and Type | Class and Description |
---|---|
class |
JmsListenerEndpointRegistrar
Helper bean for registering
JmsListenerEndpoint with a JmsListenerEndpointRegistry . |
Modifier and Type | Class and Description |
---|---|
class |
CachingConnectionFactory
|
class |
DelegatingConnectionFactory
ConnectionFactory implementation that delegates all calls
to a given target ConnectionFactory , adapting specific
create(Queue/Topic)Connection calls to the target ConnectionFactory
if necessary (e.g. |
class |
JmsTransactionManager
PlatformTransactionManager implementation
for a single JMS ConnectionFactory . |
class |
SingleConnectionFactory
A JMS ConnectionFactory adapter that returns the same Connection
from all
SingleConnectionFactory.createConnection() calls, and ignores calls to
Connection.close() . |
class |
UserCredentialsConnectionFactoryAdapter
An adapter for a target JMS
ConnectionFactory , applying the
given user credentials to every standard createConnection() call,
that is, implicitly invoking createConnection(username, password)
on the target. |
Modifier and Type | Class and Description |
---|---|
class |
JmsMessagingTemplate
An implementation of
JmsMessageOperations . |
class |
JmsTemplate
Helper class that simplifies synchronous JMS access code.
|
Modifier and Type | Class and Description |
---|---|
class |
JmsGatewaySupport
Convenient super class for application classes that need JMS access.
|
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 |
JmsMessageEndpointManager
Extension of the generic JCA 1.5
GenericMessageEndpointManager ,
adding JMS-specific support for ActivationSpec configuration. |
Modifier and Type | Class and Description |
---|---|
class |
JmsInvokerClientInterceptor
MethodInterceptor for accessing a
JMS-based remote service. |
class |
JmsInvokerProxyFactoryBean
FactoryBean for JMS invoker proxies.
|
class |
JmsInvokerServiceExporter
JMS message listener that exports the specified service bean as a
JMS service endpoint, accessible via a JMS invoker proxy.
|
Modifier and Type | Class and Description |
---|---|
class |
JmsAccessor
Base class for
JmsTemplate and other
JMS-accessing gateway helpers, defining common properties such as the
JMS ConnectionFactory to operate on. |
Modifier and Type | Class and Description |
---|---|
class |
MarshallingMessageConverter
|
class |
MessagingMessageConverter
Convert a
Message from the messaging abstraction to and from a
Message using an underlying MessageConverter
for the payload and a JmsHeaderMapper
to map the JMS headers to and from standard message headers. |
Modifier and Type | Class and Description |
---|---|
class |
JmsDestinationAccessor
Base class for
JmsTemplate and other
JMS-accessing gateway helpers, adding destination-related properties to
JmsAccessor's common properties. |
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.
|
class |
NotificationListenerRegistrar
Registrar object that associates a specific
NotificationListener
with one or more MBeans in an MBeanServer
(typically via a MBeanServerConnection ). |
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. |
class |
NotificationListenerBean
Helper class that aggregates a
NotificationListener ,
a NotificationFilter , and an arbitrary handback object. |
Modifier and Type | Class and Description |
---|---|
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. |
class |
MetadataMBeanInfoAssembler
Implementation of the
MBeanInfoAssembler interface that reads
the management interface information from source level metadata. |
Modifier and Type | Class and Description |
---|---|
class |
KeyNamingStrategy
ObjectNamingStrategy implementation that builds
ObjectName instances from the key used in the
"beans" map passed to MBeanExporter . |
class |
MetadataNamingStrategy
An implementation of the
ObjectNamingStrategy interface
that reads the ObjectName from the source-level metadata. |
Modifier and Type | Class and Description |
---|---|
class |
ConnectorServerFactoryBean
FactoryBean that creates a JSR-160 JMXConnectorServer ,
optionally registers it with the MBeanServer and then starts it. |
class |
MBeanServerConnectionFactoryBean
FactoryBean that creates a JMX 1.2 MBeanServerConnection
to a remote MBeanServer exposed via a JMXServerConnector . |
class |
MBeanServerFactoryBean
FactoryBean that obtains an MBeanServer reference
through the standard JMX 1.2 MBeanServerFactory
API (which is available on JDK 1.5 or as part of a JMX 1.2 provider). |
class |
WebSphereMBeanServerFactoryBean
FactoryBean that obtains a WebSphere MBeanServer
reference through WebSphere's proprietary AdminServiceFactory API,
available on WebSphere 5.1 and higher. |
Modifier and Type | Class and Description |
---|---|
class |
JndiObjectFactoryBean
FactoryBean that looks up a
JNDI object. |
class |
JndiObjectLocator
Convenient superclass for JNDI-based service locators,
providing configurable lookup of a specific JNDI resource.
|
class |
JndiObjectTargetSource
AOP
TargetSource that provides
configurable JNDI lookups for getTarget() calls. |
Modifier and Type | Class and Description |
---|---|
class |
ConfigurableMimeFileTypeMap
Spring-configurable
FileTypeMap implementation that will read
MIME type to file extension mappings from a standard JavaMail MIME type
mapping file, using a standard MimetypesFileTypeMap underneath. |
Modifier and Type | Class and Description |
---|---|
class |
CachingDestinationResolverProxy<D>
DestinationResolver implementation that proxies a target DestinationResolver,
caching its CachingDestinationResolverProxy.resolveDestination(java.lang.String) results. |
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 |
SimpAnnotationMethodMessageHandler
A handler for messages delegating to
@MessageMapping
and @SubscribeMapping annotated methods. |
Modifier and Type | Class and Description |
---|---|
class |
HibernateTemplate
Helper class that simplifies Hibernate data access code.
|
class |
HibernateTransactionManager
PlatformTransactionManager
implementation for a single Hibernate SessionFactory . |
class |
LocalSessionFactoryBean
FactoryBean that creates a Hibernate
SessionFactory . |
Modifier and Type | Class and Description |
---|---|
class |
HibernateDaoSupport
Convenient super class for Hibernate-based data access objects.
|
class |
OpenSessionInterceptor
Simple AOP Alliance
MethodInterceptor implementation that binds a new
Hibernate Session for each method invocation, if none bound before. |
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 |
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 |
SharedEntityManagerBean
FactoryBean that exposes a shared JPA EntityManager
reference for a given EntityManagerFactory. |
Modifier and Type | Class and Description |
---|---|
class |
CastorMarshaller
Deprecated.
as of Spring Framework 4.3.13, due to the lack of activity on the Castor project
|
Modifier and Type | Class and Description |
---|---|
class |
Jaxb2Marshaller
Implementation of the
GenericMarshaller interface for JAXB 2.2. |
Modifier and Type | Class and Description |
---|---|
class |
JibxMarshaller
Implementation of the
Marshaller and Unmarshaller interfaces for JiBX. |
Modifier and Type | Class and Description |
---|---|
class |
XStreamMarshaller
Implementation of the
Marshaller interface for XStream. |
Modifier and Type | Class and Description |
---|---|
class |
HessianClientInterceptor
MethodInterceptor for accessing a Hessian service. |
class |
HessianExporter
General stream-based protocol exporter for a Hessian endpoint.
|
class |
HessianProxyFactoryBean
FactoryBean for Hessian proxies. |
class |
HessianServiceExporter
Servlet-API-based HTTP request handler that exports the specified service bean
as Hessian service endpoint, accessible via a Hessian proxy.
|
class |
SimpleHessianServiceExporter
HTTP request handler that exports the specified service bean as
Hessian service endpoint, accessible via a Hessian proxy.
|
Modifier and Type | Class and Description |
---|---|
class |
HttpInvokerClientInterceptor
MethodInterceptor for accessing an
HTTP invoker service. |
class |
HttpInvokerProxyFactoryBean
FactoryBean for HTTP invoker proxies. |
class |
HttpInvokerServiceExporter
Servlet-API-based HTTP request handler that exports the specified service bean
as HTTP invoker service endpoint, accessible via an HTTP invoker proxy.
|
class |
SimpleHttpInvokerServiceExporter
HTTP request handler that exports the specified service bean as
HTTP invoker service endpoint, accessible via an HTTP invoker proxy.
|
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 |
LocalJaxWsServiceFactoryBean
FactoryBean for locally
defined JAX-WS Service references. |
class |
SimpleHttpServerJaxWsServiceExporter
Simple exporter for JAX-WS services, autodetecting annotated service beans
(through the JAX-WS
WebService annotation) and exporting
them through the HTTP server included in Sun's JDK 1.6. |
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 |
JndiRmiClientInterceptor
MethodInterceptor for accessing RMI services
from JNDI. |
class |
JndiRmiProxyFactoryBean
FactoryBean for RMI proxies from JNDI. |
class |
JndiRmiServiceExporter
Service exporter which binds RMI services to JNDI.
|
class |
RemoteInvocationSerializingExporter
Abstract base class for remote service exporters that explicitly deserialize
RemoteInvocation objects and serialize
RemoteInvocationResult objects,
for example Spring's HTTP invoker. |
class |
RmiClientInterceptor
MethodInterceptor for accessing conventional
RMI services or RMI invokers. |
class |
RmiProxyFactoryBean
FactoryBean for RMI proxies, supporting both conventional RMI services
and RMI invokers. |
class |
RmiRegistryFactoryBean
FactoryBean that locates a Registry and
exposes it for bean references. |
class |
RmiServiceExporter
RMI exporter that exposes the specified service as RMI object with the specified name.
|
Modifier and Type | Class and Description |
---|---|
class |
RemoteInvocationBasedAccessor
Abstract base class for remote service accessors that are based
on serialization of
RemoteInvocation objects. |
class |
SimpleHttpServerFactoryBean
FactoryBean that creates a simple
HTTP server, based on the HTTP server that is included in Sun's JRE 1.6. |
class |
UrlBasedRemoteAccessor
Abstract base class for classes that access remote services via URLs.
|
Modifier and Type | Class and Description |
---|---|
class |
TimerManagerAccessor
Base class for classes that are accessing a CommonJ
TimerManager
Defines common configuration settings and common lifecycle handling. |
class |
TimerManagerFactoryBean
FactoryBean that retrieves a
CommonJ TimerManager and exposes it for bean references. |
class |
TimerManagerTaskScheduler
Implementation of Spring's
TaskScheduler interface, wrapping
a CommonJ TimerManager . |
class |
WorkManagerTaskExecutor
TaskExecutor implementation that delegates to a CommonJ WorkManager,
implementing the
WorkManager interface,
which either needs to be specified as reference or through the JNDI name. |
Modifier and Type | Class and Description |
---|---|
class |
DefaultManagedAwareThreadFactory
JNDI-based variant of
CustomizableThreadFactory , performing a default lookup
for JSR-236's "java:comp/DefaultManagedThreadFactory" in a Java EE 7 environment,
falling back to the local CustomizableThreadFactory setup if not found. |
class |
DefaultManagedTaskExecutor
JNDI-based variant of
ConcurrentTaskExecutor , performing a default lookup for
JSR-236's "java:comp/DefaultManagedExecutorService" in a Java EE 7 environment. |
class |
DefaultManagedTaskScheduler
JNDI-based variant of
ConcurrentTaskScheduler , performing a default lookup for
JSR-236's "java:comp/DefaultManagedScheduledExecutorService" in a Java EE 7 environment. |
class |
ExecutorConfigurationSupport
Base class for setting up a
ExecutorService
(typically a ThreadPoolExecutor or
ScheduledThreadPoolExecutor ). |
class |
ForkJoinPoolFactoryBean
A Spring
FactoryBean that builds and exposes a preconfigured ForkJoinPool . |
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 |
ContextLifecycleScheduledTaskRegistrar
ScheduledTaskRegistrar subclass which redirects the actual scheduling
of tasks to the ContextLifecycleScheduledTaskRegistrar.afterSingletonsInstantiated() callback (as of 4.1.2). |
class |
ScheduledTaskRegistrar
Helper bean for registering tasks with a
TaskScheduler , typically using cron
expressions. |
class |
TaskExecutorFactoryBean
FactoryBean for creating ThreadPoolTaskExecutor instances,
primarily used behind the XML task namespace. |
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 |
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 |
SimpleThreadPoolTaskExecutor
Subclass of Quartz's SimpleThreadPool that implements Spring's
TaskExecutor interface
and listens to Spring lifecycle callbacks. |
class |
SimpleTriggerFactoryBean
A Spring
FactoryBean for creating a Quartz SimpleTrigger
instance, supporting bean-style usage for trigger configuration. |
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 |
MethodMapTransactionAttributeSource
Simple
TransactionAttributeSource implementation that
allows attributes to be stored per method in a Map . |
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 ). |
class |
TransactionProxyFactoryBean
Proxy factory bean for simplified declarative transaction handling.
|
Modifier and Type | Class and Description |
---|---|
class |
JtaTransactionManager
PlatformTransactionManager implementation
for JTA, delegating to a backend JTA provider. |
class |
WebLogicJtaTransactionManager
Special
JtaTransactionManager variant for BEA WebLogic (9.0 and higher). |
class |
WebSphereUowTransactionManager
WebSphere-specific PlatformTransactionManager implementation that delegates
to a
UOWManager instance, obtained from WebSphere's
JNDI environment. |
Modifier and Type | Class and Description |
---|---|
class |
TransactionTemplate
Template class that simplifies programmatic transaction demarcation and
transaction exception handling.
|
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 |
BeanValidationPostProcessor
Simple
BeanPostProcessor that checks JSR-303 constraint annotations
in Spring-managed beans, throwing an initialization exception in case of
constraint violations right before calling the bean's init method (if any). |
class |
CustomValidatorBean
Configurable bean class that exposes a specific JSR-303 Validator
through its original interface as well as through the Spring
Validator interface. |
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
one or more ContentNegotiationStrategy instances. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractRefreshableWebApplicationContext
AbstractRefreshableApplicationContext
subclass which implements the
ConfigurableWebApplicationContext
interface for web environments. |
class |
AnnotationConfigWebApplicationContext
WebApplicationContext
implementation which accepts annotated 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 |
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
Filter s 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 that handles CORS preflight requests and intercepts
CORS simple and actual requests thanks to a CorsProcessor implementation
(DefaultCorsProcessor by default) in order to add the relevant CORS
response headers (like Access-Control-Allow-Origin ) using the provided
CorsConfigurationSource (for example an UrlBasedCorsConfigurationSource
instance. |
class |
DelegatingFilterProxy
Proxy for a standard Servlet Filter, delegating to a Spring-managed bean that
implements the Filter interface.
|
class |
ForwardedHeaderFilter
Extract values from "Forwarded" and "X-Forwarded-*" headers in order to wrap
and override the following from the request and response:
getServerName() ,
getServerPort() ,
getScheme() ,
isSecure() , and
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
Filter that makes form encoded data available through
the ServletRequest.getParameter*() family of methods during HTTP PUT
or PATCH requests. |
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 |
MultipartFilter
Servlet Filter that resolves multipart requests via a
MultipartResolver . |
Modifier and Type | Class and Description |
---|---|
class |
RouterFunctionMapping
HandlerMapping implementation that supports RouterFunction s. |
class |
ServerResponseResultHandler
HandlerResultHandler implementation that supports ServerResponse s. |
Modifier and Type | Class and Description |
---|---|
class |
ResourceWebHandler
HttpRequestHandler that serves static resources in an optimized way
according to the guidelines of Page Speed, YSlow, etc. |
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 |
RedirectView
View that redirects to an absolute or context relative URL.
|
class |
UrlBasedViewResolver
A
ViewResolver that allow direct resolution of symbolic view names
to URLs without explicit mapping definition. |
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 |
HandlerMappingIntrospector
Helper class to get information from the
HandlerMapping that would
serve a specific request. |
Modifier and Type | Class and Description |
---|---|
class |
ServletWrappingController
Spring Controller implementation that wraps a servlet instance which it manages
internally.
|
Modifier and Type | Class and Description |
---|---|
class |
ExceptionHandlerExceptionResolver
An
AbstractHandlerMethodExceptionResolver that resolves exceptions
through @ExceptionHandler methods. |
Modifier and Type | Class and Description |
---|---|
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 |
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 |
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 |
JstlView
Specialization of
InternalResourceView for JSTL pages,
i.e. |
class |
ResourceBundleViewResolver
A
ViewResolver implementation that uses
bean definitions in a ResourceBundle , specified by the bundle basename. |
class |
ViewResolverComposite
A
ViewResolver that delegates to others. |
class |
XmlViewResolver
A
ViewResolver implementation that uses
bean definitions in a dedicated XML file for view definitions, specified by
resource location. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractPdfStamperView
Abstract superclass for PDF views that operate on an existing
document with an AcroForm.
|
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. |
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. |
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.
|
Modifier and Type | Class and Description |
---|---|
class |
WebSocketAnnotationMethodMessageHandler
A sub-class of
SimpAnnotationMethodMessageHandler to provide support
for ControllerAdvice with global @MessageExceptionHandler methods. |
Modifier and Type | Class and Description |
---|---|
class |
ServerEndpointExporter
Detects beans of type
ServerEndpointConfig and registers
with the standard Java WebSocket runtime. |
class |
ServletServerContainerFactoryBean
A
FactoryBean for configuring ServerContainer . |