由于种种原因，许多团队倾向于使用其他的web框架。比如，某些团队已经在其他的技术和工具方面进行了投入，他们希望充分利用已有的经验。另外，Struts不仅有大量的书籍和工具，而且有许多开发者熟悉它。因此，如果你能忍受Struts的架构性缺陷，它仍然是web层一个不错的选择。WebWork和其它的web框架也是这样。

如果你不想使用Spring的web MVC框架，但仍希望使用Spring提供的其它功能，你可以很容易地将你选择的web框架和Spring结合起来。只需通过Spring的ContextLoadListener启动一个root application context，你就可以在Struts或WebWork的Action中，通过ServletContext属性（或者Spring提供的相应辅助方法）进行访问。请注意我们没有提到任何具体的“plugins”，因此也不必提及如何集成。从web层的角度看，你可以以root application context实例为入口，把Spring作为一个library使用。

即便你不使用Spring的web框架，经注册的所有bean和所有Spring服务仍然可以使用。从这个用法上来讲，Spring并没有和Struts或WebWork竞争，它只是提供这些纯粹的web框架所没有的功能，例如：bean的配置、数据访问和事务处理。因此你可以使用Spring的中间层或者数据访问层来增强你的应用，即便你只是需要使用像JDBC或Hibernate事务抽象这样的功能。

Spring Web MVC框架提供了大量独特的功能，包括:

为了提供一套基础设施，所有的Spring控制器都继承了 AbstractController ，AbstractController 提供了诸如缓存支持和mimetype设置这样的功能。

当从AbstractController继承时，需要实现handleRequestInternal(HttpServletRequest, HttpServletResponse)抽象方法，该方法将用来实现自己的逻辑，并返回一个ModelAndView对象。下面这个简单的例子演示了如何从AbstractController继承以及如何在applicationContext.xml中进行配置

package samples;

public class SampleController extends AbstractController {

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

        ModelAndView mav = new ModelAndView("hello");
        mav.addObject("message", "Hello World!");
        return mav;        
    }
}

<bean id="sampleController" class="samples.SampleController">
    <property name="cacheSeconds" value="120"/>
</bean>

该controller返回的ModelAndView使用了硬编码的视图名（尽管这样做不好），并通知客户端将响应数据缓存2分钟。除了通过以上方式创建和配置controller之外，还需要配置handler mapping(请参考Section 13.4, “处理器映射（handler mapping）”)，这样该controller就可以工作了。

尽管可以继承AbstractController来实现自己的控制器，不过Spring提供的众多控制器减轻了我们开发简单MVC应用时的负担。ParameterizableViewController基本上和上面例子中的一样，不同的是，你可以在applicationContext.xml配置中指定返回视图名从而避免了在Java代码中的硬编码。

UrlFilenameViewController会检查URL，获取文件请求的文件名，并把它作为视图名加以使用。。例如，http://www.springframework.org/index.html对应的视图文件名是index。

MultiActionController将多个行为(action)合并在一个控制器里，这样可以把相关功能组合在一起。MultiActionController位于org.springframework.web.mvc.multiaction包中，它通过将请求映射到正确的方法名来调用方法。当在一个控制器存在大量公共的行为，但是有多个调用入口时，使用MultiActionController就特别方便。

MultiActionController所支持的方法需要符合下列格式：

// anyMeaningfulName can be replaced by any methodname
public [ModelAndView | Map | void] anyMeaningfulName(HttpServletRequest, HttpServletResponse [, Exception | AnyObject]);

注意：在此不允许方法重载，因为MultiActionController无法分辨出重载（overloading）了的方法。此外，你可以定义exception handler来处理方法中抛出的异常。

Exception 参数是可选的，它可以是任何异常，只要它是java.lang.Exception或java.lang.RuntimeException的子类。AnyObject参数也是可选的，它可以是任何对象。HTTP Request中的参数会存在这个对象中，以便使用。

下面几个例子示范了MultiActionController正确的方法定义。

标准格式(跟Controller接口定义的一样)。

public ModelAndView doRequest(HttpServletRequest, HttpServletResponse)

下面这个方法支持Login参数， 这个参数中包含从请求中抽取出来的信息。

public ModelAndView doLogin(HttpServletRequest, HttpServletResponse, Login)

下面这个方法可以处理Exception。

public ModelAndView processException(HttpServletRequest, HttpServletResponse, IllegalArgumentException)

下面这个方法不返回任何数值。 (请参考后面的章节 Section 13.11, “惯例优先原则(convention over configuration)”)

public void goHome(HttpServletRequest, HttpServletResponse)

This signature has a Map return type (see the section entitled Section 13.11, “惯例优先原则(convention over configuration)” below).

下面这个方法返回一个Map。 (请参考后面的章节Section 13.11, “惯例优先原则(convention over configuration)”)

public Map doRequest(HttpServletRequest, HttpServletResponse)

MethodNameResolver负责从请求中解析出需要调用的方法名称。下面是Spring中内置的三个MethodNameResolver 实现。

我们来看一组例子。首先是一个使用ParameterMethodNameResolver和代理（delegate）属性的例子，它接受包含参数名"method"的请求，调用方法retrieveIndex：

<bean id="paramResolver" class="org....mvc.multiaction.ParameterMethodNameResolver">
  <property name="paramName" value="method"/>
</bean>

<bean id="paramMultiController" class="org....mvc.multiaction.MultiActionController">
  <property name="methodNameResolver" ref="paramResolver"/>
  <property name="delegate" ref="sampleDelegate"/>
</bean>

<bean id="sampleDelegate" class="samples.SampleDelegate"/>

## together with

public class SampleDelegate {

    public ModelAndView retrieveIndex(HttpServletRequest req, HttpServletResponse resp) {

        return new ModelAndView("index", "date", new Long(System.currentTimeMillis()));
    }
}

