Package | Description |
---|---|
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.beans.factory.config |
SPI interfaces and configuration-related convenience classes for bean factories.
|
org.springframework.cache.concurrent |
Implementation package for
java.util.concurrent based caches. |
org.springframework.cache.ehcache |
Support classes for the open source cache
EhCache 2.x,
allowing to set up an EhCache CacheManager and Caches
as beans in a Spring context.
|
org.springframework.context.support |
Classes supporting the org.springframework.context package,
such as abstract base classes for ApplicationContext
implementations and a MessageSource implementation.
|
org.springframework.jca.endpoint |
This package provides a facility for generic JCA message endpoint management.
|
org.springframework.jms.listener |
This package contains the base message listener container facility.
|
org.springframework.jms.listener.endpoint |
This package provides JCA-based endpoint management for JMS message listeners.
|
org.springframework.messaging.handler.annotation.reactive |
Support classes for working with annotated message-handling methods with
non-blocking, reactive contracts.
|
org.springframework.messaging.handler.invocation.reactive |
Common infrastructure for invoking message handler methods with non-blocking,
and reactive contracts.
|
org.springframework.messaging.rsocket.annotation.support |
Support classes for working with annotated RSocket stream handling methods.
|
org.springframework.messaging.support |
Provides implementations of
Message along with
a MessageBuilder and MessageHeaderAccessor for building and working with messages and
message headers, as well as various MessageChannel
implementations and channel interceptor support. |
org.springframework.orm.hibernate5.support |
Classes supporting the
org.springframework.orm.hibernate5 package. |
org.springframework.orm.jpa |
Package providing integration of JPA (Java Persistence API) with Spring concepts.
|
org.springframework.orm.jpa.support |
Classes supporting the
org.springframework.orm.jpa package. |
org.springframework.scheduling.annotation |
Annotation support for asynchronous method execution.
|
org.springframework.scheduling.concurrent |
Scheduling convenience classes for the
java.util.concurrent
and javax.enterprise.concurrent packages, allowing to set up a
ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring
context. |
org.springframework.scheduling.config |
Support package for declarative scheduling configuration,
with XML schema being the primary configuration format.
|
org.springframework.scheduling.quartz |
Support classes for the open source scheduler
Quartz,
allowing to set up Quartz Schedulers, JobDetails and
Triggers as beans in a Spring context.
|
org.springframework.web.context.support |
Classes supporting the
org.springframework.web.context package,
such as WebApplicationContext implementations and various utility classes. |
org.springframework.web.filter |
Provides generic filter base classes allowing for bean-style configuration.
|
org.springframework.web.multipart.support |
Support classes for the multipart resolution framework.
|
org.springframework.web.reactive.function.server.support |
Classes supporting the
org.springframework.web.reactive.function.server package. |
org.springframework.web.reactive.handler |
Provides HandlerMapping implementations including abstract base classes.
|
org.springframework.web.reactive.result.method |
Infrastructure for handler method processing.
|
org.springframework.web.reactive.result.method.annotation |
Infrastructure for annotation-based handler method processing.
|
org.springframework.web.reactive.result.view |
Support for result handling through view resolution.
|
org.springframework.web.reactive.result.view.freemarker |
Support classes for the integration of
FreeMarker
as Spring web view technology.
|
org.springframework.web.reactive.result.view.script |
Support classes for views based on the JSR-223 script engine abstraction
(as included in Java 6+), e.g.
|
org.springframework.web.servlet.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.resource |
Support classes for serving static resources.
|
org.springframework.web.servlet.view |
Provides standard View and ViewResolver implementations,
including abstract base classes for custom implementations.
|
org.springframework.web.servlet.view.document |
Support classes for document generation,
providing View implementations for PDF and Excel.
|
org.springframework.web.servlet.view.feed |
Support classes for feed generation, providing View implementations for Atom and RSS.
|
org.springframework.web.servlet.view.groovy |
Support classes for the integration of
Groovy Templates as Spring web view technology.
|
org.springframework.web.servlet.view.json |
Support classes for providing a View implementation based on JSON serialization.
|
org.springframework.web.servlet.view.tiles3 |
Support classes for the integration of
Tiles 3
(the standalone version of Tiles) as Spring web view technology.
|
org.springframework.web.servlet.view.xml |
Support classes for providing a View implementation based on XML Marshalling.
|
org.springframework.web.servlet.view.xslt |
Support classes for XSLT,
providing a View implementation for XSLT stylesheets.
|
org.springframework.web.socket.server.support |
Server-side support classes including container-specific strategies
for upgrading a request.
|
Modifier and Type | Class and Description |
---|---|
class |
DefaultAdvisorAutoProxyCreator
BeanPostProcessor implementation that creates AOP proxies based on all
candidate Advisor s in the current BeanFactory . |
Modifier and Type | Class and Description |
---|---|
class |
FieldRetrievingFactoryBean
FactoryBean which retrieves a static or non-static field value. |
class |
PlaceholderConfigurerSupport
Abstract base class for property resource configurers that resolve placeholders
in bean definition property values.
|
class |
PreferencesPlaceholderConfigurer
Deprecated.
as of 5.2, along with
PropertyPlaceholderConfigurer |
class |
PropertyPathFactoryBean
FactoryBean that evaluates a property path on a given target object. |
class |
PropertyPlaceholderConfigurer
Deprecated.
as of 5.2; use
org.springframework.context.support.PropertySourcesPlaceholderConfigurer
instead which is more flexible through taking advantage of the Environment
and PropertySource mechanisms. |
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 |
AbstractRefreshableConfigApplicationContext
AbstractRefreshableApplicationContext subclass that adds common handling
of specified config locations. |
class |
AbstractXmlApplicationContext
Convenient base class for
ApplicationContext
implementations, drawing configuration from XML documents containing bean definitions
understood by an XmlBeanDefinitionReader . |
class |
ClassPathXmlApplicationContext
Standalone XML application context, taking the context definition files
from the class path, interpreting plain paths as class path resource names
that include the package path (e.g.
|
class |
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 |
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 . |
Modifier and Type | Class and Description |
---|---|
class |
AbstractMessageEndpointFactory
Abstract base implementation of the JCA 1.7
MessageEndpointFactory interface,
providing transaction management capabilities as well as ClassLoader
exposure for endpoint invocations. |
class |
GenericMessageEndpointFactory
Generic implementation of the JCA 1.7
MessageEndpointFactory interface,
providing transaction management capabilities for any kind of message
listener object (e.g. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractJmsListeningContainer
Common base class for all containers which need to implement listening
based on a JMS Connection (either shared or freshly obtained for each attempt).
|
class |
AbstractMessageListenerContainer
Abstract base class for Spring message listener container implementations.
|
class |
AbstractPollingMessageListenerContainer
Base class for listener container implementations which are based on polling.
|
class |
DefaultMessageListenerContainer
Message listener container variant that uses plain JMS client APIs, specifically
a loop of
MessageConsumer.receive() calls that also allow for
transactional reception of messages (registering them with XA transactions). |
class |
SimpleMessageListenerContainer
Message listener container that uses the plain JMS client API's
MessageConsumer.setMessageListener() method to
create concurrent MessageConsumers for the specified listeners. |
Modifier and Type | Class and Description |
---|---|
class |
JmsMessageEndpointFactory
JMS-specific implementation of the JCA 1.7
MessageEndpointFactory interface,
providing transaction management capabilities for a JMS listener object
(e.g. |
class |
JmsMessageEndpointManager
Extension of the generic JCA 1.5
GenericMessageEndpointManager ,
adding JMS-specific support for ActivationSpec configuration. |
Modifier and Type | Class and Description |
---|---|
class |
MessageMappingMessageHandler
Extension of
AbstractMethodMessageHandler for reactive, non-blocking
handling of messages via @MessageMapping methods. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractMethodMessageHandler<T>
Abstract base class for reactive HandlerMethod-based message handling.
|
Modifier and Type | Class and Description |
---|---|
class |
RSocketMessageHandler
Extension of
MessageMappingMessageHandler for handling RSocket
requests with @ConnectMapping and
@MessageMapping methods. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractMessageChannel
Abstract base class for
MessageChannel implementations. |
class |
AbstractSubscribableChannel
Abstract base class for
SubscribableChannel implementations. |
class |
ExecutorSubscribableChannel
A
SubscribableChannel that sends messages to each of its subscribers. |
Modifier and Type | Class and Description |
---|---|
class |
OpenSessionInViewFilter
Servlet Filter that binds a Hibernate Session to the thread for the entire
processing of the request.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractEntityManagerFactoryBean
Abstract
FactoryBean that creates
a local JPA EntityManagerFactory instance within
a Spring application context. |
class |
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 |
OpenEntityManagerInViewFilter
Servlet Filter that binds a JPA EntityManager to the thread for the
entire processing of the request.
|
Modifier and Type | Class and Description |
---|---|
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 setting up a
ExecutorService
(typically a ThreadPoolExecutor or
ScheduledThreadPoolExecutor ). |
class |
ScheduledExecutorFactoryBean
FactoryBean that sets up
a ScheduledExecutorService
(by default: a ScheduledThreadPoolExecutor )
and exposes it for bean references. |
class |
ThreadPoolExecutorFactoryBean
JavaBean that allows for configuring a
ThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds",
"queueCapacity" properties) and exposing it as a bean reference of its native
ExecutorService type. |
class |
ThreadPoolTaskExecutor
JavaBean that allows for configuring a
ThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity"
properties) and exposing it as a Spring TaskExecutor . |
class |
ThreadPoolTaskScheduler
A standard implementation of Spring's
TaskScheduler interface, wrapping
a native ScheduledThreadPoolExecutor and providing
all applicable configuration options for it. |
Modifier and Type | Class and Description |
---|---|
class |
TaskExecutorFactoryBean
FactoryBean for creating ThreadPoolTaskExecutor instances,
primarily used behind the XML task namespace. |
Modifier and Type | Class and Description |
---|---|
class |
CronTriggerFactoryBean
A Spring
FactoryBean for creating a Quartz CronTrigger
instance, supporting bean-style usage for trigger configuration. |
class |
JobDetailFactoryBean
A Spring
FactoryBean for creating a Quartz JobDetail
instance, supporting bean-style usage for JobDetail configuration. |
class |
MethodInvokingJobDetailFactoryBean
FactoryBean that exposes a
JobDetail object which delegates job execution to a
specified (static or non-static) method. |
class |
SchedulerFactoryBean
FactoryBean that creates and configures a Quartz Scheduler ,
manages its lifecycle as part of the Spring application context, and exposes the
Scheduler as bean reference for dependency injection. |
class |
SimpleTriggerFactoryBean
A Spring
FactoryBean for creating a Quartz SimpleTrigger
instance, supporting bean-style usage for trigger configuration. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractRefreshableWebApplicationContext
AbstractRefreshableApplicationContext
subclass which implements the
ConfigurableWebApplicationContext
interface for web environments. |
class |
AnnotationConfigWebApplicationContext
WebApplicationContext
implementation which accepts component classes as input — in particular
@Configuration
classes, but also plain @Component
classes as well as JSR-330 compliant classes using javax.inject annotations. |
class |
GroovyWebApplicationContext
WebApplicationContext implementation which takes
its configuration from Groovy bean definition scripts and/or XML files, as understood by
a GroovyBeanDefinitionReader . |
class |
XmlWebApplicationContext
WebApplicationContext implementation
which takes its configuration from XML documents, understood by an
XmlBeanDefinitionReader . |
Modifier and Type | Class and Description |
---|---|
class |
AbstractRequestLoggingFilter
Base class for
Filter s that perform logging operations before and after a request
is processed. |
class |
CharacterEncodingFilter
Servlet Filter that allows one to specify a character encoding for requests.
|
class |
CommonsRequestLoggingFilter
Simple request logging filter that writes the request URI
(and optionally the query string) to the Commons Log.
|
class |
CorsFilter
Filter to handle CORS pre-flight requests and intercept
CORS simple and actual requests with a CorsProcessor , and to update
the response, e.g. |
class |
DelegatingFilterProxy
Proxy for a standard Servlet Filter, delegating to a Spring-managed bean that
implements the Filter interface.
|
class |
FormContentFilter
Filter that parses form data for HTTP PUT, PATCH, and DELETE requests
and exposes it as Servlet request parameters. |
class |
ForwardedHeaderFilter
Extract values from "Forwarded" and "X-Forwarded-*" headers, wrap the request
and response, and make they reflect the client-originated protocol and
address in the following methods:
getServerName()
getServerPort()
getScheme()
isSecure()
sendRedirect(String) . |
class |
GenericFilterBean
Simple base implementation of
Filter which treats
its config parameters (init-param entries within the
filter tag in web.xml ) as bean properties. |
class |
HiddenHttpMethodFilter
Filter that converts posted method parameters into HTTP methods,
retrievable via HttpServletRequest.getMethod() . |
class |
HttpPutFormContentFilter
Deprecated.
as of 5.1 in favor of
FormContentFilter which is the same
but also handles DELETE. |
class |
OncePerRequestFilter
Filter base class that aims to guarantee a single execution per request
dispatch, on any servlet container.
|
class |
RelativeRedirectFilter
Overrides
HttpServletResponse.sendRedirect(String) and handles it by
setting the HTTP status and "Location" headers, which keeps the Servlet
container from re-writing relative redirect URLs into absolute ones. |
class |
RequestContextFilter
Servlet Filter that exposes the request to the current thread,
through both
LocaleContextHolder and
RequestContextHolder . |
class |
ServletContextRequestLoggingFilter
Simple request logging filter that writes the request URI
(and optionally the query string) to the ServletContext log.
|
class |
ShallowEtagHeaderFilter
Filter that generates an ETag value based on the
content on the response. |
Modifier and Type | Class and Description |
---|---|
class |
MultipartFilter
Servlet Filter that resolves multipart requests via a
MultipartResolver . |
Modifier and Type | Class and Description |
---|---|
class |
RouterFunctionMapping
HandlerMapping implementation that supports RouterFunctions . |
Modifier and Type | Class and Description |
---|---|
class |
AbstractHandlerMapping
Abstract base class for
HandlerMapping
implementations. |
class |
AbstractUrlHandlerMapping
Abstract base class for URL-mapped
HandlerMapping implementations. |
class |
SimpleUrlHandlerMapping
Implementation of the
HandlerMapping
interface to map from URLs to request handler beans. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractHandlerMethodMapping<T>
Abstract base class for
HandlerMapping implementations that define
a mapping between a request and a HandlerMethod . |
class |
RequestMappingInfoHandlerMapping
Abstract base class for classes for which
RequestMappingInfo defines
the mapping between a request and a handler method. |
Modifier and Type | Class and Description |
---|---|
class |
RequestMappingHandlerMapping
An extension of
RequestMappingInfoHandlerMapping that creates
RequestMappingInfo instances from class-level and method-level
@RequestMapping annotations. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractUrlBasedView
Abstract base class for URL-based views.
|
class |
AbstractView
Base class for
View implementations. |
class |
RedirectView
View that redirects to an absolute or context relative URL.
|
Modifier and Type | Class and Description |
---|---|
class |
FreeMarkerView
A
View implementation that uses the FreeMarker template engine. |
Modifier and Type | Class and Description |
---|---|
class |
ScriptTemplateView
An
AbstractUrlBasedView subclass designed to run any template library
based on a JSR-223 script engine. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractDetectingUrlHandlerMapping
Abstract implementation of the
HandlerMapping
interface, detecting URL mappings for handler beans through introspection of all
defined beans in the application context. |
class |
BeanNameUrlHandlerMapping
Implementation of the
HandlerMapping
interface that maps from URLs to beans with names that start with a slash ("/"),
similar to how Struts maps URLs to action names. |
Modifier and Type | Class and Description |
---|---|
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.
|
Modifier and Type | Class and Description |
---|---|
class |
ResourceUrlEncodingFilter
A filter that wraps the
HttpServletResponse and overrides its
encodeURL method in order to
translate internal resource request URLs into public URL paths for external use. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractTemplateView
Adapter base class for template-based view technologies such as FreeMarker,
with the ability to use request and session attributes in their model and
the option to expose helper objects for Spring's FreeMarker macro library.
|
class |
InternalResourceView
Wrapper for a JSP or other resource within the same web application.
|
class |
JstlView
Specialization of
InternalResourceView for JSTL pages,
i.e. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractPdfStamperView
Abstract superclass for PDF views that operate on an existing
document with an AcroForm.
|
class |
AbstractPdfView
Abstract superclass for PDF views.
|
class |
AbstractXlsView
Convenient superclass for Excel document views in traditional XLS format.
|
class |
AbstractXlsxStreamingView
Convenient superclass for Excel document views in the Office 2007 XLSX format,
using POI's streaming variant.
|
class |
AbstractXlsxView
Convenient superclass for Excel document views in the Office 2007 XLSX format
(as supported by POI-OOXML).
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractAtomFeedView
Abstract superclass for Atom Feed views, using the
ROME package.
|
class |
AbstractFeedView<T extends com.rometools.rome.feed.WireFeed>
Abstract base class for Atom and RSS Feed views, using the
ROME package.
|
class |
AbstractRssFeedView
Abstract superclass for RSS Feed views, using the
ROME package.
|
Modifier and Type | Class and Description |
---|---|
class |
GroovyMarkupView
An
AbstractTemplateView subclass based on Groovy XML/XHTML markup templates. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractJackson2View
Abstract base class for Jackson based and content type independent
AbstractView implementations. |
class |
MappingJackson2JsonView
Spring MVC
View that renders JSON content by serializing the model for the current request
using Jackson 2's ObjectMapper . |
Modifier and Type | Class and Description |
---|---|
class |
TilesView
View implementation that renders
through the Tiles Request API. |
Modifier and Type | Class and Description |
---|---|
class |
MappingJackson2XmlView
Spring MVC
View that renders XML content by serializing the model for the current request
using Jackson 2's XmlMapper . |
class |
MarshallingView
Spring-MVC
View that allows for response context to be rendered as the result
of marshalling by a Marshaller . |
Modifier and Type | Class and Description |
---|---|
class |
XsltView
XSLT-driven View that allows for response context to be rendered as the
result of an XSLT transformation.
|
Modifier and Type | Class and Description |
---|---|
class |
WebSocketHandlerMapping
Extension of
SimpleUrlHandlerMapping with support for more
precise mapping of WebSocket handshake requests to handlers of type
WebSocketHttpRequestHandler . |