Spring MVC-从零开始-view-ViewResolver

时间  2019-11-07
标签 spring mvc 开始 view viewresolver 栏目 Spring 繁體版
原文   原文链接

主要ViewResolver简介html

InternalResourceViewResolver 将逻辑视图名解析为一个路径
BeanNameViewResolver 将逻辑视图名解析为bean的name属性，从而根据name属性去找对应的bean
ResourceBundleResolver 和BeanNameViewResolver同样，只不过定义的view-bean都在一个properties文件中，用这个类进行加载这个properties文件
XmlViewResolver 和ResourceBundleResolver同样，只不过定义的view-bean在一个xml文件中，用这个类来加载xml文件
UrlBasedViewResolver 它简单实现了ViewResolver接口, 不用任何映射就能经过逻辑视图名称访问资源
VelocityViewResolver 对Velocity模版引擎的支持
FreeMarkerViewResolver 对FreeMarker模版引擎的支持

 

 

 

 

 

 

 

转载（SpringMVC介绍之视图解析器ViewResolver）java

 

SpringMVC视图解析器web

前言

   在前一篇博客中讲了SpringMVC的Controller控制器，在这篇博客中将接着介绍一下SpringMVC视图解析器。当咱们对SpringMVC控制的资源发起请求时，这些请求都会被SpringMVC的DispatcherServlet处理，接着Spring会分析看哪个HandlerMapping定义的全部请求映射中存在对该请求的最合理的映射。而后经过该HandlerMapping取得其对应的Handler，接着再经过相应的HandlerAdapter处理该Handler。HandlerAdapter在对Handler进行处理以后会返回一个ModelAndView对象。在得到了ModelAndView对象以后，Spring就须要把该View渲染给用户，即返回给浏览器。在这个渲染的过程当中，发挥做用的就是ViewResolver和View。当Handler返回的ModelAndView中不包含真正的视图，只返回一个逻辑视图名称的时候，ViewResolver就会把该逻辑视图名称解析为真正的视图View对象。View是真正进行视图渲染，把结果返回给浏览器的。spring

ViewResolver和View介绍

SpringMVC用于处理视图最重要的两个接口是ViewResolver和View。ViewResolver的主要做用是把一个逻辑上的视图名称解析为一个真正的视图，SpringMVC中用于把View对象呈现给客户端的是View对象自己，而ViewResolver只是把逻辑视图名称解析为对象的View对象。View接口的主要做用是用于处理视图，而后返回给客户端。浏览器

Spring为咱们提供了很是多的视图解析器，下面将列举一些视图解析器。缓存

AbstractCachingViewResolver：这是一个抽象类，这种视图解析器会把它曾经解析过的视图保存起来，而后每次要解析视图的时候先从缓存里面找，若是找到了对应的视图就直接返回，若是没有就建立一个新的视图对象，而后把它放到一个用于缓存的map中，接着再把新建的视图返回。使用这种视图缓存的方式能够把解析视图的性能问题降到最低。安全

