JAVAWEB开发之SpringMVC详解(一)——SpringMVC的框架原理、架构简介、与mybatis整合和注解方式的使用、

知识清单

基础知识清单

SpringMVC框架(重点)

• MVC在B/S系统中的应用方式
• SpringMVC框架原理(DispatcherServlet前端控制器、处理器映射器、处理器适配器、视图解析器)

SpringMVC入门程序

• 需求：商品列表查询
• 常用的处理器映射器，处理器适配器
• 注解的处理器映射器，处理器适配器用于注解开发(重点)

注解开发基础

• 常用注解的使用
• 参数绑定
• 自定义参数绑定

SpringMVC与Struts的区别

高级知识清单(第二部分)

使用SpringMVC上传图片

集合参数的绑定

validation校验器

异常处理器的使用(用于系统异常处理)

Restful支持

拦截器

SpringMVC框架

SpringMVC是什么?

springmvc是Spring的一个模块，提供web层解决方案(就与MVC设计架构)

MVC在B/S系统中的应用

MVC是一种设计模式，在B/S中的应用如下图所示：

SpringMVC的框架

执行过程大致如下：

第一步：用户发起request请求，请求至DispatcherServlet前端控制器。

第二步：DispatcherServlet前端控制器请求HandlerMapping处理器映射器查找Handler。DispatcherServlet: 前端控制器，相当于中央调度器，各个组件都和前端控制器进行交互，降低了各个组件之间的耦合度。

第三步：HandlerMapping处理器映射器，根据url及一些配置规则(xml配置、注解配置)查找Handler，将Handler返回给DispatcherServlet前端控制器。

第四步：DispatcherServlet前端控制器调用适配器执行Handler，有了适配器通过适配器去扩展对不同Handler执行方式(比如：原始servlet开发，注解开发)

第五步：适配器执行Handler；Handler是后端控制器，可以当成模型。

第六步：Handler执行完后后返回ModelAndView。ModelAndView: SpringMVC的一个对象，对model和view进行封装。

第七步：适配器将ModelAndView返回给DispatcherServlet前端控制器。

第八步：DispatcherServlet调用视图解析器进行视图解析，解析后生成view，视图解析器根据逻辑视图名解析出真正的视图。view：SpringMVC视图封装对象，提供了很多view，比如jsp、freemarker、pdf、execel.......。

第九步：ViewResolver视图解析器给前端控制器返回view。

第十步：DispatcherServlet调用view的渲染视图的方法，将模型数据填充到request域。

第十一步：DispatcherServlet向用户响应结果(jsp页面、json数据......).

DispatcherServlet：前端控制器，由SpringMVC提供。

HandlerMapping：处理器映射器，由SpringMVC提供。

HandlerAdapter：处理器适配器，由SpringMVC提供。

Handler：处理器，需要程序员开发。

ViewResolver：视图解析器，由SpringMVC提供。

view：真正的视图页面，由程序员编写。

入门程序

需求

实现商品列表查询

需要的jar包

使用spring3.2.0(带springmvc模块)  如下图所示

前端控制器

在web.xml中进行配置

[html] view plain copy

