第二章：springmvc入門

2．一、Spring Web MVC是什麼

Spring Web MVC是一種基於Java的實現了Web MVC設計模式的請求驅動類型的輕量級Web框架，即便用了MVC架構模式的思想，將web層進行職責解耦，基於請求驅動指的就是使用請求-響應模型，框架的目的就是幫助咱們簡化開發，Spring Web MVC也是要簡化咱們平常Web開發的。

 

另外還有一種基於組件的、事件驅動的Web框架在此就不介紹了，如Tapestry、JSF等。

 

Spring Web MVC也是服務到工做者模式的實現，但進行可優化。前端控制器是DispatcherServlet；應用控制器其實拆爲處理器映射器(Handler Mapping)進行處理器管理和視圖解析器(View Resolver)進行視圖管理；頁面控制器/動做/處理器爲Controller接口（僅包含ModelAndView handleRequest(request, response) 方法）的實現（也能夠是任何的POJO類）；支持本地化（Locale）解析、主題（Theme）解析及文件上傳等；提供了很是靈活的數據驗證、格式化和數據綁定機制；提供了強大的約定大於配置（慣例優先原則）的契約式編程支持。

2．二、Spring Web MVC能幫咱們作什麼

√讓咱們能很是簡單的設計出乾淨的Web層和薄薄的Web層；

√進行更簡潔的Web層的開發；

√天生與Spring框架集成（如IoC容器、AOP等）；

√提供強大的約定大於配置的契約式編程支持；

√能簡單的進行Web層的單元測試；

√支持靈活的URL到頁面控制器的映射；

√很是容易與其餘視圖技術集成，如Velocity、FreeMarker等等，由於模型數據不放在特定的API裏，而是放在一個Model裏（Map數據結構實現，所以很容易被其餘框架使用）；

√很是靈活的數據驗證、格式化和數據綁定機制，能使用任何對象進行數據綁定，沒必要實現特定框架的API；

√提供一套強大的JSP標籤庫，簡化JSP開發；

√支持靈活的本地化、主題等解析；

√更加簡單的異常處理；

√對靜態資源的支持；

√支持Restful風格。

2．三、Spring Web MVC架構

Spring Web MVC框架也是一個基於請求驅動的Web框架，而且也使用了前端控制器模式來進行設計，再根據請求映射規則分發給相應的頁面控制器（動做/處理器）進行處理。首先讓咱們總體看一下Spring Web MVC處理請求的流程：

 

2.3.一、Spring Web MVC處理請求的流程

如圖2-1

 

圖2-1

具體執行步驟以下：

一、  首先用戶發送請求————>前端控制器，前端控制器根據請求信息（如URL）來決定選擇哪個頁面控制器進行處理並把請求委託給它，即之前的控制器的控制邏輯部分；圖2-1中的一、2步驟；

二、  頁面控制器接收到請求後，進行功能處理，首先須要收集和綁定請求參數到一個對象，這個對象在Spring Web MVC中叫命令對象，並進行驗證，而後將命令對象委託給業務對象進行處理；處理完畢後返回一個ModelAndView（模型數據和邏輯視圖名）；圖2-1中的三、四、5步驟；

三、  前端控制器收回控制權，而後根據返回的邏輯視圖名，選擇相應的視圖進行渲染，並把模型數據傳入以便視圖渲染；圖2-1中的步驟六、7；

四、  前端控制器再次收回控制權，將響應返回給用戶，圖2-1中的步驟8；至此整個結束。

 

問題：

一、  請求如何給前端控制器？

二、  前端控制器如何根據請求信息選擇頁面控制器進行功能處理？

三、  如何支持多種頁面控制器呢？

四、  如何頁面控制器如何使用業務對象？

五、  頁面控制器如何返回模型數據？

六、  前端控制器如何根據頁面控制器返回的邏輯視圖名選擇具體的視圖進行渲染？

七、  不一樣的視圖技術如何使用相應的模型數據？

 

首先咱們知道有如上問題，那這些問題如何解決呢？請讓咱們先繼續，在後邊依次回答。

 

2.3.二、Spring Web MVC架構

一、Spring Web MVC核心架構圖，如圖2-2

 