UrlBasedViewResolver：它是对ViewResolver的一种简单实现，并且继承了AbstractCachingViewResolver，主要就是提供的一种拼接URL的方式来解析视图，它可让咱们经过prefix属性指定一个指定的前缀，经过suffix属性指定一个指定的后缀，而后把返回的逻辑视图名称加上指定的前缀和后缀就是指定的视图URL了。如prefix=/WEB-INF/jsps/，suffix=.jsp，返回的视图名称viewName=test/indx，则UrlBasedViewResolver解析出来的视图URL就是/WEB-INF/jsps/test/index.jsp。默认的prefix和suffix都是空串。URLBasedViewResolver支持返回的视图名称中包含redirect:前缀，这样就能够支持URL在客户端的跳转，如当返回的视图名称是”redirect:test.do”的时候，URLBasedViewResolver发现返回的视图名称包含”redirect:”前缀，因而把返回的视图名称前缀”redirect:”去掉，取后面的test.do组成一个RedirectView，RedirectView中将把请求返回的模型属性组合成查询参数的形式组合到redirect的URL后面，而后调用HttpServletResponse对象的sendRedirect方法进行重定向。一样URLBasedViewResolver还支持forword:前缀，对于视图名称中包含forword:前缀的视图名称将会被封装成一个InternalResourceView对象，而后在服务器端利用RequestDispatcher的forword方式跳转到指定的地址。使用UrlBasedViewResolver的时候必须指定属性viewClass，表示解析成哪一种视图，通常使用较多的就是InternalResourceView，利用它来展示jsp，可是当咱们使用JSTL的时候咱们必须使用JstlView。下面是一段UrlBasedViewResolver的定义，根据该定义，当返回的逻辑视图名称是test的时候，UrlBasedViewResolver将把逻辑视图名称加上定义好的前缀和后缀，即“/WEB-INF/test.jsp”，而后新建一个viewClass属性指定的视图类型予以返回，即返回一个url为“/WEB-INF/test.jsp”的InternalResourceView对象。服务器

Xml代码  
  1. <bean  
  2.    class="org.springframework.web.servlet.view.UrlBasedViewResolver">  
  3.    <property name="prefix" value="/WEB-INF/" />  
  4.    <property name="suffix" value=".jsp" />  
  5.    <property name="viewClass" value="org.springframework.web.servlet.view.InternalResourceView"/>  
  6. </bean>  
    <bean
       class="org.springframework.web.servlet.view.UrlBasedViewResolver">
       <property name="prefix" value="/WEB-INF/" />
       <property name="suffix" value=".jsp" />
       <property name="viewClass" value="org.springframework.web.servlet.view.InternalResourceView"/>
    </bean>

 

InternalResourceViewResolver：它是URLBasedViewResolver的子类，因此URLBasedViewResolver支持的特性它都支持。在实际应用中InternalResourceViewResolver也是使用的最普遍的一个视图解析器。那么InternalResourceViewResolver有什么本身独有的特性呢？单从字面意思来看，咱们能够把InternalResourceViewResolver解释为内部资源视图解析器，这就是InternalResourceViewResolver的一个特性。InternalResourceViewResolver会把返回的视图名称都解析为InternalResourceView对象，InternalResourceView会把Controller处理器方法返回的模型属性都存放到对应的request属性中，而后经过RequestDispatcher在服务器端把请求forword重定向到目标URL。好比在InternalResourceViewResolver中定义了prefix=/WEB-INF/，suffix=.jsp，而后请求的Controller处理器方法返回的视图名称为test，那么这个时候InternalResourceViewResolver就会把test解析为一个InternalResourceView对象，先把返回的模型属性都存放到对应的HttpServletRequest属性中，而后利用RequestDispatcher在服务器端把请求forword到/WEB-INF/test.jsp。这就是InternalResourceViewResolver一个很是重要的特性，咱们都知道存放在/WEB-INF/下面的内容是不能直接经过request请求的方式请求到的，为了安全性考虑，咱们一般会把jsp文件放在WEB-INF目录下，而InternalResourceView在服务器端跳转的方式能够很好的解决这个问题。下面是一个InternalResourceViewResolver的定义，根据该定义当返回的逻辑视图名称是test的时候，InternalResourceViewResolver会给它加上定义好的前缀和后缀，组成“/WEB-INF/test.jsp”的形式，而后把它当作一个InternalResourceView的url新建一个InternalResourceView对象返回。app

Xml代码  
  1. <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
  2.    <property name="prefix" value="/WEB-INF/"/>  
  3.    <property name="suffix" value=".jsp"></property>  
  4. </bean>  
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
       <property name="prefix" value="/WEB-INF/"/>
       <property name="suffix" value=".jsp"></property>
    </bean>

 