1. <!-- 前端控制器 -->  
2.     <servlet>  
3.         <servlet-name>springmvc</servlet-name>  
4.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
5.         <!-- 加载SpringMVC配置 -->  
6.         <init-param>  
7.             <!-- 配置文件的位置 -->  
8.             <!-- 如果不配置contextConfigLocation,  
9.                  默认查找的配置文件名称classpath下的: servlet名称+"servlet.xml"即springmvc-servlet.xml  
10.              -->  
11.             <param-name>contextConfigLocation</param-name>  
12.             <param-value>classpath:springmvc.xml</param-value>  
13.         </init-param>  
14.     </servlet>  
15.     <servlet-mapping>  
16.         <servlet-name>springmvc</servlet-name>  
17.         <!--   
18.         可以配置/, 此工程 所有请求全部由springmvc解析，此种方式可以实现  
19.         RESTful方式，需要特殊处理对静态文本的解析不能由springmvc解析  
20.         可以配置*.do或*.action, 所有请求的url扩展名为.do或.action由springmvc解析，此种方法  
21.         不可以使用/*,如果配置/*，返回的jsp也由springmvc解析，这是不对的  
22.          -->  
23.         <url-pattern>*.action</url-pattern>  
24.     </servlet-mapping>  

springmvc.xml

在springmvc.xml中配置springmvc架构的三大组件（处理器映射器、处理器适配器、视图解析器）

工程结构

处理器映射器

在springmvc.xml中进行配置：

BeanNameURLHandlerMapping：根据url( xxx.action ) 匹配Spring容器的name。

找到对应的Bean（程序员编写的Handler）

[html] view plain copy

1. <!-- 根据bean的name进行查找Handler 将action的url配置在bean的name中 -->  
2.         <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>  

注意：所有处理器映射器都实现HandlerMapping接口。

处理器适配器

在springmvc.xml中配置：

[html] view plain copy

1. <!-- 配置处理器适配器 springmvc框架根据HandlerAdapter接口判断是否是处理器适配器 -->  
2.         <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>  

注意：所有的适配器都是实现了HandlerAdapter接口。

程序员编写Handler要根据所配置的适配器的要求编写。

SimpleControllerHandlerAdapter适配器要求：通过supports方法知道Handler必须要实现哪个接口

查看HandlerAdapter(适配器接口)源代码如下：

[java] view plain copy

1. public interface HandlerAdapter {  
2.     // 已经去除文档注释  
3.     boolean supports(Object handler);   
4.           
5.     ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;  
6.   
7.     long getLastModified(HttpServletRequest request, Object handler);  
8.   
9. }  

查看SimpleControllerHandlerAdapter适配器源码如下：

[java] view plain copy

1. public class SimpleControllerHandlerAdapter implements HandlerAdapter {  
2.   
3.     public boolean supports(Object handler) {  
4.         return (handler instanceof Controller);  
5.     }  
6.   
7.     public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)  
8.             throws Exception {  
9.   
10.         return ((Controller) handler).handleRequest(request, response);  
11.     }  
12.   
13.     public long getLastModified(HttpServletRequest request, Object handler) {  
14.         if (handler instanceof LastModified) {  
15.             return ((LastModified) handler).getLastModified(request);  
16.         }  
17.         return -1L;  
18.     }  
19.   
20. }  

可以发现SimpleControllerHandlerAdapter类型的处理器适配器通过support方法根据Handler对象是否实现了Controller接口来进行判断是否支持Handler，凡是实现了Controller接口的类都可以被简单类型的处理器适配器匹配调用，简单处理器适配器通过在handle方法中调用Handler实现Controller接口的HandleRequest方法向前端控制器返回ModelAndView。

Handler的编写

需要实现Controller接口

[java] view plain copy

1. public class ItemController1 implements Controller {  
2.   
3.     public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {  
4.         // 使用静态数据将商品信息展示在jsp页面上  
5.         // 商品列表  
6.         List<Items> itemsList = new ArrayList<Items>();  
7.   
8.         Items items_1 = new Items();  
9.         items_1.setName("联想笔记本");  
10.         items_1.setPrice(6000f);  
11.         items_1.setCreatetime(new Date());  
12.         items_1.setDetail("ThinkPad T430 联想笔记本电脑！");  
13.   
14.         Items items_2 = new Items();  
15.         items_2.setName("苹果手机");  
16.         items_2.setPrice(5000f);  
17.         items_2.setDetail("iphone6苹果手机！");  
18.   
19.         itemsList.add(items_1);  
20.         itemsList.add(items_2);  
21.   
22.         ModelAndView modelAndView = new ModelAndView();  
23.         // 将数据填充到request  
24.         // request.setAttribute("itemList", itemsList);  
25.         modelAndView.addObject("itemsList", itemsList);  
26.         // 指定转发到JSP页面  
27.         modelAndView.setViewName("/WEB-INF/jsp/itemsList.jsp");  
28.         return modelAndView;  
29.     }  
30.   
31. }  

配置Handler

在springmvc.xml中配置Handler，由Spring管理Handler。

[html] view plain copy

1. <!-- 配置Handler 由于使用了BeanNameUrlHandlerMapping处理器映射器，name配置为url -->  
2.         <bean name="/itemList.action" class="lx.springmvc.first.ItemController1"/>  

配置视图解析器

配置视图解析，能够解析jsp视图

[html] view plain copy

1. <!-- 配置视图解析器 -->  
2.         <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
3.         </bean>  

工程部署

访问：http://localhost:8080/springmvc_first/itemList.action

异常

地址中Handler名称输入错误

HandlerMapping没有找到Handler，message中不显示jsp路径，这种错误一般是由于输入地址操作导致

要转向的JSP页面不存在

其它非注解处理器映射器和适配器

BeanNameUrlHandlerMapping(映射器)

根据请求url (xxx.action)匹配Spring容器中bean的name

找到对应的bean（程序编写的Handler）

SimpleUrlHandlerMapping(映射器)

[html] view plain copy

1. <!-- 简单url映射 集中配置bean的id对应的url -->  
2.     <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">  
3.         <property name="mappings">  
4.             <props>  
5.                 <prop key="itemsTest1.action">itemController1</prop>  
6.                 <prop key="itemsTest2.action">itemController1</prop>  
7.             </props>  
8.         </property>  
9.     </bean>  

注意：在springmvc.xml中配置了多个处理器映射器，多个处理器映射器就可以共存，不会排斥。

SimpleControllerHandlerAdapter(适配器)

要求程序编写的Handler (controller)需要实现Controller接口。

HttpRequestHandlerAdapter(适配器)

在springmvc.xml中配置：HttpRequestHandlerAdapter

要求编写的Handler实现 HttpRequestHandler接口

配置HttpRequestHandlerAdapter适配器

[html] view plain copy

1. <!-- 配置HttpRequestHandlerAdapter适配器 -->  
2.     <bean class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter"/>  

开发Handler

[java] view plain copy

1. public class ItemController2 implements HttpRequestHandler {  
2.   
3.     public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
4.         // 使用静态数据将商品信息展示在jsp页面上  
5.         // 商品列表  
6.         List<Items> itemsList = new ArrayList<Items>();  
7.   
8.         Items items_1 = new Items();  
9.         items_1.setName("联想笔记本");  
10.         items_1.setPrice(6000f);  
11.         items_1.setCreatetime(new Date());  
12.         items_1.setDetail("ThinkPad T430 联想笔记本电脑！");  
13.   
14.         Items items_2 = new Items();  
15.         items_2.setName("苹果手机");  
16.         items_2.setPrice(5000f);  
17.         items_2.setDetail("iphone6苹果手机！");  
18.   
19.         itemsList.add(items_1);  
20.         itemsList.add(items_2);  
21.           
22.         request.setAttribute("itemsList", itemsList);  
23.         request.getRequestDispatcher("/WEB-INF/jsp/itemsList.jsp").forward(request, response);  
24.     }  
25.   
26. }  

可以发现。HttpRequestHandler的开发方式和原始的Servlet开发方式很相近

配置Handler

[html] view plain copy

1. <!-- Handler2 -->  
2. <bean id="itemController2"  class="lx.springmvc.first.ItemController2" />  

使用简单URL映射器

[html] view plain copy

1. <!-- 简单url映射 集中配置bean的id对应的url -->  
2.     <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">  
3.         <property name="mappings">  
4.             <props>  
5.                 <prop key="itemsTest1.action">itemController1</prop>  
6.                 <prop key="itemsTest2.action">itemController2</prop>  
7.             </props>  
8.         </property>  
9.     </bean>  

DispatcherServlet.properties

DispatcherServlet前端控制器加载DispatcherServlet.properties配置文件，从而默认加载各个组件。

如果在springmvc.xml中配置了处理器映射器和适配器，以springmvc.xml的为准。

注解映射器和适配器

注解映射器

Spring3.1之前默认加载器是org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping，3.1之后要使用org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping。

在springmvc.xml中配置RequestMappingHandlerMapping：

[html] view plain copy

1. <!-- 注解处理器映射器 -->  
2.     <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>  

使用RequestMappingHandlerMapping 注解映射器需要在Handler中使用@Controller标识此类是一个控制器，使用@RequestMapping指定Handler方所对应的url。

注解适配器

Spring3.1之前默认加载映射器是org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter，3.1之后要使用org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter

RequestMappingHandlerAdapter 注解适配器不要求Handler实现任何接口，但它需要和RequestMappingHandlerMapping注解映射器配对使用，主要解析Handler方法中的形参。在springmvc.xml中配置RequestMappingHandlerAdapter如下：

[html] view plain copy

1. <!-- 注解适配器 -->  
2.     <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>  

注解开发Handler

[java] view plain copy

1. @Controller  
2. public class ItemController3 {  
3.     // 商品列表，@RequestMapping中的url建议和方法名一致，方便开发维护  
4.     @RequestMapping("/queryItems")  
5.     public ModelAndView queryItems() throws ServletException, IOException {  
6.         // 使用静态数据将商品信息展示在jsp页面上  
7.         // 商品列表  
8.         List<Items> itemsList = new ArrayList<Items>();  
9.   
10.         Items items_1 = new Items();  
11.         items_1.setName("联想笔记本");  
12.         items_1.setPrice(6000f);  
13.         items_1.setCreatetime(new Date());  
14.         items_1.setDetail("ThinkPad T430 联想笔记本电脑！");  
15.   
16.         Items items_2 = new Items();  
17.         items_2.setName("苹果手机");  
18.         items_2.setPrice(5000f);  
19.         items_2.setDetail("iphone6苹果手机！");  
20.   
21.         itemsList.add(items_1);  
22.         itemsList.add(items_2);  
23.           
24.         ModelAndView modelAndView = new ModelAndView();  
25.         modelAndView.addObject("itemsList",itemsList);  
26.         // 指定逻辑视图名  
27.         modelAndView.setViewName("/WEB-INF/jsp/itemsList.jsp");  
28.           
29.         return modelAndView;  
30.     }  
31.   
32. }  

配置Handler

[html] view plain copy

1. <!-- 注解配置Handler，单个配置 -->  
2.     <!-- <bean class="lx.springmvc.first.ItemController3"/>  -->  
3.     <!-- 使用Spring组件扫描 -->  
4.     <context:component-scan base-package="lx.springmvc.first"/>  

建议使用组件扫描，组件扫描可以扫描@Controller、@Service、@Component、@Repository

注意：要想使用注解扫描器，Spring的版本要在4.0以上，不然会抛出异常。

小结

DispatcherServlet：前端控制器，相当于中央调度器，可以降低组件之间的耦合度。

HandlerMapping：处理器映射器，负责根据url查找Handler。

HandlerAdapter：处理器适配器，负责根据适配器要求的规则去执行处理器。可以通过扩展适配器支持不同类型的Handler。

ViewResolver：视图解析器，根据逻辑视图名解析成真正的视图。

[html] view plain copy

1. <!-- 配置视图解析器 -->  
2.     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
3.         <property name="prefix" value="/WEB-INF/jsp/"/>  
4.         <property name="suffix" value=".jsp"/>  
5.     </bean>  

真正的视图地址=前缀+逻辑视图名+后缀

注意：逻辑视图名只是在ModelAndView对象中设置视图时适用，对于原始的Servlet(使用request和response进行转发或重定向)不适用。

执行过程中关键源代码如下：

1.DispatcherServlet通过HandlerMapping查找Handler

2.DispatcherServlet通过适配器去执行Handler，得到ModelAndView (在DispatcherServlet中的doDispatch方法中执行整个流程)

3.视图解析

视图解析后得到一个view

4.进行视图渲染

所谓的视图渲染就是将Model中的数据填充到request域

springmvc入门源码

代码已经上传GitHub https://github.com/LX1993728/springmvc_first

web.xml

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
3.     xmlns="http://xmlns.jcp.org/xml/ns/javaee"  
4.     xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"  
5.     id="WebApp_ID" version="3.1">  
6.     <display-name>springmvc_first</display-name>  
7.     <!-- 前端控制器 -->  
8.     <servlet>  
9.         <servlet-name>springmvc</servlet-name>  
10.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
11.         <!-- 加载SpringMVC配置 -->  
12.         <init-param>  
13.             <!-- 配置文件的位置 -->  
14.             <!-- 如果不配置contextConfigLocation,  
15.                  默认查找的配置文件名称classpath下的: servlet名称+"servlet.xml"即springmvc-servlet.xml  
16.              -->  
17.             <param-name>contextConfigLocation</param-name>  
18.             <param-value>classpath:springmvc.xml</param-value>  
19.         </init-param>  
20.     </servlet>  
21.     <servlet-mapping>  
22.         <servlet-name>springmvc</servlet-name>  
23.         <!--   
24.         可以配置/, 此工程 所有请求全部由springmvc解析，此种方式可以实现  
25.         RESTful方式，需要特殊处理对静态文本的解析不能由springmvc解析  
26.         可以配置*.do或*.action, 所有请求的url扩展名为.do或.action由springmvc解析，此种方法  
27.         不可以使用/*,如果配置/*，返回的jsp也由springmvc解析，这是不对的  
28.          -->  
29.         <url-pattern>*.action</url-pattern>  
30.     </servlet-mapping>  
31.     <welcome-file-list>  
32.         <welcome-file>index.html</welcome-file>  
33.         <welcome-file>index.htm</welcome-file>  
34.         <welcome-file>index.jsp</welcome-file>  
35.         <welcome-file>default.html</welcome-file>  
36.         <welcome-file>default.htm</welcome-file>  
37.         <welcome-file>default.jsp</welcome-file>  
38.     </welcome-file-list>  
39. </web-app>  

springmvc.xml

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"  
4.     xmlns:context="http://www.springframework.org/schema/context"  
5.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"  
6.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
7.         http://www.springframework.org/schema/beans/spring-beans-3.2.xsd   
8.         http://www.springframework.org/schema/mvc   
9.         http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd   
10.         http://www.springframework.org/schema/context   
11.         http://www.springframework.org/schema/context/spring-context-3.2.xsd   
12.         http://www.springframework.org/schema/aop   
13.         http://www.springframework.org/schema/aop/spring-aop-3.2.xsd   
14.         http://www.springframework.org/schema/tx   
15.         http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">  
16.   
17.     <!-- 配置Handler 由于使用了BeanNameUrlHandlerMapping处理器映射器，name配置为url -->  
18.     <bean id="itemController1" name="/itemList.action" class="lx.springmvc.first.ItemController1" />  
19.       
20.     <!-- Handler2 -->  
21.     <bean id="itemController2"  class="lx.springmvc.first.ItemController2" />  
22.       
23.     <!-- 注解配置Handler，单个配置 -->  
24.     <bean class="lx.springmvc.first.ItemController3"/>  
25.     <!-- 使用Spring组件扫描 -->  
26.     <!-- <context:component-scan base-package="lx.springmvc.first"/> -->  
27.      
28.   
29.     <!-- 配置处理器映射器 springmvc框架根据HandlerMapping接口判断是否是处理器映射器 -->  
30.     <!-- 根据bean的name进行查找Handler 将action的url配置在bean的name中 -->  
31.     <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" />  
32.   
33.     <!-- 简单url映射 集中配置bean的id对应的url -->  
34.     <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">  
35.         <property name="mappings">  
36.             <props>  
37.                 <prop key="itemsTest1.action">itemController1</prop>  
38.                 <prop key="itemsTest2.action">itemController2</prop>  
39.             </props>  
40.         </property>  
41.     </bean>  
42.       
43.     <!-- 注解处理器映射器 -->  
44.     <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>  
45.   
46.     <!-- 配置处理器适配器 springmvc框架根据HandlerAdapter接口判断是否是处理器适配器 -->  
47.     <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter" />  
48.       
49.     <!-- 配置HttpRequestHandlerAdapter适配器 -->  
50.     <bean class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter"/>  
51.   
52.     <!-- 注解适配器 -->  
53.     <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>  
54.   
55.     <!-- 配置视图解析器 -->  
56.     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
57.         <property name="prefix" value="/WEB-INF/jsp/"/>  
58.         <property name="suffix" value=".jsp"/>  
59.     </bean>  
60. </beans>        

itemsList.jsp

[html] view plain copy

1. <%@ page language="java" contentType="text/html; charset=UTF-8"  
2.     pageEncoding="UTF-8"%>  
3. <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>  
4. <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt"  prefix="fmt"%>  
5. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
6. <html>  
7. <head>  
8. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
9. <title>查询商品列表</title>  
10. </head>  
11. <body>   
12. <form action="${pageContext.request.contextPath }/item/queryItem.action" method="post">  
13. 查询条件：  
14. <table width="100%" border=1>  
15. <tr>  
16. <td><input type="submit" value="查询"/></td>  
17. </tr>  
18. </table>  
19. 商品列表：  
20. <table width="100%" border=1>  
21. <tr>  
22.     <td>商品名称</td>  
23.     <td>商品价格</td>  
24.     <td>生产日期</td>  
25.     <td>商品描述</td>  
26.     <td>操作</td>  
27. </tr>  
28. <c:forEach items="${itemsList }" var="item">  
29. <tr>  
30.     <td>${item.name }</td>  
31.     <td>${item.price }</td>  
32.     <td><fmt:formatDate value="${item.createtime}" pattern="yyyy-MM-dd HH-mm-ss"/></td>  
33.     <td>${item.detail }</td>  
34.       
35.     <td><a href="${pageContext.request.contextPath }/item/editItem.action?id=${item.id}">修改</a></td>  
36.   
37. </tr>  
38. </c:forEach>  
39.   
40. </table>  
41. </form>  
42. </body>  
43.   
44. </html>  

ItemController1.java

[java] view plain copy

1. package lx.springmvc.first;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Date;  
5. import java.util.List;  
6.   
7. import javax.servlet.http.HttpServletRequest;  
8. import javax.servlet.http.HttpServletResponse;  
9.   
10. import org.springframework.web.servlet.ModelAndView;  
11. import org.springframework.web.servlet.mvc.Controller;  
12.   
13. import lx.springmvc.po.Items;  
14.   
15. /** 
16.  * 入门程序，商品列表查询 
17.  *  
18.  * @author liuxun 
19.  * 
20.  */  
21. public class ItemController1 implements Controller {  
22.   
23.     public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {  
24.         // 使用静态数据将商品信息展示在jsp页面上  
25.         // 商品列表  
26.         List<Items> itemsList = new ArrayList<Items>();  
27.   
28.         Items items_1 = new Items();  
29.         items_1.setName("联想笔记本");  
30.         items_1.setPrice(6000f);  
31.         items_1.setCreatetime(new Date());  
32.         items_1.setDetail("ThinkPad T430 联想笔记本电脑！");  
33.   
34.         Items items_2 = new Items();  
35.         items_2.setName("苹果手机");  
36.         items_2.setPrice(5000f);  
37.         items_2.setDetail("iphone6苹果手机！");  
38.   
39.         itemsList.add(items_1);  
40.         itemsList.add(items_2);  
41.   
42.         ModelAndView modelAndView = new ModelAndView();  
43.         // 将数据填充到request  
44.         // request.setAttribute("itemList", itemsList);  
45.         modelAndView.addObject("itemsList", itemsList);  
46.         // 指定转发到JSP页面  
47.         modelAndView.setViewName("/WEB-INF/jsp/itemsList.jsp");  
48.         return modelAndView;  
49.     }  
50.   
51. }  