当使用上面的代理对象时，我们也可以使用PropertiesMethodNameRseolver来匹配一组URL，将它们映射到我们定义的方法上：

<bean id="propsResolver" class="org....mvc.multiaction.PropertiesMethodNameResolver">
  <property name="mappings">
    <value>
        /index/welcome.html=retrieveIndex
        /**/notwelcome.html=retrieveIndex
        /*/user?.html=retrieveIndex
    </value>
  </property>
</bean>

<bean id="paramMultiController" class="org....mvc.multiaction.MultiActionController">
    <property name="methodNameResolver" ref="propsResolver"/>
    <property name="delegate" ref="sampleDelegate"/>
</bean>

Spring的CommandController是Spring MVC的重要部分。命令控制器提供了一种和数据对象交互的方式，并动态地将来自HttpServletRequest的参数绑定到你指定的数据对象上。它的功能和Struts中的ActionForm有点像，不过在Spring中，你不需要实现任何接口来实现数据绑定。首先，让我们看一下有哪些可以使用的命令控制器：

BeanNameUrlHandlerMapping是一个简单但很强大的处理器映射，它将收到的HTTP请求映射到bean的名字上（这些bean需要在web应用上下文中定义）。例如，为了实现一个用户新建账号的功能，我们提供了FormController （关于CommandController和FormController请参考Section 13.3.4, “命令控制器”）和显示表单的JSP视图（或Velocity模版）。当使用BeanNameUrlHandlerMapping时，我们用如下方式将包含http://samples.com/editaccount.form的访问请求映射到指定的FormController上：

<beans>
  <bean id="handlerMapping" class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

  <bean name="/editaccount.form" class="org.springframework.web.servlet.mvc.SimpleFormController">
    <property name="formView" value="account"/>
    <property name="successView" value="account-created"/>
    <property name="commandName" value="account"/>
    <property name="commandClass" value="samples.Account"/>
  </bean>
<beans>

所有对/editaccount.form的请求就会由上面的FormController处理。当然我们得在web.xml中定义servlet-mapping，接受所有以.form结尾的请求。

<web-app>
    ...
    <servlet>
        <servlet-name>sample</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

   <!-- maps the sample dispatcher to *.form -->
    <servlet-mapping>
        <servlet-name>sample</servlet-name>
        <url-pattern>*.form</url-pattern>
    </servlet-mapping>
    ...
</web-app>

	Note
	要使用BeanNameUrlHandlerMapping，无须（如上所示）在web应用上下文中定义它。缺省情况下，如果在上下文中没有找到处理器映射，DispatcherServlet会为你创建一个BeanNameUrlHandlerMapping！

另一个更强大的处理器映射是SimpleUrlHandlerMapping。它在应用上下文中可以进行配置，并且有Ant风格的路径匹配功能。(请参考org.springframework.util.PathMatcher的JavaDoc)。下面几个例子可以帮助理解：

<web-app>
    ...
    <servlet>
        <servlet-name>sample</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!-- maps the sample dispatcher to *.form -->
    <servlet-mapping>
        <servlet-name>sample</servlet-name>
        <url-pattern>*.form</url-pattern>
    </servlet-mapping>

    <!-- maps the sample dispatcher to *.html -->
    <servlet-mapping>
        <servlet-name>sample</servlet-name>
        <url-pattern>*.html</url-pattern>
    </servlet-mapping>
    ...
</web-app>

The above web.xml configuration snippet enables all requests ending with .html and .form to be handled by the sample dispatcher servlet.

上面的web.xml设置允许所有以.html和.form结尾的请求都由这个sample DispatcherServlet处理。

<beans>
        
    <!-- no 'id' required, HandlerMapping beans are automatically detected by the DispatcherServlet -->
    <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
            <value>
                /*/account.form=editAccountFormController
                /*/editaccount.form=editAccountFormController
                /ex/view*.html=helpController
                /**/help.html=helpController
            </value>
        </property>
    </bean>

    <bean id="helpController"
          class="org.springframework.web.servlet.mvc.UrlFilenameViewController"/>

    <bean id="editAccountFormController"
          class="org.springframework.web.servlet.mvc.SimpleFormController">
        <property name="formView" value="account"/>
        <property name="successView" value="account-created"/>
        <property name="commandName" value="Account"/>
        <property name="commandClass" value="samples.Account"/>
    </bean>
<beans>

这个处理器映射首先将对所有目录中文件名为help.html的请求传递给helpController。 helpController是一个UrlFilenameViewController (要了解更多关于控制器的信息，请参阅 Section 13.3, “控制器”)。对ex目录中所有以view开始，以.html 结尾的请求都会被传递给helpController。 同样的，我们也为editAccountFormController定义了两个映射。

Spring的处理器映射支持拦截器。当你想要为某些请求提供特殊功能时，例如对用户进行身份认证，这就非常有用。

处理器映射中的拦截器必须实现org.springframework.web.servlet包中的HandlerInterceptor接口。这个接口定义了三个方法，一个在处理器执行前被调用，一个在处理器执行后被调用，另一个在整个请求处理完后调用。这三个方法提供你足够的灵活度做任何处理前后的操作。

preHandle(..)方法有一个boolean返回值。使用这个值，你可以调整执行链的行为。当返回true时，处理器执行链将继续执行，当返回false时，DispatcherServlet认为该拦截器已经处理完了请求（比如显示正确的视图），而不继续执行执行链中的其它拦截器和处理器。

下面的例子提供了一个拦截器，它拦截所有请求，如果当前时间不是在上午9点到下午6点，它将用户重定向到某个页面。