XmlViewResolver：它继承自AbstractCachingViewResolver抽象类，因此它也是支持视图缓存的。XmlViewResolver须要给定一个xml配置文件，该文件将使用和Spring的bean工厂配置文件同样的DTD定义，因此其实该文件就是用来定义视图的bean对象的。在该文件中定义的每个视图的bean对象都给定一个名字，而后XmlViewResolver将根据Controller处理器方法返回的逻辑视图名称到XmlViewResolver指定的配置文件中寻找对应名称的视图bean用于处理视图。该配置文件默认是/WEB-INF/views.xml文件，若是不使用默认值的时候能够在XmlViewResolver的location属性中指定它的位置。XmlViewResolver还实现了Ordered接口，所以咱们能够经过其order属性来指定在ViewResolver链中它所处的位置，order的值越小优先级越高。如下是使用XmlViewResolver的一个示例：jsp

（1）在SpringMVC的配置文件中加入XmlViewResolver的bean定义。使用location属性指定其配置文件所在的位置，order属性指定当有多个ViewResolver的时候其处理视图的优先级。关于ViewResolver链的问题将在后续内容中讲到。

Xml代码  
  1. <bean class="org.springframework.web.servlet.view.XmlViewResolver">  
  2.    <property name="location" value="/WEB-INF/views.xml"/>  
  3.    <property name="order" value="1"/>  
  4. </bean>  
    <bean class="org.springframework.web.servlet.view.XmlViewResolver">
       <property name="location" value="/WEB-INF/views.xml"/>
       <property name="order" value="1"/>
    </bean>

 

（2）在XmlViewResolver对应的配置文件中配置好所须要的视图定义。在下面的代码中咱们就配置了一个名为internalResource的InternalResourceView，其url属性为“/index.jsp”。

Xml代码  
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  5.      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
  6.     <bean id="internalResource" class="org.springframework.web.servlet.view.InternalResourceView">  
  7.        <property name="url" value="/index.jsp"/>  
  8.     </bean>  
  9. </beans>  
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <bean id="internalResource" class="org.springframework.web.servlet.view.InternalResourceView">
       <property name="url" value="/index.jsp"/>
    </bean>
</beans>

 

（3）定义一个返回的逻辑视图名称为在XmlViewResolver配置文件中定义的视图名称——internalResource。

Java代码  
  1. @RequestMapping("/xmlViewResolver")  
  2. public String testXmlViewResolver() {  
  3.    return "internalResource";  
  4. }  
    @RequestMapping("/xmlViewResolver")
    public String testXmlViewResolver() {
       return "internalResource";
    }

 

（4）这样当咱们访问到上面定义好的testXmlViewResolver处理器方法的时候返回的逻辑视图名称为“internalResource”，这时候Spring就会到定义好的views.xml中寻找id或name为“internalResource”的bean对象予以返回，这里Spring找到的是一个url为“/index.jsp”的InternalResourceView对象。

BeanNameViewResolver：这个视图解析器跟XmlViewResolver有点相似，也是经过把返回的逻辑视图名称去匹配定义好的视图bean对象。不一样点有二，一是BeanNameViewResolver要求视图bean对象都定义在Spring的application context中，而XmlViewResolver是在指定的配置文件中寻找视图bean对象，二是BeanNameViewResolver不会进行视图缓存。看一个例子，在SpringMVC的配置文件中定义了一个BeanNameViewResolver视图解析器和一个id为test的InternalResourceview bean对象。

Xml代码  
  1. <bean class="org.springframework.web.servlet.view.BeanNameViewResolver">  
  2.    <property name="order" value="1"/>  
  3. </bean>  
  4.   
  5. <bean id="test" class="org.springframework.web.servlet.view.InternalResourceView">  
  6.    <property name="url" value="/index.jsp"/>  
  7. </bean>  
    <bean class="org.springframework.web.servlet.view.BeanNameViewResolver">
       <property name="order" value="1"/>
    </bean>

    <bean id="test" class="org.springframework.web.servlet.view.InternalResourceView">
       <property name="url" value="/index.jsp"/>
    </bean>

 

