Package | Description |
---|---|
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.http.converter.json |
Provides HttpMessageConverter implementations for handling JSON.
|
org.springframework.jms.config |
Support package for declarative messaging configuration,
with Java configuration and XML schema support.
|
org.springframework.messaging.handler.invocation |
Common infrastructure for invoking message handler methods.
|
org.springframework.messaging.simp.annotation.support |
Support classes for handling messages from simple messaging protocols
(like STOMP).
|
org.springframework.messaging.simp.config |
Configuration support for WebSocket messaging using higher level messaging protocols.
|
org.springframework.scheduling.annotation |
Java 5 annotation for asynchronous method execution.
|
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.test.context.junit4 |
Support classes for integrating the Spring TestContext Framework
with JUnit 4.12 or higher.
|
org.springframework.test.context.testng |
Support classes for ApplicationContext-based and transactional
tests run with TestNG and the Spring TestContext Framework.
|
org.springframework.validation.beanvalidation |
Support classes for integrating a JSR-303 Bean Validation provider
(such as Hibernate Validator) into a Spring ApplicationContext
and in particular with Spring's data binding and validation APIs.
|
org.springframework.web.context.support |
Classes supporting the
org.springframework.web.context package,
such as WebApplicationContext implementations and various utility classes. |
org.springframework.web.reactive |
Top-level package for the
spring-webflux module that contains
DispatcherHandler , the main entry
point for WebFlux server endpoint processing including key contracts used to
map requests to handlers, invoke them, and process the result. |
org.springframework.web.reactive.config |
Spring WebFlux configuration infrastructure.
|
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 |
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.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.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.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.config.annotation |
Support for annotation-based WebSocket setup in configuration classes.
|
org.springframework.web.socket.messaging |
WebSocket integration for Spring's messaging module.
|
org.springframework.web.socket.server.standard |
Server-side classes for use with standard JSR-356 WebSocket endpoints.
|
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 |
EventListenerMethodProcessor
Registers
EventListener methods as individual ApplicationListener instances. |
Modifier and Type | Class and Description |
---|---|
class |
ApplicationObjectSupport
Convenient superclass for application objects that want to be aware of
the application context, 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). |
Modifier and Type | Class and Description |
---|---|
class |
Jackson2ObjectMapperFactoryBean
A
FactoryBean for creating a Jackson 2.x ObjectMapper (default) or
XmlMapper (createXmlMapper property set to true) with setters
to enable or disable Jackson features from within XML configuration. |
Modifier and Type | Class and Description |
---|---|
class |
JmsListenerEndpointRegistry
Creates the necessary
MessageListenerContainer instances for the
registered endpoints. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractMethodMessageHandler<T>
Abstract base class for HandlerMethod-based message handling.
|
Modifier and Type | Class and Description |
---|---|
class |
SimpAnnotationMethodMessageHandler
A handler for messages delegating to
@MessageMapping
and @SubscribeMapping annotated methods. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractMessageBrokerConfiguration
Provides essential configuration for handling messages with simple messaging
protocols such as STOMP.
|
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 |
JobDetailFactoryBean
A Spring
FactoryBean for creating a Quartz JobDetail
instance, supporting bean-style usage for JobDetail configuration. |
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. |
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 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 |
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 |
OptionalValidatorFactoryBean
LocalValidatorFactoryBean subclass that simply turns
Validator calls into no-ops
in case of no Bean Validation provider being available. |
Modifier and Type | Class and Description |
---|---|
class |
ServletContextLiveBeansView
LiveBeansView subclass which looks for all ApplicationContexts
in the web application, as exposed in ServletContext attributes. |
class |
WebApplicationObjectSupport
Convenient superclass for application objects running in a
WebApplicationContext . |
Modifier and Type | Class and Description |
---|---|
class |
DispatcherHandler
Central dispatcher for HTTP request handlers/controllers.
|
Modifier and Type | Class and Description |
---|---|
class |
DelegatingWebFluxConfiguration
A subclass of
WebFluxConfigurationSupport that detects and delegates
to all beans of type WebFluxConfigurer allowing them to customize the
configuration provided by WebFluxConfigurationSupport . |
class |
WebFluxConfigurationSupport
The main class for Spring WebFlux configuration.
|
Modifier and Type | Class and Description |
---|---|
class |
RouterFunctionMapping
HandlerMapping implementation that supports RouterFunction s. |
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 |
RequestMappingHandlerAdapter
Supports the invocation of
@RequestMapping
handler methods. |
class |
RequestMappingHandlerMapping
An extension of
RequestMappingInfoHandlerMapping that creates
RequestMappingInfo instances from class-level and method-level
@RequestMapping annotations. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractUrlBasedView
Abstract base class for URL-based views.
|
class |
AbstractView
Base class for
View implementations. |
class |
RedirectView
View that redirects to an absolute or context relative URL.
|
class |
UrlBasedViewResolver
A
ViewResolver that allow direct resolution of symbolic view names
to URLs without explicit mapping definition. |
Modifier and Type | Class and Description |
---|---|
class |
FreeMarkerView
A
View implementation that uses the FreeMarker template engine. |
class |
FreeMarkerViewResolver
A
ViewResolver for resolving FreeMarkerView instances, i.e. |
Modifier and Type | Class and Description |
---|---|
class |
ScriptTemplateView
An
AbstractUrlBasedView subclass designed to run any template library
based on a JSR-223 script engine. |
class |
ScriptTemplateViewResolver
Convenience subclass of
UrlBasedViewResolver that supports
ScriptTemplateView and custom subclasses of it. |
Modifier and Type | Class and Description |
---|---|
class |
DispatcherServlet
Central dispatcher for HTTP request handlers/controllers, e.g.
|
class |
FrameworkServlet
Base servlet for Spring's web framework.
|
Modifier and Type | Class and Description |
---|---|
class |
DelegatingWebMvcConfiguration
A subclass 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 |
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 |
HandlerMappingIntrospector
Helper class to get information from the
HandlerMapping that would
serve a specific request. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractController
Convenient superclass for controller implementations, using the Template Method
design pattern.
|
class |
AbstractUrlViewController
Abstract base class for
Controllers that return a view name
based on the request URL. |
class |
ParameterizableViewController
Trivial controller that always returns a pre-configured view and optionally
sets the response status code.
|
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 |
UrlFilenameViewController
Simple
Controller implementation that transforms the virtual
path of a URL into a view name and returns that view. |
class |
WebContentInterceptor
Handler interceptor that checks the request and prepares the response.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractHandlerMethodAdapter
Abstract base class for
HandlerAdapter implementations that support
handlers of type HandlerMethod . |
Modifier and Type | Class and Description |
---|---|
class |
ExceptionHandlerExceptionResolver
An
AbstractHandlerMethodExceptionResolver that resolves exceptions
through @ExceptionHandler methods. |
Modifier and Type | Class and Description |
---|---|
class |
ResourceHttpRequestHandler
HttpRequestHandler that serves static resources in an optimized way
according to the guidelines of Page Speed, YSlow, etc. |
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 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 |
AbstractTemplateViewResolver
Abstract base class for template view resolvers, in particular for FreeMarker views.
|
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 |
ResourceBundleViewResolver
A
ViewResolver implementation that uses
bean definitions in a ResourceBundle , specified by the bundle basename. |
class |
ViewResolverComposite
A
ViewResolver that delegates to others. |
class |
XmlViewResolver
A
ViewResolver implementation that uses
bean definitions in a dedicated XML file for view definitions, specified by
resource location. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractPdfStamperView
Abstract superclass for PDF views that operate on an existing
document with an AcroForm.
|
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 |
GroovyMarkupConfigurer
An extension of Groovy's
TemplateConfiguration and
an implementation of Spring MVC's GroovyMarkupConfig for creating
a MarkupTemplateEngine for use in a web application. |
class |
GroovyMarkupView
An
AbstractTemplateView subclass based on Groovy XML/XHTML markup templates. |
class |
GroovyMarkupViewResolver
Convenience subclass of @link AbstractTemplateViewResolver} that supports
GroovyMarkupView (i.e. |
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. |
class |
TilesViewResolver
Convenience subclass of
UrlBasedViewResolver that supports
TilesView (i.e. |
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.
|
class |
XsltViewResolver
ViewResolver implementation that
resolves instances of XsltView by translating the supplied view name
into the URL of the XSLT stylesheet. |
Modifier and Type | Class and Description |
---|---|
class |
DelegatingWebSocketMessageBrokerConfiguration
A
WebSocketMessageBrokerConfigurationSupport extension that detects
beans of type WebSocketMessageBrokerConfigurer and delegates to all
of them allowing callback style customization of the configuration provided
in WebSocketMessageBrokerConfigurationSupport . |
class |
WebSocketMessageBrokerConfigurationSupport
Extends
AbstractMessageBrokerConfiguration and adds configuration for
receiving and responding to STOMP messages from WebSocket clients. |
Modifier and Type | Class and Description |
---|---|
class |
WebSocketAnnotationMethodMessageHandler
A sub-class of
SimpAnnotationMethodMessageHandler to provide support
for ControllerAdvice with global @MessageExceptionHandler methods. |
Modifier and Type | Class and Description |
---|---|
class |
ServerEndpointExporter
Detects beans of type
ServerEndpointConfig and registers
with the standard Java WebSocket runtime. |
Modifier and Type | Class and Description |
---|---|
class |
WebSocketHandlerMapping
An extension of
SimpleUrlHandlerMapping that is also a
SmartLifecycle container and propagates start and stop calls to any
handlers that implement Lifecycle . |