<beans>
    <bean id="handlerMapping"
          class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="interceptors">
            <list>
                <ref bean="officeHoursInterceptor"/>
            </list>
        </property>
        <property name="mappings">
            <value>
                /*.form=editAccountFormController
                /*.view=editAccountFormController
            </value>
        </property>
    </bean>

    <bean id="officeHoursInterceptor"
          class="samples.TimeBasedAccessInterceptor">
        <property name="openingTime" value="9"/>
        <property name="closingTime" value="18"/>
    </bean>
<beans>

package samples;

public class TimeBasedAccessInterceptor extends HandlerInterceptorAdapter {

    private int openingTime;
    private int closingTime;

    public void setOpeningTime(int openingTime) {
        this.openingTime = openingTime;
    }

    public void setClosingTime(int closingTime) {
        this.closingTime = closingTime;
    }

    public boolean preHandle(
            HttpServletRequest request,
            HttpServletResponse response,
            Object handler) throws Exception {

        Calendar cal = Calendar.getInstance();
        int hour = cal.get(HOUR_OF_DAY);
        if (openingTime <= hour < closingTime) {
            return true;
        } else {
            response.sendRedirect("http://host.com/outsideOfficeHours.html");
            return false;
        }
    }
}

所有的请求都将被TimeBasedAccessInterceptor截获，如果当前时间不在上班时间，用户会被重定向到一个静态html页面，提供诸如只有上班时间才能访问网站之类的告示。

Spring还提供了一个adapter类HandlerInterceptorAdapter让用户更方便的扩展HandlerInterceptor接口。

正如前面（Section 13.3, “控制器”）所讨论的，SpringWeb框架的所有控制器都返回一个ModelAndView实例。Sprnig中的视图以名字为标识，视图解析器通过名字来解析视图。Spring提供了多种视图解析器。我们将举例加以说明。

举例来说，当使用JSP作为视图层技术时，就可以使用UrlBasedViewResolver。这个视图解析器会将视图名解析成URL，并将请求传递给RequestDispatcher来显示视图。

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

当返回的视图名为test时，这个视图解析器将请求传递给RequestDispatcher，RequestDispatcher再将请求传递给/WEB-INF/jsp/test.jsp。

当在一个web应用中混合使用不同的视图技术时，你可以使用ResourceBundleViewResolver:

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

ResourceBundleViewResolver通过basename所指定的ResourceBundle解析视图名。对每个待解析的视图，ResourceBundle里的[视图名].class所对应的值就是实现该视图的类。同样，[视图名].url所对应的值是该视图所对应的URL。从上面的例子里你也可以发现，你可以指定一个parent view，其它的视图都可以从parent view扩展。用这种方法，你可以声明一个默认的视图。

关于视图缓存的注意事项 －－继承AbstractCachingViewResolver的解析器可以缓存它曾经解析过的视图。当使用某些视图技术时，这可以大幅度的提升性能。你也可以关掉缓存功能，只要把cache属性设成false就可以了。而且，如果你需要在系统运行时动态地更新某些视图（比如，当一个Velocity模板被修改了），你可以调用removeFromCache(String viewName, Locale loc)方法来达到目的。

Spring支持多个视图解析器一起使用。你可以把它们当作一个解析链。这样有很多好处，比如在特定情况下重新定义某些视图。定义视图解析链很容易，只要在应用上下文中定义多个解析器就可以了。必要时，也可以通过order属性来声明每个解析器的序列。你要记住的是，某个解析器的order越高, 它在解析链中的位置越靠后。

下面这个例子展示了一个包含两个解析器的解析链。一个是InternalResourceViewResolver，这个解析器总是被自动的放到链的末端。另一个是XmlViewResolver，它 支持解析Excel视图（而InternalResourceViewResolver不可以）。

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

<bean id="excelViewResolver" class="org.springframework.web.servlet.view.XmlViewResolver">
  <property name="order" value="1"/>
  <property name="location" value="/WEB-INF/views.xml"/>
</bean>

<!-- in views.xml -->

<beans>
  <bean name="report" class="org.springframework.example.ReportExcelView"/>
</beans>

如果某个解析器没有找到合适的视图，Spring会在上下文中寻找是否配置了其它的解析器。如果有，它会继续进行解析，否则，Srping会抛出一个Exception。

你要记住，当一个视图解析器找不到合适的视图时，它可能 返回null值。但是，不是每个解析器都这么做。 这是因为，在某些情况下，解析器可能无法侦测出符合要求的视图是否存在。比如，InternalResourceViewResolver在内部调用了RequestDispatcher。请求分发是检查一个JSP文件是否存在的唯一方法，不幸的是，这个方法只能用一次。同样的问题在VelocityViewResolver和其它解析器中也有。当你使用这些解析器时，你最好仔细阅读它们的Javadoc，看看你需要的解析器是否无法发现不存在的视图。这个问题产生的副作用是，如果InternalResourceViewResolver解析器没有放在链的末端，InternalResourceViewResolver后面的那些解析器根本得不到使用，因为InternalResourceViewResolver总是返回一个视图！

在前面我们提到过，一个控制器通常会返回视图名，然后由视图解析器解析到某种视图实现。对于像JSP这样实际上由Servlet/JSP引擎处理的视图，我们通常使用InternalResourceViewResolver和InternalResourceView。这种视图实现最终会调用Servlet API的RequestDispatcher.forward(..)方法或RequestDispatcher.include()方法将用户指向最终页面。对于别的视图技术而言（比如Velocity、XSLT等等）， 视图本身就会生成返回给用户的内容。

有些时候，在视图显示以前，我们可能需要给用户发一个HTTP redirect重定向指令。比如，一个控制器成功的处理了一个表单提交（数据以HTTP POST的方式发送），它最终可能委托给另一个控制器来完成剩下的工作。在这种情况下，如果我们使用内部forward，接手工作的那个控制器将会得到所有以POST方式提交的表单数据，这可能会引起潜在的混淆，干扰那个控制器的正常工作。 另一个在显示视图之前返回HTTP redirect的原因是这可以防止用户重复提交同一表单。具体一点讲，浏览器先用POST的方式提交表单,然后它接收到重定向的指令，它继续用GET的方式去下载新的页面。从浏览器的角度看，这个新的页面不是POST的返回结果，而是GET的。这样，用户不可能在点击刷新的时候不小心再次提交表单，因为刷新的结果是再次用GET 去下载表单提交后的结果页面，而不是重新提交表单。

这个本地化解析器检查请求中客户端浏览器发送的accept-language 信息，通常这个HTTP Header包含客户端操作系统的本地化信息。

这个本地化解析器检查客户端中的Cookie是否包含本地化信息。如果有的话，就使用。当你配置这个解析器的时候，你可以指定cookie名，以及cookie的最长生存期(Max Age)。 下面这个例子定义了一个CookieLocaleResolver。

<bean id="localeResolver">

    <property name="cookieName" value="clientlanguage"/>
    
    <!-- in seconds. If set to -1, the cookie is not persisted (deleted when browser shuts down) -->
    <property name="cookieMaxAge" value="100000">

</bean>

SessionLocaleResolver允许你从用户请求相关的session中获取本地化信息。

你可以使用LocaleChangeInterceptor修改本地化信息。这个拦截器需要被添加到处理器映射中（参考Section 13.4, “处理器映射（handler mapping）”）。它可以侦测请求中某个特定的参数，然后调用上下文中的LocaleResolver中的 setLocale()方法，相应地修改本地化信息。

<bean id="localeChangeInterceptor"
      class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor">
    <property name="paramName" value="siteLanguage"/>
</bean>

<bean id="localeResolver"
      class="org.springframework.web.servlet.i18n.CookieLocaleResolver"/>

<bean id="urlMapping"
      class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
    <property name="interceptors">
        <list>
            <ref bean="localeChangeInterceptor"/>
        </list>
    </property>
    <property name="mappings">
        <value>/**/*.view=someController</value>
    </property>