这样当返回的逻辑视图名称是 test的时候，就会解析为上面定义好id为test的InternalResourceView。

ResourceBundleViewResolver：它和XmlViewResolver同样，也是继承自AbstractCachingViewResolver，可是它缓存的不是视图，这个会在后面有说到。和XmlViewResolver同样它也须要有一个配置文件来定义逻辑视图名称和真正的View对象的对应关系，不一样的是ResourceBundleViewResolver的配置文件是一个属性文件，并且必须是放在classpath路径下面的，默认状况下这个配置文件是在classpath根目录下的views.properties文件，若是不使用默认值的话，则能够经过属性baseName或baseNames来指定。baseName只是指定一个基名称，Spring会在指定的classpath根目录下寻找以指定的baseName开始的属性文件进行View解析，如指定的baseName是base，那么base.properties、baseabc.properties等等以base开始的属性文件都会被Spring当作ResourceBundleViewResolver解析视图的资源文件。ResourceBundleViewResolver使用的属性配置文件的内容相似于这样：

Properties代码  
  1. resourceBundle.(class)=org.springframework.web.servlet.view.InternalResourceView  
  2. resourceBundle.url=/index.jsp  
  3. test.(class)=org.springframework.web.servlet.view.InternalResourceView  
  4. test.url=/test.jsp  
resourceBundle.(class)=org.springframework.web.servlet.view.InternalResourceView
resourceBundle.url=/index.jsp
test.(class)=org.springframework.web.servlet.view.InternalResourceView
test.url=/test.jsp

 

在这个配置文件中咱们定义了两个InternalResourceView对象，一个的名称是resourceBundle，对应URL是/index.jsp，另外一个名称是test，对应的URL是/test.jsp。从这个定义来看咱们能够知道resourceBundle是对应的视图名称，使用resourceBundle.(class)来指定它对应的视图类型，resourceBundle.url指定这个视图的url属性。会思考的读者看到这里可能会有这样一个问题：为何resourceBundle的class属性要用小括号包起来，而它的url属性就不须要呢？这就须要从ResourceBundleViewResolver进行视图解析的方法来讲了。ResourceBundleViewResolver仍是经过bean工厂来得到对应视图名称的视图bean对象来解析视图的。那么这些bean从哪里来呢？就是从咱们定义的properties属性文件中来。在ResourceBundleViewResolver第一次进行视图解析的时候会先new一个BeanFactory对象，而后把properties文件中定义好的属性按照它自身的规则生成一个个的bean对象注册到该BeanFactory中，以后会把该BeanFactory对象保存起来，因此ResourceBundleViewResolver缓存的是BeanFactory，而不是直接的缓存从BeanFactory中取出的视图bean。而后会从bean工厂中取出名称为逻辑视图名称的视图bean进行返回。接下来就讲讲Spring经过properties文件生成bean的规则。它会把properties文件中定义的属性名称按最后一个点“.”进行分割，把点前面的内容当作是bean名称，点后面的内容当作是bean的属性。这其中有几个特别的属性，Spring把它们用小括号包起来了，这些特殊的属性通常是对应的attribute，但不是bean对象全部的attribute均可以这样用。其中(class)是一个，除了(class)以外，还有(scope)、(parent)、(abstract)、(lazy-init)。而除了这些特殊的属性以外的其余属性，Spring会把它们当作bean对象的通常属性进行处理，就是bean对象对应的property。因此根据上面的属性配置文件将生成以下两个bean对象：

