首页 > 代码库 > SpringMVC(二) 流程控制

SpringMVC(二) 流程控制

       SpringMVC主要就是用来做流程控制的,这篇博客总结一下如何在流程控制添加Interceptor(拦截器),如何将进行流程Mapping映射解析,如何编写Controller(控制器)


          一,首先看一下框架中的映射解析器,用来将uri和控制器进行绑定的:


              1   SpringMVC框架的默认解析器采用是:bean的name属性名称作为URI,与控制器进行映射绑定,BeanNameUrlHandlerMapping。例如:


[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. <bean id="defaultHandlerMapping" class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>  
  2.         <bean name="/hello.html" class="com.ljh.springmvc.controller.HelloWorldController"> 
  3. </bean>  

          这种情况看起来是很方便的,直接将uri和类进行了绑定。但是耦合性高了些,我们一般是希望将uri和类的id进行绑定,这样方便我们后期的修改,看下边框架为我们提供的这个对象。

 

            2,SimpleUrlHandlerMapping :通过映射关系将请求路径和控制器绑定在一起,设置更加灵活。这里看个例子:

[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. <bean id="simpleUrlHandlerMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">  
  2.         <property name="urlMap">  
  3.             <map>  
  4.                 <entry key="/hello*.html" value-ref="hello"></entry>  
  5.             </map>  
  6.         </property>  
  7.      </bean>         
  8.       
  9.     <!-- 控制器类 -->  
  10.     <bean id="hello" class="com.ljh.springmvc.controller.HelloWorldController">  
  11. </bean>

          这种方法,是将uri和类的id进行绑定,使彼此的耦合性更加低,独立性更高了。这样就将我们的映射关系和类独立开来了。当然了两个都可以,根据实际情况选择即可。这是我们两种最常用的映射解析器。

 

          

          二,Interceptor,通过编写Interceptor可以对控制器进行拦截,对框架进行功能扩展,非常实用的。看一下如何将自己写的Interceptor融入到框架中。


           1,自定义拦截器需要继承HandlerInterceptorAdapter父类,或者实现HandlerInterceptor接口。这里简单看一个方法前后打印系统时间的小拦截器:

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. public class TimeInterceptor extends HandlerInterceptorAdapter {  
  2.       
  3.         //整个流程请求完成之后要执行的操作。  
  4.         @Override  
  5.         public void afterCompletion(HttpServletRequest request,  
  6.                 HttpServletResponse response, Object handler, Exception ex)  
  7.                 throws Exception {  
  8.             System.out.println("invoke afterCompletion..."+new Date());  
  9.         }  
  10.       
  11.         //请求控制器结束后做的操作  
  12.         @Override  
  13.         public void postHandle(HttpServletRequest request,  
  14.                 HttpServletResponse response, Object handler,  
  15.                 ModelAndView modelAndView) throws Exception {  
  16.             System.out.println("invoke postHandle..."+new Date());  
  17.         }  
  18.       
  19.         //请求控制器执行之前做的操作  
  20.         @Override  
  21.         public boolean preHandle(HttpServletRequest request,  
  22.                 HttpServletResponse response, Object handler) throws Exception {  
  23.             System.out.println("invoke preHandle..."+new Date());  
  24.             return true;  
  25.         }  
  26.     }  


          2,当然编写了拦截器后,就需要配置到我们的配置文件SpringMVC-servlet.xml中进行声明配置:

[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. <!-- 拦截器 -->  
  2.   
  3. <bean id="timeInterceptor" class="com.ljh.springmvc.interceptor.TimeInterceptor"></bean> 

          3,这里还需要在SpringMVC-servlet.xml文件中配置,我们设置的拦截器对那些控制器起作用,这里声明拦截器和控制器的关系组合,利用SimpleUrlHandlerMapping进行映射的:

[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. <bean id="simpleUrlHandlerMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">  
  2.             <property name="interceptors">  
  3.                 <list>  
  4.                     <ref bean="timeInterceptor"/>  
  5.                 </list>  
  6.             </property>  
  7.             <property name="urlMap">  
  8.                 <map><!-- SpringMVC提供了特殊的匹配方式 -->  
  9.                     <entry key="/hello*.html" value-ref="hello"></entry>  
  10.                 </map>  
  11.             </property>  
  12.   
  13.  </bean>

          这样就可以起作用了,对框架的功能扩展相对来说还是比较方便的。

 

          三,最后看我们的Controller控制器的编写吧,这里的ControllerStruts2里边的action是相同的,但是这里有了侵入性。一般情况下需要实现Controller接口,上一遍博客有演示,同时也可以采用继承父类的方式,这里来看几个继承不同的父类,实现不同的功能。


          1,继承AbstractController,这个和接口差不多,需要我们重写里边的方法,主要的是,一般情况下,需要将此方法由父类的protected该外public的类型,供其他类的使用,其中方法名是固定的,我们指定路径和此类即可由框架帮助我们调其中的方法。这里不再举例。


          2,继承MultiActionController(多动作控制器),这样我们可以增加多个方法,处理多个客户的请求,例如:

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. public class MultiController extends MultiActionController {  
  2.   
  3.             //自定义处理请求的方法,命名规则参照父类的handleRequestInternal  
  4.             public ModelAndView insert(HttpServletRequest request,HttpServletResponse response) throws Exception {                            
  5.                 return new ModelAndView("insertSuccess");  
  6.             }  
  7.               
  8.             public ModelAndView delete(HttpServletRequest request,HttpServletResponse response) throws Exception {                            
  9.                 return new ModelAndView("deleteSuccess");  
  10.             }  
  11.         }  


         看一下配置文件的映射编写吧:

[html] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. <!-- 声明控制器类--> <bean id="multi" class="com.ljh.springmvc.controller.MultiController"></bean>  
  2.                       
  3.            <!--增加映射关系,注意其中uri的模糊匹配-->  
  4.           <bean id="simpleUrlHandlerMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">  
  5.                 <property name="urlMap">  
  6.                     <map>  
  7.                         <entry key="/multi-*.html" value-ref="multi"></entry>  
  8.                     </map>  
  9.                 </property>  
  10.          </bean>                
  11.               
  12.           <!-- 增加映射关系:将请求的uri与控制中执行的方法进行映射-->  
  13.          <bean id="multiActionController" class="org.springframework.web.servlet.mvc.multiaction.MultiActionController">  
  14.                 <property name="methodNameResolver" ref="methodNameResolver"></property>  
  15.                 <property name="delegate"> <!-- 委托,将目标对象委托给此对象进行路径和方法的映射 -->  
  16.                     <ref bean="multi"/>  
  17.                 </property>  
  18.             </bean>  
  19.               
  20.             <bean id="methodNameResolver" class="org.springframework.web.servlet.mvc.multiaction.PropertiesMethodNameResolver">  
  21.                 <property name="mappings">  
  22.                     <props>  
  23.                         <prop key="/multi-insert.html">insert</prop>  
  24.                         <prop key="/multi-delete.html">delete</prop>  
  25.                     </props>  
  26.                 </property>  
  27.             </bean>  


          3,继承AbstractCommandController指令控制器,用于获取页面的参数,将参数封装到指定的对象模型中。类似于Struts2框架的模型驱动。例如:

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. public class DemoController extends AbstractCommandController {  
  2.       
  3.           
  4.         public DemoController(){  
  5.             this.setCommandClass(User.class); //这个就是用于接收客户端请求参数的数据模型类。  
  6.         }  
  7.           
  8.         //command参数就是在构造方法中指定的数据模型对象。  
  9.         //SpringMVC框架将请求参数,封装到指定的数据模型对象中,传递给handle方法来使用。  
  10.         @Override  
  11.         protected ModelAndView handle(HttpServletRequest request,HttpServletResponse response, Object command, BindException errors)  
  12.                 throws Exception {  
  13.             User user = (User)command ;  
  14.             System.out.println(user.getUsercode());  
  15.             System.out.println(user.getUserpswd());  
  16.             return new ModelAndView("test");  
  17.         }  
  18.       
  19.     }  


          对于配置文件的映射就是类和路径的映射,这里不再赘述。这种方法就是将页面传过来的数据直接封装到了指定的对象,我们可以直接使用,非常方便。

 

          综上,为SpringMVC流程控制方面的一些内容。其实任何的MVC框架都无在乎,核心控制器,映射文件,对应的action类,扩展可以通过拦截器,过滤器等。明白了大致方向,一些小的问题,我们可以通过查看API文档,那才是我们开发有力的助手!!!

SpringMVC(二) 流程控制