</bean>

在上面这个例子中，所有对*.view资源的请求，只要包含参数siteLanguage，都会改变本地化信息。比如下面这个请求http://www.sf.net/home.view?siteLanguage=nl会将网站语言修改为荷兰语。

Sping的web MVC框架允许你通过主题(theme)来控制网页的风格，这将进一步改善用户的体验。 简单来说，一个主题就是一组静态的资源（比如样式表和图片），它们可以影响页面的视觉效果。

为了在你的web应用中使用主题，你需要设置org.springframework.ui.context.ThemeSource。 WebApplicationContext是从ThemeSource扩展而来，但是它本身并没有实现ThemeSource定义的方法，它把这些任务转交给别的专用模块。如果没有明确设置，真正实现ThemeSource的类是org.springframework.ui.context.support.ResourceBundleThemeSource。这个类在classpath的根部（比如在/WEB-INF/classes目录下）寻找合适的属性文件来完成配置。如果你想自己实现ThemeSource接口，或者你需要配置ResourceBundleThemeSource所需的属性文件的前缀名(basename prefix)，你可以在应用上下文中定义一个名为"themeSource"的bean（注意，你必须用这个名字）。web application context会自动检测并使用这个bean。

在使用ResourceBundleThemeSource时， 每个主题是用一个属性文件来配置的。这个属性文件中列举了构成一个主题所需的资源。比如:

styleSheet=/themes/cool/style.css
background=/themes/cool/img/coolBg.jpg

这些属性的名字应该和视图中的某些主题元素(themed element)一一对应。在JSP视图中，这些元素通常用spring:theme标签声明（这个标签的用法和spring:message很相似）。下文这个JSP片段使用了我们在前面定义的主题：

<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>
<html>
   <head>
      <link rel="stylesheet" href="<spring:theme code="styleSheet"/>" type="text/css"/>
   </head>
   <body background="<spring:theme code="background"/>">
      ...
   </body>
</html>

除非有特殊配置，当ResourceBundleThemeSource寻找所需的属性文件时，它默认在配置的属性文件名中没有任何前缀，也就是说，它只会在classpath的根部寻找。举例来说，如果一个主题的定义包含在cool.properties这个属性文件中，你需要把这个文件放在classpath的根部，比如在/WEB-INF/classes目录下。同时，ResourceBundleThemeSource 使用标准的Java resource bundle管理机制，这意味着实现主题的国际化是很容易的。比如，/WEB-INF/classes/cool_nl.properties这个属性文件中可以指向一个显示荷兰文字的图片。