Xml代码  
  1. <bean id="resourceBundle" class="org.springframework.web.servlet.view.InternalResourceView">  
  2.    <property name="url" value="/index.jsp"/>  
  3. </bean>  
  4.   
  5. <bean id="test" class="org.springframework.web.servlet.view.InternalResourceView">  
  6.    <property name="url" value="/test.jsp"/>  
  7. </bean>  
    <bean id="resourceBundle" class="org.springframework.web.servlet.view.InternalResourceView">
       <property name="url" value="/index.jsp"/>
    </bean>

    <bean id="test" class="org.springframework.web.servlet.view.InternalResourceView">
       <property name="url" value="/test.jsp"/>
    </bean>

 

从ResourceBundleViewResolver使用的配置文件咱们能够看出，它和XmlViewResolver同样能够解析多种不一样类型的View，由于它们的View是经过配置的方式指定的，这也就意味着咱们能够指定A视图是InternalResourceView，B视图是JstlView。

来看下面这个一个例子，我在SpringMVC的配置文件中定义了一个ResourceBundleViewResolver对象，指定其baseName为views，而后order为1。

Xml代码  
  1. <bean class="org.springframework.web.servlet.view.ResourceBundleViewResolver">  
  2.    <property name="basename" value="views"/>  
  3.    <property name="order" value="1"/>  
  4. </bean>  
    <bean class="org.springframework.web.servlet.view.ResourceBundleViewResolver">
       <property name="basename" value="views"/>
       <property name="order" value="1"/>
    </bean>

 

我在classpath的根目录下有两个属性文件，一个是views.properties，一个是views_abc.properties，它们的内容分别以下：

views.properties：

Properties代码  
  1. resourceBundle.(class)=org.springframework.web.servlet.view.InternalResourceView  
  2. resourceBundle.url=/index.jsp  
  3. test.(class)=org.springframework.web.servlet.view.InternalResourceView  
  4. test.url=/test.jsp  
resourceBundle.(class)=org.springframework.web.servlet.view.InternalResourceView
resourceBundle.url=/index.jsp
test.(class)=org.springframework.web.servlet.view.InternalResourceView
test.url=/test.jsp

 

views_abc.properties：

Properties代码  
  1. abc.(class)=org.springframework.web.servlet.view.InternalResourceView  
  2. abc.url=/abc.jsp  
abc.(class)=org.springframework.web.servlet.view.InternalResourceView
abc.url=/abc.jsp

 

定义了以下这样一个Controller，它有三个处理器方法。

Java代码  
  1. @Controller  
  2. @RequestMapping("/mytest")  
  3. public class MyController {  
  4.     @RequestMapping("resourceBundle")  
  5.     public String resourceBundle() {  
  6.        return "resourceBundle";  
  7.     }  
  8.   
  9.     @RequestMapping("testResourceBundle")  
  10.     public String testResourceBundle() {  
  11.        return "test";  
  12.     }  
  13.   
  14.     @RequestMapping("abc")  
  15.     public String abc() {  
  16.        return "abc";  
  17.     }  
  18.   
  19. }  
@Controller
@RequestMapping("/mytest")
public class MyController {
    @RequestMapping("resourceBundle")
    public String resourceBundle() {
       return "resourceBundle";
    }

    @RequestMapping("testResourceBundle")
    public String testResourceBundle() {
       return "test";
    }

    @RequestMapping("abc")
    public String abc() {
       return "abc";
    }

}

 

那么当咱们请求/mytest/resourceBundle.do的时候，ResourceBundleViewResolver会首先尝试着来解析该视图，这里Controller处理器方法返回的逻辑视图名称是resourceBundle，ResourceBundleViewResolver按照上面提到的解析方法进行解析，这个时候它发现它是能够解析的，而后就返回了一个url为/index.jsp的InternalResourceView对象。一样，请求/mytest/testResourceBundle.do返回的逻辑视图test和/mytest/abc.do返回的逻辑视图abc它均可以解析。当咱们把basename指定为包的形式，如“com.tiantian.views”，的时候Spring会按照点“.”划分为目录的形式，到classpath相应目录下去寻找basename开始的配置文件，如上面咱们指定basename为“com.tiantian.views”，那么spring就会到classpath下的com/tiantian目录下寻找文件名以views开始的properties文件做为解析视图的配置文件。

