2．1、Spring Web MVC是甚么

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

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

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

2．2、Spring Web MVC能幫我們做甚么

√讓我們能非常簡單的設計出干凈的Web層和薄薄的Web層；

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

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

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

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

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

√非常容易與其他視圖技術集成，如Velocity、FreeMarker等等，由于模型數據不放在特定的API里，而是放在1個Model里（Map數據結構實現，因此很容易被其他框架使用）；

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

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

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

√更加簡單的異常處理；

√對靜態資源的支持；

√支持Restful風格。

2．3、Spring Web MVC架構

Spring Web MVC框架也是1個基于要求驅動的Web框架，并且也使用了前端控制器模式來進行設計，再根據要求映照規則分發給相應的頁面控制器（動作/處理器）進行處理。首先讓我們整體看1下Spring Web MVC處理要求的流程：

2.3.1、Spring Web MVC處理要求的流程

如圖2⑴

圖2⑴

具體履行步驟以下：

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

2、  頁面控制器接收到要求后，進行功能處理，首先需要搜集和綁定要求參數到1個對象，這個對象在Spring Web MVC中叫命令對象，并進行驗證，然后將命令對象拜托給業務對象進行處理；處理終了后返回1個ModelAndView（模型數據和邏輯視圖名）；圖2⑴中的3、4、5步驟；

3、  前端控制器收回控制權，然后根據返回的邏輯視圖名，選擇相應的視圖進行渲染，并把模型數據傳入以便視圖渲染；圖2⑴中的步驟6、7；

4、  前端控制器再次收回控制權，將響應返回給用戶，圖2⑴中的步驟8；至此全部結束。

問題：

1、  要求如何給前端控制器？

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

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

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

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

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

7、  不同的視圖技術如何使用相應的模型數據？

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

2.3.2、Spring Web MVC架構

1、Spring Web MVC核心架構圖，如圖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.                    //步驟2、要求到處理器（頁面控制器）的映照，通過HandlerMapping進行映照  
15.                 mappedHandler = getHandler(processedRequest, false);  
16.                 if (mappedHandler == null || mappedHandler.getHandler() == null) {  
17.                     noHandlerFound(processedRequest, response);  
18.                     return;  
19.                 }  
20.                    //步驟3、處理器適配，行將我們的處理器包裝成相應的適配器（從而支持多種類型的處理器）  
21.                 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());  
22.   
23.                   // 304 Not Modified緩存支持  
24.                 //此處省略具體代碼  
25.   
26.                 // 履行處理器相干的攔截器的預處理（HandlerInterceptor.preHandle）  
27.                 //此處省略具體代碼  
28.   
29.                 // 步驟4、由適配器履行處理器（調用途理器相應功能處理方法）  
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 步驟6、解析視圖并進行視圖的渲染  
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.     }  

//前端控制器分派方法 protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception { HttpServletRequest processedRequest = request; HandlerExecutionChain mappedHandler = null; int interceptorIndex = ⑴; try { ModelAndView mv; boolean errorView = false; try { //檢查是不是是要求是不是是multipart（如文件上傳），如果是將通過MultipartResolver解析 processedRequest = checkMultipart(request); //步驟2、要求到處理器（頁面控制器）的映照，通過HandlerMapping進行映照 mappedHandler = getHandler(processedRequest, false); if (mappedHandler == null || mappedHandler.getHandler() == null) { noHandlerFound(processedRequest, response); return; } //步驟3、處理器適配，行將我們的處理器包裝成相應的適配器（從而支持多種類型的處理器） HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler()); // 304 Not Modified緩存支持 //此處省略具體代碼 // 履行處理器相干的攔截器的預處理（HandlerInterceptor.preHandle） //此處省略具體代碼 // 步驟4、由適配器履行處理器（調用途理器相應功能處理方法） mv = ha.handle(processedRequest, response, mappedHandler.getHandler()); // Do we need view name translation? if (mv != null && !mv.hasView()) { mv.setViewName(getDefaultViewName(request)); } // 履行處理器相干的攔截器的后處理（HandlerInterceptor.postHandle） //此處省略具體代碼 } catch (ModelAndViewDefiningException ex) { logger.debug("ModelAndViewDefiningException encountered", ex); mv = ex.getModelAndView(); } catch (Exception ex) { Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null); mv = processHandlerException(processedRequest, response, handler, ex); errorView = (mv != null); } //步驟5 步驟6、解析視圖并進行視圖的渲染 //步驟5 由ViewResolver解析View（viewResolver.resolveViewName(viewName, locale)） //步驟6 視圖在渲染時會把Model傳入（view.render(mv.getModelInternal(), request, response);） if (mv != null && !mv.wasCleared()) { render(mv, processedRequest, response); if (errorView) { WebUtils.clearErrorRequestAttributes(request); } } else { if (logger.isDebugEnabled()) { logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() + "': assuming HandlerAdapter completed request handling"); } } // 履行處理器相干的攔截器的完成后處理（HandlerInterceptor.afterCompletion） //此處省略具體代碼 catch (Exception ex) { // Trigger after-completion for thrown exception. triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex); throw ex; } catch (Error err) { ServletException ex = new NestedServletException("Handler processing failed", err); // Trigger after-completion for thrown exception. triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex); throw ex; } finally { // Clean up any resources used by a multipart request. if (processedRequest != request) { cleanupMultipart(processedRequest); } } }

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