译者注：如果你对ResourceBundle和它的属性文件名的规范不熟悉，请参阅JavaDoc中关于ResourceBundle.getBundle(String baseName,Locale locale)这个API。这个baseName参数和属性文件名有一定关系。比如，如果cool.properties这个属性文件放置在了/WEB-INF/classes/com/aa/bb/cc目录下，那么这个baseName的值应该为com.aa.bb.cc.cool。在这里，com.aa.bb.cc就是这个属性文件名的前缀(basename prefix)。支持前缀的API会在前缀所声明的目录下寻找相应的文件，比如getBundle(）。如果没有特殊的配置，ResourceBundleThemeSource不支持前缀，在这种情况下你要把它所需要的属性文件放在/WEB-INF/classes目录下。

现在我们已经知道如何定义主题了，剩下的事就是决定该用哪个主题。DispatcherServlet会寻找一个叫"themeResolver"的bean，这个bean应该实现了ThemeResolver接口。主题解析器的工作流程和LocaleResolver差不多。它可以解析每个请求所对应的主题，也可以动态地更换主题。下面是Spring提供的几个主题解析器：

Spring 也支持一个叫ThemeChangeInterceptor 的请求拦截器。它可以根据请求中包含的参数来动态地改变主题。

Spring支持web应用中的分段文件上传。这种支持是由即插即用的MultipartResolver来实现。这些解析器都定义在org.springframework.web.multipart包里。Spring提供了现成的MultipartResolver可以支持Commons FileUpload(http://jakarta.apache.org/commons/fileupload)和 COS FileUpload(http://www.servlets.com/cos)。本章后面的部分描述了Spring是如何支持文件上传的。

通常情况下，Spring是不处理文件上传的，因为一些开发者想要自己处理它们。如果想使用Spring的这个功能，需要在web应用的上下文中添加分段文件解析器。这样，每个请求就会被检查是否包含文件上传。如果没有，这个请求就被正常的处理，否则，应用上下文中已经定义的MultipartResolver就会被调用。然后，你请求中的文件属性就会像其它属性一样被处理。

下面的例子说明了如何使用CommonsMultipartResolver:

<bean id="multipartResolver"
    class="org.springframework.web.multipart.commons.CommonsMultipartResolver">

    <!-- one of the properties available; the maximum file size in bytes -->
    <property name="maxUploadSize" value="100000"/>
</bean>

下面这个例子使用CosMultipartResolver:

<bean id="multipartResolver" class="org.springframework.web.multipart.cos.CosMultipartResolver">

    <!-- one of the properties available; the maximum file size in bytes -->
    <property name="maxUploadSize" value="100000"/>
</bean>

当然你需要在classpath中为分段文件解析器提供正确的jar文件。如果是CommonsMultipartResolver，你需要使用commons-fileupload.jar，如果是CosMultipartResolver，则使用cos.jar。

你已经看到如何设置Spring处理文件上传请求，接下来我们看看如何使用它。当Spring的DispatcherServlet发现文件上传请求时，它会激活定义在上下文中的解析器来处理请求。这个解析器随后是将当前的HttpServletRequest封装成MultipartHttpServletRequest，后者支持分段文件上传。使用MultipartHttpServletRequest，你可以获取请求所包含的上传信息，甚至可以在控制器中获取分段文件的内容。

在MultipartResolver完成分段文件解析后，这个请求就会和其它请求一样被处理。为了使用文件上传，你需要创建一个带文件上传域(upload field)的（HTML）表单，让Spring将文件绑定到你的表单上(如下所示)：

<html>
    <head>
        <title>Upload a file please</title>
    </head>
    <body>
        <h1>Please upload a file</h1>
        <form method="post" action="upload.form" enctype="multipart/form-data">
            <input type="file" name="file"/>
            <input type="submit"/>
        </form>
    </body>
</html>

在上面这个表单里有一个input元素，这个元素的名字（“file”）和服务器端处理这个表单的bean（在下面将会提到）中类型为byte[]的属性名相同。 在这个表单里我们也声明了编码参数(enctype="multipart/form-data")以便让浏览器知道如何对这个文件上传表单进行编码（千万不要忘记这么做！）。

和其它不能自动转为字符串类型或者基本类型（primitive type)的属性一样，为了将上传的二进制数据存成bean的属性，你必须通过ServletRequestDatabinder注册一个属性编辑器。Spring中内置了几个这样的编辑器，它们可以处理文件，然后将结果存成bean的属性。比如，StringMultipartEditor可以将文件转换成一个字符串(使用用户声明的字符集)。ByteArrayMultipartEditor可以以将文件转换为byte数组。他们的功能和CustomDateEditor相似。

总而言之，为了使用表单上传文件，你需要声明一个解析器，一个控制器，再将文件上传的URL映射到控制器来处理这个请求。下面是这几个bean的声明。

<beans>
	<!-- lets use the Commons-based implementation of the MultipartResolver interface -->
    <bean id="multipartResolver"
        class="org.springframework.web.multipart.commons.CommonsMultipartResolver"/>

    <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
            <value>
                /upload.form=fileUploadController
            </value>
        </property>
    </bean>

    <bean id="fileUploadController" class="examples.FileUploadController">
        <property name="commandClass" value="examples.FileUploadBean"/>
        <property name="formView" value="fileuploadform"/>
        <property name="successView" value="confirmation"/>
    </bean>

</beans>

下面的代码定义了控制器和用来存放文件的那个bean。

public class FileUploadController extends SimpleFormController {

    protected ModelAndView onSubmit(
        HttpServletRequest request,
        HttpServletResponse response,
        Object command,
        BindException errors) throws ServletException, IOException {

         // cast the bean
        FileUploadBean bean = (FileUploadBean) command;

         let's see if there's content there
        byte[] file = bean.getFile();
        if (file == null) {
             // hmm, that's strange, the user did not upload anything
        }

         // well, let's do nothing with the bean for now and return
        return super.onSubmit(request, response, command, errors);
    }

    protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder)
        throws ServletException {
        // to actually be able to convert Multipart instance to byte[]
        // we have to register a custom editor
        binder.registerCustomEditor(byte[].class, new ByteArrayMultipartFileEditor());
        // now Spring knows how to handle multipart object and convert them
    }

}

public class FileUploadBean {

    private byte[] file;

    public void setFile(byte[] file) {
        this.file = file;
    }

    public byte[] getFile() {
        return file;
    }
}

FileUploadBean用一个byte[]类型的属性来存放文件。前面已经提到过，通常控制器注册一个自定义的编辑器以便让Spring知道如何将解析器找到的multipart对象转换成bean指定的属性，但在上面的例子中，我们除了将byte数组记录下来以外，没有对这个文件进行任何操作，在实际的应用程序中你可以做任何你想做的事情（比如将文件存储在数据库中，通过电子邮件发送给某人等等)。

在下面这个例子里，上传的文件被绑定为（表单支持的）对象（form backing object)的String属性：