ItemController2.java

[java] view plain copy

1. package lx.springmvc.first;  
2.   
3. import java.io.IOException;  
4. import java.util.ArrayList;  
5. import java.util.Date;  
6. import java.util.List;  
7.   
8. import javax.servlet.ServletException;  
9. import javax.servlet.http.HttpServletRequest;  
10. import javax.servlet.http.HttpServletResponse;  
11.   
12. import org.springframework.web.HttpRequestHandler;  
13.   
14. import lx.springmvc.po.Items;  
15.   
16. /** 
17.  * 入门程序，商品列表查询 
18.  *  
19.  * @author liuxun 
20.  * 
21.  */  
22. public class ItemController2 implements HttpRequestHandler {  
23.   
24.     public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
25.         // 使用静态数据将商品信息展示在jsp页面上  
26.         // 商品列表  
27.         List<Items> itemsList = new ArrayList<Items>();  
28.   
29.         Items items_1 = new Items();  
30.         items_1.setName("联想笔记本");  
31.         items_1.setPrice(6000f);  
32.         items_1.setCreatetime(new Date());  
33.         items_1.setDetail("ThinkPad T430 联想笔记本电脑！");  
34.   
35.         Items items_2 = new Items();  
36.         items_2.setName("苹果手机");  
37.         items_2.setPrice(5000f);  
38.         items_2.setDetail("iphone6苹果手机！");  
39.   
40.         itemsList.add(items_1);  
41.         itemsList.add(items_2);  
42.   
43.         request.setAttribute("itemsList", itemsList);  
44.         request.getRequestDispatcher("/WEB-INF/jsp/itemsList.jsp").forward(request, response);  
45.     }  
46.   
47. }  