1、  首先用戶發送要求——>DispatcherServlet，前端控制器收到要求后自己不進行處理，而是拜托給其他的解析器進行處理，作為統1訪問點，進行全局的流程控制；

2、  DispatcherServlet——>HandlerMapping， HandlerMapping將會把要求映照為HandlerExecutionChain對象（包括1個Handler處理器（頁面控制器）對象、多個HandlerInterceptor攔截器）對象，通過這類策略模式，很容易添加新的映照策略；

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

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

5、  ModelAndView的邏輯視圖名——> ViewResolver， ViewResolver將把邏輯視圖名解析為具體的View，通過這類策略模式，很容易更換其他視圖技術；

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

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

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

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

1、  要求如何給前端控制器？這個應當在web.xml中進行部署描寫，在HelloWorld中詳細講授。

2、  前端控制器如何根據要求信息選擇頁面控制器進行功能處理？ 我們需要配置HandlerMapping進行映照

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

4、  如何頁面控制器如何使用業務對象？可以預感到，肯定利用Spring IoC容器的依賴注入功能

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

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

7、  不同的視圖技術如何使用相應的模型數據？ 由于Model是1個Map數據結構，很容易支持其他視圖技術

在此我們可以看出具體的核心開發步驟：

1、  DispatcherServlet在web.xml中的部署描寫，從而攔截要求到Spring Web MVC

2、  HandlerMapping的配置，從而將要求映照到處理器

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

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

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

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

2．4、Spring Web MVC優勢

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

2、分工明確，而且擴大點相當靈活，可以很容易擴大，雖然幾近不需要；

3、由于命令對象就是1個POJO，無需繼承框架特定API，可使用命令對象直接作為業務對象；

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

5、可適配，通過HandlerAdapter可以支持任意的類作為處理器；

6、可定制性，HandlerMapping、ViewResolver等能夠非常簡單的定制；

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

8、利用Spring提供的Mock對象能夠非常簡單的進行Web層單元測試；

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

10、強大的JSP標簽庫，使JSP編寫更容易。

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

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

2．5、Hello World入門

2.5.1、準備開發環境和運行環境：

☆開發工具：eclipse

☆運行環境：tomcat6.0.20

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

☆spring框架下載：

spring-framework⑶.1.1.RELEASE-with-docs.zip

☆依賴jar包：

1、  Spring框架jar包：

為了簡單，將spring-framework⑶.1.1.RELEASE-with-docs.zip/dist/下的所有jar包拷貝到項目的WEB-INF/lib目錄下；

2、  Spring框架依賴的jar包：

需要添加Apache commons logging日志，此處使用的是commons.logging⑴.1.1.jar；

需要添加jstl標簽庫支持，此處使用的是jstl⑴.1.2.jar和standard⑴.1.2.jar；

2.5.2、前端控制器的配置

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

java代碼：

Java代碼  

1.   
2.     chapter2  
3.     class>org.springframework.web.servlet.DispatcherServletclass>  
4.     1  
5.   
6.   
7.     chapter2  
8.     /  
9.   

chapter2org.springframework.web.servlet.DispatcherServlet1chapter2/

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.3、在Spring配置文件中配置HandlerMapping、HandlerAdapter

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

java代碼：

Java代碼  

1.   
2. class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>  
3.    
4.   
5. class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>  

BeanNameUrlHandlerMapping：表示將要求的URL和Bean名字映照，如URL為 “上下文/hello”，則Spring配置文件必須有1個名字為“/hello”的Bean，上下文默許疏忽。

SimpleControllerHandlerAdapter：表示所有實現了org.springframework.web.servlet.mvc.Controller接口的Bean可以作為Spring Web MVC中的處理器。如果需要其他類型的處理器可以通過實現HadlerAdapter來解決。

2.5.4、在Spring配置文件中配置ViewResolver

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

java代碼：

Java代碼  

1.   
2. class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
3.     "viewClass" value="org.springframework.web.servlet.view.JstlView"/>  
4.     "prefix" value="/WEB-INF/jsp/"/>  
5.     "suffix" value=".jsp"/>  
6.   

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

    viewClass：JstlView表示JSP模板頁面需要使用JSTL標簽庫，classpath中必須包括jstl的相干jar包；

    prefix和suffix：查找視圖頁面的前綴和后綴（前綴[邏輯視圖名]后綴），比如傳進來的邏輯視圖名為hello，則該該jsp視圖頁面應當寄存在“WEB-INF/jsp/hello.jsp”；

