【转】SpringMVC的请求和响应过程

SpringMVC的请求和响应过程 

 
图片来自网络) 


1.客户端请求提交到DispatcherServlet 
2.DispatcherServlet查询一个或多个HandlerMapping，找到处理请求的Controller 
3.DispatcherServlet将请求提交到Controller 
4.Controller调用业务逻辑处理后，返回ModelAndView给DispatcherServlet 
5.DispatcherServlet查询一个或多个ViewResolver视图解析器，找到ModelAndView指定的视图 
6.视图负责将结果显示到客户端 

SpringMVC的核心组件DispatcherServlet、HandlerMapping、Controller、HandlerInterceptor、ViewResolver、View、LocalResolver、HandlerExceptionResolver、ModelAndView、HandlerAdapter 

Didspatcher作为前端，也是核心控制器，它拦截匹配的请求，依据HandlerMapping实现类配置的规则转发到相应的Controller中去。 
Dispatcher的配置例子： 

Java代码   

1. <!-- 配置前段控制器 -->  
2.     <servlet>  
3.         <servlet-name>dispatcher</servlet-name>     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
4.         <load-on-startup>1</load-on-startup>  
5.     </servlet>  
6.     <servlet-mapping>  
7.         <servlet-name>dispatcher</servlet-name>  
8.         <url-pattern>*.html</url-pattern>  
9.     </servlet-mapping>  

配置DispatcherServlet只需要像配置正常的Servlet即可，<servlet-name>表示该Dispatcher的名称，可以配置多个，但是要用不同的名称进行区分，而<url-pattern>则表示会拦截以.html结尾的请求。 
在默认情况下不需要指定特定的配置文件，当应用服务器启动时，DidspatcherServlet它会在web应用的WEB-INF目录下去寻找在web.xml中配置DispatcherServlet的<servlet-name>中名称一致的[servlet-name]-servlet.xml文件，去初实例化文件中配置的Bean，如果此文件不存在，则会抛出异常信息。 
信息如下： 

Java代码   

1. org.springframework.beans.factory.BeanDefinitionStoreException: IOException parsing XML document from ServletContext resource [/WEB-INF/dispatcher-servlet.xml]; nested exception is java.io.FileNotFoundException: Could not open ServletContext resource [/WEB-INF/dispatcher-servlet.xml]  

如果不想使用默认的配置，也可以进行指定配置文件名称 
配置如下： 

Java代码   

1. <!-- 配置前段控制器 -->  
2.     <servlet>  
3.         <servlet-name>dispatcher</servlet-name>  
4.     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
5.         <init-param>  
6.             <param-name>contextConfigLocation</param-name>  
7.             <param-value>/WEB-INF/extends-bean.xml</param-value>  
8.         </init-param>  
9.         <load-on-startup>1</load-on-startup>  
10.     </servlet>  
11. <servlet-mapping>  
12.         <servlet-name>dispatcher</servlet-name>  
13.         <url-pattern>*.html</url-pattern>  
14. </servlet-mapping>  

如果放置在类路径下，那么也可以使用相应的配置： 
配置如下： 

Java代码   

1. <param-value>classpath:/extends-bean.xml</param-value>  

**如果以上两种方式都有多个配置文件，那么可以使用逗号隔开！ 
**DispatcherServlet的初始化过程可以参考：http://jinnianshilongnian.iteye.com/blog/1602617 
DispatcherServlet是一个Servlet，它有自己的上下文，它的上下文继承自Spring容器的上下文。DispatcherServlet的是子上下文，而Spring容器的上下文是父上下文，子上下文可以访问并且重新覆盖父上下文的信息，但是父上下文无法访问子上下文的信息。多个DispatcherServlet的上下文之间也无法互相范文。 
子上下文覆盖父上下文的例子： 
1.web.xml中的配置 

Java代码   

1. <context-param>  
2.         <param-name>contextConfigLocation</param-name>  
3.     <param-value>/WEB-INF/dao-bean.xml,/WEB-INF/service-bean.xml</param-value>  
4.     </context-param>  
5.     <!-- 监听spring配置文件 -->  
6.     <listener>  
7.     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
8.     </listener>  
9.     <!-- 配置前段控制器 -->  
10.     <servlet>  
11.         <servlet-name>dispatcher</servlet-name>  
12.     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
13.         <init-param>  
14.             <param-name>contextConfigLocation</param-name>  
15.             <param-value>/WEB-INF/extends-bean.xml</param-value>  
16.         </init-param>  
17.         <load-on-startup>1</load-on-startup>  
18.     </servlet>  