圖2-2

 

 

架構圖對應的DispatcherServlet核心代碼以下：

 

java代碼：

Java代碼  

1. //前端控制器分派方法  

2. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {  

3.         HttpServletRequest processedRequest = request;  

4.         HandlerExecutionChain mappedHandler = null;  

5.         int interceptorIndex = -1;  

6.   

7.         try {  

8.             ModelAndView mv;  

9.             boolean errorView = false;  

10.   

11.             try {  

12.                    //檢查是不是請求是不是multipart（如文件上傳），若是是將經過MultipartResolver解析  

13.                 processedRequest = checkMultipart(request);  

14.                    //步驟二、請求處處理器（頁面控制器）的映射，經過HandlerMapping進行映射  

15.                 mappedHandler = getHandler(processedRequest, false);  

16.                 if (mappedHandler == null || mappedHandler.getHandler() == null) {  

17.                     noHandlerFound(processedRequest, response);  

18.                     return;  

19.                 }  

20.                    //步驟三、處理器適配，即將咱們的處理器包裝成相應的適配器（從而支持多種類型的處理器）  

21.                 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());  

22.   

23.                   // 304 Not Modified緩存支持  

24.                 //此處省略具體代碼  

25.   

26.                 // 執行處理器相關的攔截器的預處理（HandlerInterceptor.preHandle）  

27.                 //此處省略具體代碼  

28.   

29.                 // 步驟四、由適配器執行處理器（調用處理器相應功能處理方法）  

30.                 mv = ha.handle(processedRequest, response, mappedHandler.getHandler());  

31.   

32.                 // Do we need view name translation?  

33.                 if (mv != null && !mv.hasView()) {  

34.                     mv.setViewName(getDefaultViewName(request));  

35.                 }  

36.   

37.                 // 執行處理器相關的攔截器的後處理（HandlerInterceptor.postHandle）  

38.                 //此處省略具體代碼  

39.             }  

40.             catch (ModelAndViewDefiningException ex) {  

41.                 logger.debug("ModelAndViewDefiningException encountered", ex);  

42.                 mv = ex.getModelAndView();  

43.             }  

44.             catch (Exception ex) {  

45.                 Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);  

46.                 mv = processHandlerException(processedRequest, response, handler, ex);  

47.                 errorView = (mv != null);  

48.             }  

49.   

50.             //步驟5 步驟六、解析視圖並進行視圖的渲染  

51. //步驟5 由ViewResolver解析View（viewResolver.resolveViewName(viewName, locale)）  

52. //步驟6 視圖在渲染時會把Model傳入（view.render(mv.getModelInternal(), request, response);）  

53.             if (mv != null && !mv.wasCleared()) {  

54.                 render(mv, processedRequest, response);  

55.                 if (errorView) {  

56.                     WebUtils.clearErrorRequestAttributes(request);  

57.                 }  

58.             }  

59.             else {  

60.                 if (logger.isDebugEnabled()) {  

61.                     logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +  

62.                             "': assuming HandlerAdapter completed request handling");  

63.                 }  

64.             }  

65.   

66.             // 執行處理器相關的攔截器的完成後處理（HandlerInterceptor.afterCompletion）  

67.             //此處省略具體代碼  

68.   

69.   

70.         catch (Exception ex) {  

71.             // Trigger after-completion for thrown exception.  

72.             triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);  

73.             throw ex;  

74.         }  

75.         catch (Error err) {  

76.             ServletException ex = new NestedServletException("Handler processing failed", err);  

77.             // Trigger after-completion for thrown exception.  

78.             triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);  

79.             throw ex;  

80.         }  

81.   

82.         finally {  

83.             // Clean up any resources used by a multipart request.  

84.             if (processedRequest != request) {  

85.                 cleanupMultipart(processedRequest);  

86.             }  

87.         }  

88.     }  

 

核心架構的具體流程步驟以下：

一、  首先用戶發送請求——>DispatcherServlet，前端控制器收到請求後本身不進行處理，而是委託給其餘的解析器進行處理，做爲統一訪問點，進行全局的流程控制；

