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
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.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
Apache 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
org.springframework.scheduling.annotation.AnnotationAsyncExecutionInterceptor
or org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect . |
class |
AsyncExecutionInterceptor
AOP Alliance
MethodInterceptor that processes method invocations
asynchronously, using a given AsyncTaskExecutor . |
Modifier and Type | Class and Description |
---|---|
class |
ScopedProxyFactoryBean
Convenient proxy factory bean for scoped objects.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractBeanFactoryPointcutAdvisor
Abstract BeanFactory-based PointcutAdvisor that allows for any Advice
to be configured as reference to an Advice bean in a BeanFactory.
|
class |
DefaultBeanFactoryPointcutAdvisor
Concrete BeanFactory-based PointcutAdvisor that allows for any Advice
to be configured as reference to an Advice bean in the BeanFactory,
as well as the Pointcut to be configured through a bean property.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractBeanFactoryBasedTargetSource
Base class for
TargetSource implementations
that are based on a Spring BeanFactory ,
delegating to Spring-managed bean instances. |
class |
AbstractPoolingTargetSource
Abstract base class for pooling
TargetSource
implementations which maintain a pool of target instances, acquiring and
releasing a target object from the pool for each method invocation. |
class |
AbstractPrototypeBasedTargetSource
Base class for dynamic
TargetSource implementations
that create new prototype bean instances to support a pooling or
new-instance-per-invocation strategy. |
class |
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 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 |
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
Filter s 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
Apache 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 HandlerMethod s
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
JasperReports 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.