ItemController3.java

[java] view plain copy

1. package lx.springmvc.first;  
2.   
3. import java.io.IOException;  
4. import java.util.ArrayList;  
5. import java.util.Date;  
6. import java.util.List;  
7.   
8. import javax.servlet.ServletException;  
9.   
10. import org.springframework.stereotype.Controller;  
11. import org.springframework.web.bind.annotation.RequestMapping;  
12. import org.springframework.web.servlet.ModelAndView;  
13.   
14. import lx.springmvc.po.Items;  
15.   
16. /** 
17.  * 入门程序，商品列表查询 
18.  *  
19.  * @author liuxun 
20.  * 
21.  */  
22. @Controller  
23. public class ItemController3 {  
24.     // 商品列表，@RequestMapping中的url建议和方法名一致，方便开发维护  
25.     @RequestMapping("/queryItems")  
26.     public ModelAndView queryItems() throws ServletException, IOException {  
27.         // 使用静态数据将商品信息展示在jsp页面上  
28.         // 商品列表  
29.         List<Items> itemsList = new ArrayList<Items>();  
30.   
31.         Items items_1 = new Items();  
32.         items_1.setName("联想笔记本");  
33.         items_1.setPrice(6000f);  
34.         items_1.setCreatetime(new Date());  
35.         items_1.setDetail("ThinkPad T430 联想笔记本电脑！");  
36.   
37.         Items items_2 = new Items();  
38.         items_2.setName("苹果手机");  
39.         items_2.setPrice(5000f);  
40.         items_2.setDetail("iphone6苹果手机！");  
41.   
42.         itemsList.add(items_1);  
43.         itemsList.add(items_2);  
44.           
45.         ModelAndView modelAndView = new ModelAndView();  
46.         modelAndView.addObject("itemsList",itemsList);  
47.         // 指定逻辑视图名  
48.         modelAndView.setViewName("itemsList");  
49.           
50.         return modelAndView;  
51.     }  
52.   
53. }  

