org.springframework.web.servlet.view

## Class UrlBasedViewResolver

- 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, JasperReportsViewResolver, TilesViewResolver, 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 definition. 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`, `VelocityView` 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.do" 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.do" 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 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
  See Also:
    `setViewClass(java.lang.Class)`, `setPrefix(java.lang.String)`, `setSuffix(java.lang.String)`, `setRequestContextAttribute(java.lang.String)`, `REDIRECT_URL_PREFIX`, `AbstractUrlBasedView`, `InternalResourceView`, `VelocityView`, `FreeMarkerView`

- - ### Field Summary

    Fields
    Modifier and Type | Field and 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 and Description
    `UrlBasedViewResolver()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `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.
    `int` | `getOrder()` Return the order in which this `ViewResolver` is evaluated.
    `protected String` | `getPrefix()` Return the prefix that gets prepended to view names when building a URL.
    `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, and applies the following Spring lifecycle methods (as supported by the generic Spring bean factory): ApplicationContextAware's `setApplicationContext` InitializingBean's `afterPropertiesSet`
    `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` | `setExposePathVariables(Boolean exposePathVariables)` Whether views resolved by this resolver should add path variables the model or not.
    `void` | `setOrder(int order)` Set the order in which this `ViewResolver` is evaluated.
    `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` | `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, getCacheLimit, isCache, isCacheUnresolved, removeFromCache, resolveViewName, setCache, 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, 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(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

          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(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(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(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

          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.do"

      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.do"

      See Also:
        `RedirectView.setHttp10Compatible(boolean)`, `REDIRECT_URL_PREFIX`

    - #### isRedirectHttp10Compatible

          protected boolean isRedirectHttp10Compatible()

      Return whether redirects should stay compatible with HTTP 1.0 clients.

    - #### setRequestContextAttribute

          public void setRequestContextAttribute(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

          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(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` - 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.

    - #### setViewNames

          public void setViewNames(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

          protected String[] getViewNames()

      Return the view names (or name patterns) that can be handled by this `ViewResolver`.

    - #### setOrder

          public void setOrder(int order)

      Set the order in which this `ViewResolver` is evaluated.

    - #### getOrder

          public int getOrder()

      Return the order in which this `ViewResolver` is evaluated.
      Specified by:
        `getOrder` in interface `Ordered`
      Returns:
        the order value

    - #### setExposePathVariables

          public void setExposePathVariables(Boolean exposePathVariables)

      Whether views resolved by this resolver should add path variables the model or not. The default setting is to allow 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)`

    - #### 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, and 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)`