UrlBasedViewResolver 为它解析的每个view实例化一个viewClass类的实例。

<bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
  <property name="viewClass" value="org.springframework.web.servlet.view.tiles2.TilesView"/>
</bean>

ResourceBundleViewResolver类 需要一个属性文件，其中包含了它需要使用的视图名和视图类：

<bean id="viewResolver" class="org.springframework.web.servlet.view.ResourceBundleViewResolver">
  <property name="basename" value="views"/>
</bean>

...
welcomeView.class=org.springframework.web.servlet.view.tiles2.TilesView
welcomeView.url=welcome 
						(this is the name of a Tiles definition)

					

vetsView.class=org.springframework.web.servlet.view.tiles2.TilesView
vetsView.url=vetsView 
						(again, this is the name of a Tiles definition)

					

findOwnersForm.class=org.springframework.web.servlet.view.JstlView
findOwnersForm.url=/WEB-INF/jsp/findOwners.jsp
...

正如你所看到的，使用ResourceBundleViewResolver类时，你可以混用不同的view层技术。

作为一个高级的特性，Spring支持两个特定的Tiles 2PreparerFactory实现。如何Tiles定义文件中使用 ViewPreparer引用，详细资料查看Tiles文档。

基于指定的preparer类，指定SimpleSpringPreparerFactory 自动装配 ViewPreparer 实体，不但应用 Spring的容器回调而且应用配置Spring BeanPostProcessors。假如Spring的上下文范围 annotation-config 已经被激活，ViewPreparer 类中的注解将被自动检测到及应用。注意，在 Tiles 定义文件中预计的preparer classes，就像默认PreparerFactory所作的一样。

指定SpringBeanPreparerFactory来操作指定preparer名称，而不是类，从DispatcherServlet的应用上下文 获取相应的Spring bean。在这种情况下，完整的 bean 创建过程将在Spring应用上下文控制中，允许明确使用依赖注入，范围bean等等。 注意，需要定义为每一个preparer名称定义一个Spring bean（用于Tiles定义中）。

<bean id="tilesConfigurer" class="org.springframework.web.servlet.view.tiles2.TilesConfigurer">
  <property name="definitions">
    <list>
      <value>/WEB-INF/defs/general.xml</value>
      <value>/WEB-INF/defs/widgets.xml</value>
      <value>/WEB-INF/defs/administrator.xml</value>
      <value>/WEB-INF/defs/customer.xml</value>
      <value>/WEB-INF/defs/templates.xml</value>
    </list>
  </property>

  
						<!-- resolving preparer names as Spring bean
						definition names -->

					
  <property name="preparerFactoryClass"
       value="org.springframework.web.servlet.view.tiles2.SpringBeanPreparerFactory"/>

</bean>

这个文件是可选的，不过一旦指定，其所包含的值即影响Velocity运行时状态。只有当你要做一些高级配置时才需要这个文件，这时你可以在上面定义的 VelocityConfigurer中指定它的位置。

					<bean id="velocityConfig"
					class="org.springframework.web.servlet.view.velocity.VelocityConfigurer">
					<property name="configLocation
					value="/WEB-INF/velocity.properties"/>
					</bean>
				

另一种方法，你可以直接在Velocity config bean的定义中指定velocity属性，来取代“configLocation”属性。

<bean id="velocityConfig" class="org.springframework.web.servlet.view.velocity.VelocityConfigurer">
  <property name="velocityProperties">
    <props>
      <prop key="resource.loader">file</prop>
      <prop key="file.resource.loader.class">
        org.apache.velocity.runtime.resource.loader.FileResourceLoader
      </prop>
      <prop key="file.resource.loader.path">${webapp.root}/WEB-INF/velocity</prop>
      <prop key="file.resource.loader.cache">false</prop>
    </props>
  </property>
</bean>

关于Spring中Velocity的配置请参考 API文档或者参考Velocity自身文档中的例子和定义来了解如何配置 'velocity.properties'文件。

