All Classes and Interfaces
Class
Description
WebApplicationInitializer
to register a DispatcherServlet and use Java-based Spring configuration.Abstract superclass for Atom Feed views, using the
ROME package.
Convenient base class for
ViewResolver
implementations.Filter that determines if view should be cached.
Abstract base class to provide common methods for
implementing databinding-aware JSP tags for rendering an HTML '
input'
element with a 'type' of 'checkbox' or 'radio'.Convenient superclass for controller implementations, using the Template Method
design pattern.
Base tag for all data-binding aware JSP form tags.
Abstract implementation of the
HandlerMapping
interface, detecting URL mappings for handler beans through introspection of all
defined beans in the application context.Base class for
WebApplicationInitializer
implementations that register a DispatcherServlet in the servlet context.AbstractFeedView<T extends com.rometools.rome.feed.WireFeed>
Abstract base class for Atom and RSS Feed views, using the
ROME package.
A base class for
FlashMapManager implementations.Base class for all JSP form tags.
Abstract base class for
HandlerExceptionResolver implementations.Abstract base class for
HandlerMapping
implementations.Abstract base class for
HandlerAdapter implementations that support
handlers of type HandlerMethod.Abstract base class for
HandlerExceptionResolver
implementations that support handling exceptions from handlers of type HandlerMethod.Abstract base class for
HandlerMapping implementations that define
a mapping between a request and a HandlerMethod.Convenient superclass for many html tags that render content using the databinding
features of the
AbstractHtmlElementTag.Base class for databinding-aware JSP tags that render HTML element.
Base class for databinding-aware JSP tags that render HTML form input element.
Abstract base class for Jackson based and content type independent
AbstractView implementations.Abstract base class for
LocaleContextResolver implementations.Abstract base class for
LocaleResolver implementations.A convenient base class for
ResponseBodyAdvice implementations
that customize the response before JSON serialization with
AbstractJackson2HttpMessageConverter's concrete subclasses.A base class for resolving method argument values by reading from the body of
a request with
HttpMessageConverters.Extends
AbstractMessageConverterMethodArgumentResolver with the ability to handle method
return values by writing to the response with HttpMessageConverters.Abstract base class to provide common methods for implementing
databinding-aware JSP tags for rendering multiple
HTML '
input' elements with a 'type'
of 'checkbox' or 'radio'.Abstract superclass for PDF views that operate on an existing
document with an AcroForm.
Abstract superclass for PDF views.
A base class for
RequestCondition types providing implementations of
AbstractRequestCondition.equals(Object), AbstractRequestCondition.hashCode(), and AbstractRequestCondition.toString().Base class for
ResourceResolver
implementations.Abstract superclass for RSS Feed views, using the
ROME package.
Abstract base class to provide common methods for implementing databinding-aware
JSP tags for rendering a single HTML '
input' element with a
'type' of 'checkbox' or 'radio'.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.
Abstract base class for template view resolvers, in particular for FreeMarker views.
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
Abstract base class for URL-based views.
Abstract base class for URL-mapped
HandlerMapping implementations.Abstract base class for
Controllers that return a view name
based on the request URL.Abstract base class for
VersionStrategy implementations.File name-based
VersionPathStrategy,
e.g.A prefix-based
VersionPathStrategy,
e.g.Abstract base class for
View
implementations.Convenient superclass for Excel document views in traditional XLS format.
Convenient superclass for Excel document views in the Office 2007 XLSX format,
using POI's streaming variant.
Convenient superclass for Excel document views in the Office 2007 XLSX format
(as supported by POI-OOXML).
LocaleResolver implementation that simply uses the primary locale
specified in the Accept-Language header of the HTTP request (that is,
the locale sent by the client browser, normally that of the client's OS).Allows implementing tag to utilize nested
spring:argument tags.The
<argument> tag is based on the JSTL fmt:param tag.Extends
HandlerInterceptor with a callback method invoked after the
start of asynchronous request handling.Asynchronous subtype of
ServerResponse that exposes the future
response.Helps with configuring options for asynchronous request processing.
Handles return values of type
WebAsyncTask.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.A simple implementation of
ViewResolver
that interprets a view name as a bean name in the current application context,
i.e.This
<hasBindErrors> tag provides an Errors instance in case of
bind errors.Simple adapter to expose the bind status of a field or object.
The
<bind> tag supports evaluation of binding errors for a certain
bean or bean property.The
<button> tag renders a form field label in an HTML 'button' tag.A
ResourceResolver that
resolves resources from a Cache or otherwise
delegates to the resolver chain and saves the result in the cache.A
ResourceTransformer that checks a
Cache to see if a previously transformed resource
exists in the cache and returns it if found, and otherwise delegates to the resolver
chain and saves the result in the cache.Handles return values of type
Callable.The
<checkboxes> tag renders multiple HTML 'input' tags with type 'checkbox'.The
<checkbox> tag renders an HTML 'input' tag with type 'checkbox'.Implements the
RequestCondition contract by delegating to multiple
RequestCondition types and using a logical conjunction (' && ') to
ensure all conditions match a given request.A logical disjunction (' || ') request condition to match a request's
'Content-Type' header to a list of media type expressions.
Implementation of
ViewResolver that resolves a view based on the request file name
or Accept header.Creates a
ContentNegotiationManager and configures it with
one or more ContentNegotiationStrategy instances.A
VersionStrategy that calculates a Hex MD5 hash from the content
of the resource and appends it to the file name, e.g.No-op resolver for method arguments of type
Continuation.Base Controller interface, representing a component that receives
HttpServletRequest and HttpServletResponse
instances just like a HttpServlet but is able to
participate in an MVC workflow.Interceptor that places the configured
ConversionService in request scope
so it's available during request processing.LocaleResolver implementation that uses a cookie sent back to the user
in case of a custom setting, with a fallback to the configured default locale,
the request's Accept-Language header, or the default locale for the server.Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
BeanDefinitionParser that parses a
cors element in order to set the CORS configuration in the various
{AbstractHandlerMapping} beans created by AnnotationDrivenBeanDefinitionParser,
ResourcesBeanDefinitionParser and ViewControllerBeanDefinitionParser.Assists with the creation of a
CorsConfiguration instance for a given
URL path pattern.Assists with the registration of global, URL pattern based
CorsConfiguration mappings.A
ResourceTransformer implementation that modifies links in a CSS
file to match the public URL paths that should be exposed to clients (e.g.Abstract base class for
CssLinkResourceTransformer.LinkParser implementations.Extract content chunks that represent links.
The default implementation of the
HandlerExceptionResolver
interface, resolving standard Spring MVC exceptions and translating them to corresponding
HTTP status codes.RequestToViewNameTranslator that simply transforms the URI of
the incoming request into a view name.Configures a request handler for serving static resources by forwarding
the request to the Servlet container's "default" Servlet.
An
HttpRequestHandler for serving static files using the Servlet container's "default" Servlet.A subclass of
WebMvcConfigurationSupport that detects and delegates
to all beans of type WebMvcConfigurer allowing them to customize the
configuration provided by WebMvcConfigurationSupport.Central dispatcher for HTTP request handlers/controllers, e.g.
ServletWebRequest subclass that is aware of
DispatcherServlet's
request context, such as the Locale determined by the configured
LocaleResolver.Interface to be implemented by JSP tags that expose a
PropertyEditor for a property that they are currently bound to.
Adding this annotation to an
@Configuration class imports the Spring MVC
configuration from WebMvcConfigurationSupport, e.g.:Resolver that delegates to the chain, and if a resource is found, it then
attempts to find an encoded (e.g.
Entity-specific subtype of
ServerResponse that exposes entity data.Defines a builder for
EntityResponse.The
<errors> tag renders field errors in an HTML 'span' tag.The
<escapeBody> tag is used to escape its enclosed body content,
applying HTML escaping and/or JavaScript escaping.The
<eval> tag evaluates a Spring expression (SpEL) and either prints
the result or assigns it to a variable.An
AbstractHandlerMethodExceptionResolver that resolves exceptions
through @ExceptionHandler methods.Subclass of
ServletRequestDataBinder that adds URI template variables
to the values used for data binding.LocaleResolver implementation
that always returns a fixed default locale and optionally time zone.Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
A
VersionStrategy that relies on a fixed version applied as a request
path prefix, e.g.A FlashMap provides a way for one request to store attributes intended for
use in another.
A strategy interface for retrieving and saving FlashMap instances.
The
<form> tag renders an HTML 'form' tag and exposes a binding path to
inner tags for binding.Base servlet for Spring's web framework.
Interface to be implemented by objects that configure and manage a
FreeMarker Configuration object in a web environment.
JavaBean to configure FreeMarker for web usage, via the "configLocation"
and/or "freemarkerSettings" and/or "templateLoaderPath" properties.
Parse the
<mvc:freemarker-configurer> MVC namespace element and
register FreeMarkerConfigurer bean.View using the FreeMarker template engine.
Convenience subclass of
UrlBasedViewResolver
that supports FreeMarkerView (i.e.Interface to be implemented by objects that configure and manage a Groovy
MarkupTemplateEngine for automatic lookup in a web environment.An extension of Groovy's
TemplateConfiguration and
an implementation of Spring MVC's GroovyMarkupConfig for creating
a MarkupTemplateEngine for use in a web application.Parse the
<mvc:groovy-configurer> MVC namespace element and register a
GroovyConfigurer bean.An
AbstractTemplateView subclass based on Groovy XML/XHTML markup templates.Convenience subclass of
AbstractTemplateViewResolver that supports
GroovyMarkupView (i.e.MVC framework SPI, allowing parameterization of the core MVC workflow.
Interface to be implemented by objects that can resolve exceptions thrown during
handler mapping or execution, in the typical case to error views.
A
HandlerExceptionResolver that delegates to a list of other
HandlerExceptionResolvers.Handler execution chain, consisting of handler object and any handler interceptors.
Represents a function that filters a handler function.
Represents a function that handles a request.
HandlerAdapter implementation that supports HandlerFunctions.Workflow interface that allows for customized handler execution chains.
Interface to be implemented by objects that define a mapping between
requests and handler objects.
Helper class to get information from the
HandlerMapping that would
serve a specific request.A strategy for assigning a name to a handler method's mapping.
A logical conjunction (
' && ') request condition that matches a request against
a set of header expressions with syntax defined in RequestMapping.headers().The
<hidden> tag renders an HTML 'input' tag with type 'hidden' using
the bound value.The
<htmlEscape> tag sets default HTML escape value for the current
page.Superclass for tags that output content that might get HTML-escaped.
Resolves
HttpEntity and RequestEntity method argument values,
as well as return values of type HttpEntity, ResponseEntity,
ErrorResponse and ProblemDetail.Handles
HttpHeaders return values.Adapter to use the plain
HttpRequestHandler
interface with the generic DispatcherServlet.Extended interface for a
Resource to be written to an
HTTP response.Simple extension of
HttpServlet which treats
its config parameters (init-param entries within the
servlet tag in web.xml) as bean properties.The
<input> tag renders an HTML 'input' tag with type 'text' using
the bound value.Assists with the creation of a
MappedInterceptor.Helps with configuring a list of mapped interceptors.
Wrapper for a JSP or other resource within the same web application.
Convenient subclass of
UrlBasedViewResolver that supports
InternalResourceView (i.e.A
RequestBodyAdvice implementation that adds support for Jackson's
@JsonView annotation declared on a Spring MVC @HttpEntity
or @RequestBody method parameter.A
ResponseBodyAdvice implementation that adds support for Jackson's
@JsonView annotation declared on a Spring MVC @RequestMapping
or @ExceptionHandler method.JSP-aware (and JSTL-aware) subclass of RequestContext, allowing for
population of the context from a
jakarta.servlet.jsp.PageContext.Helper class for preparing JSTL views,
in particular for exposing a JSTL localization context.
Specialization of
InternalResourceView for JSTL pages,
i.e.The
<label> tag renders a form field label in an HTML 'label' tag.Deprecated.
as of 5.3.9 in favor of using the
checkNotModified methods
in WebRequest, or from an
annotated controller method, returning a
ResponseEntity with an "ETag" and/or
"Last-Modified" headers set.Interceptor that allows for changing the current locale on every request,
via a configurable request parameter (default parameter name: "locale").
Extension of
LocaleResolver that adds support for a rich locale context
(potentially including locale and time zone information).Interface for web-based locale resolution strategies that allows for
both locale resolution via the request and locale modification via
request and response.
Wraps a
HandlerInterceptor and uses URL patterns to determine whether
it applies to a given request.Spring MVC
View that renders JSON content by serializing the model for the current request
using Jackson 2's ObjectMapper.Spring MVC
View that renders XML content by serializing the model for the current request
using Jackson 2's XmlMapper.Spring-MVC
View that allows for response context to be rendered as the result
of marshalling by a Marshaller.Additional interface that a
HandlerMapping can implement to expose
a request matching API aligned with its internal request matching
configuration and implementation.Resolves arguments of type
Map annotated with @MatrixVariable
where the annotation does not specify a name.Resolves arguments annotated with
@MatrixVariable.A contract for media type expressions (e.g.
The
<message> tag looks up a message in the scope of this page.Holder for both Model and View in the web MVC framework.
Exception to be thrown on error conditions that should forward
to a specific view with a specific model.
Handles return values of type
ModelAndView copying view and model
information to the ModelAndViewContainer.SPI for resolving custom return values from a specific handler method.
This return value handler is intended to be ordered after all others as it
attempts to handle _any_ return value type (i.e.
NamespaceHandler for Spring MVC configuration namespace.Convenience methods for use in MVC namespace BeanDefinitionParsers.
Creates instances of
UriComponentsBuilder
by pointing to @RequestMapping methods on Spring MVC controllers.Builder class to create URLs for method arguments.
Method invocation information.
A contract for
"name!=value" style expression used to specify request
parameters and request header conditions in @RequestMapping.The
<nestedPath> tag supports and assists with nested beans or
bean properties in the model.By default, when the DispatcherServlet can't find a handler for a request it
sends a 404 response.
The
<options> tag renders a list of HTML 'option' tags.The
<option> tag renders a single HTML 'option'.Bean used to pass name-value pair parameters from a
ParamTag to a
ParamAware tag.Allows implementing tag to utilize nested
spring:param tags.Trivial controller that always returns a pre-configured view and optionally
sets the response status code.
A logical conjunction (
' && ') request condition that matches a request against
a set parameter expressions with syntax defined in RequestMapping.params().The
<param> tag collects name-value parameters and passes them to a
ParamAware ancestor in the tag hierarchy.The
<password> tag renders an HTML 'input' tag with type 'password'
using the bound value.Configure path matching options.
A logical disjunction (' || ') request condition that matches a request
against a set of URL path patterns.
A simple
ResourceResolver that tries to find a resource under the given
locations matching to the request path.Resolves
Map method arguments annotated with
@PathVariable where the annotation does not specify a
path variable name.Resolves method arguments annotated with an @
PathVariable.A logical disjunction (' || ') request condition that matches a request
against a set of URL path patterns.
Resolves an argument of type
Principal, similar to
ServletRequestMethodArgumentResolver but irrespective of whether the
argument is annotated or not.A logical disjunction (' || ') request condition to match a request's 'Accept' header
to a list of media type expressions.
The
<radiobuttons> tag renders multiple HTML 'input' tags with type 'radio'.The
<radiobutton> tag renders an HTML 'input' tag with type 'radio'.A specialization of the
Model interface that controllers can use to
select attributes for a redirect scenario.Resolves method arguments of type
RedirectAttributes.View that redirects to an absolute, context relative, or current request
relative URL.
Assist with the registration of a single redirect view controller.
Context passed to
ScriptTemplateView render function in order to make
the application context, the locale, the template loader and the url available on
scripting side.Rendering-specific subtype of
ServerResponse that exposes model and template data.Defines a builder for
RenderingResponse.Resolves method arguments annotated with an @
RequestAttribute.Allows customizing the request before its body is read and converted into an
Object and also allows for processing of the resulting Object before it is
passed into a controller method as an
@RequestBody or an
HttpEntity method argument.A convenient starting point for implementing
RequestBodyAdvice with default method implementations.Contract for request mapping conditions.
A holder for a
RequestCondition useful when the type of the request
condition is not known ahead of time, e.g.Context holder for request-specific state, like current web application context, current locale,
current theme, and potential binding errors.
Superclass for all tags that require a
RequestContext.Utility class for easy access to request-specific state which has been
set by the
DispatcherServlet.A contract for inspecting and potentially modifying request data values such
as URL query parameters or form field values before they are rendered by a
view or before a redirect.
Creates
RequestMappingInfo instances from type and method-level
@RequestMapping annotations in
@Controller classes.Request mapping information.
Defines a builder for creating a RequestMappingInfo.
Container for configuration options used for request mapping purposes.
Abstract base class for classes for which
RequestMappingInfo defines
the mapping between a request and a handler method.A
HandlerMethodMappingNamingStrategy for RequestMappingInfo-based handler
method mappings.Container for the result from request pattern matching via
MatchableHandlerMapping with a method to further extract
URI template variables from the pattern.A logical disjunction (' || ') request condition that matches a request
against a set of
RequestMethods.Resolves the following method arguments:
Annotated with @
RequestPart
Of type MultipartFile in conjunction with Spring's MultipartResolver abstraction
Of type jakarta.servlet.http.Part in conjunction with Servlet multipart requests
Represents a function that evaluates on a given
ServerRequest.Implementations of
RequestPredicate that implement various useful
request matching operations, such as matching based on path, HTTP method, etc.Receives notifications from the logical structure of request predicates.
Resolves method arguments annotated with
@RequestBody and handles return
values from methods annotated with @ResponseBody by reading and writing
to the body of the request or response with an HttpMessageConverter.Strategy interface for translating an incoming
HttpServletRequest into a
logical view name when no view name is explicitly supplied.Deprecated.
as of 5.3, in favor of Spring's common view resolver variants
and/or custom resolver implementations
Assists with the registration of resource resolvers and transformers.
Encapsulates information required to create a resource handler.
Stores registrations of resource handlers for serving static resources such
as images, css files and others through Spring MVC including setting cache
headers optimized for efficient loading in a web browser.
HttpRequestHandler that serves static resources in an optimized way
according to the guidelines of Page Speed, YSlow, etc.A strategy for resolving a request to a server-side resource.
A contract for invoking a chain of
ResourceResolvers where each resolver
is given a reference to the chain allowing it to delegate when necessary.An abstraction for transforming the content of a resource.
A contract for invoking a chain of
ResourceTransformers where each resolver
is given a reference to the chain allowing it to delegate when necessary.A base class for a
ResourceTransformer with an optional helper method
for resolving public links within a transformed resource.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.A central component to use to obtain the public URL path that clients should
use to access a static resource.
An interceptor that exposes the
ResourceUrlProvider instance it
is configured with as a request attribute.Allows customizing the response after the execution of an
@ResponseBody
or a ResponseEntity controller method but before the body is written
with an HttpMessageConverter.A controller method return value type for asynchronous request processing
where one or more objects are written to the response.
A simple holder of data to be written along with a MediaType hint for
selecting a message converter to write with.
Handler for return values of type
ResponseBodyEmitter and subclasses
such as SseEmitter including the same types wrapped with
ResponseEntity.A class with an
@ExceptionHandler method that handles all Spring MVC
raised exceptions by returning a ResponseEntity with RFC 7807
formatted error details in the body.A
HandlerExceptionResolver that uses the @ResponseStatus
annotation to map exceptions to HTTP status codes.Represents a function that routes to a handler function.
HandlerMapping implementation that supports RouterFunctions.Central entry point to Spring's functional web framework.
Exposes routing functionality, such as to create a
RouterFunction using a discoverable builder-style API, to
create a RouterFunction
given a RequestPredicate and HandlerFunction, and to do further
subrouting on an existing routing
function.Represents a discoverable builder for router functions.
Receives notifications from the logical structure of router functions.
Interface to be implemented by objects that configure and manage a
JSR-223
ScriptEngine for automatic lookup in a web environment.An implementation of Spring MVC's
ScriptTemplateConfig for creating
a ScriptEngine for use in a web application.Parse the
<mvc:script-template-configurer> MVC namespace element and
register a ScriptTemplateConfigurer bean.An
AbstractUrlBasedView subclass designed to run any template library
based on a JSR-223 script engine.Convenience subclass of
UrlBasedViewResolver that supports
ScriptTemplateView and custom subclasses of it.The
<select> tag renders an HTML 'select' element.Represents a server-side HTTP request, as handled by a
HandlerFunction.Defines a builder for a request.
Represents the headers of the HTTP request.
Represents a typed server-side HTTP response, as returned
by a handler function or
filter function.
Defines a builder that adds a body to the response.
Defines the context used during the
ServerResponse.writeTo(HttpServletRequest, HttpServletResponse, Context).Defines a builder that adds headers to the response.
Defines a builder for a body that sends server-sent events.
An
AbstractCookieValueMethodArgumentResolver
that resolves cookie values from an HttpServletRequest.Spring Controller implementation that forwards to a named servlet,
i.e.
Extends
InvocableHandlerMethod with the ability to handle return
values through a registered HandlerMethodReturnValueHandler and
also supports setting the response status based on a method-level
@ResponseStatus annotation.A Servlet-specific
ModelAttributeMethodProcessor that applies data
binding through a WebDataBinder of type ServletRequestDataBinder.Creates a
ServletRequestDataBinder.Resolves servlet backed request-related method arguments.
Resolves servlet backed response-related method arguments.
UriComponentsBuilder with additional static factory methods to create links
based on the current HttpServletRequest.
A Servlet-specific
AbstractWebArgumentResolverAdapter
that creates a NativeWebRequest from ServletRequestAttributes.Spring Controller implementation that wraps a servlet instance which it manages
internally.
Resolves method arguments annotated with an @
SessionAttribute.Store and retrieve
FlashMap instances to and from the HTTP session.LocaleResolver implementation that
uses a locale attribute in the user's session in case of a custom setting,
with a fallback to the configured default locale, the request's
Accept-Language header, or the default locale for the server.Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
Adapter to use the plain
Controller workflow interface with
the generic DispatcherServlet.HandlerExceptionResolver implementation
that allows for mapping exception class names to view names, either for a set of
given handlers or for all handlers in the DispatcherServlet.Adapter to use the Servlet interface with the generic DispatcherServlet.
BeanPostProcessor
that applies initialization and destruction callbacks to beans that
implement the Servlet interface.Implementation of the
HandlerMapping
interface that maps from URLs to request handler beans.Provides additional information about a View such as whether it
performs redirects.
A specialization of
ResponseBodyEmitter for sending
Server-Sent Events.A builder for an SSE event.
A controller method return value type for asynchronous request processing
where the application can write directly to the response
OutputStream
without holding up the Servlet container thread.Supports return values of type
StreamingResponseBody
and also ResponseEntity<StreamingResponseBody>.Utility class for writing HTML content to a
Writer instance.The
<textarea> tag renders an HTML 'textarea'.Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
Deprecated.
as of 6.0, with no direct replacement
An extension of
ByteArrayResource that a ResourceTransformer
can use to represent an original resource preserving all other information
except the content.The
<transform> tag provides transformation for reference data values
from controllers and other objects inside a spring:bind tag (or a
data-bound form element tag from Spring's form tag library).Resolvers argument values of type
UriComponentsBuilder.Simple implementation of the
ViewResolver
interface, allowing for direct resolution of symbolic view names to URLs,
without explicit mapping definitions.Assist with configuring a
UrlBasedViewResolver.Simple
Controller implementation that transforms the virtual
path of a URL into a view name and returns that view.The
<url> tag creates URLs.Interceptor that checks the authorization of the current user via the
user's roles, as evaluated by HttpServletRequest's isUserInRole method.
A strategy for extracting and embedding a resource version in its URL path.
Resolves request paths containing a version string that can be used as part
of an HTTP caching strategy in which a resource is cached with a date in the
distant future (e.g.
An extension of
VersionPathStrategy that adds a method
to determine the actual version of a Resource.MVC View for a web interaction.
Assist with the registration of a single view controller.
Assists with the registration of simple automated controllers pre-configured
with status code and/or a view.
Handles return values that are of type
View.Handles return values of types
void and String interpreting them
as view name reference.Interface to be implemented by objects that can resolve views by name.
A
ViewResolver that delegates to others.Assist with the configuration of a chain of
ViewResolver instances.Parses the
view-resolvers MVC namespace element and registers
ViewResolver bean definitions.Convenient superclass for any kind of web content generator,
like
AbstractController
and WebContentInterceptor.Handler interceptor that checks the request for supported methods and a
required session and prepares the response by applying the configured
cache settings.
A
ResourceResolver that delegates to the chain to locate a resource and then
attempts to find a matching versioned resource contained in a WebJar JAR file.This is the main class providing the configuration behind the MVC Java config.
Defines callback methods to customize the Java-based configuration for
Spring MVC enabled via
@EnableWebMvc.Adapter that implements the Servlet HandlerInterceptor interface
and wraps an underlying WebRequestInterceptor.
Deprecated.
as of 5.3, in favor of Spring's common view resolver variants
and/or custom resolver implementations
XSLT-driven View that allows for response context to be rendered as the
result of an XSLT transformation.
ViewResolver implementation that
resolves instances of XsltView by translating the supplied view name
into the URL of the XSLT stylesheet.