使用ContextLoaderListener加载初始化配置文件。 
2.service-bean.xml文件的配置： 

Java代码   

1. <bean id="service" class="cn.changluo.service.impl.UserServiceImpl">  
2.         <property name="userDao" ref="dao"></property>  
3.         <property name="username" value="lisi"></property>  
4.     </bean>  

此service Bean属于spring容器的上下文，为bean的username属性设置值为lisi 
3.extends-bean.xml文件的配置： 

Java代码   

1. <bean id="service" class="cn.changluo.service.impl.UserServiceImpl">  
2.         <property name="username" value="zhangsan"></property>  
3.         <property name="userDao" ref="dao"></property>  
4.     </bean>  

此service Bean属于DispatcherServlet的上下文，同时为username属性设置值为zhangsan。 
执行了相应的方法之后，发现输出为： 
 
也就是说，子上下文中的bean覆盖了父上下文中的bean。 
正确的理解和使用上下文可以帮助我们较好的分层，当分为多个层时，各个层之间该放置于那个上下文中，可以更好的管理和维护。如果不想使用父上下文，那么只需要使用子上下文即可。 

SpringMVC将请求映射到处理程序的方法 
在SpringMVC中，Web请求被应用程序的上下文中声明的一个或者多个处理程序映射到处理程序上。这些Bean都必须实现了HandlerMapping接口，这样DispatcherServlet才能自动侦测他们。 
1.按Bean名称映射请求 
最简单的策略就是按照处理程序的Bean名称进行映射，这也是默认的策略。为了让这个策略生效，必须将每个处理程序的Bean名称声明成URL模式的形式。可以使用通配符。 
XML配置文件示例： 

Java代码   

1. <bean name="/hello" class="mvcdemo.controller.HelloWorldController"/>  

SpringMVC提供了几个HandlerMapping实现，可以根据不同的策略来映射。默认情况下，如果你没有显示的配置处理程序映射，DispatcherServlet将利用BeanNameUrlHandlerMapping作为它的默认处理程序，它根据Bean名称中指定的Url模式将请求映射到处理程序上。 
使用此映射策略是时，必须通过name属性设置处理程序的名称。 
2.按控制器类名称映射请求 
它根据Web应用的上下文中声明的控制器的类名称，自动生成映射。Spring有提供一个专门的类ControllerClassNameHandlerMapping，它实现了Controller接口的处理程序生成处理程序的映射。 
XML配置文件示例： 

Java代码   

1. <bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping">  
2.         <!—让URL遵守JAVA的变量命名约定-->  
3.         <property name="caseSensitive" value="true"></property>  
4.         <!--   
5.         <property name="pathPrefix" value="/testproject"></property>  
6.         <property name="basePackage" value="mvcdemo.controller"></property>  
7.          -->  
8.     </bean>  
9.     <bean class="mvcdemo.controller.HelloWorldController"/>  

对于HelloWorldController这个Bean，ControllerClassNameHandlerMapping会移除类名称中的Controller后缀，并将其他部分转换成小写字母，以此来生成处理程序映射。 
HelloWorldController---------/helloworld* 
加上了以上的property后，变为 
HelloWorldController---------/helloWorld* 
使用此方法时，必须在XML中显示注册ControllerClassNameHandlerMapping这个类，并且控制处理程序必须以Controller结尾。 
3.用户定制的映射定义来映射请求 
将请求映射到处理程序最直接最灵活的策略，是显式的指定URL模式和处理程序之间的映射定义，可以通过SimpleUrlHandlerMapping来做到。 
XML配置文件示例： 

Java代码   

1. <!-- 配置请求的Controller的业务类 -->  
2.     <bean id="loginController" class="cn.changluo.controller.HelloWorldController">  
3.         <property name="failView" value="login"></property>  
4.         <property name="successView" value="success"></property>  
5.     </bean>  
6.     <!-- 配置Controller和URL的映射关系 -->  
7.     <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">  
8.         <property name="mappings">  
9.             <props>  
10.                 <prop key="/login.html">loginController</prop>  
11.             </props>  
12.         </property>  
13.     </bean>  

SimpleUrlHandlerMapping接受Properties对象形式的映射定义。属性是URL模式，而属性值则是处理器ID或者名称。URL模式也可以接受通配符，让处理程序处理多个URL。 