二、  DispatcherServlet——>HandlerMapping， HandlerMapping將會把請求映射爲HandlerExecutionChain對象（包含一個Handler處理器（頁面控制器）對象、多個HandlerInterceptor攔截器）對象，經過這種策略模式，很容易添加新的映射策略；

三、  DispatcherServlet——>HandlerAdapter，HandlerAdapter將會把處理器包裝爲適配器，從而支持多種類型的處理器，即適配器設計模式的應用，從而很容易支持不少類型的處理器；

四、  HandlerAdapter——>處理器功能處理方法的調用，HandlerAdapter將會根據適配的結果調用真正的處理器的功能處理方法，完成功能處理；並返回一個ModelAndView對象（包含模型數據、邏輯視圖名）；

五、  ModelAndView的邏輯視圖名——> ViewResolver， ViewResolver將把邏輯視圖名解析爲具體的View，經過這種策略模式，很容易更換其餘視圖技術；

六、  View——>渲染，View會根據傳進來的Model模型數據進行渲染，此處的Model實際是一個Map數據結構，所以很容易支持其餘視圖技術；

七、返回控制權給DispatcherServlet，由DispatcherServlet返回響應給用戶，到此一個流程結束。

 

此處咱們只是講了核心流程，沒有考慮攔截器、本地解析、文件上傳解析等，後邊再細述。

 

到此，再來看咱們前邊提出的問題：

 

 

一、  請求如何給前端控制器？這個應該在web.xml中進行部署描述，在HelloWorld中詳細講解。

二、  前端控制器如何根據請求信息選擇頁面控制器進行功能處理？ 咱們須要配置HandlerMapping進行映射

三、  如何支持多種頁面控制器呢？配置HandlerAdapter從而支持多種類型的頁面控制器

四、  如何頁面控制器如何使用業務對象？能夠預料到，確定利用Spring IoC容器的依賴注入功能

五、  頁面控制器如何返回模型數據？使用ModelAndView返回

六、  前端控制器如何根據頁面控制器返回的邏輯視圖名選擇具體的視圖進行渲染？ 使用ViewResolver進行解析

七、  不一樣的視圖技術如何使用相應的模型數據？ 由於Model是一個Map數據結構，很容易支持其餘視圖技術

 

在此咱們能夠看出具體的核心開發步驟：

一、  DispatcherServlet在web.xml中的部署描述，從而攔截請求到Spring Web MVC

二、  HandlerMapping的配置，從而將請求映射處處理器

三、  HandlerAdapter的配置，從而支持多種類型的處理器

四、  ViewResolver的配置，從而將邏輯視圖名解析爲具體視圖技術

五、處理器（頁面控制器）的配置，從而進行功能處理

 

上邊的開發步驟咱們會在Hello World中詳細驗證。

 

2．四、Spring Web MVC優點

一、清晰的角色劃分：前端控制器（DispatcherServlet）、請求處處理器映射（HandlerMapping）、處理器適配器（HandlerAdapter）、視圖解析器（ViewResolver）、處理器或頁面控制器（Controller）、驗證器（   Validator）、命令對象（Command  請求參數綁定到的對象就叫命令對象）、表單對象（Form Object 提供給表單展現和提交到的對象就叫表單對象）。

二、分工明確，並且擴展點至關靈活，能夠很容易擴展，雖然幾乎不須要；

三、因爲命令對象就是一個POJO，無需繼承框架特定API，可使用命令對象直接做爲業務對象；

四、和Spring 其餘框架無縫集成，是其它Web框架所不具有的；

五、可適配，經過HandlerAdapter能夠支持任意的類做爲處理器；

六、可定製性，HandlerMapping、ViewResolver等可以很是簡單的定製；

七、功能強大的數據驗證、格式化、綁定機制；

八、利用Spring提供的Mock對象可以很是簡單的進行Web層單元測試；

九、本地化、主題的解析的支持，使咱們更容易進行國際化和主題的切換。

十、強大的JSP標籤庫，使JSP編寫更容易。

………………還有好比RESTful風格的支持、簡單的文件上傳、約定大於配置的契約式編程支持、基於註解的零配置支持等等。

 

