protected AbstractUrlBasedView buildView(String viewName) throws Exception 
{
		AbstractUrlBasedView view = (AbstractUrlBasedView) BeanUtils.instantiateClass(getViewClass());
		view.setUrl(getPrefix() + viewName + getSuffix());
		String contentType = getContentType();
		if (contentType != null) {
			view.setContentType(contentType);
		}
		view.setRequestContextAttribute(getRequestContextAttribute());
		view.setAttributesMap(getAttributesMap());
		return view;
}

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.

 protected boolean canHandle(String viewName,
    Locale locale) 
{
		String[] viewNames = getViewNames();
		return (viewNames == null || PatternMatchUtils.simpleMatch(viewNames, viewName));
}

Indicates whether or not this org.springframework.web.servlet.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 .

 protected View createView(String viewName,
    Locale locale) throws Exception 
{
		// If this resolver is not supposed to handle the given view,
		// return null to pass on to the next resolver in the chain.
		if (!canHandle(viewName, locale)) {
			return null;
		}
		// Check for special "redirect:" prefix.
		if (viewName.startsWith(REDIRECT_URL_PREFIX)) {
			String redirectUrl = viewName.substring(REDIRECT_URL_PREFIX.length());
			return new RedirectView(
							redirectUrl, isRedirectContextRelative(), isRedirectHttp10Compatible());
		}
		// Check for special "forward:" prefix.
		if (viewName.startsWith(FORWARD_URL_PREFIX)) {
			String forwardUrl = viewName.substring(FORWARD_URL_PREFIX.length());
			return new InternalResourceView(forwardUrl);
		}
		// Else fall back to superclass implementation: calling loadView.
		return super.createView(viewName, locale);
}

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.

 public Map getAttributesMap() 
{
		return this.staticAttributes;
}

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.

 protected Object getCacheKey(String viewName,
    Locale locale) 
{
		return viewName;
}

This implementation returns just the view name, as this ViewResolver doesn't support localized resolution.

 protected String getContentType() 
{
		return this.contentType;
}

Return the content type for all views, if any.

 public int getOrder() 
{
		return this.order;
}

Return the order in which this org.springframework.web.servlet.ViewResolver is evaluated.

 protected String getPrefix() 
{
		return this.prefix;
}

Return the prefix that gets prepended to view names when building a URL.

 protected String getRequestContextAttribute() 
{
		return this.requestContextAttribute;
}

Return the name of the RequestContext attribute for all views, if any.

 protected String getSuffix() 
{
		return this.suffix;
}

Return the suffix that gets appended to view names when building a URL.

 protected Class getViewClass() 
{
		return this.viewClass;
}

Return the view class to be used to create views.

 protected String[] getViewNames() 
{
		return this.viewNames;
}

Return the view names (or name patterns) that can be handled by this org.springframework.web.servlet.ViewResolver .

 protected  void initApplicationContext() 
{
		super.initApplicationContext();
		if (getViewClass() == null) {
			throw new IllegalArgumentException("Property 'viewClass' is required");
		}
}

 protected boolean isRedirectContextRelative() 
{
		return this.redirectContextRelative;
}

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.

 protected boolean isRedirectHttp10Compatible() 
{
		return this.redirectHttp10Compatible;
}

Return whether redirects should stay compatible with HTTP 1.0 clients.

 protected View loadView(String viewName,
    Locale locale) throws Exception 
{
		AbstractUrlBasedView view = buildView(viewName);
		return (View) getApplicationContext().getAutowireCapableBeanFactory().initializeBean(view, viewName);
}

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 AbstractUrlBasedView.class;
}

Return the required type of view for this resolver. This implementation returns AbstractUrlBasedView.

 public  void setAttributes(Properties props) 
{
		setAttributesMap(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.

 public  void setAttributesMap(Map attributes) 
{
		if (attributes != null) {
			this.staticAttributes.putAll(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.

 public  void setContentType(String contentType) 
{
		this.contentType = 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.

 public  void setOrder(int order) 
{
		this.order = order;
}

Set the order in which this org.springframework.web.servlet.ViewResolver is evaluated.

 public  void setPrefix(String prefix) 
{
		this.prefix = (prefix != null ? prefix : "");
}

Set the prefix that gets prepended to view names when building a URL.

 public  void setRedirectContextRelative(boolean redirectContextRelative) 
{
		this.redirectContextRelative = 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"

 public  void setRedirectHttp10Compatible(boolean redirectHttp10Compatible) 
{
		this.redirectHttp10Compatible = 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"

 public  void setRequestContextAttribute(String requestContextAttribute) 
{
		this.requestContextAttribute = requestContextAttribute;
}

Set the name of the RequestContext attribute for all views.

 public  void setSuffix(String suffix) 
{
		this.suffix = (suffix != null ? suffix : "");
}

Set the suffix that gets appended to view names when building a URL.

 public  void setViewClass(Class viewClass) 
{
	                           	 
		if (viewClass == null || !requiredViewClass().isAssignableFrom(viewClass)) {
			throw new IllegalArgumentException(
					"Given view class [" + (viewClass != null ? viewClass.getName() : null) +
					"] is not of type [" + requiredViewClass().getName() + "]");
		}
		this.viewClass = viewClass;
}

Set the view class that should be used to create views.

 public  void setViewNames(String[] viewNames) 
{
		this.viewNames = viewNames;
}

Set the view names (or name patterns) that can be handled by this org.springframework.web.servlet.ViewResolver . View names can contain simple wildcards such that 'my*', '*Report' and '*Repo*' will all match the view name 'myReport'.