Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.springframework.web.servlet.view
Class ResourceBundleViewResolver

    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.ResourceBundleViewResolver

All Implemented Interfaces:
  DisposableBean, ApplicationContextAware, Ordered, ServletContextAware, ViewResolver

    public class ResourceBundleViewResolver

extends AbstractCachingViewResolver
implements Ordered, DisposableBean

`ViewResolver` implementation that uses bean definitions in a `ResourceBundle`, specified by the bundle basename.

The bundle is typically defined in a properties file, located in the class path. The default bundle basename is "views".

This `ViewResolver` supports localized view definitions, using the default support of `PropertyResourceBundle`. For example, the basename "views" will be resolved as class path resources "views_de_AT.properties", "views_de.properties", "views.properties" - for a given Locale "de_AT".

Note: this `ViewResolver` implements the `Ordered` interface to allow for flexible participation in `ViewResolver` chaining. For example, some special views could be defined via this `ViewResolver` (giving it 0 as "order" value), while all remaining views could be resolved by a `UrlBasedViewResolver`.

Author:
  Rod Johnson, Juergen Hoeller
See Also:
  `ResourceBundle.getBundle(java.lang.String)`, `PropertyResourceBundle`, `UrlBasedViewResolver`

Field Summary
`static String` | `DEFAULT_BASENAME` The default basename if no other basename is supplied.

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

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

Constructor Summary
`ResourceBundleViewResolver()`

Method Summary
`void` | `destroy()` Close the bundle View factories on context shutdown.
`protected ResourceBundle` | `getBundle(String basename, Locale locale)` Obtain the resource bundle for the given basename and `Locale`.
`protected ClassLoader` | `getBundleClassLoader()` Return the `ClassLoader` to load resource bundles with.
`int` | `getOrder()` Return the order value of this object, with a higher value meaning greater in terms of sorting.
`protected void` | `initApplicationContext()` Subclasses can override this for custom initialization behavior.
`protected BeanFactory` | `initFactory(Locale locale)` Initialize the View `BeanFactory` from the `ResourceBundle`, for the given `locale`.
`protected View` | `loadView(String viewName, Locale locale)` Subclasses must implement this method, building a View object for the specified view.
`void` | `setBasename(String basename)` Set a single basename, following `ResourceBundle` conventions.
`void` | `setBasenames(String[] basenames)` Set an array of basenames, each following `ResourceBundle` conventions.
`void` | `setBundleClassLoader(ClassLoader classLoader)` Set the `ClassLoader` to load resource bundles with.
`void` | `setDefaultParentView(String defaultParentView)` Set the default parent for views defined in the `ResourceBundle`.
`void` | `setLocalesToInitialize(Locale[] localesToInitialize)` Specify Locales to initialize eagerly, rather than lazily when actually accessed.
`void` | `setOrder(int order)`

Methods inherited from class org.springframework.web.servlet.view.AbstractCachingViewResolver
`clearCache, createView, getCacheKey, isCache, removeFromCache, resolveViewName, setCache`

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

### DEFAULT_BASENAME

    public static final String DEFAULT_BASENAME

  The default basename if no other basename is supplied.

  See Also:
    Constant Field Values

Constructor Detail

### ResourceBundleViewResolver

    public ResourceBundleViewResolver()

Method Detail

### setOrder

    public void setOrder(int order)

### getOrder

    public int getOrder()

  Description copied from interface: `Ordered`
  Return the order value of this object, with a higher value meaning greater in terms of sorting.

  Normally starting with 0 or 1, with `Ordered.LOWEST_PRECEDENCE` indicating greatest. Same order values will result in arbitrary positions for the affected objects.

  Higher value can be interpreted as lower priority, consequently the first object has highest priority (somewhat analogous to Servlet "load-on-startup" values).

  Note that order values below 0 are reserved for framework purposes. Application-specified values should always be 0 or greater, with only framework components (internal or third-party) supposed to use lower values.

  Specified by:
    `getOrder` in interface `Ordered`
  Returns:
    the order value
  See Also:
    `Ordered.LOWEST_PRECEDENCE`

### setBasename

    public void setBasename(String basename)

  Set a single basename, following `ResourceBundle` conventions. The default is "views".

  `ResourceBundle` supports different suffixes. For example, a base name of "views" might map to `ResourceBundle` files "views", "views_en_au" and "views_de".

  Note that ResourceBundle names are effectively classpath locations: As a consequence, the JDK's standard ResourceBundle treats dots as package separators. This means that "test.theme" is effectively equivalent to "test/theme", just like it is for programmatic `java.util.ResourceBundle` usage.

  See Also:
    `setBasenames(java.lang.String[])`, `ResourceBundle.getBundle(String)`