到此咱們已經簡單的瞭解了Spring Web MVC，接下來讓咱們來個實例來具體使用下這個框架。

2．五、Hello World入門

2.5.一、準備開發環境和運行環境：

☆開發工具：eclipse

☆運行環境：tomcat6.0.20

☆工程：動態web工程（springmvc-chapter2）

☆spring框架下載：

spring-framework-3.1.1.RELEASE-with-docs.zip

☆依賴jar包：

一、  Spring框架jar包：

爲了簡單，將spring-framework-3.1.1.RELEASE-with-docs.zip/dist/下的全部jar包拷貝到項目的WEB-INF/lib目錄下；

二、  Spring框架依賴的jar包：

須要添加Apache commons logging日誌，此處使用的是commons.logging-1.1.1.jar；

須要添加jstl標籤庫支持，此處使用的是jstl-1.1.2.jar和standard-1.1.2.jar；

2.5.二、前端控制器的配置

在咱們的web.xml中添加以下配置：

 

java代碼：

Java代碼  

1. <servlet>  

2.     <servlet-name>chapter2</servlet-name>  

3.     <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>chapter2</servlet-name>  

8.     <url-pattern>/</url-pattern>  

9. </servlet-mapping>  

load-on-startup：表示啓動容器時初始化該Servlet；

url-pattern：表示哪些請求交給Spring Web MVC處理， 「/」 是用來定義默認servlet映射的。也能夠如「*.html」表示攔截全部以html爲擴展名的請求。

 

自此請求已交給Spring Web MVC框架處理，所以咱們須要配置Spring的配置文件，默認DispatcherServlet會加載WEB-INF/[DispatcherServlet的Servlet名字]-servlet.xml配置文件。本示例爲WEB-INF/ chapter2-servlet.xml。

 

2.5.三、在Spring配置文件中配置HandlerMapping、HandlerAdapter

具體配置在WEB-INF/ chapter2-servlet.xml文件中：

 

java代碼：

Java代碼  

1. <!-- HandlerMapping -->  

2. <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>  

3.    

4. <!-- HandlerAdapter -->  

5. <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>  

 

BeanNameUrlHandlerMapping：表示將請求的URL和Bean名字映射，如URL爲 「上下文/hello」，則Spring配置文件必須有一個名字爲「/hello」的Bean，上下文默認忽略。

SimpleControllerHandlerAdapter：表示全部實現了org.springframework.web.servlet.mvc.Controller接口的Bean能夠做爲Spring Web MVC中的處理器。若是須要其餘類型的處理器能夠經過實現HadlerAdapter來解決。

2.5.四、在Spring配置文件中配置ViewResolver

具體配置在WEB-INF/ chapter2-servlet.xml文件中：

 

java代碼：

Java代碼  

1. <!-- ViewResolver -->  

2. <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  

3.     <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>  

4.     <property name="prefix" value="/WEB-INF/jsp/"/>  

5.     <property name="suffix" value=".jsp"/>  

6. </bean>  

 

InternalResourceViewResolver：用於支持Servlet、JSP視圖解析；

    viewClass：JstlView表示JSP模板頁面須要使用JSTL標籤庫，classpath中必須包含jstl的相關jar包；

    prefix和suffix：查找視圖頁面的前綴和後綴（前綴[邏輯視圖名]後綴），好比傳進來的邏輯視圖名爲hello，則該該jsp視圖頁面應該存放在「WEB-INF/jsp/hello.jsp」；

 

2.5.五、開發處理器/頁面控制器

 

java代碼：

Java代碼  

1. package cn.javass.chapter2.web.controller;  

2. import javax.servlet.http.HttpServletRequest;  

3. import javax.servlet.http.HttpServletResponse;  

4. import org.springframework.web.servlet.ModelAndView;  

5. import org.springframework.web.servlet.mvc.Controller;  