FreeMarkerViewResolver、VolocityViewResolver：这两个视图解析器都是UrlBasedViewResolver的子类。FreeMarkerViewResolver会把Controller处理方法返回的逻辑视图解析为FreeMarkerView，而VolocityViewResolver会把返回的逻辑视图解析为VolocityView。由于这两个视图解析器相似，因此这里我就只挑FreeMarkerViewResolver来作一个简单的讲解。FreeMarkerViewResolver和VilocityViewResolver都继承了UrlBasedViewResolver。

对于FreeMarkerViewResolver而言，它会按照UrlBasedViewResolver拼接URL的方式进行视图路径的解析。可是使用FreeMarkerViewResolver的时候不须要咱们指定其viewClass，由于FreeMarkerViewResolver中已经把viewClass定死为FreeMarkerView了。

咱们先在SpringMVC的配置文件里面定义一个FreeMarkerViewResolver视图解析器，并定义其解析视图的order顺序为1。

Xml代码  
  1. <bean class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver">  
  2.    <property name="prefix" value="fm_"/>  
  3.    <property name="suffix" value=".ftl"/>  
  4.    <property name="order" value="1"/>  
  5. </bean>  
    <bean class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver">
       <property name="prefix" value="fm_"/>
       <property name="suffix" value=".ftl"/>
       <property name="order" value="1"/>
    </bean>

 

那么当咱们请求的处理器方法返回一个逻辑视图名称viewName的时候，就会被该视图处理器加上先后缀解析为一个url为“fm_viewName.ftl”的FreeMarkerView对象。对于FreeMarkerView咱们须要给定一个FreeMarkerConfig的bean对象来定义FreeMarker的配置信息。FreeMarkerConfig是一个接口，Spring已经为咱们提供了一个实现，它就是FreeMarkerConfigurer。咱们能够经过在SpringMVC的配置文件里面定义该bean对象来定义FreeMarker的配置信息，该配置信息将会在FreeMarkerView进行渲染的时候使用到。对于FreeMarkerConfigurer而言，咱们最简单的配置就是配置一个templateLoaderPath，告诉Spring应该到哪里寻找FreeMarker的模板文件。这个templateLoaderPath也支持使用“classpath:”和“file:”前缀。当FreeMarker的模板文件放在多个不一样的路径下面的时候，咱们可使用templateLoaderPaths属性来指定多个路径。在这里咱们指定模板文件是放在“/WEB-INF/freemarker/template”下面的。

Xml代码  
  1. <bean class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">  
  2.    <property name="templateLoaderPath" value="/WEB-INF/freemarker/template"/>  
  3. </bean>  
    <bean class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
       <property name="templateLoaderPath" value="/WEB-INF/freemarker/template"/>
    </bean>

 

接下来咱们定义以下一个Controller：

Java代码  
  1. @Controller  
  2. @RequestMapping("/mytest")  
  3. public class MyController {  
  4.   
  5.     @RequestMapping("freemarker")  
  6.     public ModelAndView freemarker() {  
  7.        ModelAndView mav = new ModelAndView();  
  8.        mav.addObject("hello", "andy");  
  9.        mav.setViewName("freemarker");  
  10.        return mav;  
  11.     }  
  12.   
  13. }  
@Controller
@RequestMapping("/mytest")
public class MyController {

    @RequestMapping("freemarker")
    public ModelAndView freemarker() {
       ModelAndView mav = new ModelAndView();
       mav.addObject("hello", "andy");
       mav.setViewName("freemarker");
       return mav;
    }

}

 