SpringMVC和Mybatis整合工程搭建

整合思路

在Mybatis和Spring整合的基础上 添加springmvc

Spring要管理springmvc编写的Handler(controller)、mybatis的SqlSessionFactory、mapper

第一步：整合Dao，Spring和mybatis整合

第二步：整合Service，Spring管理Service接口，Service中可以调用Spring容器中的dao (mapper)

第三步：整合controller，Spring管理controller接口，在controller调用Service

导入jar包

mybatis：3.2.7

Spring：3.2.0

mybatis的jar

mybatis和Spring整合包

Spring的相关Jar包(包括SpringMVC的包)

数据库驱动包

log4j日志

工程结构

配置文件

applicationContext-dao.xml——配置数据源、SqlSessionFactory、mapper扫描器

applicationContext-service.xml——配置Service接口

applicationContext-transaction.xml——事务管理

springmvc.xml——SpringMVC的配置，配置处理器映射器、适配器、视图解析器

SqlMapConfig.xml——mybatis的配置文件，配置别名、settings、mapper

applicationContext-dao.xml

配置mybatis的数据源、sqlSessionFactory、mapper扫描器

[html] view plain copy

1. <!-- 加载配置文件 -->  
2.     <context:property-placeholder location="classpath:db.properties" />  
3.     <!-- 数据库连接池 -->  
4.     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"  
5.         destroy-method="close">  
6.       <property name="driverClassName">${jdbc.driver}</property>  
7.       <property name="url">${jdbc.url}</property>  
8.       <property name="username">${jdbc.username}</property>  
9.       <property name="password">${jdbc.password}</property>  
10.       <property name="maxActive" value="10"/>  
11.       <property name="maxIdle" value="5"/>  
12.     </bean>  
13.       
14.     <!-- SqlSessionFactory -->  
15.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
16.         <!-- 数据源 -->  
17.         <property name="dataSource" ref="dataSource"/>  
18.         <!-- mybatis配置文件 -->  
19.         <property name="configLocation" value="classpath:mybatis/SqlMapConfig.xml"/>  
20.     </bean>  
21.       
22.     <!--   
23.     MapperScannerConfigurer: mapper扫描器，将包下边的mapper接口自动创建代理对象，  
24.     自动创建到Spring容器中，bean的id是mapper的类名(首字母小写)  
25.      -->  
26.      <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">  
27.          <!-- 配置扫描包的路径  
28.          如果要扫描多个包，中间使用半角逗号隔开  
29.          要求mapper.xml和mapper.java同名且在同一目录  
30.           -->  
31.          <property name="basePackage" value="liuxun.ssm.mapper"/>  
32.          <!-- 使用SqlSessionFactoryBeanName -->  
33.          <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>  
34.      </bean>  

applicationContext-transaction.xml

在此配置文件配置事务，声明式事务控制

[html] view plain copy