6. public class HelloWorldController implements Controller {  

7.     @Override  

8.     public ModelAndView handleRequest(HttpServletRequest req, HttpServletResponse resp) throws Exception {  

9.        //一、收集參數、驗證參數  

10.        //二、綁定參數到命令對象  

11.        //三、將命令對象傳入業務對象進行業務處理  

12.        //四、選擇下一個頁面  

13.        ModelAndView mv = new ModelAndView();  

14.        //添加模型數據 能夠是任意的POJO對象  

15.        mv.addObject("message", "Hello World!");  

16.        //設置邏輯視圖名，視圖解析器會根據該名字解析到具體的視圖頁面  

17.        mv.setViewName("hello");  

18.        return mv;  

19.     }  

20. }  

 

org.springframework.web.servlet.mvc.Controller：頁面控制器/處理器必須實現Controller接口，注意別選錯了；後邊咱們會學習其餘的處理器實現方式；

public ModelAndView handleRequest(HttpServletRequest req, HttpServletResponse resp) ：功能處理方法，實現相應的功能處理，好比收集參數、驗證參數、綁定參數到命令對象、將命令對象傳入業務對象進行業務處理、最後返回ModelAndView對象；

ModelAndView：包含了視圖要實現的模型數據和邏輯視圖名；「mv.addObject("message", "Hello World!");

」表示添加模型數據，此處能夠是任意POJO對象；「mv.setViewName("hello");」表示設置邏輯視圖名爲「hello」，視圖解析器會將其解析爲具體的視圖，如前邊的視圖解析器InternalResourceVi。wResolver會將其解析爲「WEB-INF/jsp/hello.jsp」。

 

 

咱們須要將其添加到Spring配置文件(WEB-INF/chapter2-servlet.xml)，讓其接受Spring IoC容器管理:

 

java代碼：

Java代碼  

1. <!-- 處理器 -->  

2. <bean name="/hello" class="cn.javass.chapter2.web.controller.HelloWorldController"/>  

 

name="/hello"：前邊配置的BeanNameUrlHandlerMapping，表示如過請求的URL爲 「上下文/hello」，則將會交給該Bean進行處理。 

2.5.六、開發視圖頁面

建立 /WEB-INF/jsp/hello.jsp視圖頁面：

 

java代碼：

Java代碼  

1. <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>  

2. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  

3. <html>  

4. <head>  

5. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  

6. <title>Hello World</title>  

7. </head>  

8. <body>  

9. ${message}  

10. </body>  

11. </html>  

 

${message}：表示顯示由HelloWorldController處理器傳過來的模型數據。

2.5.六、啓動服務器運行測試

經過請求：http://localhost:9080/springmvc-chapter2/hello，若是頁面輸出「Hello World! 」就代表咱們成功了！

 

 

2.5.七、運行流程分析

如圖2-3

 

圖2-3

運行步驟：

一、  首先用戶發送請求http://localhost:9080/springmvc-chapter2/hello——>web容器，web容器根據「/hello」路徑映射到DispatcherServlet（url-pattern爲/）進行處理；

二、  DispatcherServlet——>BeanNameUrlHandlerMapping進行請求處處理的映射，BeanNameUrlHandlerMapping將「/hello」路徑直接映射到名字爲「/hello」的Bean進行處理，即HelloWorldController，BeanNameUrlHandlerMapping將其包裝爲HandlerExecutionChain（只包括HelloWorldController處理器，沒有攔截器）；

三、  DispatcherServlet——> SimpleControllerHandlerAdapter，SimpleControllerHandlerAdapter將HandlerExecutionChain中的處理器（HelloWorldController）適配爲SimpleControllerHandlerAdapter；

四、  SimpleControllerHandlerAdapter——> HelloWorldController處理器功能處理方法的調用，SimpleControllerHandlerAdapter將會調用處理器的handleRequest方法進行功能處理，該處理方法返回一個ModelAndView給DispatcherServlet；

五、  hello（ModelAndView的邏輯視圖名）——>InternalResourceViewResolver， InternalResourceViewResolver使用JstlView，具體視圖頁面在/WEB-INF/jsp/hello.jsp；

六、  JstlView（/WEB-INF/jsp/hello.jsp）——>渲染，將在處理器傳入的模型數據(message=HelloWorld！)在視圖中展現出來；

七、  返回控制權給DispatcherServlet，由DispatcherServlet返回響應給用戶，到此一個流程結束。

 

