你的位置:首页 > Java教程

[Java教程]SpringMVC核心——视图渲染(包含视图解析)问题


一、本来想说的是返回值处理问题,但在 SpringMVC 中,返回值处理问题的核心就是视图渲染。所以这里标题叫视图渲染问题。

本来想在上一篇文章中对视图解析进行说明的,但是通过源码发现,它应该算到视图渲染中,所以在这篇文章中进行说明

org.springframework.web.servlet.DispatcherServlet#doDispatch方法中

mv = ha.handle(processedRequest, response, mappedHandler.getHandler());//945行返回了 ModelAndView 对象

processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);// 959行进行的就是返回值处理问题

org.springframework.web.servlet.DispatcherServlet#processDispatchResult方法中

render(mv, request, response); //1012进行视图的渲染(包含视图解析)

org.springframework.web.servlet.DispatcherServlet#render 方法

protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {    // Determine locale for request and apply it to the response.    Locale locale = this.localeResolver.resolveLocale(request);    response.setLocale(locale);    View view;    if (mv.isReference()) {      // We need to resolve the view name.      view = resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request);      if (view == null) {        throw new ServletException(            "Could not resolve view with name '" + mv.getViewName() + "' in servlet with name '" +                getServletName() + "'");      }    }    else {      // No need to lookup: the ModelAndView object contains the actual View object.      view = mv.getView();      if (view == null) {        throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +            "View object in servlet with name '" + getServletName() + "'");      }    }    // Delegate to the View object for rendering.    if (logger.isDebugEnabled()) {      logger.debug("Rendering view [" + view + "] in DispatcherServlet with name '" + getServletName() + "'");    }    try {      view.render(mv.getModelInternal(), request, response);    }    catch (Exception ex) {      if (logger.isDebugEnabled()) {        logger.debug("Error rendering view [" + view + "] in DispatcherServlet with name '"            + getServletName() + "'", ex);      }      throw ex;    }  }

可以看到有两个 if ,第一个 if 解决的是视图解析问题,第二个 if 解决的是视图渲染问题。还有官方是这样描述这个方法的:Render the given ModelAndView.

二、视图解析:通过视图解析器进行视图的解析

1.解析一个视图名到一个视图对象,具体解析的过程是:在容器中查找所有配置好的视图解析器(List类型),然后进行遍历,

只要有一个视图解析器能解析出视图就返回 View 对象,若遍历完成后都不能解析出视图,那么返回 null。

具体来看:

org.springframework.web.servlet.DispatcherServlet#resolveViewName

protected View resolveViewName(String viewName, Map<String, Object> model, Locale locale,      HttpServletRequest request) throws Exception {  for (ViewResolver viewResolver : this.viewResolvers) {    View view = viewResolver.resolveViewName(viewName, locale);    if (view != null) {      return view;    }  }  return null;}

2. ViewResolver

(1)官方描述:

* Interface to be implemented by objects that can resolve views by name.
*
* <p>View state doesn't change during the running of the application,
* so implementations are free to cache views.
*
* <p>Implementations are encouraged to support internationalization,
* i.e. localized view resolution.

 

 

 

 

 

 

说明:

ViewResolver 接口由能解析视图名称的实现类来实现。

在程序运行期间视图的状态不能更改,所以实现能被随意缓存。鼓励实现支持国际化。

(2)ViewResolver 的整个体系

可以看出 SpringMVC 提供了很多类型视图解析器。

(3)在 SpringMVC 的第一篇文章中,配置过一个视图解析器。

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  <property name="prefix" value="/WEB-INF/views/"/>  <property name="suffix" value=".jsp"/></bean>

发送一个请求之后,发现要遍历的 ViewResolvers 只有一个,就是上面的这个 ViewResolver。没有其他默认的视图解析器。所以说在SpringMVC 配置文件中,必须配置至少一个 视图解析器。

那么这里会有一个问题?如果配置多个视图解析器,他们的遍历顺序是怎么样的呢?

ViewResolver 的所有实现类中都存在一个 order 属性。

看这个属性的 setOrder() 注释:Set the order in which this {@link org.springframework.web.servlet.ViewResolver} is evaluated。设置谁先被评估。

还有一点小不同:

除 ContentNegotiatingViewResolver 之外,其他所有的 ViewResolver 的默认值都是:Integer.MAX_VALUE(2^31 -1,即2147483647),

而 ContentNegotiatingViewResolver 的默认值为 Ordered.HIGHEST_PRECEDENCE(-2147483648)。

那他们的遍历的顺序与 order 是什么关系呢?如果不设置 order 的话,遍历顺序又是怎么样的?

<1>设置 order 属性后,遍历顺序是怎么样的

<bean class="org.springframework.web.servlet.view.BeanNameViewResolver">  <property name="order" value="99"/></bean><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  <property name="prefix" value="/WEB-INF/views/"/>  <property name="suffix" value=".jsp"/>  <property name="order" value="-99"/></bean>

对 BeanNameViewResolver 的 order 属性指定为 99,对 InternalResourceViewResolver 指定为-99。这里故意将 BeanNameViewResolver 放到了 InternalResourceViewResolver 前面。

遍历顺序:

发现 InternalResourceViewResolver 会先被遍历。

结论:

在指定 order 属性的情况下,order 值越小的,越先会遍历。

<2>不设置 order 属性,遍历顺序是怎样的

在测试这个的时候,发现一个这样的现象:我将 BeanNameViewResolver 和 InternalResourceViewResolver 的 order 属性都去掉,我这里用的是 Jrebel 的热部署。发现再次请求的时候,

这两个视图的 order 属性值还和之前的一样:

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  <property name="prefix" value="/WEB-INF/views/"/>  <property name="suffix" value=".jsp"/></bean><bean class="org.springframework.web.servlet.view.BeanNameViewResolver"></bean>

为什么呢?想起了官方的描述:"在程序运行期间视图的状态不能更改,所以实现能被随意缓存",这里被缓存了。重启后来看真正的测试。

第一种情况:

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  <property name="prefix" value="/WEB-INF/views/"/>  <property name="suffix" value=".jsp"/></bean><bean class="org.springframework.web.servlet.view.BeanNameViewResolver"></bean>

第二种情况:将 bean 在 SpringMVC  Config 文件中的顺序进行替换,需要注意的是,重启服务器,否则它们的顺序还是会被缓存下来。重启后来看:

<bean class="org.springframework.web.servlet.view.BeanNameViewResolver"></bean><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  <property name="prefix" value="/WEB-INF/views/"/>  <property name="suffix" value=".jsp"/></bean>

结论已经很明显了:

在同等优先级的情况下,遍历的顺序是由 ViewResolver 在 SpringMVC Config 文件中配置的顺序决定的,谁在前谁先遍历。

这里不对具体的每个视图解析器进行说明,路已经指明了。

3.ViewResolver 具体是怎么将 view name 解析为一个视图的?

先看 ViewResolver 中的 View resolveViewName(String viewName, Locale locale)

说明:

解析视图通过其名称。注意:允许 ViewResolver 链。

如果一个给定名称的view 没有在一个 ViewResolver 中定义,那么它应该返回 null。

然而它也不是必须的:有一些 ViewResolver 当尝试通过视图名称构建 View 对象失败后,不返回 null。而替代它的是,抛出一个异常。

 

以 org.springframework.web.servlet.view.AbstractCachingViewResolver 进行分析。

@Overridepublic View resolveViewName(String viewName, Locale locale) throws Exception {  if (!isCache()) {    return createView(viewName, locale);  }  else {    Object cacheKey = getCacheKey(viewName, locale);    View view = this.viewAccessCache.get(cacheKey);    if (view == null) {      synchronized (this.viewCreationCache) {      view = this.viewCreationCache.get(cacheKey);      if (view == null) {        // Ask the subclass to create the View object.        view = createView(viewName, locale);        if (view == null && this.cacheUnresolved) {          view = UNRESOLVED_VIEW;        }        if (view != null) {          this.viewAccessCache.put(cacheKey, view);          this.viewCreationCache.put(cacheKey, view);          if (logger.isTraceEnabled()) {            logger.trace("Cached view [" + cacheKey + "]");          }        }      }    }  }  return (view != UNRESOLVED_VIEW ? view : null);  }}

判断该视图是否被缓存,如果没有被缓存,则创建视图,如果被缓存,则从缓存中获取。

创建视图,以 InternalResourceViewResolver 和 BeanNameViewResolver 为例:

(1)InternalResourceViewResolver 

org.springframework.web.servlet.view.UrlBasedViewResolver#createView

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());    RedirectView view = new RedirectView(redirectUrl, isRedirectContextRelative(), isRedirectHttp10Compatible());    return applyLifecycleMethods(viewName, view);  }  // 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);}  

在创建视图前会检查返回值是否是以:"redirect:" 或 "forward:" 开头的。

如果是重定向:则创建一个重定向视图,返回创建的视图。如果是转发:则返回通过 转发 url 创建的 InternalResourceView 视图。

org.springframework.web.servlet.view.UrlBasedViewResolver#loadView

AbstractUrlBasedView view = buildView(viewName);View result = applyLifecycleMethods(viewName, view);return (view.checkResource(locale) ? result : null);

调用具体的 InternalResourceViewResolver ,然后又调用 父类的 buildView() 方法

org.springframework.web.servlet.view.UrlBasedViewResolver#buildView

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());  if (this.exposePathVariables != null) {    view.setExposePathVariables(exposePathVariables);  }  return view;}

可以看出:是通过 BeanUtils.instantiateClass(getViewClass()) 来创建 View 对象的。这个例子与其说是 InternalResourceViewResolver ,倒不如说是 UrlBasedViewResolver 类型的例子。

从这里也可以看出:该类型最终要到的目标URL为:getPrefix() + viewName + getSuffix()

(2)BeanNameViewResolver 

public View resolveViewName(String viewName, Locale locale) throws BeansException {  ApplicationContext context = getApplicationContext();  if (!context.containsBean(viewName)) {    // Allow for ViewResolver chaining.    return null;  }  return context.getBean(viewName, View.class);}  

org.springframework.context.support.AbstractApplicationContext#getBean(java.lang.String, java.lang.Class<T>)

public <T> T getBean(String name, Class<T> requiredType) throws BeansException {  this.assertBeanFactoryActive();  return this.getBeanFactory().getBean(name, requiredType);}

可以看出:是通过 BeanFactory.getBean(String name, Class<T> requiredType) 来获取的。

三、视图渲染

1.View

官方文档:

* MVC View for a web interaction. Implementations are responsible for rendering
* content, and exposing the model. A single view exposes multiple model attributes.
*
* <p>This class and the MVC approach associated with it is discussed in Chapter 12 of
* <a href="http://www.amazon.com/exec/obidos/tg/detail/-/0764543857/">Expert One-On-One J2EE Design and Development</a>
* by Rod Johnson (Wrox, 2002).
*
* <p>View implementations may differ widely. An obvious implementation would be
* JSP-based. Other implementations might be XSLT-based, or use an HTML generation library.
* This interface is designed to avoid restricting the range of possible implementations.
*
* <p>Views should be beans. They are likely to be instantiated as beans by a ViewResolver.
* As this interface is stateless, view implementations should be thread-safe.

 

 

 

 

 

 

 

 

 

 

说明:

SpringMVC 对一个 web 来说是相互作用的(不太明白)。View 的实现类是负责呈现内容的,并且 exposes(暴露、揭露、揭发的意思,这里就按暴露解释吧,想不出合适的词语) 模型的。

一个单一的视图可以包含多个模型。

View 的实现可能有很大的不同。一个明显的实现是基于 JSP 的。其他的实现可能是基于 XSLT 的,或者是一个 HTML 生成库。

设计这个接口是为了避免约束可能实现的范围(这里是不是说,我们可以通过实现该接口来自定义扩展自定义视图?)。

所有的视图都应该是一个 Bean 类。他们可能被 ViewResolver 当做一个 bean 进行实例化。

由于这个接口是无状态的,View 的所有实现类应该是线程安全的。

2.View 的整个体系

3.具体渲染的一个过程

org.springframework.web.servlet.view.AbstractView#render

说明一下这个方法:

为指定的模型指定视图,如果有必要的话,合并它静态的属性和RequestContext中的属性,renderMergedOutputModel() 执行实际的渲染。

public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception {  if (logger.isTraceEnabled()) {    logger.trace("Rendering view with name '" + this.beanName + "' with model " + model +      " and static attributes " + this.staticAttributes);  }  Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);  prepareResponse(request, response);  renderMergedOutputModel(mergedModel, request, response);}

这里只看 org.springframework.web.servlet.view.InternalResourceView#renderMergedOutputModel 这个方法

@Overrideprotected void renderMergedOutputModel(    Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {  // Determine which request handle to expose to the RequestDispatcher.  HttpServletRequest requestToExpose = getRequestToExpose(request);  // Expose the model object as request attributes.  exposeModelAsRequestAttributes(model, requestToExpose);   // Expose helpers as request attributes, if any.  exposeHelpers(requestToExpose);  // Determine the path for the request dispatcher.  String dispatcherPath = prepareForRendering(requestToExpose, response);  // Obtain a RequestDispatcher for the target resource (typically a JSP).  RequestDispatcher rd = getRequestDispatcher(requestToExpose, dispatcherPath);  if (rd == null) {    throw new ServletException("Could not get RequestDispatcher for [" + getUrl() +        "]: Check that the corresponding file exists within your web application archive!");  }  // If already included or response already committed, perform include, else forward.  if (useInclude(requestToExpose, response)) {    response.setContentType(getContentType());    if (logger.isDebugEnabled()) {      logger.debug("Including resource [" + getUrl() + "] in InternalResourceView '" + getBeanName() + "'");    }    rd.include(requestToExpose, response);  }  else {    // Note: The forwarded resource is supposed to determine the content type itself.    if (logger.isDebugEnabled()) {      logger.debug("Forwarding to resource [" + getUrl() + "] in InternalResourceView '" + getBeanName() + "'");    }    rd.forward(requestToExpose, response);  }}

可以看到前面的几个步骤都是为 RequestDispatch 做准备,装填数据。最后,到目标页面是通过转发。

四、总结

介绍了 SpringMVC 视图解析和视图渲染问题是如何解决的。SpringMVC 为逻辑视图提供了多种视图解析策略,可以在配置文件中配置多个视图的解析策略。并制定其先后顺序。

这里所说的视图解析策略,就是指视图解析器。视图解析器会将逻辑视图名解析为一个具体的视图对象。再说视图渲染的过程,视图对模型进行了渲染,最终将模型的数据以某种形式呈现给用户。

 

到此为止,在我看来,SpringMVC 整个流程已经跑完,前面的几篇文章,从一个小栗子开始,然后分别介绍了请求映射问题,参数问题,返回值问题,到这篇文章,返回值处理问题

我认为这几个问题是整个 SpringMVC 的核心内容。其他的问题,都是建立在该问题的基础上,或者是对这几个问题的一种延伸。

 

还有想说的是,在边测试边看源码边写文章的时候,给我这么一个感觉,不论是何种开源框架,它所有的应用都是从源码中来的,不论哪个人或者那本书把这个知识讲的多好,

但是在我看来,想要学好某个框架,都要到它源码中去,找到它的根,这样才会有理有据,不会忘的那么快,纵然忘了,下次还是可以找出来为什么。

纵然在看源码的过程中,可能会遇到很多困难,比如英文单词不认识,整个句子读不通,但是如果你能结合自己的理解,

然后理解文档中的话,我相信对你帮助是很大的,其实这就是一种自学能力,摸的着,看得见。

 

算是给各位看客老爷的一种建议吧,愿各位在学习的道路上不要停滞不前。