| 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 |
Generic support classes for target source creation.
|
| 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 |
This package contains implementations of the org.springframework.aop.TargetSource interface.
|
| 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 JDK 1.6 ServiceLoader facility.
|
| 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.concurrent |
Implementation package for
java.util.concurrent based caches. |
| org.springframework.cache.ehcache |
Support classes for the open source cache
EhCache,
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.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.number |
Formatters for
java.lang.Number properties. |
| org.springframework.format.support |
Support classes for the formatting package,
providing common implementations as well as adapters.
|
| org.springframework.jca.context |
Integration package that allows for deploying a Spring application context
as a JCA 1.5 compliant RAR file.
|
| org.springframework.jca.work |
Convenience classes for scheduling based on the JCA 1.5 WorkManager facility,
as supported within JCA 1.5 ResourceAdapters.
|
| org.springframework.jca.work.glassfish |
Convenience package for obtaining a GlassFish JCA WorkManager for use in
web applications.
|
| org.springframework.jca.work.jboss |
Convenience package for obtaining a JBoss JCA WorkManager for use in
web applications.
|
| 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.listener |
This package contains the base message listener container facility.
|
| 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 |
JDK 1.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.orm.hibernate3 |
Package providing integration of
Hibernate 3.x
with Spring concepts.
|
| org.springframework.orm.hibernate3.annotation |
Support package for the Hibernate3 Annotation add-on,
which supports EJB3-compliant JDK 1.5+ annotations for mappings.
|
| org.springframework.orm.hibernate3.support |
Classes supporting the
org.springframework.orm.hibernate3 package. |
| org.springframework.orm.jdo |
Package providing integration of JDO (Java Date Objects) with Spring concepts.
|
| org.springframework.orm.jdo.support |
Classes supporting the
org.springframework.orm.jdo 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.castor |
Package providing integration of Castor within Springs O/X Mapping
support
|
| org.springframework.oxm.jaxb |
Package providing integration of JAXB with Springs O/X Mapping
support
|
| org.springframework.oxm.xstream |
Package providing integration of XStream with Springs O/X Mapping support
|
| org.springframework.remoting.caucho |
This package provides remoting classes for Caucho's Hessian and Burlap
protocols: a proxy factory for accessing Hessian/Burlap services,
and an exporter for making beans available to Hessian/Burlap clients.
|
| org.springframework.remoting.httpinvoker |
Remoting classes for transparent Java-to-Java remoting via HTTP invokers.
|
| org.springframework.remoting.jaxrpc |
Remoting classes for Web Services via JAX-RPC.
|
| 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 |
JDK 1.5+ annotation for asynchronous method execution.
|
| org.springframework.scheduling.concurrent |
Scheduling convenience classes for the JDK 1.5+ Executor mechanism
in the
java.util.concurrent package, allowing to set up a
ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring
context. |
| org.springframework.scheduling.config |
Support package for declarative scheduling configuration,
with XML schema being the primary configuration format.
|
| org.springframework.scheduling.support |
Generic support classes for scheduling.
|
| org.springframework.scheduling.timer |
Scheduling convenience classes for the JDK Timer,
allowing to set up Timers and ScheduledTimerTasks
as beans in a Spring context.
|
| org.springframework.scripting.groovy |
Package providing integration of
Groovy
into Spring's scripting infrastructure.
|
| org.springframework.scripting.jruby |
Package providing integration of
JRuby
into Spring's scripting infrastructure.
|
| org.springframework.scripting.support |
Support classes for Spring's scripting package.
|
| org.springframework.test.context.junit38 |
Support classes for ApplicationContext-based and transactional
tests run with JUnit 3.8 and the Spring TestContext Framework.
|
| org.springframework.test.context.junit4 |
Support classes for ApplicationContext-based and transactional
tests run with JUnit 4.5+ and the Spring TestContext Framework.
|
| org.springframework.test.context.testng |
Support classes for ApplicationContext-based and transactional
tests run with TestNG and the Spring TestContext Framework.
|
| org.springframework.transaction.annotation |
JDK 1.5+ annotation for transaction demarcation.
|
| org.springframework.transaction.interceptor |
AOP-based solution for declarative transaction demarcation.
|
| org.springframework.ui.freemarker |
Support classes for setting up
FreeMarker
within a Spring application context.
|
| org.springframework.ui.velocity |
Support classes for setting up
Velocity
within a Spring application context.
|
| org.springframework.validation.beanvalidation |
Support classes for integrating a JSR-303 Bean Validation provider
(such as Hibernate Validator 4.0) 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
Jakarta Commons FileUpload.
|
| org.springframework.web.multipart.support |
Support classes for the multipart resolution framework.
|
| org.springframework.web.portlet |
Provides JSR-168 portlets that integrate with the application context
infrastructure, and the core interfaces and classes for the Portlet
variant of Spring's web MVC framework.
|
| org.springframework.web.portlet.context |
Support for Spring's application context concept in a portlet environment,
including ApplicationContext implementations and various utility classes.
|
| org.springframework.web.portlet.handler |
Provides standard HandlerMapping implementations,
including abstract base classes for custom implementations.
|
| org.springframework.web.portlet.multipart |
Multipart resolution framework for handling file uploads.
|
| org.springframework.web.portlet.mvc |
Standard controller implementations for the portlet MVC framework that
comes with Spring.
|
| 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.mvc.multiaction |
Package allowing MVC Controller implementations to handle requests
at method rather than class level.
|
| org.springframework.web.servlet.mvc.support |
Support package for MVC controllers.
|
| 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.freemarker |
Support classes for the integration of
FreeMarker
as Spring web view technology.
|
| org.springframework.web.servlet.view.jasperreports |
Support classes for the integration of
JasperReports
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.tiles |
Support classes for the integration of
Tiles
(included in Struts) as Spring web view technology.
|
| org.springframework.web.servlet.view.tiles2 |
Support classes for the integration of
Tiles2
(the standalone version of Tiles) as Spring web view technology.
|
| org.springframework.web.servlet.view.velocity |
Support classes for the integration of
Velocity
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.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AspectJExpressionPointcut
Spring
Pointcut implementation
that uses the AspectJ weaver to evaluate a 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. |
| 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 |
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:
: CommonsPoolTargetSource
% ThreadLocalTargetSource
! PrototypeTargetSource
|
| Modifier and Type | Class and Description |
|---|---|
class |
AsyncExecutionAspectSupport
Base class for asynchronous method execution aspects, such as
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 |
CommonsPoolTargetSource
TargetSource implementation that holds
objects in a configurable Apache Commons 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
BeanPostProcessor implementation
that enforces required JavaBean properties to have been configured. |
| 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 |
BeanReferenceFactoryBean
Deprecated.
as of Spring 3.2, in favor of using regular bean name aliases
(which support placeholder parsing since Spring 2.5)
|
class |
CustomEditorConfigurer
BeanFactoryPostProcessor implementation that allows for convenient
registration of custom property editors. |
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 |
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
Subclass of PropertyPlaceholderConfigurer that supports JDK 1.4's
Preferences API (
java.util.prefs). |
class |
PropertyPathFactoryBean
FactoryBean that evaluates a property path on a given target object. |
class |
PropertyPlaceholderConfigurer
PlaceholderConfigurerSupport subclass that resolves ${...} placeholders
against local properties and/or system properties
and environment variables. |
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 |
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 |
ConcurrentMapCacheFactoryBean
FactoryBean for easy configuration of a ConcurrentMapCache
when used within a Spring container. |
| 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 |
CacheProxyFactoryBean
Proxy factory bean for simplified declarative caching handling.
|
| 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 |
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 scans the classpath 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 |
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 |
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 |
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
Adapter for live beans view exposure, building a snapshot of current beans
and their dependencies from either a local
ApplicationContext (with a
local LiveBeansView bean definition) or all registered ApplicationContexts
(driven by the "spring.liveBeansView.mbeanDomain" environment property). |
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
Formats fields annotated with the
DateTimeFormat annotation using Joda-Time. |
| Modifier and Type | Class and Description |
|---|---|
class |
NumberFormatAnnotationFormatterFactory
Formats fields annotated with the
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 | 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 |
WorkManagerTaskExecutor
TaskExecutor implementation
that delegates to a JCA 1.5 WorkManager, implementing the
WorkManager interface. |
| Modifier and Type | Class and Description |
|---|---|
class |
GlassFishWorkManagerTaskExecutor
Spring TaskExecutor adapter for the GlassFish JCA WorkManager.
|
| Modifier and Type | Class and Description |
|---|---|
class |
JBossWorkManagerTaskExecutor
Spring TaskExecutor adapter for the JBoss JCA WorkManager.
|
| 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 |
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 message listener containers.
|
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 |
DefaultMessageListenerContainer102
Deprecated.
as of Spring 3.0, in favor of the JMS 1.1 based
DefaultMessageListenerContainer |
class |
SimpleMessageListenerContainer
Message listener container that uses the plain JMS client API's
MessageConsumer.setMessageListener() method to
create concurrent MessageConsumers for the specified listeners. |
class |
SimpleMessageListenerContainer102
Deprecated.
as of Spring 3.0, in favor of the JMS 1.1 based
SimpleMessageListenerContainer |
| Modifier and Type | Class and Description |
|---|---|
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 |
MappingJackson2MessageConverter
Message converter that uses the Jackson 2 library to convert messages to and from JSON.
|
class |
MappingJacksonMessageConverter
Message converter that uses Jackson 1.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 JDK 1.5+ 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 |
FilterDefinitionFactoryBean
Convenient FactoryBean for defining Hibernate FilterDefinitions.
|
class |
HibernateAccessor
Base class for
HibernateTemplate and HibernateInterceptor,
defining common properties such as SessionFactory and flushing behavior. |
class |
HibernateInterceptor
This interceptor binds a new Hibernate Session to the thread before a method
call, closing and removing it afterwards in case of any method outcome.
|
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. |
class |
TypeDefinitionBean
Bean that encapsulates a Hibernate type definition.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AnnotationSessionFactoryBean
Subclass of Spring's standard LocalSessionFactoryBean for Hibernate,
supporting annotation metadata for mappings.
|
| Modifier and Type | Class and Description |
|---|---|
class |
OpenSessionInViewFilter
Servlet 2.3 Filter that binds a Hibernate Session to the thread for the entire
processing of the request.
|
class |
OpenSessionInViewInterceptor
Spring web request interceptor that binds a Hibernate
Session to the
thread for the entire processing of the request. |
| Modifier and Type | Class and Description |
|---|---|
class |
LocalPersistenceManagerFactoryBean
FactoryBean that creates a
JDO PersistenceManagerFactory. |
| Modifier and Type | Class and Description |
|---|---|
class |
OpenPersistenceManagerInViewFilter
Servlet 2.3 Filter that binds a JDO PersistenceManager 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 an EntityManagerFactory,
usually in order to obtain an EntityManager.
|
class |
JpaAccessor
Deprecated.
as of Spring 3.1, in favor of native EntityManager usage
(typically obtained through
@PersistenceContext) |
class |
JpaInterceptor
Deprecated.
as of Spring 3.1, in favor of native EntityManager usage
(typically obtained through
@PersistenceContext) and
AOP-driven exception translation through
PersistenceExceptionTranslationPostProcessor |
class |
JpaTemplate
Deprecated.
as of Spring 3.1, in favor of native EntityManager usage
(typically obtained through
@PersistenceContext)
Note that this class did not get upgraded to JPA 2.0 and never will. |
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 2.3 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
Simple
FactoryBean that exposes the underlying SessionFactory
behind a Hibernate-backed JPA EntityManagerFactory. |
| Modifier and Type | Class and Description |
|---|---|
class |
CastorMarshaller
Implementation of the
Marshaller interface for Castor. |
| Modifier and Type | Class and Description |
|---|---|
class |
Jaxb2Marshaller
Implementation of the
GenericMarshaller interface for JAXB 2.0+. |
| Modifier and Type | Class and Description |
|---|---|
class |
XStreamMarshaller
Implementation of the
Marshaller interface for XStream. |
| Modifier and Type | Class and Description |
|---|---|
class |
BurlapClientInterceptor
MethodInterceptor for accessing a Burlap service. |
class |
BurlapExporter
General stream-based protocol exporter for a Burlap endpoint.
|
class |
BurlapProxyFactoryBean
FactoryBean for Burlap proxies. |
class |
BurlapServiceExporter
Servlet-API-based HTTP request handler that exports the specified service bean
as Burlap service endpoint, accessible via a Burlap proxy.
|
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 |
SimpleBurlapServiceExporter
HTTP request handler that exports the specified service bean as
Burlap service endpoint, accessible via a Burlap 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 |
AbstractHttpInvokerRequestExecutor
Abstract base implementation of the HttpInvokerRequestExecutor interface.
|
class |
CommonsHttpInvokerRequestExecutor
HttpInvokerRequestExecutor implementation that uses
Jakarta Commons HttpClient
to execute POST requests. |
class |
HttpComponentsHttpInvokerRequestExecutor
HttpInvokerRequestExecutor implementation that uses
Apache HttpComponents HttpClient
to execute POST requests. |
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 |
SimpleHttpInvokerRequestExecutor
HttpInvokerRequestExecutor implementation that uses standard J2SE facilities
to execute POST requests, without support for HTTP authentication or
advanced configuration options.
|
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 |
JaxRpcPortProxyFactoryBean
Deprecated.
in favor of JAX-WS support in
org.springframework.remoting.jaxws |
| 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
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 |
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 |
RmiBasedExporter
Convenient superclass for RMI-based remote exporters.
|
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 |
RmiServiceExporter
RMI exporter that exposes the specified service as RMI object with the specified name.
|
| 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 |
ExecutorConfigurationSupport
Base class for classes that are setting up a
java.util.concurrent.ExecutorService
(typically a ThreadPoolExecutor). |
class |
ScheduledExecutorFactoryBean
FactoryBean that sets up
a JDK 1.5 ScheduledExecutorService
(by default: a ScheduledThreadPoolExecutor)
and exposes it for bean references. |
class |
ThreadPoolExecutorFactoryBean
JavaBean that allows for configuring a JDK 1.5
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 JDK 1.5
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 that redirects the actual scheduling
of tasks to the ContextRefreshedEvent callback. |
class |
TaskExecutorFactoryBean
FactoryBean for creating ThreadPoolTaskExecutor instances, choosing
between the standard concurrent and the backport-concurrent variant.
|
| 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 |
MethodInvokingTimerTaskFactoryBean
Deprecated.
as of Spring 3.0, in favor of the
scheduling.concurrent
package which is based on Java 5's java.util.concurrent.ExecutorService |
class |
TimerFactoryBean
Deprecated.
as of Spring 3.0, in favor of the
scheduling.concurrent
package which is based on Java 5's java.util.concurrent.ExecutorService |
class |
TimerTaskExecutor
Deprecated.
as of Spring 3.0, in favor of the
scheduling.concurrent
package which is based on Java 5's java.util.concurrent.ExecutorService |
| Modifier and Type | Class and Description |
|---|---|
class |
GroovyScriptFactory
ScriptFactory implementation
for a Groovy script. |
| Modifier and Type | Class and Description |
|---|---|
class |
JRubyScriptFactory
ScriptFactory implementation
for a JRuby script. |
| Modifier and Type | Class and Description |
|---|---|
class |
ScriptFactoryPostProcessor
BeanPostProcessor that
handles ScriptFactory definitions,
replacing each factory with the actual scripted Java object generated by it. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractJUnit38SpringContextTests
Deprecated.
as of Spring 3.1, in favor of using
AbstractJUnit4SpringContextTests |
class |
AbstractTransactionalJUnit38SpringContextTests
Deprecated.
as of Spring 3.1, in favor of using
AbstractTransactionalJUnit4SpringContextTests |
| 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.5+ 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 |
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 |
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 |
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 |
FreeMarkerConfigurationFactoryBean
Factory bean that creates a FreeMarker Configuration and provides it as
bean reference.
|
| Modifier and Type | Class and Description |
|---|---|
class |
VelocityEngineFactoryBean
Factory bean that configures a VelocityEngine 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. |
| Modifier and Type | Class and Description |
|---|---|
class |
ContentNegotiationManagerFactoryBean
A factory providing convenient access to a
ContentNegotiationManager
configured with one or more 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 annotated classes as input - in particular
@Configuration-annotated
classes, but also plain @Component
classes and JSR-330 compliant classes using javax.inject annotations. |
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 |
ServletContextFactoryBean
Deprecated.
as of Spring 3.0, since "servletContext" is now available
as a default bean in every WebApplicationContext
|
class |
ServletContextLiveBeansView
LiveBeansView subclass which looks for all ApplicationContexts
in the web application, as exposed in ServletContext attributes. |
class |
ServletContextParameterFactoryBean
FactoryBean that retrieves a specific ServletContext init parameter
(that is, a "context-param" defined in web.xml). |
class |
ServletContextPropertyPlaceholderConfigurer
Deprecated.
in Spring 3.1 in favor of
PropertySourcesPlaceholderConfigurer
in conjunction with StandardServletEnvironment. |
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 2.3/2.4 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 |
DelegatingFilterProxy
Proxy for a standard Servlet 2.3 Filter, delegating to a Spring-managed
bean that implements the Filter interface.
|
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 |
Log4jNestedDiagnosticContextFilter
Request logging filter that adds the request log message to the Log4J
nested diagnostic context (NDC) before the request is processed,
removing it again after the request is processed.
|
class |
OncePerRequestFilter
Filter base class that aims to guarantee a single execution per request
dispatch, on any servlet container.
|
class |
RequestContextFilter
Servlet 2.3 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 Jakarta Commons FileUpload
1.2 or above. |
| Modifier and Type | Class and Description |
|---|---|
class |
MultipartFilter
Servlet 2.3 Filter that resolves multipart requests via a MultipartResolver.
|
| Modifier and Type | Class and Description |
|---|---|
class |
DispatcherPortlet
Central dispatcher for use within the Portlet MVC framework, e.g.
|
class |
FrameworkPortlet
Base portlet for Spring's portlet framework.
|
class |
GenericPortletBean
Simple extension of
javax.portlet.GenericPortlet that treats
its config parameters as bean properties. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
PortletConfigAware
Interface to be implemented by any object that wishes to be notified
of the PortletConfig (typically determined by the PortletApplicationContext)
that it runs in.
|
interface |
PortletContextAware
Interface to be implemented by any object that wishes to be notified
of the PortletContext (typically determined by the PortletApplicationContext)
that it runs in.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractRefreshablePortletApplicationContext
AbstractRefreshableApplicationContext
subclass which implements the ConfigurablePortletApplicationContext
interface for portlet environments. |
class |
PortletApplicationObjectSupport
Convenient superclass for application objects running in a Portlet ApplicationContext.
|
class |
XmlPortletApplicationContext
Portlet-based
WebApplicationContext
implementation which takes its configuration from XML documents, understood
by an XmlBeanDefinitionReader. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractMapBasedHandlerMapping<K>
Abstract base class for
HandlerMapping
implementations that rely on a map which caches handler objects per lookup key. |
class |
ParameterHandlerMapping
Implementation of the
HandlerMapping
to map from a request parameter to request handler beans. |
class |
PortletContentGenerator
Convenient superclass for any kind of web content generator,
like
AbstractController. |
class |
PortletModeHandlerMapping
Implementation of the
HandlerMapping
interface to map from the current PortletMode to request handler beans. |
class |
PortletModeParameterHandlerMapping
Implementation of the
HandlerMapping
interface to map from the current PortletMode and a request parameter to
request handler beans. |
class |
SimplePortletHandlerAdapter
Adapter to use the Portlet interface with the generic DispatcherPortlet.
|
class |
SimplePortletPostProcessor
Bean post-processor that applies initialization and destruction callbacks
to beans that implement the Portlet interface.
|
| Modifier and Type | Class and Description |
|---|---|
class |
CommonsPortletMultipartResolver
PortletMultipartResolver implementation for
Jakarta Commons FileUpload
1.2 or above. |
| Modifier and Type | Class and Description |
|---|---|
class |
PortletWrappingController
Controller implementation that wraps a portlet instance which it manages
internally. |
class |
SimpleControllerHandlerAdapter
Adapter to use the Controller workflow interface with the generic DispatcherPortlet.
|
| 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. |
class |
ResourceServlet
Simple servlet that can expose an internal resource, including a
default URL if the specified resource is not found.
|
| Modifier and Type | Class and Description |
|---|---|
class |
DelegatingWebMvcConfiguration
A sub-class 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 |
AbstractHandlerMapping
Abstract base class for
HandlerMapping
implementations. |
class |
AbstractHandlerMethodMapping<T>
Abstract base class for
HandlerMapping implementations that define a
mapping between a request and a HandlerMethod. |
class |
AbstractUrlHandlerMapping
Abstract base class for URL-mapped
HandlerMapping
implementations. |
class |
BeanNameUrlHandlerMapping
Implementation of the
HandlerMapping
interface that map from URLs to beans with names that start with a slash ("/"),
similar to how Struts maps URLs to action names. |
class |
SimpleServletPostProcessor
BeanPostProcessor
that applies initialization and destruction callbacks to beans that
implement the Servlet interface. |
class |
SimpleUrlHandlerMapping
Implementation of the
HandlerMapping
interface to map from URLs to request handler beans. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractCommandController
Deprecated.
as of Spring 3.0, in favor of annotated controllers
|
class |
AbstractController
Convenient superclass for controller implementations, using the Template
Method design pattern.
|
class |
AbstractFormController
Deprecated.
as of Spring 3.0, in favor of annotated controllers
|
class |
AbstractUrlViewController
Abstract base class for
Controllers that return a view name
based on the request URL. |
class |
AbstractWizardFormController
Deprecated.
as of Spring 3.0, in favor of annotated controllers
|
class |
BaseCommandController
Deprecated.
as of Spring 3.0, in favor of annotated controllers
|
class |
CancellableFormController
Deprecated.
as of Spring 3.0, in favor of annotated controllers
|
class |
ParameterizableViewController
Trivial controller that always returns a named view.
|
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 |
SimpleFormController
Deprecated.
as of Spring 3.0, in favor of annotated controllers
|
class |
UrlFilenameViewController
Simple
Controller implementation that transforms the virtual
path of a URL into a view name and returns that view. |
class |
WebContentInterceptor
Interceptor that checks and prepares request and response.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AnnotationMethodHandlerAdapter
Deprecated.
in Spring 3.2 in favor of
RequestMappingHandlerAdapter |
class |
DefaultAnnotationHandlerMapping
Deprecated.
in Spring 3.2 in favor of
RequestMappingHandlerMapping |
class |
ResponseStatusExceptionResolver
Implementation of the
HandlerExceptionResolver
interface 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. |
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 |
ExceptionHandlerExceptionResolver
An
AbstractHandlerMethodExceptionResolver that resolves exceptions
through @ExceptionHandler methods. |
class |
RequestMappingHandlerAdapter
An
AbstractHandlerMethodAdapter that supports HandlerMethods
with the signature -- method argument and return types, defined in
@RequestMapping. |
class |
RequestMappingHandlerMapping
Creates
RequestMappingInfo instances from type and method-level
@RequestMapping annotations in
@Controller classes. |
| Modifier and Type | Class and Description |
|---|---|
class |
MultiActionController
Controller
implementation that allows multiple request types to be handled by the same
class. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractControllerUrlHandlerMapping
Base class for
HandlerMapping implementations
that derive URL paths according to conventions for specific controller types. |
class |
ControllerBeanNameHandlerMapping
Implementation of
HandlerMapping that
follows a simple convention for generating URL path mappings from the bean names
of registered Controller beans
as well as @Controller annotated beans. |
class |
ControllerClassNameHandlerMapping
Implementation of
HandlerMapping that
follows a simple convention for generating URL path mappings from the class names
of registered Controller beans
as well as @Controller annotated beans. |
| 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 optimized for superior browser performance
(according to the guidelines of Page Speed, YSlow, etc.) by allowing for flexible cache settings
("cacheSeconds" property, last-modified support). |
| 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
Velocity and FreeMarker, with the ability to use request and session
attributes in their model and the option to expose helper objects
for Spring's Velocity/FreeMarker macro library.
|
class |
AbstractTemplateViewResolver
Abstract base class for template view resolvers,
in particular for Velocity and FreeMarker views.
|
class |
AbstractUrlBasedView
Abstract base class for URL-based views.
|
class |
AbstractView
Abstract base class for
View
implementations. |
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 |
RedirectView
View that redirects to an absolute, context relative, or current request
relative URL.
|
class |
ResourceBundleViewResolver
A
ViewResolver implementation that uses
bean definitions in a ResourceBundle, specified by the bundle basename. |
class |
UrlBasedViewResolver
Simple implementation of the
ViewResolver
interface, allowing for direct resolution of symbolic view names to URLs,
without explicit mapping definition. |
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 |
AbstractExcelView
Convenient superclass for Excel document views.
|
class |
AbstractJExcelView
Convenient superclass for Excel document views.
|
class |
AbstractPdfStamperView
Abstract superclass for PDF views that operate on an existing
document with an AcroForm.
|
class |
AbstractPdfView
Abstract superclass for PDF views, using Bruno Lowagie's
iText package.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractAtomFeedView
Abstract superclass for Atom Feed views, using java.net's
ROME package.
|
class |
AbstractFeedView<T extends com.sun.syndication.feed.WireFeed>
Abstract base class for Atom and RSS Feed views, using java.net's
ROME package.
|
class |
AbstractRssFeedView
Abstract superclass for RSS Feed views, using java.net's
ROME package.
|
| Modifier and Type | Class and Description |
|---|---|
class |
FreeMarkerConfigurer
JavaBean to configure FreeMarker for web usage, via the "configLocation"
and/or "freemarkerSettings" and/or "templateLoaderPath" properties.
|
class |
FreeMarkerView
View using the FreeMarker template engine.
|
class |
FreeMarkerViewResolver
Convenience subclass of
UrlBasedViewResolver
that supports FreeMarkerView (i.e. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractJasperReportsSingleFormatView
Extends
AbstractJasperReportsView to provide basic rendering logic
for views that use a fixed format, e.g. |
class |
AbstractJasperReportsView
Base class for all JasperReports views.
|
class |
ConfigurableJasperReportsView
Configurable JasperReports View, allowing to specify the JasperReports exporter
to be specified through bean properties rather than through the view class name.
|
class |
JasperReportsCsvView
Implementation of
AbstractJasperReportsSingleFormatView
that renders report results in CSV format. |
class |
JasperReportsHtmlView
Implementation of
AbstractJasperReportsSingleFormatView
that renders report results in HTML format. |
class |
JasperReportsMultiFormatView
Jasper Reports view class that allows for the actual rendering format to be
specified at runtime using a parameter contained in the model.
|
class |
JasperReportsPdfView
Implementation of
AbstractJasperReportsSingleFormatView
that renders report results in PDF format. |
class |
JasperReportsViewResolver
ViewResolver implementation that
resolves instances of AbstractJasperReportsView by translating
the supplied view name into the URL of the report file. |
class |
JasperReportsXlsView
Implementation of
AbstractJasperReportsSingleFormatView
that renders report results in XLS format. |
| Modifier and Type | Class and Description |
|---|---|
class |
MappingJackson2JsonView
Spring MVC
View that renders JSON content by serializing the model for the current request
using Jackson 2's ObjectMapper. |
class |
MappingJacksonJsonView
Spring MVC
View that renders JSON content by serializing the model for the current request
using Jackson 1.x's ObjectMapper. |
| Modifier and Type | Class and Description |
|---|---|
class |
TilesJstlView
Deprecated.
as of Spring 3.0
|
| Modifier and Type | Class and Description |
|---|---|
class |
TilesConfigurer
Helper class to configure Tiles 2.x for the Spring Framework.
|
class |
TilesView
View implementation that retrieves a
Tiles definition. |
class |
TilesViewResolver
Convenience subclass of
UrlBasedViewResolver
that supports TilesView (i.e. |
| Modifier and Type | Class and Description |
|---|---|
class |
VelocityConfigurer
JavaBean to configure Velocity for web usage, via the "configLocation"
and/or "velocityProperties" and/or "resourceLoaderPath" bean properties.
|
class |
VelocityLayoutView
VelocityLayoutView emulates the functionality offered by Velocity's
VelocityLayoutServlet to ease page composition from different templates.
|
class |
VelocityLayoutViewResolver
Convenience subclass of VelocityViewResolver, adding support
for VelocityLayoutView and its properties.
|
class |
VelocityToolboxView
VelocityView subclass which adds support for Velocity Tools toolboxes
and Velocity Tools ViewTool callbacks / Velocity Tools 1.3 init methods. |
class |
VelocityView
View using the Velocity template engine.
|
class |
VelocityViewResolver
Convenience subclass of
UrlBasedViewResolver
that supports VelocityView (i.e. |
| Modifier and Type | Class and Description |
|---|---|
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 |
AbstractXsltView
Deprecated.
since Spring 2.5; superseded by
XsltView and its
more flexible XsltView.locateSource(java.util.Map<java.lang.String, java.lang.Object>) mechanism |
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. |
Copyright © 2015. All rights reserved.