由上面的定义咱们能够看到这个Controller的处理器方法freemarker返回的逻辑视图名称是“freemarker”。那么若是咱们须要把该freemarker视图交给FreeMarkerViewResolver来解析的话，咱们就须要根据上面的定义，在模板路径下定义视图对应的模板，即在“/WEB-INF/freemarker/template”目录下创建fm_freemarker.ftl模板文件。这里咱们定义其内容以下：

Ftl代码  
  1. <html>  
  2.     <head>  
  3.        <title>FreeMarker</title>  
  4.     </head>  
  5.     <body>  
  6.        <b>Hello World</b>  
  7.        <font color="red">Hello World!</font>  
  8.        ${hello}  
  9.     </body>  
  10. </html>  
<html>
    <head>
       <title>FreeMarker</title>
    </head>
    <body>
       <b>Hello World</b>
       <font color="red">Hello World!</font>
       ${hello}
    </body>
</html>

 

通过上面的定义当咱们访问/mytest/freemarker.do的时候就会返回一个逻辑视图名称为“freemarker”的ModelAndView对象，根据定义好的视图解析的顺序，首先进行视图解析的是FreeMarkerViewResolver，这个时候FreeMarkerViewResolver会试着解析该视图，根据它自身的定义，它会先解析到该视图的URL为fm_freemarker.ftl，而后它会看是否可以实例化该视图对象，即在定义好的模板路径下是否有该模板存在，若是有则返回该模板对应的FreeMarkerView。在这里的话/WEB-INF/freemarker/template目录下是存在模板文件fm_freemarker.ftl的，因此会返回一个url为fm_freemarker.ftl的FreeMarkerView对象。接着FreeMarkerView就能够利用该模板文件进行视图的渲染了。因此访问结果应该以下所示：  

 

视图解析器链

       在SpringMVC中能够同时定义多个ViewResolver视图解析器，而后它们会组成一个ViewResolver链。当Controller处理器方法返回一个逻辑视图名称后，ViewResolver链将根据其中ViewResolver的优先级来进行处理。全部的ViewResolver都实现了Ordered接口，在Spring中实现了这个接口的类都是能够排序的。在ViewResolver中是经过order属性来指定顺序的，默认都是最大值。因此咱们能够经过指定ViewResolver的order属性来实现ViewResolver的优先级，order属性是Integer类型，order越小，对应的ViewResolver将有越高的解析视图的权利，因此第一个进行解析的将是ViewResolver链中order值最小的那个。当一个ViewResolver在进行视图解析后返回的View对象是null的话就表示该ViewResolver不能解析该视图，这个时候若是还存在其余order值比它大的ViewResolver就会调用剩余的ViewResolver中的order值最小的那个来解析该视图，依此类推。当ViewResolver在进行视图解析后返回的是一个非空的View对象的时候，就表示该ViewResolver可以解析该视图，那么视图解析这一步就完成了，后续的ViewResolver将不会再用来解析该视图。当定义的全部ViewResolver都不能解析该视图的时候，Spring就会抛出一个异常。

       基于Spring支持的这种ViewResolver链模式，咱们就能够在SpringMVC应用中同时定义多个ViewResolver，给定不一样的order值，这样咱们就能够对特定的视图特定处理，以此来支持同一应用中有多种视图类型。注意：像InternalResourceViewResolver这种能解析全部的视图，即永远能返回一个非空View对象的ViewResolver必定要把它放在ViewResolver链的最后面。

 

Xml代码  
  1. <bean class="org.springframework.web.servlet.view.XmlViewResolver">  
  2.    <property name="location" value="/WEB-INF/views.xml"/>  
  3.    <property name="order" value="1"/>  
  4. </bean>  
  5.   
  6. <bean  
  7.    class="org.springframework.web.servlet.view.UrlBasedViewResolver">  
  8.    <property name="prefix" value="/WEB-INF/" />  
  9.    <property name="suffix" value=".jsp" />  
  10.    <property name="viewClass" value="org.springframework.web.servlet.view.InternalResourceView"/>  
  11. </bean>  
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程