FreeMarker的'Settings'和'SharedVariables'配置可以通过直接设置 FreeMarkerConfigurer 的相应属性来传递给Spring管理的FreeMarker Configuration对象，其中 freemarkerSettings 属性需要一个java.util.Properties类型对象， freemarkerVariables需要一个 java.util.Map类型对象。

<bean id="freemarkerConfig" class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
  <property name="templateLoaderPath" value="/WEB-INF/freemarker/"/>
  <property name="freemarkerVariables">
    <map>
      <entry key="xml_escape" value-ref="fmXmlEscape"/>
    </map>
  </property>
</bean>

<bean id="fmXmlEscape" class="freemarker.template.utility.XmlEscape"/>

关于settings和variables如何影响 Configuration 对象的细节信息，请参考FreeMarker的文档。

spring.jar文件为这两种语言维护了一套标准宏，对于正确配置的应用，它们总是可用的。

在Spring库中定义的一些宏被认为是内部的（私有的），但当宏定义中不存在这样的范围界定时， 会使得所有的宏均是可见的，能够任意调用代码和用户模板。下面的一节将集中讨论模板中可以直接调用的宏。 如果希望直接查看宏的代码，它们分别是 org.springframework.web.servlet.view.velocity 包中的spring.vm文件和 org.springframework.web.servlet.view.freemarker 包中的spring.ftl文件。

在扮演Spring表单控制器对应视图的html表单（或vm/ftl模板）里， 你可以模仿下面的代码来绑定表单数据并显示错误信息（和JSP的形式非常相似）。 注意默认情况下命令对象的名字是“command”，你可以在配置自己的表单控制器时通过设置'commandName'属性来覆盖默认值。 例子代码如下（其中的personFormV 和personFormF是前面定义的视图）：

					<!-- velocity宏自动可用 --> <html> ...
					<form action="" method="POST"> Name:
					#springBind( "command.name" ) <input type="text"
					name="${status.expression}" value="$!status.value"
					/><br> #foreach($error in
					$status.errorMessages) <b>$error</b>
					<br> #end <br> ... <input
					type="submit" value="submit"/> </form> ...
					</html>
				

					<!-- FreeMarker宏必须导入到一个名称空间，这里推荐你定义为'spring'空间
					--> <#import "spring.ftl" as spring />
					<html> ... <form action=""
					method="POST"> Name: <@spring.bind
					"command.name" /> <input type="text"
					name="${spring.status.expression}"
					value="${spring.status.value?default("")}"
					/><br> <#list
					spring.status.errorMessages as error>
					<b>${error}</b> <br>
					</#list> <br> ... <input
					type="submit" value="submit"/> </form> ...
					</html>
				

#springBind / <@spring.bind> 需要一个'path'属性，格式为命令对象的名字（默认值为'command'， 除非你在配置FormController的属性时改变它）后跟圆点再加上你希望绑定到的命令对象的属性名。 你也可以使用类似“command.address.street”的格式来处理嵌套对象。使用 bind宏时，HTML转码行为由web.xml中名为 defaultHtmlEscape的ServletContext参数指定。

上述宏的另一种可选形式是 #springBindEscaped / <@spring.bindEscaped> ，它另外接受一个布尔型参数，显式指定了输出值或错误信息这些状态信息时是否使用HTML转码。 附加的表单处理宏简化了HTML转码的使用，只要有可能，你就应该使用它们。关于它们的细节将在下节讲述。

为这两种语言附加的一些很方便的宏同时简化了表单绑定和表单生成（包括显示校验错误信息）。 不需要使用这些宏来生成表单输入域，它们可以被混杂并匹配到简单HTML，或者直接调用前面讲过的spring绑定宏。

下表展示了可用的宏的VTL定义和FTL定义，以及它们需要的参数。

* 在FTL（FreeMarker）中，这二种宏实际上并不是必需的，因为你可以使用普通的 formInput 宏，指定fieldType 参数的值为 'hidden ' 或 'password'即可 。

上面列出的所有宏的参数都具有一致的含义，如下述：