到此HelloWorld就完成了，步驟是否是有點多？並且回憶下咱們主要進行了以下配置：

 

一、  前端控制器DispatcherServlet；

二、  HandlerMapping

三、  HandlerAdapter

四、  ViewResolver

五、  處理器/頁面控制器

六、  視圖

 

所以，接下來幾章讓咱們詳細看看這些配置，先從DispatcherServlet開始吧。

 

2．六、POST中文亂碼解決方案

spring Web MVC框架提供了org.springframework.web.filter.CharacterEncodingFilter用於解決POST方式形成的中文亂碼問題，具體配置以下：

 

java代碼：

Java代碼  

1. <filter>  

2.     <filter-name>CharacterEncodingFilter</filter-name>  

3.     <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  

4.     <init-param>  

5.         <param-name>encoding</param-name>  

6.         <param-value>utf-8</param-value>  

7.     </init-param>  

8. </filter>  

9. <filter-mapping>  

10.     <filter-name>CharacterEncodingFilter</filter-name>  

11.     <url-pattern>/*</url-pattern>  

12. </filter-mapping>  

 

之後咱們項目及全部頁面的編碼均爲UTF-8。

 

 

2.七、Spring3.1新特性

1、Spring2.5以前，咱們都是經過實現Controller接口或其實現來定義咱們的處理器類。

 

2、Spring2.5引入註解式處理器支持，經過@Controller 和 @RequestMapping註解定義咱們的處理器類。而且提供了一組強大的註解：

 

須要經過處理器映射DefaultAnnotationHandlerMapping和處理器適配器AnnotationMethodHandlerAdapter來開啓支持@Controller 和 @RequestMapping註解的處理器。

 

@Controller：用於標識是處理器類；

@RequestMapping：請求處處理器功能方法的映射規則；

@RequestParam：請求參數處處理器功能處理方法的方法參數上的綁定；

@ModelAttribute：請求參數到命令對象的綁定；

@SessionAttributes：用於聲明session級別存儲的屬性，放置在處理器類上，一般列出模型屬性（如@ModelAttribute）對應的名稱，則這些屬性會透明的保存到session中；

@InitBinder：自定義數據綁定註冊支持，用於將請求參數轉換到命令對象屬性的對應類型；

 

3、Spring3.0引入RESTful架構風格支持(經過@PathVariable註解和一些其餘特性支持),且又引入了更多的註解支持：

@CookieValue：cookie數據處處理器功能處理方法的方法參數上的綁定；

@RequestHeader：請求頭（header）數據處處理器功能處理方法的方法參數上的綁定；

@RequestBody：請求的body體的綁定（經過HttpMessageConverter進行類型轉換）；

@ResponseBody：處理器功能處理方法的返回值做爲響應體（經過HttpMessageConverter進行類型轉換）；

@ResponseStatus：定義處理器功能處理方法/異常處理器返回的狀態碼和緣由；

@ExceptionHandler：註解式聲明異常處理器；

@PathVariable：請求URI中的模板變量部分處處理器功能處理方法的方法參數上的綁定，從而支持RESTful架構風格的URI；

 

4、還有好比：

JSR-303驗證框架的無縫支持（經過@Valid註解定義驗證元數據）；

使用Spring 3開始的ConversionService進行類型轉換（PropertyEditor依然有效），支持使用@NumberFormat 和 @DateTimeFormat來進行數字和日期的格式化；

HttpMessageConverter（Http輸入/輸出轉換器，好比JSON、XML等的數據輸出轉換器）；

ContentNegotiatingViewResolver，內容協商視圖解析器，它仍是視圖解析器，只是它支持根據請求信息將同一模型數據以不一樣的視圖方式展現（如json、xml、html等），RESTful架構風格中很重要的概念（同一資源，多種表現形式）；

Spring 3 引入 一個  mvc XML的命名空間用於支持mvc配置，包括如：

    <mvc:annotation-driven>：

      自動註冊基於註解風格的處理器須要的DefaultAnnotationHandlerMapping、AnnotationMethodHandlerAdapter

      支持Spring3的ConversionService自動註冊

      支持JSR-303驗證框架的自動探測並註冊（只需把JSR-303實現放置到classpath）

      自動註冊相應的HttpMessageConverter（用於支持@RequestBody  和 @ResponseBody）（如XML輸入輸出轉換器（只需將JAXP實現放置到classpath）、JSON輸入輸出轉換器（只需將Jackson實現放置到classpath））等。

    <mvc:interceptors>：註冊自定義的處理器攔截器；

    <mvc:view-controller>：和ParameterizableViewController相似，收到相應請求後直接選擇相應的視圖；

    <mvc:resources>：邏輯靜態資源路徑到物理靜態資源路徑的支持；

    <mvc:default-servlet-handler>：當在web.xml 中DispatcherServlet使用<url-pattern>/</url-pattern> 映射時，能映射靜態資源（當Spring Web MVC框架沒有處理請求對應的控制器時（如一些靜態資源），轉交給默認的Servlet來響應靜態文件，不然報404找不到資源錯誤，）。

 

……等等。

 

5、Spring3.1新特性：

對Servlet 3.0的全面支持。

 

@EnableWebMvc：用於在基於Java類定義Bean配置中開啓MVC支持，和XML中的<mvc:annotation-driven>功能同樣；

 

新的@Contoller和@RequestMapping註解支持類：處理器映射RequestMappingHandlerMapping 和 處理器適配器RequestMappingHandlerAdapter組合來代替Spring2.5開始的處理器映射DefaultAnnotationHandlerMapping和處理器適配器AnnotationMethodHandlerAdapter，提供更多的擴展點，它們之間的區別咱們在處理器映射一章介紹。

 

新的@ExceptionHandler 註解支持類：ExceptionHandlerExceptionResolver來代替Spring3.0的AnnotationMethodHandlerExceptionResolver，在異常處理器一章咱們再詳細講解它們的區別。

 

@RequestMapping的"consumes" 和 "produces" 條件支持：用於支持@RequestBody 和 @ResponseBody，

1consumes指定請求的內容是什麼類型的內容，即本處理方法消費什麼類型的數據，如consumes="application/json"表示JSON類型的內容，Spring會根據相應的HttpMessageConverter進行請求內容區數據到@RequestBody註解的命令對象的轉換；

2produces指定生產什麼類型的內容，如produces="application/json"表示JSON類型的內容，Spring的根據相應的HttpMessageConverter進行請求內容區數據到@RequestBody註解的命令對象的轉換，Spring會根據相應的HttpMessageConverter進行模型數據（返回值）到JSON響應內容的轉換

3以上內容，本章第×××節詳述。

 

URI模板變量加強：URI模板變量能夠直接綁定到@ModelAttribute指定的命令對象、@PathVariable方法參數在視圖渲染以前被合併到模型數據中（除JSON序列化、XML混搭場景下）。

 

@Validated：JSR-303的javax.validation.Valid一種變體（非JSR-303規範定義的，而是Spring自定義的），用於提供對Spring的驗證器（org.springframework.validation.Validator）支持，須要Hibernate Validator 4.2及更高版本支持；

 

@RequestPart：提供對「multipart/form-data」請求的全面支持，支持Servlet 3.0文件上傳（javax.servlet.http.Part）、支持內容的HttpMessageConverter（即根據請求頭的Content-Type，來判斷內容區數據是什麼類型，如JSON、XML，能自動轉換爲命令對象），比@RequestParam更強大（只能對請求參數數據綁定，key-alue格式），而@RequestPart支持如JSON、XML內容區數據的綁定；詳見本章的第×××節；

 

Flash 屬性 和 RedirectAttribute：經過FlashMap存儲一個請求的輸出，當進入另外一個請求時做爲該請求的輸入，典型場景如重定向（POST-REDIRECT-GET模式，一、POST時將下一次須要的數據放在FlashMap；二、重定向；三、經過GET訪問重定向的地址，此時FlashMap會把1放到FlashMap的數據取出放到請求中，並從FlashMap中刪除；從而支持在兩次請求之間保存數據並防止了重複表單提交）。

Spring Web MVC提供FlashMapManager用於管理FlashMap，默認使用SessionFlashMapManager，即數據默認存儲在session中。