public class FileUploadController extends SimpleFormController {

    protected ModelAndView onSubmit(
        HttpServletRequest request,
        HttpServletResponse response,
        Object command,
        BindException errors) throws ServletException, IOException {

         // cast the bean
        FileUploadBean bean = (FileUploadBean) command;

         let's see if there's content there
        String file = bean.getFile();
        if (file == null) {
             // hmm, that's strange, the user did not upload anything
        }

         // well, let's do nothing with the bean for now and return
        return super.onSubmit(request, response, command, errors);
    }

    protected void initBinder(HttpServletRequest request, ServletRequestDataBinder binder)
        throws ServletException {
        // to actually be able to convert Multipart instance to a String
        // we have to register a custom editor
        binder.registerCustomEditor(String.class, new StringMultipartFileEditor());
        // now Spring knows how to handle multipart object and convert them
    }

}

public class FileUploadBean {

    private String file;

    public void setFile(String file) {
        this.file = file;
    }

    public String getFile() {
        return file;
    }
}

如果仅仅是处理一个文本文件的上传，上面这个例子的做法还是合理的。但如果上传的是一张图片， 那段代码就会出问题。

最后的解决方法就是将表单支持对象（form backing object) 的相关属性设成MultipartFile类型。 这样的话，没有类型转换的需要，我们也就不需要声明任何属性编辑器（PropertyEditor）。

public class FileUploadController extends SimpleFormController {

    protected ModelAndView onSubmit(
        HttpServletRequest request,
        HttpServletResponse response,
        Object command,
        BindException errors) throws ServletException, IOException {

         // cast the bean
        FileUploadBean bean = (FileUploadBean) command;

         let's see if there's content there
        MultipartFile file = bean.getFile();
        if (file == null) {
             // hmm, that's strange, the user did not upload anything
        }

         // well, let's do nothing with the bean for now and return
        return super.onSubmit(request, response, command, errors);
    }
}

public class FileUploadBean {

    private MultipartFile file;

    public void setFile(MultipartFile file) {
        this.file = file;
    }

    public MultipartFile getFile() {
        return file;
    }
}

Spring的表单标签库存在spring.jar中。这个库的描述文件（descriptor)是 spring-form.tld。

如果你想使用这些标签， 请在JSP代码的起始部分加入下面这行声明。

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

在上面的声明中， form 是这个标签库所提供标签的前缀名。

这个标签会生成HTML form标签，同时为form内部所包含的标签提供一个绑定路径（binding path)。 它把命令对象（command object)存在PageContext中，这样form内部的标签 就可以使用这个对象了。标签库中的其他标签都声明在form标签的内部。

让我们假设有一个叫User的领域对象，它是一个JavaBean，有着诸如 firstName和lastName这样的属性。我们将把它当作 一个表单支持对象（form backing object)，它对应的表单控制器用 form.jsp页面来显示表单。下面是form.jsp的内容片段。

<form:form>
    <table>
        <tr>
            <td>First Name:</td>
            <td><form:input path="firstName" /></td>
        </tr>
        <tr>
            <td>Last Name:</td>
            <td><form:input path="lastName" /></td>
        </tr>
        <tr>
            <td colspan="3">
                <input type="submit" value="Save Changes" />
            </td>
        </tr>
    </table>
</form:form>

上面例子中的firstName和lastName由控制器从 存在PageContext中的命令对象中得到。 下面几个更复杂的例子展示了form内部标签的用法。

这是由form标签所生成的HTML代码，和标准的HTML form没有什么区别：

<form method="POST">
    <table>
      <tr>
          <td>First Name:</td>
          <td><input name="firstName" type="text" value="Harry"/></td>
          <td></td>
      </tr>
      <tr>
          <td>Last Name:</td>
          <td><input name="lastName" type="text" value="Potter"/></td>
          <td></td>
      </tr>
      <tr>
          <td colspan="3">
            <input type="submit" value="Save Changes" />
          </td>
      </tr>
    </table>
</form>

上面这个例子有一个隐藏的前提：表单支持对象（form backing object)的变量名是command。 如果你将这个对象用其他名称加以定义（这可算是一种最佳实践），你就可以将这个变量名绑定到表单上，如下例所示。

<form:form commandName="user">
    <table>
        <tr>
            <td>First Name:</td>
            <td><form:input path="firstName" /></td>
        </tr>
        <tr>
            <td>Last Name:</td>
            <td><form:input path="lastName" /></td>
        </tr>
        <tr>
            <td colspan="3">
                <input type="submit" value="Save Changes" />
            </td>
        </tr>
    </table>
</form:form>

这个标签生成text类型的HTML input标签。使用这个标签时，path属性的值将对应 HTML input标签中name属性的值。Section 13.9.2, “form标签”这一节中 有关于这个标签的例子。

这个标签生成checkbox类型的HTML input标签。

假设模型中的User支持每个用户设置自己的喜好，比如新闻订阅或者一组业余爱好，等等。下面是Preferences这个类的定义：

这个标签生成类型为radio的HTML input 标签。

这个标签的典型用法是一次声明多个标签实例，所有的标签都有相同的path属性，但是他们的value属性不同。

<tr>
    <td>Sex:</td>
    <td>Male: <form:radiobutton path="sex" value="M"/> <br/>
        Female: <form:radiobutton path="sex" value="F"/> </td>
    <td></td>
</tr>

这个标签生成类型为password的HTML input标签。input标签的值和表单支持对象相应属性的值保持一致。

<tr>
    <td>Password:</td>
    <td>
        <form:password path="password" />
    </td>
</tr>

这个标签生成HTML select标签。在生成的HTML代码中，被选中的选项和表单支持对象相应属性的值保持一致。这个标签也支持嵌套的option和options标签。