宏的例子在下面描述，其中一些是FTL的，一些是VTL的。两种语言之间的用法差别在旁注中解释。

							<!-- 上面提到的Name域的例子，使用VTL中定义的表单宏 -->
							... Name: #springFormInput("command.name"
							"")<br> #springShowErrors("<br>"
							"")<br>
						

						<@spring.formInput "command.name"/>
						<@spring.showErrors "<br>"/>
					

						Name: <input type="text" name="name" value=""
						> <br> <b>required</b>
						<br> <br>
					

						... Town: <@spring.formRadioButtons
						"command.address.town", cityMap, ""
						/><br><br>
					

						Town: <input type="radio" name="address.town"
						value="London"> London <input type="radio"
						name="address.town" value="Paris"
						checked="checked"> Paris <input
						type="radio" name="address.town" value="New
						York"> New York
					

						protected Map referenceData(HttpServletRequest
						request) throws Exception { Map cityMap = new
						LinkedHashMap(); cityMap.put("LDN", "London");
						cityMap.put("PRS", "Paris"); cityMap.put("NYC",
						"New York");

						Map m = new HashMap(); m.put("cityMap",
						cityMap); return m; }
					

						Town: <input type="radio" name="address.town"
						value="LDN"> London <input type="radio"
						name="address.town" value="PRS"
						checked="checked"> Paris <input
						type="radio" name="address.town" value="NYC">
						New York
					

缺省情况下使用上面这些宏将产生符合HTML 4.01标准的标签，并且Spring的绑定支持使用web.xml中定义的HTML转码行为。为了产生符合XHTML标准的标签以及覆盖默认的HTML转码行为，你可以在你的模板（或者模板可见的模型对象）中指定两个变量。在模板中指定的好处是稍后的模板处理中可以为表单中不同的域指定不同的行为。

要切换到符合XHTML的输出，你可以设置model/context变量xhtmlCompliant的值为true：

					## for Velocity.. #set($springXhtmlCompliant = true)

					<#-- for FreeMarker --> <#assign
					xhtmlCompliant = true in spring>
				

在进行完这些处理之后，由Spring宏产生的所有标签都符合XHTML标准了。

类似地，可以为每个输入域指定HTML转码行为：

					<#-- 该句覆盖默认HTML转码行为 -->

					<#assign htmlEscape = true in spring> <#--
					next field will use HTML escaping -->
					<@spring.formInput "command.name" />

					<#assign htmlEscape = false in spring> <#--
					all future fields will be bound with HTML escaping
					off -->
				

这是一个简单的Spring应用的标准配置。dispatcher servlet配置文件包含一个指向 ViewResolver的引用、URL映射和一个简单的实现了我们的词语生成逻辑的controller bean：

<bean id="homeController"class="xslt.HomeController"/>

它实现了我们的词语生成“逻辑”。

控制器逻辑封装在一个AbstractController的子类，它的handler方法定义如下：

protected ModelAndView handleRequestInternal(
    HttpServletRequest request,
    HttpServletResponse response) throws Exception {
        
    Map map = new HashMap();
    List wordList = new ArrayList();
        
    wordList.add("hello");
    wordList.add("world");
       
    map.put("wordList", wordList);
      
    return new ModelAndView("home", map);
}

到目前为止，我们还没有做什么特定于XSLT的事情。在任何一种Spring MVC应用中，模型数据都以同样的方式被创建。 现在根据应用的配置，词语列表可以作为请求属性加入从而被JSP/JSTL渲染，或者通过加入 VelocityContext来被Velocity处理。 为了使用XSLT渲染它们，应该以某种方式把它们转化为XML文档。有些软件包能自动完成对象图到XML文档对象模型的转化。 但在Spring中，你有完全的自由度，能以任何方式完成从模型数据到XML的转化。 这可以防止XML转化部分在你的模型结构中占据太大的比重，使用额外工具来管理转化过程是一种风险。

为了从词语列表或任何其他模型数据创建XML文档，我们必须创建一个 org.springframework.web.servlet.view.xslt.AbstractXsltView 的子类， 通常我们也必须实现抽象方法 createXsltSource(..)s。其第一个参数即model Map。 下面是我们这个小应用中 HomePage类的完整代码:

package xslt;

// imports omitted for brevity
					

public class HomePage extends AbstractXsltView {

    protected Source createXsltSource(Map model, String rootName, HttpServletRequest
        request, HttpServletResponse response) throws Exception {

        Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
        Element root = document.createElement(rootName);

        List words = (List) model.get("wordList");
        for (Iterator it = words.iterator(); it.hasNext();) {
            String nextWord = (String) it.next();
            Element wordNode = document.createElement("word");
            Text textNode = document.createTextNode(nextWord);
            wordNode.appendChild(textNode);
            root.appendChild(wordNode);
        }
        return new DOMSource(root);
    }

}

你可以在上述子类中定义一些传给转化对象的参数，它们由健值对（name/value pairs）构成， 其中参数名必须与XSLT模板中定义的 <xsl:param name="myParam">defaultValue</xsl:param> 一致。 为了指定这些参数，你需要覆写继承自 AbstractXsltView的getParameters() 方法并返回一个包含健值对的 Map。 如果你需要从当前请求中获取信息，你可以选择覆写 getParameters(HttpServletRequest request) 方法。（这个方法只有Spring 1.1以后的版本才支持。）

比起JSTL和Velocity，XSLT对本地货币和日期格式的支持相对较弱。 基于这点，Spring提供了一个辅助类，你可以在 createXsltSource(..) 方法中调用它来获得这样的支持。 请参考 org.springframework.web.servlet.view.xslt.FormatHelper 类的Javadoc。

对于“写在段首”中的只有一个视图的情况来说，views.properties文件（或者等价的xml文件，如果你用一种基于XML的视图解析器的话，就像在上面的Velocity例子中）看起来是这样的：

home.class=xslt.HomePage
home.stylesheetLocation=/WEB-INF/xsl/home.xslt
home.root=words

这里你可以看到，第一个属性 '.class' 指定了视图类，即我们的HomePage ，其中完成从模型数据到XML文档的转化。 第二个属性 'stylesheetLocation' 指定了XSLT文件的位置，它用于完成从XML到HTML的转化。 最后一个属性 '.root' 指定了用作XML文档根元素的名字，它被作为 createXsltSource(..) 方法的第二个参数传给HomePage类。

最后，我们有一段转换上述文档的XSLT代码。 正如在 'views.properties'中看到的，它被命名为 'home.xslt'，存放在war文件中的 'WEB-INF/xsl'目录下。

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

    <xsl:output method="html" omit-xml-declaration="yes"/>

    <xsl:template match="/">
        <html>
            <head><title>Hello!</title></head>
            <body>
                <h1>My First Words</h1>
                <xsl:apply-templates/>
            </body>
        </html>
    </xsl:template>

    <xsl:template match="word">
        <xsl:value-of select="."/><br/>
    </xsl:template>

</xsl:stylesheet>

首先，我们修改view.properties（或等价的xml文件），增加两种文档类型的视图定义。整个文件现在看起来是这个样子：

						home.class=xslt.HomePage
						home.stylesheetLocation=/WEB-INF/xsl/home.xslt
						home.root=words

						xl.class=excel.HomePage

						pdf.class=pdf.HomePage
					

如果你想在一个电子表格模板基础上添加模型数据，可以在视图定义中为'url'属性指定一个文件位置。

这里用的controller代码，除了视图名以外，其他的与XSLT例子中的完全一样。 当然，你可能有更聪明的做法，通过URL参数或其他方式选择视图名，这也证明了Spirng在控制器与视图的解耦方面确实非常优秀！

和在XSLT例子中一样，我们需要从适当的抽象类扩展一个具体类，以实现输出文档的行为。 对Excel来说，这意味着创建一个 org.springframework.web.servlet.view.document.AbstractExcelView （使用POI）或 org.springframework.web.servlet.view.document.AbstractJExcelView （使用JExcelApi）的子类， 并实现 buildExcelDocument方法。