2.5.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.        //1、搜集參數、驗證參數  
10.        //2、綁定參數到命令對象  
11.        //3、將命令對象傳入業務對象進行業務處理  
12.        //4、選擇下1個頁面  
13.        ModelAndView mv = new ModelAndView();  
14.        //添加模型數據 可以是任意的POJO對象  
15.        mv.addObject("message", "Hello World!");  
16.        //設置邏輯視圖名，視圖解析器會根據該名字解析到具體的視圖頁面  
17.        mv.setViewName("hello");  
18.        return mv;  
19.     }  
20. }  

package cn.javass.chapter2.web.controller; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.springframework.web.servlet.ModelAndView; import org.springframework.web.servlet.mvc.Controller; public class HelloWorldController implements Controller { @Override public ModelAndView handleRequest(HttpServletRequest req, HttpServletResponse resp) throws Exception { //1、搜集參數、驗證參數 //2、綁定參數到命令對象 //3、將命令對象傳入業務對象進行業務處理 //4、選擇下1個頁面 ModelAndView mv = new ModelAndView(); //添加模型數據 可以是任意的POJO對象 mv.addObject("message", "Hello World!"); //設置邏輯視圖名，視圖解析器會根據該名字解析到具體的視圖頁面 mv.setViewName("hello"); return mv; } }

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. "/hello" class="cn.javass.chapter2.web.controller.HelloWorldController"/>  

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

2.5.6、開發視圖頁面

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

java代碼：

Java代碼  

1. <%@ page language="java" contentType="text/html; charset=UTF⑻" pageEncoding="UTF⑻"%>  
2. "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
3.   
4.   
5. "Content-Type" content="text/html; charset=UTF⑻">  
6. Hello World  
7.   
8.   
9. ${message}  
10.   
11.   

<%@ page language="java" contentType="text/html; charset=UTF⑻" pageEncoding="UTF⑻"%> Hello World${message}

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

2.5.6、啟動服務器運行測試

通過要求：http://localhost:9080/springmvc-chapter2/hello，如果頁面輸出“Hello World! ”就表明我們成功了！

2.5.7、運行流程分析

如圖2⑶

圖2⑶

運行步驟：

1、  首先用戶發送要求http://localhost:9080/springmvc-chapter2/hello——>web容器，web容器根據“/hello”路徑映照到DispatcherServlet（url-pattern為/）進行處理；

2、  DispatcherServlet——>BeanNameUrlHandlerMapping進行要求到處理的映照，BeanNameUrlHandlerMapping將“/hello”路徑直接映照到名字為“/hello”的Bean進行處理，即HelloWorldController，BeanNameUrlHandlerMapping將其包裝為HandlerExecutionChain（只包括HelloWorldController處理器，沒有攔截器）；

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

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

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

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

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

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

1、  前端控制器DispatcherServlet；

2、  HandlerMapping

3、  HandlerAdapter

4、  ViewResolver

5、  處理器/頁面控制器

6、  視圖

因此，接下來幾章讓我們詳細看看這些配置，先從DispatcherServlet開始吧。

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

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

java代碼：

Java代碼  

1.   
2.     CharacterEncodingFilter  
3.     class>org.springframework.web.filter.CharacterEncodingFilterclass>  
4.       
5.         encoding  
6.         utf-8  
7.       
8.   
9.   
10.     CharacterEncodingFilter  
11.     /*  
12.   

CharacterEncodingFilterorg.springframework.web.filter.CharacterEncodingFilterencodingutf⑻CharacterEncodingFilter/*

以后我們項目及所有頁面的編碼均為UTF⑻。

2.7、Spring3.1新特性

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

2、Spring2.5引入注解式處理器支持，通過@Controller 和 @RequestMapping注解定義我們的處理器類。并且提供了1組強大的注解：

需要通過處理器映照DefaultAnnotationHandlerMapping和處理器適配器AnnotationMethodHandlerAdapter來開啟支持@Controller 和 @RequestMapping注解的處理器。

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

@RequestMapping：要求到處理器功能方法的映照規則；

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

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

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

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

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

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

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

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

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

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

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

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

4、還有比如：

JSR⑶03驗證框架的無縫支持（通過@Valid注解定義驗證元數據）；

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

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

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

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

   ：

      自動注冊基于注解風格的處理器需要的DefaultAnnotationHandlerMapping、AnnotationMethodHandlerAdapter

      支持Spring3的ConversionService自動注冊

      支持JSR⑶03驗證框架的自動探測并注冊（只需把JSR⑶03實現放置到classpath）

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

   ：注冊自定義的處理器攔截器；

   ：和ParameterizableViewController類似，收到相應要求后直接選擇相應的視圖；

    ：邏輯靜態資源路徑到物理靜態資源路徑的支持；

    ：當在web.xml 中DispatcherServlet使用/ 映照時，能映照靜態資源（當Spring Web MVC框架沒有處理要求對應的控制器時（如1些靜態資源），轉交給默許的Servlet來響應靜態文件，否則報404找不到資源毛病，）。

……等等。

5、Spring3.1新特性：

對Servlet 3.0的全面支持。

@EnableWebMvc：用于在基于Java類定義Bean配置中開啟MVC支持，和XML中的