java.lang.Object
- org.springframework.context.support.ApplicationObjectSupport
- - org.springframework.web.context.support.WebApplicationObjectSupport
  - - org.springframework.web.servlet.view.AbstractCachingViewResolver
    - - org.springframework.web.servlet.view.UrlBasedViewResolver

All Implemented Interfaces:
Aware, ApplicationContextAware, Ordered, ServletContextAware, ViewResolver
Direct Known Subclasses:
AbstractTemplateViewResolver, InternalResourceViewResolver, ScriptTemplateViewResolver, TilesViewResolver, XsltViewResolver
```
public class UrlBasedViewResolver
extends AbstractCachingViewResolver
implements Ordered
```
Simple implementation of the ViewResolver interface, allowing for direct resolution of symbolic view names to URLs, without explicit mapping definitions. This is useful if your symbolic names match the names of your view resources in a straightforward manner (i.e. the symbolic name is the unique part of the resource's filename), without the need for a dedicated mapping to be defined for each view.
Supports AbstractUrlBasedView subclasses like InternalResourceView and FreeMarkerView. The view class for all views generated by this resolver can be specified via the "viewClass" property.
View names can either be resource URLs themselves, or get augmented by a specified prefix and/or suffix. Exporting an attribute that holds the RequestContext to all views is explicitly supported.
Example: prefix="/WEB-INF/jsp/", suffix=".jsp", viewname=test -> "/WEB-INF/jsp/test.jsp"
As a special feature, redirect URLs can be specified via the "redirect:" prefix. E.g.: "redirect:myAction" will trigger a redirect to the given URL, rather than resolution as standard view name. This is typically used for redirecting to a controller URL after finishing a form workflow.
Furthermore, forward URLs can be specified via the "forward:" prefix. E.g.: "forward:myAction" will trigger a forward to the given URL, rather than resolution as standard view name. This is typically used for controller URLs; it is not supposed to be used for JSP URLs - use logical view names there.
Note: This class does not support localized resolution, i.e. resolving a symbolic view name to different resources depending on the current locale.
Note: When chaining ViewResolvers, a UrlBasedViewResolver will check whether the specified resource actually exists. However, with InternalResourceView, it is not generally possible to determine the existence of the target resource upfront. In such a scenario, a UrlBasedViewResolver will always return a View for any given view name; as a consequence, it should be configured as the last ViewResolver in the chain.
Since:
13.12.2003
Author:
Juergen Hoeller, Rob Harrop, Sam Brannen
See Also:
setViewClass(java.lang.Class<?>), setPrefix(java.lang.String), setSuffix(java.lang.String), setRequestContextAttribute(java.lang.String), REDIRECT_URL_PREFIX, AbstractUrlBasedView, InternalResourceView, FreeMarkerView

Nested Class Summary
- Nested classes/interfaces inherited from class org.springframework.web.servlet.view.AbstractCachingViewResolver
  AbstractCachingViewResolver.CacheFilter

Field Summary

Fields
Modifier and Type	Field	Description
`static String`	`FORWARD_URL_PREFIX`	Prefix for special view names that specify a forward URL (usually to a controller after a form has been submitted and processed).
`static String`	`REDIRECT_URL_PREFIX`	Prefix for special view names that specify a redirect URL (usually to a controller after a form has been submitted and processed).

Fields inherited from class org.springframework.web.servlet.view.AbstractCachingViewResolver
DEFAULT_CACHE_LIMIT

Fields inherited from class org.springframework.context.support.ApplicationObjectSupport
logger

Fields inherited from interface org.springframework.core.Ordered
HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE

Constructor Summary
Constructors
Constructor Description
UrlBasedViewResolver()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`protected View`	`applyLifecycleMethods(String viewName, AbstractUrlBasedView view)`	Apply the containing `ApplicationContext`'s lifecycle methods to the given `View` instance, if such a context is available.
`protected AbstractUrlBasedView`	`buildView(String viewName)`	Creates a new View instance of the specified view class and configures it.
`protected boolean`	`canHandle(String viewName, Locale locale)`	Indicates whether or not this `ViewResolver` can handle the supplied view name.
`protected View`	`createView(String viewName, Locale locale)`	Overridden to implement check for "redirect:" prefix.
`Map<String,Object>`	`getAttributesMap()`	Allow Map access to the static attributes for views returned by this resolver, with the option to add or override specific entries.
`protected Object`	`getCacheKey(String viewName, Locale locale)`	This implementation returns just the view name, as this ViewResolver doesn't support localized resolution.
`protected String`	`getContentType()`	Return the content type for all views, if any.
`protected Boolean`	`getExposeContextBeansAsAttributes()`
`protected String[]`	`getExposedContextBeanNames()`
`protected Boolean`	`getExposePathVariables()`	Return whether views resolved by this resolver should add path variables to the model or not.
`int`	`getOrder()`	Get the order value of this object.
`protected String`	`getPrefix()`	Return the prefix that gets prepended to view names when building a URL.
`String[]`	`getRedirectHosts()`	Return the configured application hosts for redirect purposes.
`protected String`	`getRequestContextAttribute()`	Return the name of the RequestContext attribute for all views, if any.
`protected String`	`getSuffix()`	Return the suffix that gets appended to view names when building a URL.
`protected Class<?>`	`getViewClass()`	Return the view class to be used to create views.
`protected String[]`	`getViewNames()`	Return the view names (or name patterns) that can be handled by this `ViewResolver`.
`protected void`	`initApplicationContext()`	Subclasses can override this for custom initialization behavior.
`protected boolean`	`isRedirectContextRelative()`	Return whether to interpret a given redirect URL that starts with a slash ("/") as relative to the current ServletContext, i.e.
`protected boolean`	`isRedirectHttp10Compatible()`	Return whether redirects should stay compatible with HTTP 1.0 clients.
`protected View`	`loadView(String viewName, Locale locale)`	Delegates to `buildView` for creating a new instance of the specified view class.
`protected Class<?>`	`requiredViewClass()`	Return the required type of view for this resolver.
`void`	`setAttributes(Properties props)`	Set static attributes from a `java.util.Properties` object, for all views returned by this resolver.
`void`	`setAttributesMap(Map<String,?> attributes)`	Set static attributes from a Map, for all views returned by this resolver.
`void`	`setContentType(String contentType)`	Set the content type for all views.
`void`	`setExposeContextBeansAsAttributes(boolean exposeContextBeansAsAttributes)`	Set whether to make all Spring beans in the application context accessible as request attributes, through lazy checking once an attribute gets accessed.
`void`	`setExposedContextBeanNames(String... exposedContextBeanNames)`	Specify the names of beans in the context which are supposed to be exposed.
`void`	`setExposePathVariables(Boolean exposePathVariables)`	Specify whether views resolved by this resolver should add path variables to the model or not.
`void`	`setOrder(int order)`	Specify the order value for this ViewResolver bean.
`void`	`setPrefix(String prefix)`	Set the prefix that gets prepended to view names when building a URL.
`void`	`setRedirectContextRelative(boolean redirectContextRelative)`	Set whether to interpret a given redirect URL that starts with a slash ("/") as relative to the current ServletContext, i.e.
`void`	`setRedirectHosts(String... redirectHosts)`	Configure one or more hosts associated with the application.
`void`	`setRedirectHttp10Compatible(boolean redirectHttp10Compatible)`	Set whether redirects should stay compatible with HTTP 1.0 clients.
`void`	`setRequestContextAttribute(String requestContextAttribute)`	Set the name of the RequestContext attribute for all views.
`void`	`setSuffix(String suffix)`	Set the suffix that gets appended to view names when building a URL.
`void`	`setViewClass(Class<?> viewClass)`	Set the view class that should be used to create views.
`void`	`setViewNames(String... viewNames)`	Set the view names (or name patterns) that can be handled by this `ViewResolver`.

Methods inherited from class org.springframework.web.servlet.view.AbstractCachingViewResolver
clearCache, getCacheFilter, getCacheLimit, isCache, isCacheUnresolved, removeFromCache, resolveViewName, setCache, setCacheFilter, setCacheLimit, setCacheUnresolved

Methods inherited from class org.springframework.web.context.support.WebApplicationObjectSupport
getServletContext, getTempDir, getWebApplicationContext, initApplicationContext, initServletContext, isContextRequired, setServletContext

Methods inherited from class org.springframework.context.support.ApplicationObjectSupport
getApplicationContext, getMessageSourceAccessor, obtainApplicationContext, requiredContextClass, setApplicationContext

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - REDIRECT_URL_PREFIX
```
public static final String REDIRECT_URL_PREFIX
```
    Prefix for special view names that specify a redirect URL (usually to a controller after a form has been submitted and processed). Such view names will not be resolved in the configured default way but rather be treated as special shortcut.
    See Also:
    Constant Field Values
  - FORWARD_URL_PREFIX
```
public static final String FORWARD_URL_PREFIX
```
    Prefix for special view names that specify a forward URL (usually to a controller after a form has been submitted and processed). Such view names will not be resolved in the configured default way but rather be treated as special shortcut.
    See Also:
    Constant Field Values
- Constructor Detail
  - UrlBasedViewResolver
```
public UrlBasedViewResolver()
```
- Method Detail
  - setViewClass
```
public void setViewClass(@Nullable
                         Class<?> viewClass)
```
    Set the view class that should be used to create views.
    Parameters:
    viewClass - class that is assignable to the required view class (by default, AbstractUrlBasedView)
    See Also:
    AbstractUrlBasedView
  - getViewClass
```
@Nullable
protected Class<?> getViewClass()
```
    Return the view class to be used to create views.
  - requiredViewClass
```
protected Class<?> requiredViewClass()
```
    Return the required type of view for this resolver. This implementation returns AbstractUrlBasedView.
    See Also:
    AbstractUrlBasedView
  - setPrefix
```
public void setPrefix(@Nullable
                      String prefix)
```
    Set the prefix that gets prepended to view names when building a URL.
  - getPrefix
```
protected String getPrefix()
```
    Return the prefix that gets prepended to view names when building a URL.
  - setSuffix
```
public void setSuffix(@Nullable
                      String suffix)
```
    Set the suffix that gets appended to view names when building a URL.
  - getSuffix
```
protected String getSuffix()
```
    Return the suffix that gets appended to view names when building a URL.
  - setContentType
```
public void setContentType(@Nullable
                           String contentType)
```
    Set the content type for all views.
    May be ignored by view classes if the view itself is assumed to set the content type, e.g. in case of JSPs.
  - getContentType
```
@Nullable
protected String getContentType()
```
    Return the content type for all views, if any.
  - setRedirectContextRelative
```
public void setRedirectContextRelative(boolean redirectContextRelative)
```
    Set whether to interpret a given redirect URL that starts with a slash ("/") as relative to the current ServletContext, i.e. as relative to the web application root.
    Default is "true": A redirect URL that starts with a slash will be interpreted as relative to the web application root, i.e. the context path will be prepended to the URL.
    Redirect URLs can be specified via the "redirect:" prefix. E.g.: "redirect:myAction"
    See Also:
    RedirectView.setContextRelative(boolean), REDIRECT_URL_PREFIX
  - isRedirectContextRelative
```
protected boolean isRedirectContextRelative()
```
    Return whether to interpret a given redirect URL that starts with a slash ("/") as relative to the current ServletContext, i.e. as relative to the web application root.
  - setRedirectHttp10Compatible
```
public void setRedirectHttp10Compatible(boolean redirectHttp10Compatible)
```
    Set whether redirects should stay compatible with HTTP 1.0 clients.
    In the default implementation, this will enforce HTTP status code 302 in any case, i.e. delegate to HttpServletResponse.sendRedirect. Turning this off will send HTTP status code 303, which is the correct code for HTTP 1.1 clients, but not understood by HTTP 1.0 clients.
    Many HTTP 1.1 clients treat 302 just like 303, not making any difference. However, some clients depend on 303 when redirecting after a POST request; turn this flag off in such a scenario.
    Redirect URLs can be specified via the "redirect:" prefix. E.g.: "redirect:myAction"
    See Also:
    RedirectView.setHttp10Compatible(boolean), REDIRECT_URL_PREFIX
  - isRedirectHttp10Compatible
```
protected boolean isRedirectHttp10Compatible()
```
    Return whether redirects should stay compatible with HTTP 1.0 clients.
  - setRedirectHosts
```
public void setRedirectHosts(@Nullable
                             String... redirectHosts)
```
    Configure one or more hosts associated with the application. All other hosts will be considered external hosts.
    In effect, this property provides a way turn off encoding on redirect via HttpServletResponse.encodeRedirectURL(java.lang.String) for URLs that have a host and that host is not listed as a known host.
    If not set (the default) all URLs are encoded through the response.
    Parameters:
    redirectHosts - one or more application hosts
    Since:
    4.3
  - getRedirectHosts
```
@Nullable
public String[] getRedirectHosts()
```
    Return the configured application hosts for redirect purposes.
    Since:
    4.3
  - setRequestContextAttribute
```
public void setRequestContextAttribute(@Nullable
                                       String requestContextAttribute)
```
    Set the name of the RequestContext attribute for all views.
    Parameters:
    requestContextAttribute - name of the RequestContext attribute
    See Also:
    AbstractView.setRequestContextAttribute(java.lang.String)
  - getRequestContextAttribute
```
@Nullable
protected String getRequestContextAttribute()
```
    Return the name of the RequestContext attribute for all views, if any.
  - setAttributes
```
public void setAttributes(Properties props)
```
    Set static attributes from a java.util.Properties object, for all views returned by this resolver.
    This is the most convenient way to set static attributes. Note that static attributes can be overridden by dynamic attributes, if a value with the same name is included in the model.
    Can be populated with a String "value" (parsed via PropertiesEditor) or a "props" element in XML bean definitions.
    See Also:
    PropertiesEditor, AbstractView.setAttributes(java.util.Properties)
  - setAttributesMap
```
public void setAttributesMap(@Nullable
                             Map<String,?> attributes)
```
    Set static attributes from a Map, for all views returned by this resolver. This allows to set any kind of attribute values, for example bean references.
    Can be populated with a "map" or "props" element in XML bean definitions.
    Parameters:
    attributes - a Map with name Strings as keys and attribute objects as values
    See Also:
    AbstractView.setAttributesMap(java.util.Map<java.lang.String, ?>)
  - getAttributesMap
```
public Map<String,Object> getAttributesMap()
```
    Allow Map access to the static attributes for views returned by this resolver, with the option to add or override specific entries.
    Useful for specifying entries directly, for example via "attributesMap[myKey]". This is particularly useful for adding or overriding entries in child view definitions.
  - setExposePathVariables
```
public void setExposePathVariables(@Nullable
                                   Boolean exposePathVariables)
```
    Specify whether views resolved by this resolver should add path variables to the model or not.
    >The default setting is to let each View decide (see AbstractView.setExposePathVariables(boolean). However, you can use this property to override that.
    Parameters:
    exposePathVariables -
    true - all Views resolved by this resolver will expose path variables
    false - no Views resolved by this resolver will expose path variables
    null - individual Views can decide for themselves (this is used by the default)
    See Also:
    AbstractView.setExposePathVariables(boolean)
  - getExposePathVariables
```
@Nullable
protected Boolean getExposePathVariables()
```
    Return whether views resolved by this resolver should add path variables to the model or not.
  - setExposeContextBeansAsAttributes
```
public void setExposeContextBeansAsAttributes(boolean exposeContextBeansAsAttributes)
```
    Set whether to make all Spring beans in the application context accessible as request attributes, through lazy checking once an attribute gets accessed.
    This will make all such beans accessible in plain ${...} expressions in a JSP 2.0 page, as well as in JSTL's c:out value expressions.
    Default is "false".
    See Also:
    AbstractView.setExposeContextBeansAsAttributes(boolean)
  - getExposeContextBeansAsAttributes
```
@Nullable
protected Boolean getExposeContextBeansAsAttributes()
```
  - setExposedContextBeanNames
```
public void setExposedContextBeanNames(@Nullable
                                       String... exposedContextBeanNames)
```
    Specify the names of beans in the context which are supposed to be exposed. If this is non-null, only the specified beans are eligible for exposure as attributes.
    See Also:
    AbstractView.setExposedContextBeanNames(java.lang.String...)
  - getExposedContextBeanNames
```
@Nullable
protected String[] getExposedContextBeanNames()
```
  - setViewNames
```
public void setViewNames(@Nullable
                         String... viewNames)
```
    Set the view names (or name patterns) that can be handled by this ViewResolver. View names can contain simple wildcards such that 'my*', '*Report' and '*Repo*' will all match the view name 'myReport'.
    See Also:
    canHandle(java.lang.String, java.util.Locale)
  - getViewNames
```
@Nullable
protected String[] getViewNames()
```
    Return the view names (or name patterns) that can be handled by this ViewResolver.
  - setOrder
```
public void setOrder(int order)
```
    Specify the order value for this ViewResolver bean.
    The default value is Ordered.LOWEST_PRECEDENCE, meaning non-ordered.
    See Also:
    Ordered.getOrder()
  - getOrder
```
public int getOrder()
```
    Description copied from interface: Ordered
    Get the order value of this object.
    Higher values are interpreted as lower priority. As a consequence, the object with the lowest value has the highest priority (somewhat analogous to Servlet load-on-startup values).
    Same order values will result in arbitrary sort positions for the affected objects.
    Specified by:
    getOrder in interface Ordered
    Returns:
    the order value
    See Also:
    Ordered.HIGHEST_PRECEDENCE, Ordered.LOWEST_PRECEDENCE
  - initApplicationContext
```
protected void initApplicationContext()
```
    Description copied from class: ApplicationObjectSupport
    Subclasses can override this for custom initialization behavior.
    The default implementation is empty. Called by ApplicationObjectSupport.initApplicationContext(org.springframework.context.ApplicationContext).
    Overrides:
    initApplicationContext in class ApplicationObjectSupport
    See Also:
    ApplicationObjectSupport.setApplicationContext(org.springframework.context.ApplicationContext)
  - getCacheKey
```
protected Object getCacheKey(String viewName,
                             Locale locale)
```
    This implementation returns just the view name, as this ViewResolver doesn't support localized resolution.
    Overrides:
    getCacheKey in class AbstractCachingViewResolver
  - createView
```
protected View createView(String viewName,
                          Locale locale)
                   throws Exception
```
    Overridden to implement check for "redirect:" prefix.
    Not possible in loadView, since overridden loadView versions in subclasses might rely on the superclass always creating instances of the required view class.
    Overrides:
    createView in class AbstractCachingViewResolver
    Parameters:
    viewName - the name of the view to retrieve
    locale - the Locale to retrieve the view for
    Returns:
    the View instance, or null if not found (optional, to allow for ViewResolver chaining)
    Throws:
    Exception - if the view couldn't be resolved
    See Also:
    loadView(java.lang.String, java.util.Locale), requiredViewClass()
  - canHandle
```
protected boolean canHandle(String viewName,
                            Locale locale)
```
    Indicates whether or not this ViewResolver can handle the supplied view name. If not, createView(String, java.util.Locale) will return null. The default implementation checks against the configured view names.
    Parameters:
    viewName - the name of the view to retrieve
    locale - the Locale to retrieve the view for
    Returns:
    whether this resolver applies to the specified view
    See Also:
    PatternMatchUtils.simpleMatch(String, String)
  - loadView
```
protected View loadView(String viewName,
                        Locale locale)
                 throws Exception
```
    Delegates to buildView for creating a new instance of the specified view class. Applies the following Spring lifecycle methods (as supported by the generic Spring bean factory):
    ApplicationContextAware's setApplicationContext
    InitializingBean's afterPropertiesSet
    Specified by:
    loadView in class AbstractCachingViewResolver
    Parameters:
    viewName - the name of the view to retrieve
    locale - the Locale to retrieve the view for
    Returns:
    the View instance
    Throws:
    Exception - if the view couldn't be resolved
    See Also:
    buildView(String), ApplicationContextAware.setApplicationContext(org.springframework.context.ApplicationContext), InitializingBean.afterPropertiesSet()
  - buildView
```
protected AbstractUrlBasedView buildView(String viewName)
                                  throws Exception
```
    Creates a new View instance of the specified view class and configures it. Does not perform any lookup for pre-defined View instances.
    Spring lifecycle methods as defined by the bean container do not have to be called here; those will be applied by the loadView method after this method returns.
    Subclasses will typically call super.buildView(viewName) first, before setting further properties themselves. loadView will then apply Spring lifecycle methods at the end of this process.
    Parameters:
    viewName - the name of the view to build
    Returns:
    the View instance
    Throws:
    Exception - if the view couldn't be resolved
    See Also:
    loadView(String, java.util.Locale)
  - applyLifecycleMethods
```
protected View applyLifecycleMethods(String viewName,
                                     AbstractUrlBasedView view)
```
    Apply the containing ApplicationContext's lifecycle methods to the given View instance, if such a context is available.
    Parameters:
    viewName - the name of the view
    view - the freshly created View instance, pre-configured with AbstractUrlBasedView's properties
    Returns:
    the View instance to use (either the original one or a decorated variant)
    Since:
    5.0
    See Also:
    ApplicationObjectSupport.getApplicationContext(), ApplicationContext.getAutowireCapableBeanFactory(), AutowireCapableBeanFactory.initializeBean(java.lang.Object, java.lang.String)

Class UrlBasedViewResolver

Nested Class Summary

Nested classes/interfaces inherited from class org.springframework.web.servlet.view.AbstractCachingViewResolver

Field Summary

Fields inherited from class org.springframework.web.servlet.view.AbstractCachingViewResolver

Fields inherited from class org.springframework.context.support.ApplicationObjectSupport

Fields inherited from interface org.springframework.core.Ordered

Constructor Summary

Method Summary

Methods inherited from class org.springframework.web.servlet.view.AbstractCachingViewResolver

Methods inherited from class org.springframework.web.context.support.WebApplicationObjectSupport

Methods inherited from class org.springframework.context.support.ApplicationObjectSupport

Methods inherited from class java.lang.Object

Field Detail

REDIRECT_URL_PREFIX

FORWARD_URL_PREFIX

Constructor Detail

UrlBasedViewResolver

Method Detail

setViewClass

getViewClass

requiredViewClass

setPrefix

getPrefix

setSuffix

getSuffix

setContentType

getContentType

setRedirectContextRelative

isRedirectContextRelative

setRedirectHttp10Compatible

isRedirectHttp10Compatible

setRedirectHosts

getRedirectHosts

setRequestContextAttribute

getRequestContextAttribute

setAttributes

setAttributesMap

getAttributesMap

setExposePathVariables

getExposePathVariables

setExposeContextBeansAsAttributes

getExposeContextBeansAsAttributes

setExposedContextBeanNames

getExposedContextBeanNames

setViewNames

getViewNames

setOrder

getOrder

initApplicationContext

getCacheKey

createView

canHandle

loadView

buildView

applyLifecycleMethods