Spring MVC 三大组件

㈠ HandlerMapping 处理器映射

通过处理器映射，你可以将Web 请求映射到正确的处理器 Controller 上。当接收到请求时，DispactherServlet 将请求交给 HandlerMapping 处理器映射，让他检查请求并找到一个合适的HandlerExecutionChain，这个HandlerExecutionChain 包含一个能处理该请求的处理器 Controller。然后，DispactherServlet 执行在HandlerExecutionChain 中的处理器 Controller。

Spring 内置了许多处理器的映射策略，如：SimpleUrlHandlerMapping 或者 BeanNameUrlHandlerMapping。

● SimpleUrlHandlerMapping

SimpleUrlHandlerMapping 在应用上下文中可以进行配置，并且有Ant 风格的路径匹配功能。例如我们在applicationContext.xml 中配置一个SimpleUrlHandlerMapping 处理器映射。

<beans>
      <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
             <props>
                      <prop key="/**/help.do">helpAction</prop>
                      <prop key="/ex/view*.do">helpAction</prop>
                      <prop key="/*/account.do">accountAction</prop>
                      <prop key="/*/editAccount.do">accountAction</prop<>>
            </props>
     </bean>
     <bean id="helpAction" class="org.springframework.web.servlet.mvc.UrlFielNameViewController"/>
     <bean id="accountAction" 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>

● BeanNameUrlHandlerMapping

BeanNameUrlHandlerMapping 将收到的Http请求映射到bean 的名字上。如：我们用如下方式将包含http://samples.com/editAccount.do的访问请求映射到指定的FormController 上。

<beans>
        <bean id="handlerMapping" class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
        <bean name="/editAccount.do" class="org.springframework.web.servlet.mvc.SimpleFromController">
                <property name="formView" value="account"/>
                <property name="successView' value="account-created"/>
                <property name="commandName" value="Account"/>
                <property name="commandClass" value="samples.Account"/>
       </bean>
</beans>

在默认情况下，如果没有在上下文中没有找到处理器映射，DispactherServlet 会为你创建一个BeanNameUrlHandlerMapping。

● HandlerInterceptor 拦截器

在处理器映射中通过配置拦截器（包括处理器执行前、执行后、执行后进行拦截）将使功能更强大。一个自定义的处理器映射不仅可以根据请求的URL，还可以根据和请求相关的session状态来选择处理器。处理器中的拦截器必须实现org.springframework.web.servlet包中的HandlerInterceptor接口，这个接口定义了3个方法，一个是在处理器执行前被调用，一个是在处理器执行后被调用，另一个是在整个请求处理完后调用。

<beans>
         <bean id="handlerMapping" class="org.springframework.web.servlet.handler.SimpleUrlhandlerMapping">
                 <property name="interceptor">
                            <list>
                                 <ref bean="officeHoursInterceptor"/>
                            </list>
                </property>
                <property name="mappings">
                            <props>
                                     <prop key="/*/account.do">accountAction</prop>
                                     <prop key="/*/editAction.do">accountAction</prop>
                           </props>
                </property>
         </bean>
         <bean id="officeHoursInterceptor" class="samples.TimeBasedAccessInterceptor">
                    <property name="openningTime" value="9">
                    <property name="closingTime" value="18">
         </bean>
</beans>

public class TimeBaseAccessInterceptor 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{  //在处理器执行前被调用
  
          }
}

㈡ Controller 处理器

 Spring 提供了许多功能强大的Controller 的实现，可以继承一个合适的Controller来简化代码。

 

public interface Controller{

         ModelAndView handlerRequest( HttpServletRequest request, HttpServletResponse response) thorws Exception;

} 

 

Spring 本身包含表单处理器、命令处理器、向导型处理器等多种多样的控制器等。

① AbstractControll

所有的Spring 控制器都继承了AbstractController，AbstractController 提供了诸如缓存支持和mimetype设置的功能。

public class SampleController extends AbstractController{
            public ModelAndView handlerRequestInternal( HttpServletRequest request,

                       HttpServletResponse response) throws Exception{
                     ModelAndView mav = new ModelAndView(" hello");
                     mav. addObject(" message"," HelloWorld!");
                     return mav;
            }
}
<bean id="sampleController" class="samples.SampleController">
              <property name="cacheSeconds" value="120"/>
</bean>

该Controller 返回了硬编码的视图名"hello"，并通知客户端将响应数据缓存2分钟。

● ParameterizableViewController 基本上和上面的例子中一样，不同的是你可以在applicationContext.xml 配置中指定返回视图名，从而避免的在Java 程序中硬编码。

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

 

② MultiActionController

MultiActionController 将多个Action合并在一个处理器里，这样可以吧=把相关的功能合并在一起，它通过将请求映射到正确的方法名来调用方法。如果需要处理多个类似的请求，可以考虑使用MultiActionController 来实现，而不必分别编写多个单一功能的Controller，该类类似于Struts 中的DispactherAction 类，可以分发多个请求的函数。