1. <!-- 事务管理器 -->  
2.     <bean id="transactionManager"  
3.         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
4.         <property name="dataSource" ref="dataSource" />  
5.     </bean>  
6.   
7.     <!-- 通知 -->  
8.     <tx:advice id="txAdvice" transaction-manager="transactionManager">  
9.         <tx:attributes>  
10.             <tx:method name="save*" propagation="REQUIRED" />  
11.             <tx:method name="insert*" propagation="REQUIRED" />  
12.             <tx:method name="update*" propagation="REQUIRED" />  
13.             <tx:method name="delete*" propagation="REQUIRED" />  
14.             <tx:method name="find*" propagation="SUPPORTS" read-only="true" />  
15.             <tx:method name="select*" propagation="SUPPORTS" read-only="true" />  
16.             <tx:method name="get*" propagation="SUPPORTS" read-only="true" />  
17.         </tx:attributes>  
18.     </tx:advice>  
19.   
20.     <!-- aop -->  
21.     <aop:config>  
22.         <aop:advisor advice-ref="txAdvice" pointcut="execution(* liuxun.ssm.service.impl.*.*(..))" />  
23.     </aop:config>  

前端控制器配置

[html] view plain copy

1. <!-- 前端控制器 -->  
2.     <servlet>  
3.         <servlet-name>springmvc</servlet-name>  
4.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
5.         <!-- 加载springmvc配置 -->  
6.         <init-param>  
7.             <param-name>contextConfigLocation</param-name>  
8.             <!-- 配置文件的地址 如果不配置contextConfigLocation，  
9.              默认查找的配置文件名称classpath下的：servlet名称+"-serlvet.xml"  
10.              即：springmvc-serlvet.xml   
11.              -->  
12.             <param-value>classpath:spring/springmvc.xml</param-value>  
13.         </init-param>  
14.     </servlet>  
15.     <servlet-mapping>  
16.         <servlet-name>springmvc</servlet-name>  
17.         <!-- 可以配置/ ，此工程 所有请求全部由springmvc解析，此种方式可以实现 RESTful方式，需要特殊处理对静态文件的解析不能由springmvc解析   
18.             可以配置*.do或*.action，所有请求的url扩展名为.do或.action由springmvc解析，此种方法常用 不可以/*，如果配置/*，返回jsp也由springmvc解析，这是不对的。 -->  
19.         <url-pattern>*.action</url-pattern>  
20.     </servlet-mapping>  

配置springmvc.xml

[html] view plain copy

1. <!-- 使用spring组件扫描 -->  
2.     <context:component-scan base-package="liuxun.ssm.controller" />  
3.   
4.     <!-- 通过使用mvc的annotation-driven 可以替代下边的处理器映射器和适配器 -->  
5.     <!-- <mvc:annotation-driven></mvc:annotation-driven> -->  
6.   
7.     <!-- 注解处理器映射器 -->  
8.     <bean  
9.         class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"></bean>  
10.   
11.     <!-- 注解适配器 -->  
12.     <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"></bean>  
13.   
14.     <!-- 配置视图解析器 要求将jstl的包加到classpath -->  
15.     <!-- ViewResolver -->  
16.     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
17.         <property name="prefix" value="/WEB-INF/jsp/"/>  
18.         <property name="suffix" value=".jsp"/>  
19.     </bean>  

商品列表开发

需求

查询商品列表

mapper

功能描述：根据条件查询商品信息，返回商品列表

一般情况下对查询mapper需要自定义mapper

首先针对单表进行****，生成代码（包括PO类、mapper.xml、mapper.java）如下图所示：

mapper.xml

为了避免影响****生成的代码，一般不去修改，新建一个自定义的mapper(.xml和.java) 

新建ItemsMapperCustom.xml 添加如下配置

[html] view plain copy

1. <sql id="query_items_where">  
2.      <if test="itemsCustom!=null">  
3.         <if test="itemsCustom.name!=null and itemsCustom.name.trim().length >0">  
4.          and name like '%${itemsCustom.name.trim()}%'  
5.         </if>  
6.         <if test="itemsCustom.id!=null">  
7.             and id = #{itemsCustom.id}  
8.         </if>  
9.      </if>  
10.    </sql>  
11.      
12.    <!-- 商品查询  
13.    parameterType：输入查询条件  
14.     -->  
15.   <select id="findItemsList" parameterType="liuxun.ssm.po.ItemsQueryVo" resultType="liuxun.ssm.po.ItemsCustom">  
16.       SELECT * FROM items  
17.       <where>  
18.         <include refid="query_items_where"/>  
19.       </where>  
20.   </select>    

包装类：ItemsQueryVo

[java] view plain copy

1. public class ItemsQueryVo {  
2.   
3.     // 商品信息  
4.     private ItemsCustom itemsCustom;  
5.   
6.        // setter与getter  
7.        ......  
8. }  

mapper.java

新建接口ItemsMapperCustom.java

[java] view plain copy

1. // 商品查询列表  
2.     public List<ItemsCustom> findItemsList(ItemsQueryVo itemsQueryVo) throws Exception;  

Service

[java] view plain copy

1. public class ItemsServiceImpl implements ItemsService {  
2.      
3.     // 注入mapper  
4.     @Autowired  
5.     private ItemsMapperCustom itemsMapperCustom;  
6.       
7.     @Autowired  
8.     private ItemsMapper itemsMapper;  
9.       
10.     public List<ItemsCustom> findItemsList(ItemsQueryVo itemsQueryVo) throws Exception {  
11.         return itemsMapperCustom.findItemsList(itemsQueryVo);  
12.     }  
13.   
14. }  

在applicationContext-service.xml中配置Service

[html] view plain copy

1. <!-- 商品管理的Service -->  
2.    <bean  id="itemsService" class="liuxun.ssm.service.impl.ItemsServiceImpl"></bean>  

controller

[java] view plain copy

1. @Controller  
2. public class ItemsController {  
3.   
4.     // 注入Service  
5.     @Autowired  
6.     private ItemsService itemsService;   
7.   
8.     @RequestMapping("queryItems")  
9.     public ModelAndView queryItems(HttpServletRequest request) throws Exception {  
10.   
11.         // 调用Service查询商品列表  
12.         List<ItemsCustom> itemsList = itemsService.findItemsList(null);  
13.   
14.         ModelAndView modelAndView = new ModelAndView();  
15.         modelAndView.addObject("itemsList", itemsList);  
16.         // 指定逻辑视图名  
17.         modelAndView.setViewName("itemsList");  
18.   
19.         return modelAndView;  
20.     }  
21. }  

jsp

在web.xml中配置Spring监听器

[html] view plain copy

1. <!-- 配置Spring容器监听器 -->  
2.     <context-param>  
3.         <param-name>contextConfigLocation</param-name>  
4.         <param-value>classpath:spring/applicationContext-*.xml</param-value>   
5.     </context-param>  
6.     <listener>  
7.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
8.     </listener>  

注解开发基础

商品修改

需求

功能描述：商品信息修改

操作流程：

1.在商品列表页面点击修改链接。

2.打开商品修改页面，显示了当前商品的信息。

（根据商品的id查询商品信息）

3.修改商品信息，点击提交

（更新商品信息）

mapper

已使用****生成代码：

根据商品id查询商品信息

更新商品信息

Service

[java] view plain copy

1. // 根据商品id查询商品信息  
2.     public ItemsCustom findItemsById(int id) throws Exception;  
3.       
4.     // 更新商品信息  
5.     /** 
6.      * 定义Service接口，遵循单一职责，将业务参数细化（不要使用包装类型，比如Map） 
7.      * @param id  修改商品的id 
8.      * @param itemsCustom  修改商品的信息 
9.      * @throws Exception 
10.      */  
11.     public void updateItems(Integer id,ItemsCustom itemsCustom) throws Exception;  