HandlerInterceptor是SpringMVC提供的拦截器，你可以通过处理拦截器，拦截Web请求，进行前置处理和后置处理。拦截器是在SpringMVC应用程序的上下文中配置的，因此它们可以利用各种容器特性，并引用容器中声明的任何bean。处理拦截是针对特殊的处理程序映射进行注册的，因此它只拦截通过这些处理程序映射的请求。 
每个拦截器都必须实现HandlerInterceptor这个接口，它有三个方法：preHandler()、postHandler()、afterCompletion()。第一个和第二个方法分别是在处理程序处理请求之前和之后被调用的。第二个方法还允许访问返回的ModelAndView对象。最后一个方法是在所有请求处理完之后被调用的，也就是呈现视图之后。 
preHandler()方法返回true时，继续处理请求，否则直接将响应返回给用户。 
SpringMVC允许拦截器继承自HandlerInterceptorAdapter，实现HandlerInterceptor需要实现所有的方法，当我们仅仅需要实现其中的某个方法时，则可以继承HandlerInterceptorAdapter 
拦截器示例： 
1.拦截器类： 

Java代码   

1. public class MyInterceptor implements HandlerInterceptor {  
2.     @Override  
3.     public void afterCompletion(HttpServletRequest request,  
4.             HttpServletResponse response, Object handler, Exception exception)  
5.             throws Exception {  
6.         System.out.println("afterCompletion");  
7.     }  
8.     @Override  
9.     public void postHandle(HttpServletRequest request, HttpServletResponse response,  
10.             Object handler, ModelAndView mv) throws Exception {  
11.         System.out.println("postHandle");  
12.     }  
13.     @Override  
14.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response,  
15.             Object handler) throws Exception {  
16.         System.out.println("preHandle");  
17.         return true;  
18.     }  
19. }  

第二个拦截器类同上，只是输出内容不同 
2.interceptor-bean.xml配置 

Java代码   

1. <!-- 配置Controller和URL的映射关系 -->  
2.     <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">  
3.         <property name="interceptors">  
4.             <list>  
5.                 <ref bean="myInterceptor1"/>  
6.                 <ref bean="myInterceptor3"/>  
7.             </list>  
8.         </property>  
9.         <property name="mappings">  
10.             <props>  
11.                 <!-- 通配符 -->  
12.                 <prop key="/context.html">contextController</prop>  
13.             </props>  
14.         </property>  
15.     </bean>  
16.     <bean id="myInterceptor1" class="cn.changluo.interceptor.MyInterceptor"></bean>  
17.     <bean id="myInterceptor3" class="cn.changluo.interceptor.MyInterceptor3"></bean>  

执行之后的结果如下： 

Java代码   

1. preHandle  
2. preHandle3  
3. contextcontroller  
4. postHandle3  
5. postHandle  
6. afterCompletion3  
7. afterCompletion  

如果你在控制器返回的视图中输出一句话，就会发现，它是在afterCompletion这个方法输出之前调用 

SpringMVC的重定向和转发 
转发：将请求转发到另外一个Action中进行处理 
重定向：重定向到应用或者其他外部资源，可以防止表单重复提交 
转发和重定向的区别在于： 
1.重定向时，浏览器上的地址栏改变，而转发时，浏览器的地址栏不变 
2.重定向其实是产生了两次请求，没有，而转发只有一次请求 
3.重定向可以到任何网址，转发必须是本站点的网址 
在SpringMVC中，对于转发和重定向的写法有如下几种： 
转发： 

Java代码   

1. return new ModelAndView("forward:/context.html")  

重定向： 

Java代码   

1. ModelMap model = new ModelMap();  
2.         model.addAttribute("param1", "param1");  
3.         model.addAttribute("param2", "param2");  
4.           
5.         return new ModelAndView("redirect:/index.jsp",model);   //http://localhost:8083/mvcdemo/index.jsp?param1=param1&param2=param2  
6.         //添加了参数之后，会在URL重定向到相应的界面，并且后面加了一串参数  
7.         //下面的这种方式结果和上面的一致  
8.         RedirectView rv = new RedirectView("index.jsp");  
9.         ModelMap model = new ModelMap();  
10.         model.addAttribute("param1", "data1");  
11.         model.addAttribute("param2", "data2");  
12.         rv.setAttributesMap(model);  
13.         return new ModelAndView(rv);  