下面是一段使用POI生成Excel视图的完整代码，它从模型数据中取得词语列表，把它显示为电子表格中第一栏内连续的行：

						package excel;

						// imports omitted for brevity

						public class HomePage extends AbstractExcelView
						{

						protected void buildExcelDocument( Map model,
						HSSFWorkbook wb, HttpServletRequest req,
						HttpServletResponse resp) throws Exception {

						HSSFSheet sheet; HSSFRow sheetRow; HSSFCell
						cell;

						// Go to the first sheet // getSheetAt: only if
						wb is created from an existing document //sheet
						= wb.getSheetAt( 0 ); sheet =
						wb.createSheet("Spring");
						sheet.setDefaultColumnWidth((short)12);

						// write a text at A1 cell = getCell( sheet, 0,
						0 ); setText(cell,"Spring-Excel test");

						List words = (List ) model.get("wordList"); for
						(int i=0; i < words.size(); i++) { cell =
						getCell( sheet, 2+i, 0 ); setText(cell, (String)
						words.get(i));

						} } }
					

这是一个使用JExcelApi的版本，生成同样的Excel文件：

						package excel;

						// imports omitted for brevity

						public class HomePage extends AbstractExcelView
						{

						protected void buildExcelDocument(Map model,
						WritableWorkbook wb, HttpServletRequest request,
						HttpServletResponse response) throws Exception {

						WritableSheet sheet = wb.createSheet("Spring");

						sheet.addCell(new Label(0, 0, "Spring-Excel
						test");

						List words = (List)model.get("wordList"); for
						(int i = -; i < words.size(); i++) {
						sheet.addCell(new Label(2+i, 0,
						(String)words.get(i)); } } }
					

注意这些API间的差别。我们发现JExcelApi使用起来更直观，而且在图像处理方面更好。 但也发现使用JExcelApi处理大文件时存在内存问题。

如果你现在修改controller的代码，让它返回名为 xl 的视图（ return new ModelAndView("xl", map); ）， 然后再次运行你的应用，你会发现，当你请求同样的页面时，Excel电子表格被创建出来并自动开始下载。

生成PDF版本的词语列表就更简单了。 现在，你创建一个 org.springframework.web.servlet.view.document.AbstractPdfView 的子类，并实现 buildPdfDocument()方法，如下：

						package pdf;

						// imports omitted for brevity

						public class PDFPage extends AbstractPdfView {

						protected void buildPdfDocument( Map model,
						Document doc, PdfWriter writer,
						HttpServletRequest req, HttpServletResponse
						resp) throws Exception {

						List words = (List) model.get("wordList");

						for (int i=0; i<words.size(); i++) doc.add(
						new Paragraph((String) words.get(i)));

						} }
					

同样地，修改controller，让它返回名为 pdf 的视图（ return new ModelAndView("pdf", map); ）， 运行应用并请求同样的URL，这次将会打开一个PDF文档，列出模型数据中的每个词语。

通常，你会使用ResourceBundleViewResolver 来根据一个属性文件把视图名映射到视图类和相关文件：

<bean id="viewResolver" class="org.springframework.web.servlet.view.ResourceBundleViewResolver">
    <property name="basename" value="views"/>
</bean>

这里我们已经定义了一个 ResourceBundleViewResolver 的实例， 它将通过基名（base name） views 在资源文件中查找视图映射。 这个文件的详细内容将在下节内容叙述。

Spring中包含了JasperReports的五种视图实现，其中四种对应到JasperReports支持的四种输出格式，另一种支持在运行时确定输出格式。

把这些类映射到视图名和报表文件只需要简单地在前述资源文件中添加适当的条目。如下：

					simpleReport.class=org.springframework.web.servlet.view.jasperreports.JasperReportsPdfView
					simpleReport.url=/WEB-INF/reports/DataSourceReport.jasper
				

这里你可以看到名为simpleReport 的视图被映射到JasperReportsPdfView 类。 这将产生PDF格式的报表输出。该视图的url属性被设置为底层报表文件的位置。

JasperReports有两种不同的报表文件：一种是设计文件，以 .jrxml 为扩展名；另一种是编译后的格式，以 .jasper 为扩展名。 通常，你使用JasperReports自带的Ant任务来把你的 .jrxml 文件编译为 .jasper 文件，然后部署到应用中。 在Spring里你可以把任一种设计文件映射到报表文件，Spring能帮你自动编译 .jrxml 文件。 但你要注意， .jrxml 被编译后即缓存起来并在整个应用活动期间有效，如果你要做一些改动，就得重启应用。

JasperReportsMultiFormatView 允许在运行时指定报表格式， 真正解析报表委托给其它JasperReports的view类 - JasperReportsMultiFormatView类简单地增加了一层包装，允许在运行时准确地指定实现。

JasperReportsMultiFormatView 类引入了两个概念：format key和discriminator key。 JasperReportsMultiFormatView 使用mapping key来查找实际实现类，而使用format key来查找mapping key。 从编程角度来说，你在model中添加一个条目，以format key作键并以mapping key作值，例如：

					public ModelAndView
					handleSimpleReportMulti(HttpServletRequest request,
					HttpServletResponse response) throws Exception {

					String uri = request.getRequestURI(); String format
					= uri.substring(uri.lastIndexOf(".") + 1);

					Map model = getModel(); model.put("format", format);

					return new ModelAndView("simpleReportMulti", model);
					}
				

在这个例子中，mapping key由 request URI的扩展名来决定，并以默认的format key值 format 加入了model。 如果希望使用不同的format key，你可以使用 JasperReportsMultiFormatView 类的formatKey属性来配置它。

JasperReportsMultiFormatView中默认已经配置了下列mapping key：

所以上例中一个对/foo/myReport.pdf的请求将被映射至 JasperReportsPdfView。 你可以使用 JasperReportsMultiFormatView 的formatMappings属性覆盖mapping key到视图类的映射配置。

使用Spring时，为了控制哪个子报表文件被包含，你的报表文件必须被配置为能够从外部来源接受子报表。 要完成这些你得在报表文件中声明一个参数，像这样：

						<parameter name="ProductsSubReport"
						class="net.sf.jasperreports.engine.JasperReport"/>
					

然后，你用这个参数定义一个子报表：

						<subreport> <reportElement
						isPrintRepeatedValues="false" x="5" y="25"
						width="325" height="20"
						isRemoveLineWhenBlank="true"
						backcolor="#ffcc99"/> <subreportParameter
						name="City">
						<subreportParameterExpression><![CDATA[$F{city}]]></subreportParameterExpression>
						</subreportParameter>
						<dataSourceExpression><![CDATA[$P{SubReportData}]]></dataSourceExpression>
						<subreportExpression
						class="net.sf.jasperreports.engine.JasperReport">
						<![CDATA[$P{ProductsSubReport}]]></subreportExpression>
						</subreport>
					

这样就定义了一个主报表文件，接受一个名为 ProductsSubReport 的参数， 它的值是一个 net.sf.jasperreports.engine.JasperReports 类型实例。 然后配置Jasper视图类时，你通过使用 subReportUrls 属性来告诉Spring载入一个报表文件并作为子报表传递给JasperReports引擎。

						<property name="subReportUrls">
						<map> <entry key="ProductsSubReport"
						value="/WEB-INF/reports/subReportChild.jrxml"/>
						</map> </property>
					

这里Map 中的key对应于报表设计文件中子报表参数的名字，它的值代表子报表文件的URL。 Spring将载入该文件，需要的话进行编译，然后以给定的key为参数名传递给JasperReports引擎。

当使用Spring配置子报表时，这一步完全是可选的。如果你喜欢，仍可以使用静态查询作为子报表的数据源。 然而，如果你希望Spring把你返回的 ModelAndView中的数据转化为 JRDataSource， 你就得告诉Spring ModelAndView 中的那个参数需要被转化。 实际操作时，你需要使用所选视图类的 subReportDataKeys 属性，为其配置一个参数名列表：

						<property name="subReportDataKeys"
						value="SubReportData"/>
					

这里提供的key值必须与ModelAndView和报表设计文件中使用的key值对应。