SpringMVC(二)——流程控制

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

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

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

1. <span style="font-size:18px;">  <bean id="defaultHandlerMapping" class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
2. <bean name="/hello.html" class="com.ljh.springmvc.controller.HelloWorldController"></bean>
3. </span>

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

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

1. <span style="font-size:18px;">  <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. <bean id="hello" class="com.ljh.springmvc.controller.HelloWorldController"></bean>
10. </span>

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

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

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

1. <span style="font-size:18px;">  public class TimeInterceptor extends HandlerInterceptorAdapter {
2. //整个流程请求完成之后要执行的操作。
3. @Override
4. public void afterCompletion(HttpServletRequest request,
5. HttpServletResponse response, Object handler, Exception ex)
6. throws Exception {
7. System.out.println("invoke afterCompletion..."+new Date());
8. }
9. //请求控制器结束后做的操作
10. @Override
11. public void postHandle(HttpServletRequest request,
12. HttpServletResponse response, Object handler,
13. ModelAndView modelAndView) throws Exception {
14. System.out.println("invoke postHandle..."+new Date());
15. }
16. //请求控制器执行之前做的操作
17. @Override
18. public boolean preHandle(HttpServletRequest request,
19. HttpServletResponse response, Object handler) throws Exception {
20. System.out.println("invoke preHandle..."+new Date());
21. return true;
22. }
23. }
24. </span>

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

1. <span style="font-size:18px;">  <!-- 拦截器 -->
2. <bean id="timeInterceptor" class="com.ljh.springmvc.interceptor.TimeInterceptor"></bean></span>

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

1. <span style="font-size:18px;">  <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. </bean></span>

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

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

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

2，继承MultiActionController（多动作控制器），这样我们可以增加多个方法，处理多个客户的请求，例如：

1. <span style="font-size:18px;">      public class MultiController extends MultiActionController {
2. //自定义处理请求的方法，命名规则参照父类的handleRequestInternal
3. public ModelAndView insert(HttpServletRequest request,HttpServletResponse response) throws Exception {
4. return new ModelAndView("insertSuccess");
5. }
6. public ModelAndView delete(HttpServletRequest request,HttpServletResponse response) throws Exception {
7. return new ModelAndView("deleteSuccess");
8. }
9. }
10. </span>

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

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

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

1. <span style="font-size:18px;">  public class DemoController extends AbstractCommandController {
2. public DemoController(){
3. this.setCommandClass(User.class); //这个就是用于接收客户端请求参数的数据模型类。
4. }
5. //command参数就是在构造方法中指定的数据模型对象。
6. //SpringMVC框架将请求参数，封装到指定的数据模型对象中，传递给handle方法来使用。
7. @Override
8. protected ModelAndView handle(HttpServletRequest request,HttpServletResponse response, Object command, BindException errors)
9. throws Exception {
10. User user = (User)command ;
11. System.out.println(user.getUsercode());
12. System.out.println(user.getUserpswd());
13. return new ModelAndView("test");
14. }
15. }
16. </span>

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

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