| AbstractAdvisorAutoProxyCreator |
Generic auto proxy creator that builds AOP proxies for specific beans
based on detected Advisors for each bean. |
| AbstractApplicationEventMulticaster |
Abstract implementation of the ApplicationEventMulticaster interface,
providing the basic listener registration facility. |
| AbstractAtomFeedView |
Abstract superclass for Atom Feed views, using java.net's
ROME package. |
| AbstractAutoProxyCreator |
BeanPostProcessor implementation
that wraps each eligible bean with an AOP proxy, delegating to specified interceptors
before invoking the bean itself. |
| AbstractBeanFactoryBasedTargetSource |
Base class for TargetSource implementations
that are based on a Spring BeanFactory,
delegating to Spring-managed bean instances. |
| AbstractBeanFactoryBasedTargetSourceCreator |
Convenient superclass for
TargetSourceCreator
implementations that require creating multiple instances of a prototype bean. |
| AbstractBeanFactoryPointcutAdvisor |
Abstract BeanFactory-based PointcutAdvisor that allows for any Advice
to be configured as reference to an Advice bean in a BeanFactory. |
| AbstractCachingViewResolver |
Convenient base class for ViewResolver
implementations. |
| AbstractCommandController |
This class is deprecated.
as of Spring 3.0, in favor of annotated controllers
|
| AbstractController |
Convenient superclass for controller implementations, using the Template
Method design pattern. |
| AbstractControllerUrlHandlerMapping |
Base class for HandlerMapping implementations
that derive URL paths according to conventions for specific controller types. |
| AbstractDetectingUrlHandlerMapping |
Abstract implementation of the HandlerMapping
interface, detecting URL mappings for handler beans through introspection of all
defined beans in the application context. |
| AbstractEntityManagerFactoryBean |
Abstract FactoryBean that
creates a local JPA javax.persistence.EntityManagerFactory
instance within a Spring application context. |
| AbstractExcelView |
Convenient superclass for Excel document views. |
| AbstractFactoryBean<T> |
Simple template superclass for FactoryBean implementations that
creates a singleton or a prototype object, depending on a flag. |
| AbstractFeedView<T extends WireFeed> |
Abstract base class for Atom and RSS Feed views, using java.net's
ROME package. |
| AbstractFormController |
This class is deprecated.
as of Spring 3.0, in favor of annotated controllers
|
| AbstractHandlerMapping |
Abstract base class for HandlerMapping
implementations. |
| AbstractHttpInvokerRequestExecutor |
Abstract base implementation of the HttpInvokerRequestExecutor interface. |
| AbstractJExcelView |
Convenient superclass for Excel document views. |
| AbstractJUnit38SpringContextTests |
Abstract base TestCase which integrates the Spring TestContext
Framework and explicit ApplicationContext testing support in a
JUnit 3.8 environment. |
| AbstractJUnit4SpringContextTests |
Abstract base test class which integrates the Spring TestContext
Framework with explicit ApplicationContext testing support in a
JUnit 4.5+ environment. |
| AbstractJasperReportsSingleFormatView |
Extends AbstractJasperReportsView to provide basic rendering logic
for views that use a fixed format, e.g. |
| AbstractJasperReportsView |
Base class for all JasperReports views. |
| AbstractJaxWsServiceExporter |
Abstract exporter for JAX-WS services, autodetecting annotated service beans
(through the JAX-WS javax.jws.WebService annotation). |
| 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). |
| AbstractMapBasedHandlerMapping<K> |
Abstract base class for HandlerMapping
implementations that rely on a map which caches handler objects per lookup key. |
| AbstractMessageListenerContainer |
Abstract base class for message listener containers. |
| AbstractPdfStamperView |
Abstract superclass for PDF views that operate on an existing
document with an AcroForm. |
| AbstractPdfView |
Abstract superclass for PDF views, using Bruno Lowagie's
iText package. |
| AbstractPollingMessageListenerContainer |
Base class for listener container implementations which are based on polling. |
| 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. |
| AbstractPrototypeBasedTargetSource |
Base class for dynamic TargetSource implementations that create new prototype
bean instances to support a pooling or new-instance-per-invocation strategy. |
| AbstractRefreshableConfigApplicationContext |
AbstractRefreshableApplicationContext subclass that adds common handling
of specified config locations. |
| AbstractRefreshablePortletApplicationContext |
AbstractRefreshableApplicationContext
subclass which implements the ConfigurablePortletApplicationContext
interface for portlet environments. |
| AbstractRefreshableWebApplicationContext |
AbstractRefreshableApplicationContext
subclass which implements the
ConfigurableWebApplicationContext
interface for web environments. |
| AbstractRequestLoggingFilter |
Base class for Filters that perform logging operations before and after a request is processed. |
| AbstractRssFeedView |
Abstract superclass for RSS Feed views, using java.net's
ROME package. |
| AbstractServiceLoaderBasedFactoryBean |
Abstract base class for FactoryBeans operating on the
JDK 1.6 java.util.ServiceLoader facility. |
| AbstractSingletonProxyFactoryBean |
Convenient proxy factory bean superclass for proxy factory
beans that create only singletons. |
| 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. |
| AbstractTemplateViewResolver |
Abstract base class for template view resolvers,
in particular for Velocity and FreeMarker views. |
| AbstractTestNGSpringContextTests |
Abstract base test class which integrates the
Spring TestContext Framework with explicit
ApplicationContext testing support in a TestNG
environment. |
| AbstractTransactionalJUnit38SpringContextTests |
Abstract transactional extension of
AbstractJUnit38SpringContextTests which adds convenience
functionality for JDBC access. |
| AbstractTransactionalJUnit4SpringContextTests |
Abstract transactional extension of
AbstractJUnit4SpringContextTests which adds convenience functionality
for JDBC access. |
| AbstractTransactionalTestNGSpringContextTests |
Abstract transactional extension of
AbstractTestNGSpringContextTests which adds convenience functionality
for JDBC access. |
| AbstractUrlBasedView |
Abstract base class for URL-based views. |
| AbstractUrlHandlerMapping |
Abstract base class for URL-mapped HandlerMapping
implementations. |
| AbstractUrlViewController |
Abstract base class for Controllers that return a view name
based on the request URL. |
| AbstractView |
Abstract base class for View
implementations. |
| AbstractWizardFormController |
This class is deprecated.
as of Spring 3.0, in favor of annotated controllers
|
| AbstractXmlApplicationContext |
Convenient base class for ApplicationContext
implementations, drawing configuration from XML documents containing bean definitions
understood by an XmlBeanDefinitionReader. |
| AbstractXsltView |
This class is deprecated.
since Spring 2.5; superseded by XsltView and its
more flexible locateSource(Map) mechanism
|
| AnnotationAwareAspectJAutoProxyCreator |
AspectJAwareAdvisorAutoProxyCreator subclass that processes all AspectJ
annotation aspects in the current application context, as well as Spring Advisors. |
| AnnotationConfigWebApplicationContext |
WebApplicationContext implementation
which accepts annotated classes as input - in particular
@Configuration-annotated
classes, but also plain @Components
and JSR-330 compliant classes using javax.inject annotations. |
| AnnotationMBeanExporter |
Convenient subclass of Spring's standard MBeanExporter,
activating Java 5 annotation usage for JMX exposure of Spring beans:
ManagedResource, ManagedAttribute, ManagedOperation, etc. |
| AnnotationMethodHandlerAdapter |
Implementation of the HandlerAdapter interface
that maps handler methods based on HTTP paths, HTTP methods and request parameters
expressed through the RequestMapping annotation. |
| AnnotationSessionFactoryBean |
Subclass of Spring's standard LocalSessionFactoryBean for Hibernate,
supporting JDK 1.5+ annotation metadata for mappings. |
| ApplicationContextAware |
Interface to be implemented by any object that wishes to be notified
of the ApplicationContext that it runs in. |
| ApplicationEventPublisherAware |
Interface to be implemented by any object that wishes to be notified
of the ApplicationEventPublisher (typically the ApplicationContext)
that it runs in. |
| ApplicationObjectSupport |
Convenient superclass for application objects that want to be aware of
the application context, e.g. |
| 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. |
| AspectJExpressionPointcut |
Spring Pointcut implementation
that uses the AspectJ weaver to evaluate a pointcut expression. |
| AspectJWeavingEnabler |
Post-processor that registers AspectJ's
org.aspectj.weaver.loadtime.ClassPreProcessorAgentAdapter
with the Spring application context's default
LoadTimeWeaver. |
| 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). |
| AutowiredAnnotationBeanPostProcessor |
BeanPostProcessor implementation
that autowires annotated fields, setter methods and arbitrary config methods. |
| BaseCommandController |
This class is deprecated.
as of Spring 3.0, in favor of annotated controllers
|
| BeanClassLoaderAware |
Callback that allows a bean to be aware of the bean
ClassLoader class loader; that is, the class loader used by the
present bean factory to load bean classes. |
| BeanConfigurerSupport |
Convenient base class for configurers that can perform Dependency Injection
on objects (however they may be created). |
| BeanFactoryAware |
Interface to be implemented by beans that wish to be aware of their
owning BeanFactory. |
| BeanFactoryCacheDefinitionSourceAdvisor |
Advisor driven by a CacheDefinitionSource, used to include a
transaction advice bean for methods that are transactional. |
| BeanFactoryDataSourceLookup |
DataSourceLookup implementation based on a Spring BeanFactory. |
| BeanFactoryDestinationResolver |
DestinationResolver implementation based on a Spring BeanFactory. |
| BeanFactoryTransactionAttributeSourceAdvisor |
Advisor driven by a TransactionAttributeSource, used to include
a transaction advice bean for methods that are transactional. |
| BeanNameAutoProxyCreator |
Auto proxy creator that identifies beans to proxy via a list of names. |
| BeanNameAware |
Interface to be implemented by beans that want to be aware of their
bean name in a bean factory. |
| 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. |
| BeanNameViewResolver |
Simple implementation of ViewResolver that interprets a view name
as bean name in the current application context, i.e. |
| BeanReferenceFactoryBean |
FactoryBean that exposes an arbitrary target bean under a different name. |
| 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. |
| BshScriptFactory |
ScriptFactory implementation
for a BeanShell script. |
| BurlapClientInterceptor |
org.aopalliance.intercept.MethodInterceptor for accessing a Burlap service. |
| BurlapExporter |
General stream-based protocol exporter for a Burlap endpoint. |
| BurlapProxyFactoryBean |
FactoryBean for Burlap proxies. |
| BurlapServiceExporter |
Servlet-API-based HTTP request handler that exports the specified service bean
as Burlap service endpoint, accessible via a Burlap proxy. |
| CacheProxyFactoryBean |
Proxy factory bean for simplified declarative caching handling. |
| CancellableFormController |
This class is deprecated.
as of Spring 3.0, in favor of annotated controllers
|
| CharacterEncodingFilter |
Servlet 2.3/2.4 Filter that allows one to specify a character encoding for
requests. |
| ClassPathBeanDefinitionScanner |
A bean definition scanner that detects bean candidates on the classpath,
registering corresponding bean definitions with a given registry (BeanFactory
or ApplicationContext). |
| ClassPathScanningCandidateComponentProvider |
A component provider that scans the classpath from a base package. |
| 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. |
| CommonAnnotationBeanPostProcessor |
BeanPostProcessor implementation
that supports common Java annotations out of the box, in particular the JSR-250
annotations in the javax.annotation package. |
| CommonsHttpInvokerRequestExecutor |
HttpInvokerRequestExecutor implementation that uses
Jakarta Commons HttpClient
to execute POST requests. |
| CommonsMultipartResolver |
Servlet-based MultipartResolver implementation
for Jakarta Commons FileUpload
1.2 or above. |
| CommonsPoolTargetSource |
TargetSource implementation that holds objects in a configurable
Jakarta Commons Pool. |
| CommonsPortletMultipartResolver |
PortletMultipartResolver implementation for
Jakarta Commons FileUpload
1.2 or above. |
| CommonsRequestLoggingFilter |
Simple request logging filter that writes the request URI
(and optionally the query string) to the Commons Log. |
| ConcurrentCacheFactoryBean<K, V> |
Factory bean for easy configuration of ConcurrentCache through Spring. |
| ConfigurableJasperReportsView |
Configurable JasperReports View, allowing to specify the JasperReports exporter
to be specified through bean properties rather than through the view class name. |
| ConfigurationClassPostProcessor |
BeanFactoryPostProcessor used for bootstrapping processing of
@Configuration classes. |
| ContentNegotiatingViewResolver |
Implementation of ViewResolver that resolves a view based on the request file name or Accept header. |
| 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. |
| 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. |
| CronTriggerBean |
Convenience subclass of Quartz's org.quartz.CronTrigger class,
making bean-style usage easier. |
| CustomAutowireConfigurer |
A BeanFactoryPostProcessor
implementation that allows for convenient registration of custom autowire
qualifier types. |
| CustomEditorConfigurer |
BeanFactoryPostProcessor implementation that allows for convenient
registration of custom PropertyEditor property editors. |
| CustomScopeConfigurer |
Simple BeanFactoryPostProcessor implementation that registers
custom Scope(s) with the containing ConfigurableBeanFactory. |
| DefaultAdvisorAutoProxyCreator |
BeanPostProcessor implementation that creates AOP proxies based on all candidate
Advisors in the current BeanFactory. |
| DefaultAnnotationHandlerMapping |
Implementation of the HandlerMapping
interface that maps handlers based on HTTP paths expressed through the
RequestMapping annotation at the type or method level. |
| 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. |
| DefaultContextLoadTimeWeaver |
Default LoadTimeWeaver bean for use in an application context,
decorating an automatically detected internal LoadTimeWeaver. |
| DefaultFormattingConversionService |
A specialization of FormattingConversionService configured by default with
converters and formatters appropriate for most applications. |
| DefaultLifecycleProcessor |
Default implementation of the LifecycleProcessor strategy. |
| DefaultMessageListenerContainer |
Message listener container variant that uses plain JMS client API, specifically
a loop of MessageConsumer.receive() calls that also allow for
transactional reception of messages (registering them with XA transactions). |
| DefaultMessageListenerContainer102 |
This class is deprecated.
as of Spring 3.0, in favor of the JMS 1.1 based DefaultMessageListenerContainer
|
| DefaultPersistenceUnitManager |
Default implementation of the PersistenceUnitManager interface. |
| DefaultServletHttpRequestHandler |
An HttpRequestHandler for serving static files using the Servlet container's "default" Servlet. |
| DelegatingFilterProxy |
Proxy for a standard Servlet 2.3 Filter, delegating to a Spring-managed
bean that implements the Filter interface. |
| DispatcherPortlet |
Central dispatcher for use within the Portlet MVC framework, e.g. |
| DispatcherServlet |
Central dispatcher for HTTP request handlers/controllers, e.g. |
| EhCacheFactoryBean |
FactoryBean that creates a named EHCache net.sf.ehcache.Cache instance
(or a decorator that implements the net.sf.ehcache.Ehcache interface),
representing a cache region within an EHCache net.sf.ehcache.CacheManager. |
| EmbeddedValueResolverAware |
Interface to be implemented by any object that wishes to be notified of a
StringValueResolver for the resolution of embedded definition values. |
| EnvironmentAware |
Interface to be implemented by any bean that wishes to be notified
of the Environment that it runs in. |
| EventPublicationInterceptor |
MethodInterceptor Interceptor that publishes an
ApplicationEvent to all ApplicationListeners
registered with an ApplicationEventPublisher after each
successful method invocation. |
| ExecutorConfigurationSupport |
Base class for classes that are setting up a
java.util.concurrent.ExecutorService
(typically a java.util.concurrent.ThreadPoolExecutor). |
| FieldRetrievingFactoryBean |
FactoryBean which retrieves a static or non-static field value. |
| 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. |
| FilterDefinitionFactoryBean |
Convenient FactoryBean for defining Hibernate FilterDefinitions. |
| FormattingConversionService |
A ConversionService implementation
designed to be configured as a FormatterRegistry. |
| FormattingConversionServiceFactoryBean |
A factory providing convenient access to a FormattingConversionService
configured with converters and formatters for common types such as numbers and
datetimes. |
| FrameworkPortlet |
Base portlet for Spring's portlet framework. |
| FrameworkServlet |
Base servlet for Spring's web framework. |
| FreeMarkerConfigurationFactoryBean |
Factory bean that creates a FreeMarker Configuration and provides it as
bean reference. |
| FreeMarkerConfigurer |
JavaBean to configure FreeMarker for web usage, via the "configLocation"
and/or "freemarkerSettings" and/or "templateLoaderPath" properties. |
| FreeMarkerView |
View using the FreeMarker template engine. |
| FreeMarkerViewResolver |
Convenience subclass of UrlBasedViewResolver
that supports FreeMarkerView (i.e. |
| GenericFilterBean |
Simple base implementation of javax.servlet.Filter which treats
its config parameters (init-param entries within the
filter tag in web.xml) as bean properties. |
| GenericPortletBean |
Simple extension of javax.portlet.GenericPortlet that treats
its config parameters as bean properties. |
| GlassFishWorkManagerTaskExecutor |
Spring TaskExecutor adapter for the GlassFish JCA WorkManager. |
| GroovyScriptFactory |
ScriptFactory implementation
for a Groovy script. |
| HessianClientInterceptor |
org.aopalliance.intercept.MethodInterceptor for accessing a Hessian service. |
| HessianExporter |
General stream-based protocol exporter for a Hessian endpoint. |
| HessianProxyFactoryBean |
FactoryBean for Hessian proxies. |
| HessianServiceExporter |
Servlet-API-based HTTP request handler that exports the specified service bean
as Hessian service endpoint, accessible via a Hessian proxy. |
| HibernateAccessor |
Base class for HibernateTemplate and HibernateInterceptor,
defining common properties such as SessionFactory and flushing behavior. |
| 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. |
| HibernateTemplate |
Helper class that simplifies Hibernate data access code. |
| HibernateTransactionManager |
PlatformTransactionManager
implementation for a single Hibernate org.hibernate.SessionFactory. |
| HiddenHttpMethodFilter |
javax.servlet.Filter that converts posted method parameters into HTTP methods,
retrievable via getMethod(). |
| HttpInvokerClientInterceptor |
org.aopalliance.intercept.MethodInterceptor for accessing an
HTTP invoker service. |
| HttpInvokerProxyFactoryBean |
FactoryBean for HTTP invoker proxies. |
| HttpInvokerServiceExporter |
Servlet-API-based HTTP request handler that exports the specified service bean
as HTTP invoker service endpoint, accessible via an HTTP invoker proxy. |
| HttpServletBean |
Simple extension of javax.servlet.http.HttpServlet which treats
its config parameters (init-param entries within the
servlet tag in web.xml) as bean properties. |
| InfrastructureAdvisorAutoProxyCreator |
Auto-proxy creator that considers infrastructure Advisor beans only,
ignoring any application-defined Advisors. |
| InterfaceBasedMBeanInfoAssembler |
Subclass of AbstractReflectiveMBeanInfoAssembler that allows for
the management interface of a bean to be defined using arbitrary interfaces. |
| InternalResourceView |
Wrapper for a JSP or other resource within the same web application. |
| InternalResourceViewResolver |
Convenient subclass of UrlBasedViewResolver that supports
InternalResourceView (i.e. |
| JBossWorkManagerTaskExecutor |
Spring TaskExecutor adapter for the JBoss JCA WorkManager. |
| JRubyScriptFactory |
ScriptFactory implementation
for a JRuby script. |
| JasperReportsCsvView |
Implementation of AbstractJasperReportsSingleFormatView
that renders report results in CSV format. |
| JasperReportsHtmlView |
Implementation of AbstractJasperReportsSingleFormatView
that renders report results in HTML format. |
| JasperReportsMultiFormatView |
Jasper Reports view class that allows for the actual rendering format to be
specified at runtime using a parameter contained in the model. |
| JasperReportsPdfView |
Implementation of AbstractJasperReportsSingleFormatView
that renders report results in PDF format. |
| JasperReportsViewResolver |
ViewResolver implementation that
resolves instances of AbstractJasperReportsView by translating
the supplied view name into the URL of the report file. |
| JasperReportsXlsView |
Implementation of AbstractJasperReportsSingleFormatView
that renders report results in XLS format. |
| JaxRpcPortProxyFactoryBean |
This class is deprecated.
in favor of JAX-WS support in org.springframework.remoting.jaxws
|
| JaxWsPortClientInterceptor |
org.aopalliance.intercept.MethodInterceptor for accessing a specific
port of a JAX-WS service. |
| JaxWsPortProxyFactoryBean |
FactoryBean for a specific port of a
JAX-WS service. |
| Jaxb2Marshaller |
Implementation of the Marshaller interface for JAXB 2.0. |
| JmsInvokerProxyFactoryBean |
FactoryBean for JMS invoker proxies. |
| JmsInvokerServiceExporter |
JMS message listener that exports the specified service bean as a
JMS service endpoint, accessible via a JMS invoker proxy. |
| JndiObjectFactoryBean |
FactoryBean that looks up a
JNDI object. |
| JndiRmiProxyFactoryBean |
FactoryBean for RMI proxies from JNDI. |
| JndiRmiServiceExporter |
Service exporter which binds RMI services to JNDI. |
| JobDetailBean |
Convenience subclass of Quartz's org.quartz.JobDetail class,
making bean-style usage easier. |
| JodaDateTimeFormatAnnotationFormatterFactory |
Formats fields annotated with the DateTimeFormat annotation. |
| JstlView |
Specialization of InternalResourceView for JSTL pages,
i.e. |
| LazyInitTargetSource |
TargetSource that lazily accesses a
singleton bean from a BeanFactory. |
| LazyInitTargetSourceCreator |
TargetSourceCreator that enforces a LazyInitTargetSource for each bean
that is defined as "lazy-init". |
| ListFactoryBean |
Simple factory for shared List instances. |
| LoadTimeWeaverAware |
Interface to be implemented by any object that wishes to be notified
of the application context's default LoadTimeWeaver. |
| LoadTimeWeaverAwareProcessor |
BeanPostProcessor
implementation that passes the context's default LoadTimeWeaver
to beans that implement the LoadTimeWeaverAware interface. |
| LocalContainerEntityManagerFactoryBean |
FactoryBean that creates a JPA
javax.persistence.EntityManagerFactory according to JPA's standard
container bootstrap contract. |
| LocalEntityManagerFactoryBean |
FactoryBean that creates a JPA
javax.persistence.EntityManagerFactory according to JPA's standard
standalone bootstrap contract. |
| LocalPersistenceManagerFactoryBean |
FactoryBean that creates a
JDO javax.jdo.PersistenceManagerFactory. |
| LocalSessionFactoryBean |
FactoryBean that creates a
Hibernate org.hibernate.SessionFactory. |
| LocalStatelessSessionProxyFactoryBean |
Convenient FactoryBean for local Stateless Session Bean (SLSB) proxies. |
| 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 javax.validation.Validator interface and the
javax.validation.ValidatorFactory interface itself. |
| 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. |
| MBeanClientInterceptor |
org.aopalliance.intercept.MethodInterceptor that routes calls to an
MBean running on the supplied MBeanServerConnection. |
| MBeanExporter |
JMX exporter that allows for exposing any Spring-managed bean to a
JMX javax.management.MBeanServer, without the need to define any
JMX-specific information in the bean classes. |
| MBeanProxyFactoryBean |
Creates a proxy to a managed resource running either locally or remotely. |
| MBeanServerConnectionFactoryBean |
FactoryBean that creates a JMX 1.2 MBeanServerConnection
to a remote MBeanServer exposed via a JMXServerConnector. |
| MapFactoryBean |
Simple factory for shared Map instances. |
| MappingJacksonJsonView |
Spring-MVC View that renders JSON content by serializing the model for the current request using Jackson's ObjectMapper. |
| MarshallingView |
Spring-MVC View that allows for response context to be rendered as the result of marshalling by a Marshaller. |
| MessageSourceAware |
Interface to be implemented by any object that wishes to be notified
of the MessageSource (typically the ApplicationContext) that it runs in. |
| MethodInvokingFactoryBean |
FactoryBean which returns a value which is the result of a static or instance
method invocation. |
| MethodInvokingJobDetailFactoryBean |
FactoryBean that exposes a
org.quartz.JobDetail object which delegates job execution to a
specified (static or non-static) method. |
| MethodInvokingRunnable |
Adapter that implements the Runnable interface as a configurable
method invocation based on Spring's MethodInvoker. |
| MethodInvokingTimerTaskFactoryBean |
This class is deprecated.
as of Spring 3.0, in favor of the scheduling.concurrent
package which is based on Java 5's java.util.concurrent.ExecutorService
|
| MethodLocatingFactoryBean |
FactoryBean implementation that locates a Method on a specified bean. |
| MethodMapTransactionAttributeSource |
Simple TransactionAttributeSource implementation that
allows attributes to be stored per method in a Map. |
| MultiActionController |
Controller
implementation that allows multiple request types to be handled by the same
class. |
| MultipartFilter |
Servlet 2.3 Filter that resolves multipart requests via a MultipartResolver. |
| NotificationPublisherAware |
Interface to be implemented by any Spring-managed resource that is to be
registered with an javax.management.MBeanServer and wishes to send
JMX javax.management.Notification javax.management.Notifications. |
| NumberFormatAnnotationFormatterFactory |
Formats fields annotated with the NumberFormat annotation. |
| ObjectFactoryCreatingFactoryBean |
A FactoryBean implementation that
returns a value which is an ObjectFactory
that in turn returns a bean sourced from a BeanFactory. |
| OncePerRequestFilter |
Filter base class that guarantees to be just executed once per request,
on any servlet container. |
| OpenEntityManagerInViewFilter |
Servlet 2.3 Filter that binds a JPA EntityManager to the thread for the
entire processing of the request. |
| OpenPersistenceManagerInViewFilter |
Servlet 2.3 Filter that binds a JDO PersistenceManager to the thread for the
entire processing of the request. |
| OpenSessionInViewFilter |
Servlet 2.3 Filter that binds a Hibernate Session to the thread for the entire
processing of the request. |
| OpenSessionInViewInterceptor |
Spring web request interceptor that binds a Hibernate Session to the
thread for the entire processing of the request. |
| ParameterHandlerMapping |
Implementation of the HandlerMapping
to map from a request parameter to request handler beans. |
| ParameterizableViewController |
Trivial controller that always returns a named view. |
| PersistenceAnnotationBeanPostProcessor |
BeanPostProcessor that processes javax.persistence.PersistenceUnit
and javax.persistence.PersistenceContext annotations, for injection of
the corresponding JPA resources javax.persistence.EntityManagerFactory
and javax.persistence.EntityManager. |
| PersistenceExceptionTranslationInterceptor |
AOP Alliance MethodInterceptor that provides persistence exception translation
based on a given PersistenceExceptionTranslator. |
| PersistenceExceptionTranslationPostProcessor |
Bean post-processor that automatically applies persistence exception
translation to any bean that carries the
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). |
| PlaceholderConfigurerSupport |
Abstract base class for property resource configurers that resolve placeholders
in bean definition property values. |
| PortletApplicationObjectSupport |
Convenient superclass for application objects running in a Portlet ApplicationContext. |
| 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. |
| PortletContentGenerator |
Convenient superclass for any kind of web content generator,
like AbstractController. |
| 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. |
| PortletModeHandlerMapping |
Implementation of the HandlerMapping
interface to map from the current PortletMode to request handler beans. |
| PortletModeParameterHandlerMapping |
Implementation of the HandlerMapping
interface to map from the current PortletMode and a request parameter to
request handler beans. |
| PortletWrappingController |
Controller implementation that wraps a portlet instance which it manages
internally. |
| PreferencesPlaceholderConfigurer |
Subclass of PropertyPlaceholderConfigurer that supports JDK 1.4's
Preferences API (java.util.prefs). |
| PropertyPathFactoryBean |
FactoryBean that evaluates a property path on a given target object. |
| PropertyPlaceholderConfigurer |
PlaceholderConfigurerSupport subclass that resolves ${...} placeholders
against local properties and/or system properties
and environment variables. |
| PropertySourcesPlaceholderConfigurer |
Specialization of PlaceholderConfigurerSupport
Local properties are added as a property source in any case. |
| PrototypeTargetSource |
TargetSource that creates a new instance of the target bean for each
request, destroying each instance on release (after each request). |
| ProviderCreatingFactoryBean |
A FactoryBean implementation that
returns a value which is a JSR-330 javax.inject.Provider that in turn
returns a bean sourced from a BeanFactory. |
| ProxyFactoryBean |
FactoryBean implementation that builds an
AOP proxy based on beans in Spring BeanFactory. |
| QualifierAnnotationAutowireCandidateResolver |
AutowireCandidateResolver implementation that matches bean definition qualifiers
against qualifier annotations on the field or parameter to be autowired. |
| QuickTargetSourceCreator |
Convenient TargetSourceCreator using bean name prefixes to create one of three
well-known TargetSource types:
: CommonsPoolTargetSource
% ThreadLocalTargetSource
! PrototypeTargetSource |
| RedirectView |
View that redirects to an absolute, context relative, or current request
relative URL. |
| ReloadableResourceBundleMessageSource |
MessageSource implementation that
accesses resource bundles using specified basenames. |
| RemoteAccessor |
Abstract base class for classes that access a remote service. |
| RemoteExporter |
Abstract base class for classes that export a remote service. |
| RemoteInvocationBasedAccessor |
Abstract base class for remote service accessors that are based
on serialization of RemoteInvocation objects. |
| RemoteInvocationBasedExporter |
Abstract base class for remote service exporters that are based
on deserialization of RemoteInvocation objects. |
| RemoteInvocationSerializingExporter |
Abstract base class for remote service exporters that explicitly deserialize
RemoteInvocation objects and serialize
RemoteInvocationResult objects,
for example Spring's HTTP invoker. |
| RemotingSupport |
Generic support base class for remote accessor and exporters,
providing common bean ClassLoader handling. |
| RequestContextFilter |
Servlet 2.3 Filter that exposes the request to the current thread,
through both LocaleContextHolder and
RequestContextHolder. |
| RequiredAnnotationBeanPostProcessor |
BeanPostProcessor implementation
that enforces required JavaBean properties to have been configured. |
| ResourceBundleMessageSource |
MessageSource implementation that
accesses resource bundles using specified basenames. |
| ResourceBundleViewResolver |
ViewResolver implementation
that uses bean definitions in a ResourceBundle, specified by
the bundle basename. |
| 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). |
| ResourceLoaderAware |
Interface to be implemented by any object that wishes to be notified of
the ResourceLoader (typically the ApplicationContext) that it runs in. |
| ResourceServlet |
Simple servlet that can expose an internal resource, including a
default URL if the specified resource is not found. |
| RmiBasedExporter |
Convenient superclass for RMI-based remote exporters. |
| RmiClientInterceptor |
org.aopalliance.intercept.MethodInterceptor for accessing conventional
RMI services or RMI invokers. |
| RmiProxyFactoryBean |
FactoryBean for RMI proxies, supporting both conventional RMI services
and RMI invokers. |
| RmiServiceExporter |
RMI exporter that exposes the specified service as RMI object with the specified name. |
| 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. |
| ScheduledExecutorFactoryBean |
FactoryBean that sets up
a JDK 1.5 java.util.concurrent.ScheduledExecutorService
(by default: a java.util.concurrent.ScheduledThreadPoolExecutor)
and exposes it for bean references. |
| SchedulerAccessor |
Common base class for accessing a Quartz Scheduler, i.e. |
| SchedulerAccessorBean |
Spring bean-style class for accessing a Quartz Scheduler, i.e. |
| SchedulerContextAware |
Callback interface to be implemented by Spring-managed
Quartz artifacts that need access to the SchedulerContext
(without having natural access to it). |
| SchedulerFactoryBean |
FactoryBean that creates and configures a Quartz org.quartz.Scheduler,
manages its lifecycle as part of the Spring application context, and exposes the
Scheduler as bean reference for dependency injection. |
| ScopedProxyFactoryBean |
Convenient proxy factory bean for scoped objects. |
| ScriptFactoryPostProcessor |
BeanPostProcessor that
handles ScriptFactory definitions,
replacing each factory with the actual scripted Java object generated by it. |
| ServiceFactoryBean |
FactoryBean that exposes the
'primary' service for the configured service class, obtained through
the JDK 1.6 java.util.ServiceLoader facility. |
| ServiceListFactoryBean |
FactoryBean that exposes all
services for the configured service class, represented as a List of service objects,
obtained through the JDK 1.6 java.util.ServiceLoader facility. |
| ServiceLoaderFactoryBean |
FactoryBean that exposes the
JDK 1.6 java.util.ServiceLoader for the configured service 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. |
| 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. |
| ServletContextAttributeExporter |
Exporter that takes Spring-defined objects and exposes them as
ServletContext attributes. |
| ServletContextAttributeFactoryBean |
FactoryBean that fetches a specific, existing ServletContext attribute. |
| 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. |
| ServletContextFactoryBean |
This class is deprecated.
as of Spring 3.0, since "servletContext" is now available
as a default bean in every WebApplicationContext
|
| ServletContextParameterFactoryBean |
FactoryBean that retrieves a specific ServletContext init parameter
(that is, a "context-param" defined in web.xml). |
| ServletContextPropertyPlaceholderConfigurer |
This class is deprecated.
in Spring 3.1 in favor of PropertySourcesPlaceholderConfigurer
in conjunction with DefaultWebEnvironment.
|
| ServletContextRequestLoggingFilter |
Simple request logging filter that writes the request URI
(and optionally the query string) to the ServletContext log. |
| ServletForwardingController |
Spring Controller implementation that forwards to a named servlet,
i.e. |
| ServletWrappingController |
Spring Controller implementation that wraps a servlet instance which it manages
internally. |
| SetFactoryBean |
Simple factory for shared Set instances. |
| ShallowEtagHeaderFilter |
javax.servlet.Filter that generates an ETag value based on the content on the response. |
| SimpleApplicationEventMulticaster |
Simple implementation of the ApplicationEventMulticaster interface. |
| SimpleBeanFactoryAwareAspectInstanceFactory |
Implementation of AspectInstanceFactory that locates the aspect from the
BeanFactory using a configured bean name. |
| SimpleBeanTargetSource |
Simple TargetSource implementation,
freshly obtaining the specified target bean from its containing
Spring BeanFactory. |
| SimpleBurlapServiceExporter |
HTTP request handler that exports the specified service bean as
Burlap service endpoint, accessible via a Burlap proxy. |
| SimpleControllerHandlerAdapter |
Adapter to use the Controller workflow interface with the generic DispatcherPortlet. |
| SimpleFormController |
This class is deprecated.
as of Spring 3.0, in favor of annotated controllers
|
| SimpleHessianServiceExporter |
HTTP request handler that exports the specified service bean as
Hessian service endpoint, accessible via a Hessian proxy. |
| SimpleHttpInvokerRequestExecutor |
HttpInvokerRequestExecutor implementation that uses standard J2SE facilities
to execute POST requests, without support for HTTP authentication or
advanced configuration options. |
| SimpleHttpInvokerServiceExporter |
HTTP request handler that exports the specified service bean as
HTTP invoker service endpoint, accessible via an HTTP invoker proxy. |
| SimpleHttpServerJaxWsServiceExporter |
Simple exporter for JAX-WS services, autodetecting annotated service beans
(through the JAX-WS javax.jws.WebService annotation) and exporting
them through the HTTP server included in Sun's JDK 1.6. |
| SimpleJaxWsServiceExporter |
Simple exporter for JAX-WS services, autodetecting annotated service beans
(through the JAX-WS javax.jws.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. |
| SimpleMessageListenerContainer |
Message listener container that uses the plain JMS client API's
MessageConsumer.setMessageListener() method to
create concurrent MessageConsumers for the specified listeners. |
| SimpleMessageListenerContainer102 |
This class is deprecated.
as of Spring 3.0, in favor of the JMS 1.1 based SimpleMessageListenerContainer
|
| SimplePortletHandlerAdapter |
Adapter to use the Portlet interface with the generic DispatcherPortlet. |
| SimplePortletPostProcessor |
Bean post-processor that applies initialization and destruction callbacks
to beans that implement the Portlet interface. |
| SimpleRemoteStatelessSessionProxyFactoryBean |
Convenient FactoryBean for remote SLSB proxies. |
| SimpleServletPostProcessor |
BeanPostProcessor
that applies initialization and destruction callbacks to beans that
implement the javax.servlet.Servlet interface. |
| SimpleTriggerBean |
Convenience subclass of Quartz's org.quartz.SimpleTrigger class,
making bean-style usage easier. |
| SimpleUrlHandlerMapping |
Implementation of the HandlerMapping
interface to map from URLs to request handler beans. |
| SortedResourcesFactoryBean |
FactoryBean implementation that takes a list of location Strings
and creates a sorted array of Resource instances. |
| SpringBeanJobFactory |
Subclass of AdaptableJobFactory that also supports Spring-style
dependency injection on bean properties. |
| TaskExecutorFactoryBean |
FactoryBean for creating ThreadPoolTaskExecutor instances, choosing
between the standard concurrent and the backport-concurrent variant. |
| ThreadLocalTargetSource |
Alternative to an object pool. |
| ThreadPoolExecutorFactoryBean |
JavaBean that allows for configuring a JDK 1.5 java.util.concurrent.ThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds",
"queueCapacity" properties) and exposing it as a bean reference of its native
java.util.concurrent.ExecutorService type. |
| ThreadPoolTaskExecutor |
JavaBean that allows for configuring a JSR-166 backport
edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor in bean
style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity"
properties), exposing it as a Spring TaskExecutor. |
| ThreadPoolTaskScheduler |
Implementation of Spring's TaskScheduler interface, wrapping
a native java.util.concurrent.ScheduledThreadPoolExecutor. |
| TilesConfigurer |
This class is deprecated.
as of Spring 3.0
|
| TilesJstlView |
This class is deprecated.
as of Spring 3.0
|
| TilesView |
This class is deprecated.
as of Spring 3.0
|
| TilesViewResolver |
Convenience subclass of UrlBasedViewResolver
that supports TilesView (i.e. |
| TimerFactoryBean |
This class is deprecated.
as of Spring 3.0, in favor of the scheduling.concurrent
package which is based on Java 5's java.util.concurrent.ExecutorService
|
| TimerTaskExecutor |
This class is deprecated.
as of Spring 3.0, in favor of the scheduling.concurrent
package which is based on Java 5's java.util.concurrent.ExecutorService
|
| TransactionAspectSupport |
Base class for transactional aspects, such as the TransactionInterceptor
or an AspectJ aspect. |
| TransactionInterceptor |
AOP Alliance MethodInterceptor for declarative transaction
management using the common Spring transaction infrastructure
(PlatformTransactionManager). |
| TransactionProxyFactoryBean |
Proxy factory bean for simplified declarative transaction handling. |
| TypeDefinitionBean |
Bean that encapsulates a Hibernate type definition. |
| UrlBasedRemoteAccessor |
Abstract base class for classes that access remote services via URLs. |
| UrlBasedViewResolver |
Simple implementation of the ViewResolver
interface, allowing for direct resolution of symbolic view names to URLs,
without explicit mapping definition. |
| UrlFilenameViewController |
Simple Controller implementation that transforms the virtual
path of a URL into a view name and returns that view. |
| VelocityConfigurer |
JavaBean to configure Velocity for web usage, via the "configLocation"
and/or "velocityProperties" and/or "resourceLoaderPath" bean properties. |
| VelocityEngineFactoryBean |
Factory bean that configures a VelocityEngine and provides it as bean
reference. |
| VelocityLayoutView |
VelocityLayoutView emulates the functionality offered by Velocity's
VelocityLayoutServlet to ease page composition from different templates. |
| VelocityLayoutViewResolver |
Convenience subclass of VelocityViewResolver, adding support
for VelocityLayoutView and its properties. |
| VelocityToolboxView |
VelocityView subclass which adds support for Velocity Tools toolboxes
and Velocity Tools ViewTool callbacks / Velocity Tools 1.3 init methods. |
| VelocityView |
View using the Velocity template engine. |
| VelocityViewResolver |
Convenience subclass of UrlBasedViewResolver
that supports VelocityView (i.e. |
| WebApplicationObjectSupport |
Convenient superclass for application objects running in a WebApplicationContext. |
| WebContentGenerator |
Convenient superclass for any kind of web content generator,
like AbstractController
and WebContentInterceptor. |
| WebContentInterceptor |
Interceptor that checks and prepares request and response. |
| WorkManagerTaskExecutor |
TaskExecutor implementation
that delegates to a JCA 1.5 WorkManager, implementing the
javax.resource.spi.work.WorkManager interface. |
| XStreamMarshaller |
Implementation of the Marshaller interface for XStream. |
| XmlPortletApplicationContext |
Portlet-based WebApplicationContext
implementation which takes its configuration from XML documents, understood
by an XmlBeanDefinitionReader. |
| XmlViewResolver |
Implementation of ViewResolver that uses bean definitions in an
XML file, specified by resource location. |
| XmlWebApplicationContext |
WebApplicationContext implementation
which takes its configuration from XML documents, understood by an
XmlBeanDefinitionReader. |
| XsltView |
XSLT-driven View that allows for response context to be rendered as the
result of an XSLT transformation. |
| XsltViewResolver |
ViewResolver implementation that
resolves instances of XsltView by translating the supplied view name
into the URL of the XSLT stylesheet. |
Known Indirect Subclasses