@RequestMapping

设置方法对应的url(完成url映射)

一个方法对应一个url

[java] view plain copy

1. @RequestMapping("/queryItems")  
2.     public ModelAndView queryItems(HttpServletRequest request) throws Exception {  

窄化请求映射

在Class上定义根路径

[java] view plain copy

1. @Controller  
2. //定义url的根路径，访问时 根路径+方法的url  
3. @RequestMapping("/items")  
4. public class ItemsController {  

好处：重新规范系统的url，避免url冲突

限制http请求的方法

通过requestMapping限制url请求的http方法

如果限制请求必须是post，如果get请求就会抛出异常

商品修改方法，限制为http的get：

[java] view plain copy

1. @RequestMapping(value="/editItems",method={RequestMethod.GET})  

controller方法返回值

返回ModelAndView

[java] view plain copy

1. @RequestMapping("/queryItems")  
2.     public ModelAndView queryItems(HttpServletRequest request) throws Exception {  
3.   
4.         // 调用Service查询商品列表  
5.         List<ItemsCustom> itemsList = itemsService.findItemsList(null);  
6.   
7.         ModelAndView modelAndView = new ModelAndView();  
8.         modelAndView.addObject("itemsList", itemsList);  
9.         // 指定逻辑视图名  
10.         modelAndView.setViewName("itemsList");  
11.   
12.         return modelAndView;  
13.     }  

返回字符串

如果controller方法返回JSP页面，可以简单将方法返回值类型定义为字符串，最终返回逻辑视图名称

[java] view plain copy

1. //方法返回字符串，字符串就是逻辑视图名，Model作用就是将数据填充到request域，在页面展示  
2.     @RequestMapping(value="/editItems",method={RequestMethod.GET})  
3.     public String editItems(Model model) throws Exception{  
4.           
5.         // 调用Service查询商品信息  
6.         ItemsCustom itemsCustom = itemsService.findItemsById(1);  
7.         //将模型数据传到jsp  
8.         model.addAttribute("item", itemsCustom);  
9.   
10.         return "editItem";  
11.     }  

返回void

[java] view plain copy

1. // 方法返回void  
2.     @RequestMapping(value="/editItems",method={RequestMethod.GET})  
3.     public void editItems(HttpServletRequest request,HttpServletResponse response) throws Exception{  
4.           
5.         // 调用Service查询商品信息  
6.         ItemsCustom itemsCustom = itemsService.findItemsById(1);  
7.         request.setAttribute("item", itemsCustom);  
8.         // 注意如果使用request转向页面，这里指定页面的完整路径  
9.         request.getRequestDispatcher("/WEB-INF/jsp/editItem.jsp").forward(request, response);  
10.     }  

使用此方法，容易输出json、xml格式的数据：

通过response指定响应结果，例如响应json数据如下：

response.setCharacterEncoding("utf-8");

response.setContentType("application/json;charset=utf-8");

response.getWriter().write("json串");

redirect重定向

如果方法重定向到另一个url，方法返回值为 "redirect:url路径"，url路径一般指的具体的路径或别的请求路径 不能是虚拟视图名。

使用redirect进行重定向，request数据无法共享，url的地址栏会发生变化。

forward转发

使用forward进行请求转发，request数据可以共享，url地址栏不会改变。

方法返回值为"forward:url路径"

参数绑定

参数绑定过程

默认支持的参数类型

处理器方法形参中添加如下类型的参数，处理器适配器会默认识别并进行赋值的。

HttpServletRequest

通过request对象获取请求信息

HttpServletResponse

通过response处理响应信息

HttpSession

通过Session对象得到Session中存放的对象

Model

通过model向页面传递数据，如下：

[java] view plain copy

1. // 调用Service查询商品信息  
2.         ItemsCustom itemsCustom = itemsService.findItemsById(id);  
3.         //将模型数据传到jsp  
4.         model.addAttribute("item", itemsCustom);  

页面通过${item.xxx}获取对象的属性值

@RequestParam

如果request请求的参数名和controller方法的形参参数名一致，适配器自动进行参数绑定。如果不一致可以通过@RequestParam指定request请求的参数名(value属性)绑定到哪个方法形参上。

对于必须要传入的参数，通过@RequestParam中的属性required设置为true，设置后如果不传入此参数则会报错。

对于有些参数如果不传入，还需要设置默认值，使用@RequestParam中属性defaultvalue设置默认值。

可以绑定简单类型

可以绑定整型、字符串、单精/双精度、日期、布尔型

可以绑定简单pojo类型

简单pojo类型只包括简单类型的属性。

绑定过程：request请求的参数名称和pojo的属性名一致，就可以绑定成功。

问题：

如果controller方法形参中有多个pojo且pojo中有重复的属性，使用简单pojo绑定无法有针对性的绑定。

比如：方法形参中有items和User，pojo同时存name属性，从http请求过程的name无法有针对性的绑定到items或user。

可以绑定包装的pojo

包装的pojo里包括的pojo

页面参数定义：

包装类型的属性也是itemsCustom

按照上边的规则进行包装类型的绑定。

自定义绑定使用属性编辑器

SpringMVC没有提供对日期类型的绑定，需要自定义日期类型的绑定。

使用WebDataBinder(了解)

在controller类中定义

[java] view plain copy

1. //自定义属性编辑器  
2.     @InitBinder  
3.     public void initBinder(WebDataBinder binder) throws Exception {  
4.         // Date.class必须是与controler方法形参pojo属性一致的date类型，这里是java.util.Date  
5.         binder.registerCustomEditor(Date.class, new CustomDateEditor(  
6.                 new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"), true));  
7.     }  

使用这种方法是无法在多个controller共用

使用WebBindingInitializer(了解)

使用WebBindingInitializer让多个控制器共用属性编辑器

自定义WebBindingInitializer，注入到处理器适配器中。

如果想使多个controller共用属性编辑器，需要共同注册相同的属性编辑器，可以实现PropertyEditorRegistrar接口，并且注入到webBindingInitializer中。

编写CustomPropertyEditor

[java] view plain copy

1. public class CustomPropertyEditor implements PropertyEditorRegistrar {  
2.   
3.     public void registerCustomEditors(PropertyEditorRegistry binder) {  
4.         binder.registerCustomEditor(Date.class,  
5.                 new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"), true));  
6.     }  
7.   
8. }  

在springmvc.xml中添加如下配置

[html] view plain copy

1.     <!-- 注解适配器 -->  
2.       <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">  
3.     <!-- 在webBindingInitializer中注入自定义属性编辑器，自定义转换器 -->  
4.     <property name="webBindingInitializer" ref="customBinder"/>  
5.       </bean>  
6. <!-- 自定义webBinder -->  
7. <bean id="customBinder" class="org.springframework.web.bind.support.ConfigurableWebBindingInitializer">  
8.     <!-- propertyEditorRegistrars用于属性编辑器 -->  
9.     <property name="propertyEditorRegistrars">  
10.         <list>  
11.             <ref bean="customPropertyEditor"/>  
12.         </list>  
13.     </property>  
14. </bean>  
15.   
16. <!-- 注册属性编辑器 -->  
17. <bean id="customPropertyEditor" class="liuxun.ssm.controller.propertyeditor.CustomPropertyEditor"/>  

配置步骤：

编写自定义转换器 实现PropertyEditorRegistrar接口

注册自定义的属性编辑器。

注册webBinder（org.springframework.web.bind.support.ConfigurableWebBindingInitializer类型），并将已经注册的属性编辑器注入到propertyEditorRegistrars的list属性集合中。

最后将已注册的webBinder注入到注解适配器中。

自定义参数绑定使用转换器(重点)

实现Converter接口

定义日期类型转换器和字符串去除前后空格的转换器

配置转换器

配置方式：

自定义转换器实现Converter<K,V> 接口 K:原始数据类型  V:转换后的数据类型
自定义日期转换器

[java] view plain copy

1. /** 
2.  * 自定义日期转换器 
3.  * @author liuxun 
4.  * 
5.  */  
6. public class CustomDateConverter implements Converter<String, Date> {  
7.   
8.     @Override  
9.     public Date convert(String source) {  
10.           
11.         // 进行日期转换  
12.         try {  
13.             return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(source);  
14.         } catch (ParseException e) {  
15.             e.printStackTrace();  
16.         }  
17.         return null;  
18.     }  
19.   
20. }  

自定义去空格转换器

[java] view plain copy

1. /** 
2.  * 自定义去除字符串前后空格的转换器 
3.  * @author liuxun 
4.  * 
5.  */  
6. public class StringTrimConverter implements Converter<String, String>{  
7.   
8.     @Override  
9.     public String convert(String source) {  
10.           
11.         //去掉字符串两边空格，如果去除后为空设置为null  
12.         if (source!=null) {  
13.             source = source.trim();  
14.             if (source.equals("")) {  
15.                 return null;  
16.             }  
17.         }  
18.           
19.         return source;  
20.     }  
21.   
22. }  

配置如下

注册FormattingConversionServiceFactoryBean，并将自定义的转换器注入到converters数组属性中

[html] view plain copy

1. <!-- 注册转换器 -->  
2.     <bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">  
3.         <property name="converters">  
4.             <list>  
5.                 <bean class="liuxun.ssm.controller.converter.CustomDateConverter"/>  
6.                 <bean class="liuxun.ssm.controller.converter.StringTrimConverter"/>  
7.             </list>  
8.         </property>  
9.     </bean>  

并将注册的转换器注入到webBinder中

[html] view plain copy

1. <!-- 自定义webBinder -->  
2.     <bean id="customBinder" class="org.springframework.web.bind.support.ConfigurableWebBindingInitializer">  
3.         <!-- 使用converter进行参数转换 -->  
4.         <property name="conversionService" ref="conversionService"/>  
5.     </bean>  

最后将其webBinder注入到注解适配器中

[html] view plain copy

1. <!-- 注解适配器 -->  
2.    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">  
3.     <!-- 在webBindingInitializer中注入自定义属性编辑器，自定义转换器 -->  
4.     <property name="webBindingInitializer" ref="customBinder"/>  
5.    </bean>  

问题处理

post乱码

在web.xml中加入

[html] view plain copy

1. <!-- post乱码处理 -->  
2.     <filter>  
3.         <filter-name>CharacterEncodingFilter</filter-name>  
4.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
5.         <init-param>  
6.             <param-name>encoding</param-name>  
7.             <param-value>utf-8</param-value>  
8.         </init-param>  
9.     </filter>  
10.     <filter-mapping>  
11.         <filter-name>CharacterEncodingFilter</filter-name>  
12.         <url-pattern>/*</url-pattern>  
13.     </filter-mapping>  

以上可解决post乱码问题

get乱码

对于get请求中文参数出现乱码解决方法有两个

修改Tomcat配置文件添加编码与工程一致 如下：

[html] view plain copy

1. <Connector URIEncoding="utf-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>  

另外一种方法对参数进行重新编码：
String userName=new String(request.getParamter("userName").getBytes("ISO8859-1"),"utf-8")
ISO8859-1是tomcat默认编码，需要将tomcat编码后的内容按utf-8编码
(具体源码在第二篇中综合展示)