SpringMVC使用PDF和Excel视图 
具体的解释可以参考Spring的文档 
示例： 
1.controller控制类 
1）ExcelController类： 

Java代码   

1. public class ExcelController extends AbstractController{  
2.     @SuppressWarnings("unchecked")  
3.     @Override  
4.     protected ModelAndView handleRequestInternal(HttpServletRequest request,  
5.             HttpServletResponse response) throws Exception {  
6.         List<String> list = getModelData();  
7.         Map model = new HashMap();  
8.         model.put("data", list);  
9.         return new ModelAndView("exl",model);  
10.     }  
11.     public List<String> getModelData(){  
12.         List<String> list = new ArrayList<String>();  
13.         for(int i = 0 ;i<10;i++){  
14.             list.add("this demo"+i);  
15.         }  
16.         return list;  
17.     }  
18. }  

2）PdfController类： 

Java代码   

1. public class PdfController extends AbstractController {  
2.     @SuppressWarnings("unchecked")  
3.     @Override  
4.     protected ModelAndView handleRequestInternal(HttpServletRequest arg0,  
5.             HttpServletResponse arg1) throws Exception {  
6.         List<String> list = getModelData();  
7.         Map model = new HashMap();  
8.         model.put("data", list);  
9.         return new ModelAndView("pdf", model);  
10.     }  
11.     public List<String> getModelData() {  
12.         List<String> list = new ArrayList<String>();  
13.         for (int i = 0; i < 10; i++) {  
14.             list.add("this demo" + i);  
15.         }  
16.         return list;  
17.     }  
18. }  

2.demoview-bean.xml的配置 

Java代码   

1. <bean id="viewRosolver" class="org.springframework.web.servlet.view.ResourceBundleViewResolver">  
2. <!--   
3.     ResourceBundleViewResolver视图解析器会在classpath中寻找properties属性文件，根据此bean配置的  
4.     <property name="basename" value="view" />  
5.     说明寻找的properties文件名为view.properties   
6.     -->  
7.         <property name="basename" value="view"></property>  
8.         <property name="order" value="2"></property>  
9.     </bean>  
10.     <!-- 配置Controller和URL的映射关系 -->  
11.     <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">  
12.         <property name="mappings">  
13.             <props>  
14.                 <prop key="/show_excel.html">excelController</prop>  
15.                 <prop key="/show_pdf.html">pdfController</prop>  
16.             </props>  
17.         </property>  
18.     </bean>  
19.     <bean id="excelController" class="cn.changluo.controller.ExcelController"/>  
20.     <bean id="pdfController" class="cn.changluo.controller.PdfController"/>  

4.view.properties属性文件的配置 

Java代码   

1. exl.(class)=cn.changluo.view.ExcelHomepage  
2. pdf.(class)=cn.changluo.view.PdfHomepage  

5.view.properties文件中配置的两个类的具体实现 
1）ExcelHomepage类： 

Java代码   

1. public class ExcelHomepage extends AbstractExcelView {  
2.     @SuppressWarnings("unchecked")  
3.     @Override  
4.     protected void buildExcelDocument(Map model, HSSFWorkbook wb,  
5.             HttpServletRequest request, HttpServletResponse response)  
6.             throws Exception {  
7.         HSSFSheet sheet = null;  
8.         HSSFCell cell = null;  
9.         sheet = wb.createSheet("springMvc excel view");  
10.         sheet.setDefaultColumnWidth((short)10);  
11.         cell = getCell(sheet, 0, 0);  
12.         setText(cell, "springMVC-excel");  
13.         List<String> list = (List<String>)model.get("data");  
14.         for(int i=0;i<list.size();i++){  
15.             cell = getCell(sheet, 2, i);  
16.             setText(cell, list.get(i));  
17.         }  
18.     }  
19. }  

2）PdfHomepage类： 

Java代码   

1. public class PdfHomepage extends AbstractPdfView {  
2.     @SuppressWarnings("unchecked")  
3.     @Override  
4.     protected void buildPdfDocument(Map model, Document doc, PdfWriter pw,HttpServletRequest request, HttpServletResponse response)  
5.             throws Exception {  
6.         List<String> words = (List<String>) model.get("data");  
7.         for (int i = 0; i < words.size(); i++)  
8.             doc.add(new Paragraph((String) words.get(i)));  
9.     }  
10. }  

转自：http://changluo.iteye.com/blog/1944445