在下面的例子中，我们假设User可以选择自己的专业技能（多项选择）：

<tr>
    <td>Skills:</td>
    <td><form:select path="skills" items="${skills}"/></td>
    <td></td>
</tr>

如果某个User的专业是草药学(Herbology)，生成的HTML代码就会像下面这样：

<tr>
    <td>Skills:</td>
    <td><select name="skills" multiple="true">
        <option value="Potions">Potions</option>
        <option value="Herbology" selected="true">Herbology</option>
        <option value="Quidditch">Quidditch</option></select></td>
    <td></td>
</tr>

这个标签生成HTML option标签。在生成的HTML代码中，被选中的选项和表单支持对象相应属性的值保持一致。

<tr>
    <td>House:</td>
    <td>
        <form:select path="house">
            <form:option value="Gryffindor"/>
            <form:option value="Hufflepuff"/>
            <form:option value="Ravenclaw"/>
            <form:option value="Slytherin"/>
        </form:select>
    </td>
</tr>

如果某个User的宿舍是Gryffindor，生成的HTML代码就会像下面这样：

<tr>
    <td>House:</td>
    <td>
        <select name="house">
            <option value="Gryffindor" selected="true">Gryffindor</option>
            <option value="Hufflepuff">Hufflepuff</option>
            <option value="Ravenclaw">Ravenclaw</option>
            <option value="Slytherin">Slytherin</option>
        </select>
    </td>
 </tr>

译者注：这一节中的几个例子都跟《哈里波特》这本小说的内容有关。

这个标签生成一系列的HTML option标签。在生成的HTML代码中，被选中的选项和表单支持对象相应属性的值保持一致。

<tr>
    <td>Country:</td>
    <td>
        <form:select path="country">
            <form:option value="-" label="--Please Select"/>
            <form:options items="${countryList}" itemValue="code" itemLabel="name"/>
        </form:select>
    </td>
    <td></td>
</tr>

如果某个User住在英国，生成的HTML代码就会像下面这样：

 <tr>
    <td>Country:</td>
    <tr>
        <td>Country:</td>
        <td>
            <select name="country">
                <option value="-">--Please Select</option>
                <option value="AT">Austria</option>
                <option value="UK" selected="true">United Kingdom</option>
                <option value="US">United States</option>
            </select>
        </td>
        <td></td>
    </tr>
    <td></td>
</tr>

上面的这个例子同时使用了option标签和options标签。这两个标签生成的HTML代码是相同的，但是第一个option标签允许你在JSP中明确声明这个标签的值只供显示使用，并不绑定到表单支持对象的属性上。

这个标签生成HTML textarea标签。

<tr>
    <td>Notes:</td>
    <td><form:textarea path="notes" rows="3" cols="20" /></td>
    <td><form:errors path="notes" /></td>
</tr>

这个标签生成类型为hidden的HTML input标签。在生成的HTML代码中，input标签的值和表单支持对象相应属性的值保持一致。如果你需要声明一个类型为hidden的input标签，但是表单支持对象中没有对应的属性，你只能使用HTML的标签。

<form:hidden path="house" />

上面的例子表示我们需要将house的值以隐含参数的形式提交，生成的HTML代码如下：

<input name="house" type="hidden" value="Gryffindor"/>

这个标签生成类型为'span'的HTML标签，用来显示表单验证时出现的错误信息。通过这个标签，你可以访问控制器(controller)和与控制器关联的验证器(validator)产生的错误信息。

假设我们需要在表单提交时显示所有跟firstName和lastName有关的错误信息。我们为User这个类编写了名为UserValidator的验证器。

public class UserValidator implements Validator {

    public boolean supports(Class candidate) {
        return User.class.isAssignableFrom(candidate);
    }

    public void validate(Object obj, Errors errors) {
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "firstName", "required", "Field is required.");
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "lastName", "required", "Field is required.");
    }
}

现在，form.jsp是下面这个样子：

<form:form>
    <table>
        <tr>
            <td>First Name:</td>
            <td><form:input path="firstName" /></td>
            <%-- Show errors for firstName field --%>
            <td><form:errors path="firstName" /></td>
        </tr>

        <tr>
            <td>Last Name:</td>
            <td><form:input path="lastName" /></td>
            <%-- Show errors for lastName field --%>
            <td><form:errors path="lastName"  /></td>
        </tr>
        <tr>
            <td colspan="3">
                <input type="submit" value="Save Changes" />
            </td>
        </tr>
    </table>
</form:form>

如果我们提交表单时没有填firstHame和lastName这两个栏目，服务器返回的HTML页面就会像下面这样：

<form method="POST">
    <table>
        <tr>
            <td>First Name:</td>
            <td><input name="firstName" type="text" value=""/></td>
            <%-- Associated errors to firstName field displayed --%>
            <td><span name="firstName.errors">Field is required.</span></td>
        </tr>

        <tr>
            <td>Last Name:</td>
            <td><input name="lastName" type="text" value=""/></td>
            <%-- Associated errors to lastName field displayed --%>
            <td><span name="lastName.errors">Field is required.</span></td>
        </tr>
        <tr>
            <td colspan="3">
                <input type="submit" value="Save Changes" />
            </td>
        </tr>
    </table>
</form>

如果我们想显示一个页面上所有的错误信息，应该怎么办呢？ errors标签支持基本的通配符功能。

下面这个例子在页面的上方显示所有的错误信息，同时在表单每个栏目的旁边显示和该栏目有关的错误信息。

<form:form>
    <form:errors path="*" cssClass="errorBox" />
    <table>
        <tr>
            <td>First Name:</td>
            <td><form:input path="firstName" /></td>
            <td><form:errors path="firstName" /></td>
        </tr>
        <tr>
            <td>Last Name:</td>
            <td><form:input path="lastName" /></td>
            <td><form:errors path="lastName"  /></td>
        </tr>
        <tr>
            <td colspan="3">
                <input type="submit" value="Save Changes" />
            </td>
        </tr>
    </table>