### setBasenames

    public void setBasenames(String[] basenames)

  Set an array of basenames, each following `ResourceBundle` conventions. The default is a single basename "views".

  `ResourceBundle` supports different suffixes. For example, a base name of "views" might map to `ResourceBundle` files "views", "views_en_au" and "views_de".

  The associated resource bundles will be checked sequentially when resolving a message code. Note that message definitions in a previous resource bundle will override ones in a later bundle, due to the sequential lookup.

  Note that ResourceBundle names are effectively classpath locations: As a consequence, the JDK's standard ResourceBundle treats dots as package separators. This means that "test.theme" is effectively equivalent to "test/theme", just like it is for programmatic `java.util.ResourceBundle` usage.

  See Also:
    `setBasename(java.lang.String)`, `ResourceBundle.getBundle(String)`

### setBundleClassLoader

    public void setBundleClassLoader(ClassLoader classLoader)

  Set the `ClassLoader` to load resource bundles with. Default is the thread context `ClassLoader`.

### getBundleClassLoader

    protected ClassLoader getBundleClassLoader()

  Return the `ClassLoader` to load resource bundles with.

  Default is the specified bundle `ClassLoader`, usually the thread context `ClassLoader`.

### setDefaultParentView

    public void setDefaultParentView(String defaultParentView)

  Set the default parent for views defined in the `ResourceBundle`.

  This avoids repeated "yyy1.(parent)=xxx", "yyy2.(parent)=xxx" definitions in the bundle, especially if all defined views share the same parent.

  The parent will typically define the view class and common attributes. Concrete views might simply consist of an URL definition then: a la "yyy1.url=/my.jsp", "yyy2.url=/your.jsp".

  View definitions that define their own parent or carry their own class can still override this. Strictly speaking, the rule that a default parent setting does not apply to a bean definition that carries a class is there for backwards compatiblity reasons. It still matches the typical use case.

### setLocalesToInitialize

    public void setLocalesToInitialize(Locale[] localesToInitialize)

  Specify Locales to initialize eagerly, rather than lazily when actually accessed.

  Allows for pre-initialization of common Locales, eagerly checking the view configuration for those Locales.

### initApplicationContext

    protected void initApplicationContext()
                                   throws BeansException

  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`
  Throws:
    `ApplicationContextException` - in case of initialization errors
    `BeansException` - if thrown by ApplicationContext methods
  See Also:
    `ApplicationObjectSupport.setApplicationContext(org.springframework.context.ApplicationContext)`

### loadView

    protected View loadView(String viewName,
                            Locale locale)
                     throws Exception

  Description copied from class: `AbstractCachingViewResolver`
  Subclasses must implement this method, building a View object for the specified view. The returned View objects will be cached by this ViewResolver base class.

  Subclasses are not forced to support internationalization: A subclass that does not may simply ignore the locale parameter.

  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, or `null` if not found (optional, to allow for ViewResolver chaining)
  Throws:
    `Exception` - if the view couldn't be resolved
  See Also:
    `AbstractCachingViewResolver.resolveViewName(java.lang.String, java.util.Locale)`

### initFactory

    protected BeanFactory initFactory(Locale locale)
                               throws BeansException

  Initialize the View `BeanFactory` from the `ResourceBundle`, for the given `locale`.

  Synchronized because of access by parallel threads.

  Parameters:
    `locale` - the target `Locale`
  Returns:
    the View factory for the given Locale
  Throws:
    `BeansException` - in case of initialization errors

### getBundle

    protected ResourceBundle getBundle(String basename,
                                       Locale locale)
                                throws MissingResourceException

  Obtain the resource bundle for the given basename and `Locale`.

  Parameters:
    `basename` - the basename to look for
    `locale` - the `Locale` to look for
  Returns:
    the corresponding `ResourceBundle`
  Throws:
    `MissingResourceException` - if no matching bundle could be found
  See Also:
    `ResourceBundle.getBundle(String, java.util.Locale, ClassLoader)`

### destroy

    public void destroy()
                 throws BeansException

  Close the bundle View factories on context shutdown.

  Specified by:
    `destroy` in interface `DisposableBean`
  Throws:
    `BeansException`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2002-2008 The Spring Framework.