public class UserAction extends MultiActionController{
              public ModelAndAction create( HttpServletRequest request, HttpServletResponse response) throws Exception{
                          return new ModelAndView(" create",model);
              }
               public ModelAndView retried( HttpServletRequest request, HttpServletResponse response) throws Exception{
                          return new ModelAndView(" retried",model);
              }
               public ModelAndView update( HttpServletRequest request, HttpServletResponse response) throws Exception{
                         return new ModelAndView(" update",model); 
              }
              public ModelAndView delete( HttpServletRequest request, HttpServletResponse response) throws Exception{
                        return new ModelAndView(" delete",model);
              }
}

<bean id="methodNameResolver" class="org.springramework.web.servlet.mvc.multiaction. ParameterMethodNameResovler">
             <property name="paramName" value=" method"/>
             <property name="defaultMethodName" value="retried"/>
</bean>

该解析器使用了Spring默认的解析器实现类 ParameterMethodNameResolver，并指定提取方法名的参数为“method”，默认的方法名为：retried。

这样，ParameterMethodNameResolver 根据URL 的method参数来确定方法名称。将methodNameResovler注入到ViewProfileController后，若用户请求“/*.do? method=create”，则methodNameResovler将根据参数method=create 来决定调用UserAction 的 create()方法处理用户请求；若用户请求“/*.do? method=update”，则调用update()方法；若找不到“method” 参数，则methodNameResovler根据defaultMethodName 属性来调用retried()方法。

 

我们也可以手动来编写代码来确定使用哪个方法

public class TestAction extends SimpleFormController{
        protected ModelAndView onSubmit( HttpServletRequest request, HttpServletResponse response,
                 Object command, BindException errors) throws Exception{
                String methodName = request.getParameter(" mehod");
                 if(methodName.equals(" create"))
                            return create(request,response);
                 if(methodName.equals(" retried"))
                            return retired(request.response);
                 if(method.equals(" update"))
                            return update(request,response);
                 if(method.equals(" delete"))
                            return delete(request,response);
                 return retired(request,response);
       }
       public ModelAndAction create(HttpServletRequest request,HttpServletResponse response) throws Exception{
                 return new ModelAndView("create",model);
       }
       public ModelAndView retried(HttpServletRequest request,HttpServletResponse response) throws Exception{
                return new ModelAndView("retried",model);
       }
       public ModelAndView update(HttpServletRequest request,HttpServletResponse response) throws Exception{
                return new ModelAndView("update",model); 
       }
       public ModelAndView delete(HttpServletRequest request,HttpServletResponse response) throws Exception{
               return new ModelAndView("delete",model);
      }
}

 

③ BaseCommandController  命令处理器

命令处理器提供了一种和数据对象交互的方式，并动态地将来自HttpServletRequest 的参数绑定到你指定的数据对象上。它的功能和Struts中的ActionForm 有点像，不过在Spring 中，你不需要实现任何接口来实现数据绑定。

 

● AbstractCommandController：它能够将请求参数绑定到你指定的命令对象。这个类并不提供任何表单功能，但是它提供验证功能，并且让你在子类中去实现如何处理由请求参数产生的命令对象。

 

● AbstractFormController：你可以定义表单，并使用控制器获取数据对象构建表单。当用户输入表单内容时，它将用户输入的内容绑定到命令对象，验证表单内容，并将该表单对象交给处理器，完成相应的操作。它有防止重复提交、表单验证及一般的表单处理流程。如果你需要表单，但不想在应用上下文中指定显示给用户的视图，就使用这个处理器。

 

● SimpleFormController：根据命令对象来创建相应的form的时候，该类可以提供更多的支持。你可以为其指定一个命令对象，显示表单的视图名，当表单提交成功后显示给用户的视图名等。

SimpleFormController 主要通过以下几个属性来决定如何显示和提交表单。

◆ commandClass：表单类（或称命令类），Spring 根据此来实例化一个表单，在Spring 中，表单对象被称为Command对象，这和Struts 中的ActionForm类似，但Spring 中的Command 对象不要求实现任何接口。

◆ formView：显示表单的视图名称。

◆ successView：提交表单成功后的视图名称。

 

● CancellableFormController：于SimpleFormController 类似，它实现了取消表单提交的功能。

● AbstractWizardFormController：继承这个类需要实现validatePage()、processFinish()、processCancel()方法，可以实现向导功能，如果你的表单项很多，需要进行翻页显示输入时，可以使用该类。

㈢ ViewResolver 视图解析器

Spring 提供了视图解析器供你在浏览器显示模型数据，而不必拘束再特定的视图技术上。Spring 内置了对JSP、Velocity、FreeMarker模板和XSLT视图等的技术。

 Spring 中的视图以名字为标识，视图解析器通过名字来解析视图。

当使用JSP作为视图层技术时，就可以使用UrlBaseViewResolver，这个视图解析器就会将视图名解析成URL：

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

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

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

使用InternalResourceViewResolver解析JSP视图

<!-- 定义视图 -->
 <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
          <property name="viewClass">
                      <value>org.springframework.web.servlet.view.InternalResourceView</value>
          </property>
          <!-- JSP都放在/目录下 -->
         <property name="prefix">
                    <value>/</value>
        </property>
        <!-- JSP页面的后缀都是.JSP -->
        <property name="suffix">
                   <value>.jsp</value>
        </property>
 </bean>