</form:form>

生成的HTML代码如下所示:

<form method="POST">
    <span name="*.errors" class="errorBox">Field is required.<br/>Field is required.</span>
    <table>
        <tr>
            <td>First Name:</td>
            <td><input name="firstName" type="text" value=""/></td>
            <td><span name="firstName.errors">Field is required.</span></td>
        </tr>

        <tr>
            <td>Last Name:</td>
            <td><input name="lastName" type="text" value=""/></td>
            <td><span name="lastName.errors">Field is required.</span></td>
        </tr>
        <tr>
            <td colspan="3">
                <input type="submit" value="Save Changes" />
            </td>
        </tr>
</form>

ControllerClassNameHandlerMapping是HandlerMapping接口的一个实现。它检查请求的URL，然后通过惯例来决定与之相对应的控制器。

比如，下面有个非常简单的控制器实现，请特别注意这个类的名字。

public class ViewShoppingCartController implements Controller {

    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) {
        // the implementation is not hugely important for this example...
    }
}

下文是从Spring Web MVC 框架的配置文件中选出来的一段：

<bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping "/>
                
<bean id="viewShoppingCart" class="x.y.z.ViewShoppingCartController">
    <!-- inject dependencies as required... -->
</bean>

ControllerClassNameHandlerMapping在应用的上下文中找出所有的请求处理器（handler)（或实现了Controller接口的）bean。把这些bean的名字中Controller后缀去掉，就得到了每个控制器所能处理的URL。

让我们通过举例来进一步解释这个映射的工作原理。

当控制器是MultiActionController的子类时，自动生成的映射就稍有点复杂，但应该还是比较好理解的。下面例子中这几个控制器都是MultiActionController。

如果你的控制器类遵守这些命名规范（xxxController），ControllerClassNameHandlerMapping可以自动生成映射，这样你就不必费劲的定义和维护一长串SimpleUrlHandlerMapping（或者类似的映射策略）。

ControllerClassNameHandlerMapping是AbstractHandlerMapping的子类，所以你仍旧可以像对待其他HandlerMapping实例一样来定义HandlerInterceptor的实例。

ModelMap是一个加强版的Map实现。在这个Map里，每个对象的键都遵守一个命名规范，然后这些对象就可以显示在视图中。这个类的使用其实很简单，不需要长篇大论。下面让我们看几个例子，然后我们结合例子进行讲解。

下面是一个Controller的实现。请注意当我们把对象加到ModelAndView时，我们不需要声明每个对象的键名。

public class DisplayShoppingCartController implements Controller {

    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) {
        
        List cartItems = // get a List of CartItem objects
        User user = // get the User doing the shopping
        
        ModelAndView mav = new ModelAndView("displayShoppingCart"); <-- the logical view name

        mav.addObject(cartItems); <-- look ma, no name, just the object
        mav.addObject(user); <-- and a'ain ma!

        return mav;
    }
}

ModelAndView在内部使用了ModelMap。ModelMap是一个自定义的Map实现，它可以为加入其中的每个对象自动生成一个键名。这些键名是有规律的。当存入的对象是存储单值的对象（scalar object），比如User，生成的键名就是对象的类名（不包括包的名字）。下面几个例子详细解释了这个命名规范：

当你加入ModelAndView中的对象是Set、List或者数组时，Spring会检查这个集合，取出这个集合中的第一个对象，然后用它的类名，加上List后缀，就是最终生成的名字。下面几个例子进一步解释了这个命名规则：

RequestToViewNameTranslator这个接口的功能是自动寻找请求所对应的视图名（当某个视图名没有明确配置的时候)。这个接口目前只有一个实现，类名为DefaultRequestToViewNameTranslator。

为了解释DefaultRequestToViewNameTranslator是如何将请求的URL映射到视图名,最好的方法就是举例说明。下面是一个Controller的实现，和它对应的配置文件。

public class RegistrationController implements Controller {
                
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) {
        // process the request...
        ModelAndView mav = new ModelAndView();
        // add data as necessary to the model...
        return mav;
        // notice that no View or logical view name has been set
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
        "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>

    <!-- this bean with the well known name generates view names for us -->
    <bean id="viewNameTranslator" class="org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator"/>

    <bean class="x.y.RegistrationControllerController">
        <!-- inject dependencies as necessary -->
    </bean>
    
    <!-- maps request URLs to Controller names -->
    <bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"/>

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

</beans>

请注意，在这个handleRequest(..)方法中，返回的ModelAndView实例不包含View的实例或者逻辑视图名。真正从请求的URL中分析出逻辑视图名(logical view name)的是DefaultRequestToViewNameTranslator。在上面这个例子中，RegistrationControllerController和ControllerClassNameHandlerMapping在一起使用，所有对http://localhost/registration.html这个URL的请求将会对应registration这个逻辑视图名。这个视图名正是由DefaultRequestToViewNameTranslator解析出来的。然后，InternalResourceViewResolver这个bean会将这个逻辑视图名进一步解析成/WEB-INF/jsp/registration.jsp这个视图。

	Tip
	你甚至不需要配置类型为DefaultRequestToViewNameTranslator的bean。如果DefaultRequestToViewNameTranslator的缺省行为已经符合你的要求，你就可以使用这个类。当你没有明确声明时，Spring Web MVC 中DispatcherServlet这个类会自动生成一个DefaultRequestToViewNameTranslator的实例。

当然，如果你有自己特殊的要求，你就需要配置DefaultRequestToViewNameTranslator bean。如果你需要知道这个类有哪些可以设置的参数，请参阅DefaultRequestToViewNameTranslator的Javadoc。