Spring MVC（2）Spring MVC 组件开发

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

一、控制器接收各类请求参数

代码测试环境：

接收各类参数的控制器--ParamsController

package com.ssm.chapter15.controller;@Controller
@RequestMapping("/params")
public class ParamsController {
// 各种控制器方法
}

先看一下目录结构：

这里需要知道的知识点是，WebContent文件夹下的.jsp文件都可以通过http://localhost:8080/工程名/文件名.jsp直接访问。

而WEB-INF里面的文件，必须通过Spring MVC 中的Controller控制器产生映射才能访问。

1.接收普通请求参数

params.jsp文件的内容如下，其中action="./params/commonParams.do"表示提交按钮按下后，跳转到action指定的页面。

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>参数</title>
<body>

<form id="form" action="./params/commonParams.do">
<table>
<tr>
<td>角色名称</td>
<td><input id="roleName" name="roleName" value="" /></td>
</tr>
<tr>
<td>备注</td>
<td><input id="note" name="note" /></td>
</tr>
<tr>
<td></td>
<td align="right"><input type="submit" value="提交" /></td>
</tr>
</table>
</form>
</body>
</html>

而对应的控制器方法：commonParams方法

@Controller
@RequestMapping("/params")
public class ParamsController { @RequestMapping("/commonParams")
public ModelAndView commonParams(String roleName, String note) {
System.out.println("roleName =>" + roleName);
System.out.println("note =>" + note);
ModelAndView mv = new ModelAndView();
mv.setViewName("index");
return mv;
}

这里因为当前Spring MVC 比较智能化，如果传递进来的参数名称和HTTP的保存一致，意思就是传递进来的参数名称为roleName和note，而params.jsp中<input id="roleName" name="roleName" value="" />和<input id="note" name="note" />两个参数名称都和roleName和note一致，因此，可以获取到params.js中提交的参数。

测试：首先输入访问表单，输入任意参数，并提交

然后，正确跳转到./params/commonParams.do?roleName=mingcheng&note=beizhu，这一URL，说明参数传递成功。

但是，在参数很多的情况下，再使用这样的方式，显然所写方法的参数就会非常多，这是应该考虑到使用一个POJO来管理这些参数。在没有任何注解的情况下，Spring MVC 也有映射POJO的能力。

新建一个角色参数类，将两个参数封装到类中：

package com.ssm.chapter14.pojo;public class RoleParams {
private String roleName;
private String note;

/*getter and setter*/
}

然后增加控制器方法：由于上面的POJO的属性和HTTP参数（jsp文件中的参数）一一对应了，然后在commonParamPojo方法中将POJO类对象RoleParams roleParams当成方法的参数，也可以在没有任何注解的情况下实现参数的有效传递。

@RequestMapping("/commonParamPojo")
public ModelAndView commonParamPojo(RoleParams roleParams) {
System.out.println("roleName =>" + roleParams.getRoleName());
System.out.println("note =>" + roleParams.getNote());
ModelAndView mv = new ModelAndView();
mv.setViewName("index");
return mv;
}

另外，还需要修改jsp中的action成<form id="form" action="./params/commonParamPojo.do">才能进行测试。

2.使用@RequestParam注解获取参数

前面的两种情况，仅仅在参数名称和jsp文件中的参数名称一一对应时才有效。那么，如果修改jsp中的参数名称，例如，<td><input id="role_name" name="role_name" value="" /></td>将roleName修改成role_Name，此时由于参数不一致，就无法再进行自动对应传递了。

可以用@RequestParam注解获取参数的方式解决这个问题：使用@RequestParam("role_name")来讲HTTP的参数名称（即jsp文件中的参数名称）和传递进去的roleName参数一一对应。

@RequestMapping("/requestParam")
//使用@RequestParam("role_name")指定映射HTTP参数名称
public ModelAndView requestParam(@RequestParam("role_name") String roleName, String note) {
System.out.println("roleName =>" + roleName);
System.out.println("note =>" + note);
ModelAndView mv = new ModelAndView();
mv.setViewName("index");
return mv;
}

同样，修改action，然后也可以得到正确的测试结果：

3.使用URL传递参数

一些网站使用URL的形式传递参数，对于一些业务比较简单的应用是非常常见的，如果想把获得数据库中id为1的role的信息，那么就写成/params/getRole/1，这里的1就代表角色编号，只不过是在URL中传递。Spring MVC 也提供了支持。

需要通过@RequestMapping注解和@PathVariable注解协作完成。其中，

@RequestMapping("/getRole/{id}")中的{id}表示处理器需要接受一个由URL组成的参数，且参数名称为id

@PathVariable("id")的意思是获取定义在@RequestMapping中参数名称为id的参数，这样就可以在方法内获取这个参数了

然后通过劫色服务类获取角色对象，并将其绑定到视图中，将视图设置为JSON视图。

//注入角色服务对象
@Autowired
RoleService roleService; //{id}代表接收一个参数
@RequestMapping("/getRole/{id}")
//注解@PathVariable表示从URL的请求地址中获取参数
public ModelAndView pathVariable(@PathVariable("id") Long id) {
Role role = roleService.getRole(id);
ModelAndView mv = new ModelAndView();
//绑定数据模型
mv.addObject(role);
//设置为JSON视图
mv.setView(new MappingJackson2JsonView());
return mv;
}

测试结果：

4.传递JSON参数

假如要传递更多的参数。例如，对于查询参数，假设还有开始行start和限制返回大小的limit，那么加上roleName和note，就有了4个参数。

首先定义分页参数POJO类PageParams类：

package com.ssm.chapter14.pojo;public class PageParams {
private int start;
private int limit;/*getter and setter*/
}

然后，在原来的RoleParams类中增加一个PageParams类的对象，即：

package com.ssm.chapter14.pojo;public class RoleParams {
private String roleName;
private String note; private PageParams pageParams = null;// 分页参数/*getter and setter*/
}

这样，查询参数和分页参数就都可以被传递了。这时，为了模拟传递过程，在params.jsp中增加JavaScript脚本代码：

/** 传递JSON**/
$(document).ready(function() {
//JSON参数和类RoleParams一一对应
var data = {
//角色查询参数
roleName : 'role',
note : 'note',
//分页参数
pageParams : {
start : 0,
limit : 4
}
}
//Jquery的post请求
$.post({
url : "./params/findRoles.do",
//此处需要告知传递参数类型为JSON，不能缺少
contentType : "application/json",
//将JSON转化为字符串传递
data : JSON.stringify(data),
//成功后的方法
success : function(result) {
}
});
});

与之对应的findRoles方法：首先传递的JSON数据需要和对应参数的POJO保持一致。其次，在请求的时候需要告知请求的参数类型为JSON。最后，传递的参数是一个字符串，而不是一个JSON，所以需要将JSON转换成字符串。然后，通过@RequestBody注解，就可以将和JavaScript代码中对应的POJO类对象roleParams传递进去。

@RequestMapping("/findRoles")
public ModelAndView findRoles(@RequestBody RoleParams roleParams) {
List<Role> roleList = roleService.findRoles(roleParams);
ModelAndView mv = new ModelAndView();
//绑定模型
//mv.addObject(roleList);
//设置为JSON视图
//mv.setView(new MappingJackson2JsonView());
return mv;
}

与之对应的Mapper中的配置：

<select id="findRoles" parameterType="com.ssm.chapter15.pojo.RoleParams"
resultType="com.ssm.chapter14.pojo.Role">
select id, role_name as roleName, note from t_role
<where>
<if test="roleName != null">
and role_name like concat('%', #{roleName}, '%')
</if>
<if test="note != null">
and note like concat('%', #{note}, '%')
</if>
</where>
limit #{pageParams.start}, #{pageParams.limit}
</select>

另外，还需要将原来的params.jsp文件中的action配置删除才能进行正确的测试：

5.接收列表数据和表单序列化

（1）传递数组给控制器，进行一次性删除多个角色的操作

查看删除前的数据库：

jsp中对应的应该添加的JavaScript代码：

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>参数</title>
<script type="text/javascript"
src="https://code.jquery.com/jquery-3.2.0.js"></script><script type="text/javascript">
/**传递数组**/
$(document).ready(function() {
//删除角色数组
var idList = [ 1, 2, 3 ];
//jQuery的post请求
$.post({
url : "./params/deleteRoles.do",
//将JSON转化为字符串传递
data : JSON.stringify(idList),
//指定传递数据类型，不可缺少
contentType : "application/json",
//成功后的方法
success : function(result) {
}
});
});
</script>
</head>
</html>

与之对应的deleteRoles方法：这里的@RequestBody List<Long> idList表示要求Spring MVC 将传递过来的JSON数组数据，转换为对应的Java集合类型。

@RequestMapping("/deleteRoles")
public ModelAndView deleteRoles(@RequestBody List<Long> idList) {
ModelAndView mv = new ModelAndView();
//删除角色
int total = roleService.deleteRoles(idList);
System.out.println(total);
//绑定视图
// mv.addObject("total", total);
//JSON视图
// mv.setView(new MappingJackson2JsonView());
return mv;
}

roleService的deleteRoles方法的实现：

@Override
@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
public int deleteRoles(List<Long> idList) {
int count = 0;
for (Long id : idList) {
count += roleDao.deleteRole(id);
}
return count;
}

对应映射器Mapper中deleteRoles的配置：

<delete id="deleteRole" parameterType="long">
delete from t_role where
id = #{id}
</delete>

执行http://localhost:8080/Chapter14/deleteRoles.jsp后，控制台输出：3，并且数据库的结果为：

（2）新增多个角色

同理addRole.jsp的内容是：

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>参数</title>
<script type="text/javascript"
src="https://code.jquery.com/jquery-3.2.0.js"></script><script type="text/javascript">
$(document).ready(function () {
//新增角色数组
var roleList = [
{roleName: 'role_name_1', note: 'note_1'},
{roleName: 'role_name_2', note: 'note_2'},
{roleName: 'role_name_3', note: 'note_3'}
];
//jQuery的post请求
$.post({
url: "./params/addRoles.do",
//将JSON转化为字符串传递
data: JSON.stringify(roleList),
contentType: "application/json",
//成功后的方法
success: function (result) {
}
});
});
</script>
</head>
</html>

与之对应的视图处理器中的addRoles方法：通过@RequestBody注解来获取对应的角色列表参数，这样就可以在控制器中通过@ResponseBody将对应的JSON数据转换成对象列表。

@RequestMapping("/addRoles")
public ModelAndView addRoles(@RequestBody List<Role> roleList) {
ModelAndView mv = new ModelAndView();
// 新增
int total = roleService.insertRoles(roleList);
System.out.println(total);
//绑定视图
// mv.addObject("total", total);
//JSON视图
// mv.setView(new MappingJackson2JsonView());
return mv;
}

roleService的insertRoles方法：

@Override
@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
public int insertRoles(List<Role> roleList) {
int count = 0;
for (Role role : roleList) {
count += roleDao.insertRole(role);
}
return count;
}

MyBatis映射器Mapper中的insertRoles配置：

<insert id="insertRole"
parameterType="com.ssm.chapter14.pojo.Role" keyProperty="id"
useGeneratedKeys="true">
insert into t_role (role_name, note) value(#{roleName}, #{note})
</insert>

在浏览器中输入http://localhost:8080/Chapter14/addRoles.jsp然后查看数据库的结果为：

（3）通过表单序列化也可以将表单数据转换为字符串传递到后台，因为一些隐藏表单需要一定的计算，所以我们也需要在用户点击提交按钮后，通过序列化去提交表单。

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>参数</title>

<script type="text/javascript"
src="https://code.jquery.com/jquery-3.2.0.js">
</script>
<script type="text/javascript">
$(document).ready(function() {
$("#commit").click(function() {
var str = $("form").serialize();
//提交表单
$.post({
url : "./params/commonParamPojo2.do",
//将form数据序列化，传递给后台，则将数据以roleName=xxx&&note=xxx传递
data : $("form").serialize(),
//成功后的方法
success : function(result) {
}
});
});
});
</script>
</head>
<body>
<form id="form">
<table>
<tr>
<td>角色名称</td>
<td><input id="roleName" name="roleName" value="" /></td>
</tr>
<tr>
<td>备注</td>
<td><input id="note" name="note" /></td>
</tr>
<tr>
<td></td>
<td align="right"><input id="commit" type="button" value="提交" /></td>
</tr>
</table>
</form>
</body>
</html>

对应的commonParamPojo2方法：从表单获取数据后，点击提交按钮，就会把数据在后台打印出来。

@RequestMapping("/commonParamPojo2")
public ModelAndView commonParamPojo2(String roleName, String note) {
System.out.println("roleName =>" + roleName);
System.out.println("note =>" + note);
ModelAndView mv = new ModelAndView();
// mv.setViewName("index");
return mv;
}

这里需要说明的是，jquery中的$.post方法中，在执行完方法后，是无法跳转到Spring MVC 返回的ModelAndView类型的mv页面的。具体可以了解Ajax的内容。

二、重定向

通过之前的例子，我们知道，可以showRoleJsonInfo方法可以接收三个参数，然后就可以将这些参数转化为视图，通过JSON的形式展示在页面上。

@RequestMapping("/showRoleJsonInfo")
public ModelAndView showRoleJsonInfo(Long id, String roleName, String note) {
ModelAndView mv = new ModelAndView();
mv.setView(new MappingJackson2JsonView());
mv.addObject("id", id);
mv.addObject("roleName", roleName);
mv.addObject("note", note);
return mv;
}

例如：浏览器中输入参数，就可以将参数信息转化成视图，然后展示出来。

但是，如果想要实现：每当新增一一个角色信息时，需要其将数据以JSON视图的形式展示给请求者。

实现方法是：在数据保存到数据库后，由数据库返回角色编号，再将角色信息传递showRoleJsonInfo方法，就可以展示JSON视图给请求者了。

1.在视图控制器中新增重定向功能的方法：这里需要注意的是，在执行完roleService.insertRole(role);语句后，插入数据库的id会回填到role对象中。

然后通过返回字符串类型的"redirect:./showRoleJsonInfo.do"来进行重定向，其中如果字符串中带有“redirect”，那么就会认为是一个重定向。

@RequestMapping("/addRole")
//Model为重定向数据模型，Spring MVC会自动初始化它
public String addRole(Model model, String roleName, String note) {
Role role = new Role();
role.setRoleName(roleName);
role.setNote(note);
//插入角色后，会回填角色编号
roleService.insertRole(role);
//绑定重定向数据模型
model.addAttribute("roleName", roleName);
model.addAttribute("note", note);
model.addAttribute("id", role.getId());
return "redirect:./showRoleJsonInfo.do";
}

只需要指定roleName和note参数即可，

2.不仅可以通过字符串来实现重定向，还可以通过返回视图来实现重定向

@RequestMapping("/addRole2")
//ModelAndView对象Spring MVC会自定初始化它
public ModelAndView addRole2(ModelAndView mv, String roleName, String note) {
Role role = new Role();
role.setRoleName(roleName);
role.setNote(note);
//插入角色后，会回填角色编号
roleService.insertRole(role);
//绑定重定向数据模型
mv.addObject("roleName", roleName);
mv.addObject("note", note);
mv.addObject("id", role.getId());
mv.setViewName("redirect:./showRoleJsonInfo.do");
return mv;
}

3.上面的例子都是传递简单的String类型的参数，有些时候需要传递角色POJO，而不是一个个字段的传递。

修改showRoleJsonInfo方法成showRoleJsonInfo2，可以以JSON的形式展示role对象

@RequestMapping("/showRoleJsonInfo2")
public ModelAndView showRoleJsonInfo(Role role) {
ModelAndView mv = new ModelAndView();
mv.setView(new MappingJackson2JsonView());
mv.addObject("role", role);
return mv;
}

但是，在URL重定向的过程中，并不能有效传递对象，因为HTTP的重定向参数是以字符串传递的。为了解决这个问题，可以使用Spring MVC 的flash属性，即RedirectAttributes参数，

@RequestMapping("/addRole3")
//RedirectAttribute对象Spring MVC会自动初始化它
public String addRole3(RedirectAttributes ra, Role role) {
//插入角色后，会回填角色编号
roleService.insertRole(role);
//绑定重定向数据模型
ra.addFlashAttribute("role", role);
return "redirect:./showRoleJsonInfo2.do";
}

这样就能传递POJO对象到下一个地址了，Spring MVC 的实现方式是：将数据保存在Session中，重定向后就会将其消除，这样就能传递数据给下一个地址了。

三、保存并获取属性参数（request、session、cookie和HTTP header）

Spring MVC 可以通过一些注解从HTTP的request对象或者Session对象中获取数据。

1.@RequestAttribute注解可以从HTTP的request对象中取出请求属性，只是范围是在一次请求中存在。

request.jsp的内容如下，

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<%
//设置请求属性
request.setAttribute("id", 11L);
//转发给控制器
request.getRequestDispatcher("./attribute/requestAttribute.do").forward(request, response);
%>
</body>
</html>

对应的控制器中的sessionAttribute方法：jsp文件中设置request的属性id为1，然后进行了转发控制器，这样将有对应的控制器去处理业务逻辑，然后由AttributeController控制器去处理它，通过(@RequestAttribute("id") Long id)将jsp中设置的request属性获取到。

@RequestAttribute和@RequestParam注解一样，默认是不能为空的，否则系统会抛出异常。但是，它们都有一个required配置项，只要配置成false，参数就可以为空了。

package com.ssm.chapter14.controller;@Controller
@RequestMapping("/attribute")
public class AttributeController { @Autowired
private RoleService roleService = null; @RequestMapping("/requestAttribute")
public ModelAndView reqAttr(@RequestAttribute("id") Long id) {
ModelAndView mv = new ModelAndView();
Role role = roleService.getRole(id);
mv.addObject("role", role);
mv.setView(new MappingJackson2JsonView());
return mv;
}
}

在浏览器中输入http://localhost:8080/Chapter14/request.jsp，就可以获取jsp中定义的request属性值，并跳转到指定的界面。

2.@SessionAttribute和@SessionAttributes

这两个注解都和HTTP的会话对象有关，在浏览器和服务器保持联系的时候HTTP会创建一个会话对象，这样可以让我们在和服务器会话期间通过它读/写会话对象的属性，缓存一定的数据信息。

（1）通过@SessionAttributes设置会话属性

@SessionAttributes注解只能对类进行标注，不能对方法或者参数注解。它可以配置属性名称或者属性类型。它的作用是当这个类被注解后，Spring MVC 执行完控制器的逻辑后，将数据模型中对应的属性名称或者属性类型保存到HTTP的Session对象中。

sessionAttrs方法中，通过首先根据传递进来的id，通过查询得到role对象，而由于AttributeController类中通过@SessionAttributes设置了名称和类型，因此，id和role对象都会保存到Session对象中。

（2）通过@SessionAttribute获取会话属性

当浏览器中输入/attribute/sessionAttributes.do?id=1时，id和role就会被保存到Session对象中，可以在sessionAttribute.jsp中通过session.getAttribute("role")和session.getAttribute("id")两个方法获取到之前保存进去的role和id。

package com.ssm.chapter14.controller;@Controller
@RequestMapping("/attribute")
// 可以配置数据模型的名称和类型，两者取或关系
@SessionAttributes(names ={"id"}, types = { Role.class })
public class AttributeController { @Autowired
private RoleService roleService = null; @RequestMapping("/sessionAttributes")
public ModelAndView sessionAttrs(Long id) {
ModelAndView mv = new ModelAndView();
Role role = roleService.getRole(id);
//根据类型，session将会保存角色信息
mv.addObject("role", role);
//根据名称，session将会保存id
mv.addObject("id", id);
//视图名称，定义跳转到一个JSP文件上
mv.setViewName("sessionAttribute");
return mv;
} @RequestMapping("/sessionAttribute")
public ModelAndView sessionAttr(@SessionAttribute("id") Long id) {
ModelAndView mv = new ModelAndView();
Role role = roleService.getRole(id);
mv.addObject("role", role);
mv.setView(new MappingJackson2JsonView());
return mv;
}
}

和之前的设置request属性值的jsp脚本类似：编写设置Session属性的jsp脚本，然后就会跳转到sessionAttribute控制器去处理。

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>session</title>
</head>
<body>
<%
//设置Session属性
session.setAttribute("id", 7L);
//执行跳转
response.sendRedirect("./attribute/sessionAttribute.do");
%>
</body>
</html>

3.@CookieValue和@RequestHeader

可以通过@CookieValue和@RequestHeader注解分别从Cookie和HTTP Header中读取信息。

@RequestMapping("/getHeaderAndCookie")
public String testHeaderAndCookie(
@RequestHeader(value="User-Agent", required = false, defaultValue = "attribute")
String userAgent,
@CookieValue(value = "JSESSIONID", required = true, defaultValue = "MyJsessionId")
String jsessionId) {
System.out.println("User-Agent：" + userAgent);
System.out.println("JSESSIONID：" + jsessionId);
return "index";
}

四、拦截器

拦截器是Spring MVC 中强大的组件，它可以在进入处理器之前做一些操作，或者在处理器完成后进行操作，甚至是在渲染视图后进行操作。

回顾Spring MVC 执行流程：Spring MVC 会在启动期间就通过@RequestMapping的注解解析URL和处理器的对应关系，在运行的时候通过请求找到对应的HandlerMapping，然后构建一个执行的责任链对象即HandlerExecutionChain对象，而HandlerExecutionChain对象中包含了handler对象，这个对象指向了控制器所对应的方法和拦截器。

1.定义拦截器

Spring 要求处理器的拦截器都要实现接口org.springframework.web.servlet.HandlerInterceptor，这个接口定义了3个方法：

preHandle方法：在处理器之前执行的前置方法，这样 Spring MVC 可以在进入处理器前处理一些方法。它将返回一个boolean值，会影响到后面 Spring MVC 的流程。
postHandle方法：在处理器之后执行的后置方法，处理器的逻辑完成后运行它。
afterCompletion方法：无论是否产生异常都会在渲染视图后执行的方法。

2.拦截器的执行流程：

需要注意的是，当前置方法返回false时，就不会再执行后面的逻辑了。

3.开发拦截器

Spring MVC 中拦截器的设计：

其中，Spring MVC 还提供了公共拦截器HandlerInterceptorAdapter，当只想实现3个拦截器方法中的一到两个时，可以继承这个公共拦截器，然后按照需要重写需要的方法就可以了。

创建角色拦截器RoleInterceptor类，其继承了HandlerInterceptorAdapter公共拦截器类：

package com.ssm.chapter15.interceptor;import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;public class RoleInterceptor extends HandlerInterceptorAdapter { @Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
System.err.println("preHandle");
return true;
} @Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception {
System.err.println("postHandle");
} @Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) throws Exception {
System.err.println("afterCompletion");
}}

然后还需要在Spring MVC 的配置文件dispatcher-servlet.xml中进行配置：需要声明RoleInterceptor所在的包和类的全限定名

<mvc:interceptors> <mvc:interceptor>
<mvc:mapping path="/role/*.do" />
<bean class="com.ssm.chapter14.interceptor.RoleInterceptor" />
</mvc:interceptor> </mvc:interceptors>

4.多个拦截器执行的顺序

假设现在有3个拦截器，在各自的方法中，分别打印拦截器方法名+编号（1,2,3）

<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/role/*.do" />
<bean class="com.ssm.chapter14.interceptor.RoleInterceptor1" />
</mvc:interceptor>
<mvc:interceptor>
<mvc:mapping path="/role/*.do" />
<bean class="com.ssm.chapter14.interceptor.RoleInterceptor2" />
</mvc:interceptor>
<mvc:interceptor>
<mvc:mapping path="/role/*.do" />
<bean class="com.ssm.chapter14.interceptor.RoleInterceptor3" />
</mvc:interceptor>
</mvc:interceptors>

（1）加入三个拦截器的preHandle方法的返回值都是true，那么会先从第一个拦截器开始进入前置方法，前置方法是顺序执行的，而后置和完成方法则是逆序运行的，这里参考拦截器执行流程。

preHandle1
preHandle2
preHandle3
业务逻辑
postHandle3
postHandle2
postHandle1
afterCompletion3
afterCompletion2
afterCompletion1

（2）加入第二个拦截器的preHandle方法的返回值为false，那么后面的拦截器的preHandle方法都不会运行了，即后面的所有拦截器都不起作用。

preHandle1
preHandle2
afterCompletion1

五、验证表单

在实际工作中，得到数据后的第一步就是检验数据的正确性，如果存在录入上的问题，一般会通过注解校验，发现错误后返回给用户，但是对于一些逻辑上的错误，比如购买金额=购满数量×单价，这样的规则就很难使用注解方式进行验证了，这个时候可以使用验证器（Validator）规则去验证。

1.使用JSR 303注解验证输入内容

Spring提供了对Bean的功能校验，通过注解表明哪个Bean需要进行验证以及验证内容：

首先，新建一个POJO类，并且根据实际需要在字段上分别进行标注：

package com.ssm.chapter14.pojo;public class Transaction {
// 产品编号
@NotNull // 不能为空
private Long productId; // 用户编号
@NotNull // 不能为空
private Long userId; // 交易日期
@Future // 只能是将来的日期
@DateTimeFormat(pattern = "yyyy-MM-dd") // 日期格式化转换
@NotNull // 不能为空
private Date date; // 价格
@NotNull // 不能为空
@DecimalMin(value = "0.1") // 最小值0.1元
private Double price; // 数量
@Min(1) // 最小值为1
@Max(100) // 最大值
@NotNull // 不能为空
private Integer quantity; // 交易金额
@NotNull // 不能为空
@DecimalMax("500000.00") // 最大金额为5万元
@DecimalMin("1.00") // 最小交易金额1元
private Double amount; // 邮件
@Pattern(// 正则式
regexp = "^([a-zA-Z0-9]*[-_]?[a-zA-Z0-9]+)*@"
+ "([a-zA-Z0-9]*[-_]?[a-zA-Z0-9]+)+[\\.][A-Za-z]{2,3}([\\.][A-Za-z]{2})?$",
// 自定义消息提示
message = "不符合邮件格式")
private String email; // 备注
@Size(min = 0, max = 256) // 0到255个字符
private String note;

/**************************getter and setter*****************************************/
}

然后创建一个表单，其中action指定了提交过后应该调用的控制器视图：

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>validate</title>
</head>
<body>
<form action = "./validate/annotation.do">
<table>
<tr>
<td>产品编号：</td>
<td><input name="productId" id="productId"/></td>
</tr>
...
<tr><td colspan="2" align="right"> <input type="submit" value="提交"/> </tr>
</table>
<form>
</body>
</html>

然后定义一个当Bean的检验失败后的处理器，@Valid Transaction trans中使用@Valid注解表明这个Bean将会被检验，而另外一个Errors的参数则是用于保存是否存在错误信息的。

package com.ssm.chapter14.controller;import@Controller
@RequestMapping("/validate")
public class ValidateController { @RequestMapping("/annotation")
public ModelAndView annotationValidate(@Valid Transaction trans, Errors errors) {
// 是否存在错误
if (errors.hasErrors()) {
// 获取错误信息
List<FieldError> errorList = errors.getFieldErrors();
for (FieldError error : errorList) {
// 打印字段错误信息
System.err.println("fied :" + error.getField() + "\t" + "msg:" + error.getDefaultMessage());
}
}
ModelAndView mv = new ModelAndView();
mv.setViewName("index");
return mv;
}
}

测试结果：

打印结果：

fied :quantity msg:最大不能超过100
fied :productId msg:不能为null
fied :date msg:需要是一个将来的时间
fied :userId msg:不能为null
fied :email msg:不符合邮件格式
fied :price msg:必须大于或等于0.1

2.使用验证器Validator规则验证输入内容

有时候除了简单的输入格式、非空型等校验，也需要一定的业务检验，Spring 提供了Validator接口来实现校验，它将在进入控制器逻辑之前对参数的合法性进行检验。

首先定义验证器，必须实现Validator接口：首先验证是否是Transaction对象，如果是，就验证交易金额是否等于单价×数量

package com.ssm.chapter14.validator;import org.springframework.validation.Errors;
import org.springframework.validation.Validator;import com.ssm.chapter14.pojo.Transaction;public class TransactionValidator implements Validator {
@Override
public boolean supports(Class<?> clazz) {
//判断验证是否为Transaction，如果是则进行验证
return Transaction.class.equals(clazz);
} @Override
public void validate(Object target, Errors errors) {
Transaction trans = (Transaction) target;
//求交易金额和价格×数量的差额
double dis = trans.getAmount() - (trans.getPrice() * trans.getQuantity());
//如果差额大于0.01，则认为业务错误
if (Math.abs(dis) > 0.01) {
//加入错误信息
errors.rejectValue("amount", null, "交易金额和购买数量与价格不匹配");
}
}
}

然后，还需要将验证器TransactionValidator和控制器绑定起来，Spring MVC 提供了@InitBinder注解，通过这个注解就可以将验证器和控制器绑定到一起了：

package com.ssm.chapter14.controller;import
@Controller
@RequestMapping("/validate")
public class ValidateController { @InitBinder
public void initBinder(DataBinder binder) {
// 数据绑定器加入验证器
binder.setValidator(new TransactionValidator());
} @RequestMapping("/validator")
public ModelAndView validator(@Valid Transaction trans, Errors errors) {
// 是否存在错误
if (errors.hasErrors()) {
// 获取错误信息
List<FieldError> errorList = errors.getFieldErrors();
for (FieldError error : errorList) {
// 打印字段错误信息
System.err.println("fied :" + error.getField() + "\t" + "msg:" + error.getDefaultMessage());
}
}
ModelAndView mv = new ModelAndView();
mv.setViewName("index");
return mv;
}
}

最后，还需要修改表单的action项为新的当前的控制器<form action = "./validate/validator.do">，然后进行测试：在控制台打印出：

fied :amount msg:交易金额和购买数量与价格不匹配

还需要注意的是，JSR 303注解方式和验证器方式不能同时使用，不过可以在使用JSR 303注解额方式得到基本的检验信息后，再使用自己的方法进行验证。

六、数据模型

视图是业务处理后展现给用户的内容，不过一般伴随着业务处理返回的数据，用来给用户查看。Spring MVC 的流程是从控制器获取数据后，会装载数据到数据模型和视图中，然后将视图名称转发到视图解析器中，通过解析器解析后得到最终视图，最后将数据模型渲染到视图中，展示最终的结果给用户。

之前一直使用ModelAndView来定义视图类型，包括JSON视图，也用它来加载数据模型。ModelAndView有一个类型为ModelMap的属性model，而ModelMap继承了LinkedHashMap<String, Object>，因此它可以存放各种键值对，为了进一步定义数据模型功能，Spring 还创建了类ExtendedModelMap，这个类实现了数据模型定义的Model 接口，并且还在此基础上派生了关于数据绑定的类---BindAwareModelMap：

在控制器的方法中，可以把ModelAndView、Model、ModelMap作为参数。在Spring MVC 运行的时候，会自动初始化它们，因此可以选择 ModelMap 或者 Model 作为数据模型。

@RequestMapping(value = "/getRoleByModelMap", method = RequestMethod.GET)
public ModelAndView getRoleByModelMap(@RequestParam("id") Long id, ModelMap modelMap) {
Role role = roleService.getRole(id);
ModelAndView mv = new ModelAndView();
mv.setViewName("roleDetails");
modelMap.addAttribute("role", role);
return mv;
} @RequestMapping(value = "/getRoleByModel", method = RequestMethod.GET)
public ModelAndView getRoleByModel(@RequestParam("id") Long id, Model model) {
Role role = roleService.getRole(id);
ModelAndView mv = new ModelAndView();
mv.setViewName("roleDetails");
model.addAttribute("role", role);
return mv;
} @RequestMapping(value = "/getRoleByMv", method = RequestMethod.GET)
public ModelAndView getRoleByMv(@RequestParam("id") Long id, ModelAndView mv) {
Role role = roleService.getRole(id);
mv.setViewName("roleDetails");
mv.addObject("role", role);
return mv;
}

在浏览器直接输入http://localhost:8080/Chapter14/role/getRoleByModel.do?id=8也会得到正确的跳转视图。

事实上，无论是 Model 还是 ModelMap，Spring MVC 创建的是一个BindingAwareModelMap 实例，而 BindingAwareModelMap 是一个继承了 ModelMap 实现了 Model 接口的类，所以就有了相互转换的功能。

七、视图和视图解析器

视图是展示给用户的内容，而在此之前，要通过控制器得到对应的数据模型，如果是非逻辑视图，则不会经过视图解析器定位视图，而是直接将数据模型渲染便结束了；而逻辑视图则是要对其进一步解析，以定位真实视图，这就是视图解析器的作用了。而视图则是把从控制器查询回来的数据模型进行渲染，以展示给请求者查看。

1.视图

在请求之后，Spring MVC 控制器获取了对应的数据，绑定到数据模型中，那么视图就可以展示数据模型的信息了。

视图又分为逻辑视图和非逻辑视图，比如MappingJackson2JsonView是一个非逻辑视图，它的目的就是将数据模型转换为一个JSON视图，展现给用户，无须对视图名字再进行下一步的解析。这其中，由于非逻辑视图在没有视图解析器的情况下就可以进行渲染，最终将其绑定的数据模型转换为JSON数据。

Spring MVC 中定义了多种视图，它们都需要实现视图接口--View，而View接口中主要有方法getContentType和render，其中getContentType方法表示返回一个字符串，表明给用户什么类型的文件响应，可以使HTML、JSON、PDF等，而render方法则是一个渲染视图的方法，其参数包括其数据模型Model，HTTP请求对象和HTTP响应对象。当控制器返回ModelAndView 的时候，视图解析器就会解析它，然后将数据模型传递给 render 方法，这样就能将数据模型渲染成各种视图，然后通过HTTP请求兑现和HTTP响应对象展示给用户了。

public interface View {
...
String getContentType();
void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throw Exception;
}

而InternalResourceView是一个逻辑视图，对于逻辑视图而言它需要一个视图解析器，视图解析器的作用也就是，通过前缀和后缀加上视图名称就能够找到对应的JSP文件，然后把数据模型渲染到JSP文件中，这样便能展现视图给用户了。

<bean id="viewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver"
p:prefix="/WEB-INF/jsp/" p:suffix=".jsp" />

2.视图解析器

对于逻辑视图而言，把视图名称转换为逻辑视图是一个必备的过程，InternalResourceView会加载到 Spring MVC 的视图解析器列表中去，当返回ModelAndView的时候，Spring MVC 就会在视图解析器列表中遍历，找到对应的视图解析器去解析视图。

视图解析器的定义如下，其中viewName表示传递进来的视图名称，而Locale类型的locale是国际化对象。

public interface ViewResolver {
View resolveViewName(String viewName, Local locale) throws Exception;
}

有时候在控制器中并没有返回一个 ModelAndView，而是只返回了一个字符串，它也能够渲染视图，因为视图解析器生成了对应的视图：

@RequestMapping(value = "/index", method = RequestMethod.GET)
public String index(@RequestParam("id") Long id, ModelMap model) {
Role role = roleService.getRole(id);
model.addAttribute("role", role);
return "roleDetails";
}

3.实例：Excel视图的使用

需求：用户通过输入URL，然后通过GET请求下载到保存了数据库中所有的查询记录的Excel表

（1）选择视图类

对于Excel而言，Spring MVC 所推荐的是使用AbstractXlsView，根据视图类的关系可以看到，AbstractXlsView继承了AbstractView类，而AbstractView类又实现了View接口。

由于AbstractXlsView是抽象类，因此需要实现其中的抽象方法buildExcelDocument：

protected abstract void buildExcelDocument(Map<String, Object> model, Workbook workbook, HttpServletRequest request, HttpServletResponse response) throws Exception);

其中，model表示数据模型，workbook表示POI workbook对象，这个方法的主要任务是创建一个Workbook，它要用到POI的API。

（2）自定义导出接口

目前的需求是导出所有就是信息，但是将来或许还需要增加其他的导出功能，因此，先定义一个接口，这个接口的功能是让开发者自定义生成Excel的规则。

package com.ssm.chapter14.view;import java.util.Map;
import org.apache.poi.ss.usermodel.Workbook;
public interface ExcelExportService { /***
* 生成exel文件规则
* @param model 数据模型
* @param workbook excel workbook
*/
public void makeWorkBook(Map<String, Object> model, Workbook workbook);}

（3）定义Excel视图

即Excel视图类:对于导出来说，还需要一个下载文件名称，所以还需要定义一个fileName属性。由于该视图不是一个逻辑视图，所以无需视图解析器也可以运行它。

对于buildExcelDocument方法来说，其最后一行才是关键：excelExpService.makeWorkBook(model, workbook);，意思就是调用ExcelExportService接口的makeWorkBook方法使用自定义的规则进行Excel创建。即可以根据需要进行自定义生成Excel的规则。

package com.ssm.chapter14.view;
import
public class ExcelView extends AbstractXlsView { // 文件名
private String fileName = null; // 导出视图自定义接口
private ExcelExportService excelExpService = null; // 构造方法1
public ExcelView(ExcelExportService excelExpService) {
this.excelExpService = excelExpService;
} // 构造方法2
public ExcelView(String viewName, ExcelExportService excelExpService) {
this.setBeanName(viewName);
}

/******** getter and setter **********/
@Override
protected void buildExcelDocument(Map<String, Object> model, Workbook workbook, HttpServletRequest request,
HttpServletResponse response) throws Exception {
// 没有自定义接口
if (excelExpService == null) {
throw new RuntimeException("导出服务接口不能为null！！");
}
// 文件名不为空，为空则使用请求路径中的字符串作为文件名
if (!StringUtils.isEmpty(fileName)) {
// 进行字符转换
String reqCharset = request.getCharacterEncoding();
reqCharset = reqCharset == null ? "UTF-8" : reqCharset;
fileName = new String(fileName.getBytes(reqCharset), "ISO8859-1");
// 设置下面文件名
response.setHeader("Content-disposition", "attachment;filename=" + fileName);
}
// 回调接口方法，使用自定义生成Excel文档
excelExpService.makeWorkBook(model, workbook);
}}

（4）定义控制器

其中ExcelView ev = new ExcelView(exportService());将得到ExcelView类型的视图ev，然后mv.addObject("roleList", roleList);加入数据模型，最后mv.setView(ev);将视图设置为ev。

ExcelView ev = new ExcelView(exportService());中exportService()方法就是(5)中定义的ExcelExportService接口的实现类的方法。

@RequestMapping(value = "/export", method = RequestMethod.GET)
public ModelAndView export() {
//模型和视图
ModelAndView mv = new ModelAndView();
//Excel视图，并设置自定义导出接口
ExcelView ev = new ExcelView(exportService());
//文件名
ev.setFileName("所有角色.xlsx");
//设置SQL后台参数
RoleParams roleParams = new RoleParams();
//限制1万条
PageParams page = new PageParams();
page.setStart(0);
page.setLimit(10000);
roleParams.setPageParams(page);
//查询
List<Role> roleList = roleService.findRoles(roleParams);
//加入数据模型
mv.addObject("roleList", roleList);
mv.setView(ev);
return mv;
}

（5）定义ExcelExportService接口的实现：这里是使用了Lambda表达式实现的，看起来比较高级。

@SuppressWarnings({ "unchecked"})
private ExcelExportService exportService() {
//使用Lambda表达式自定义导出excel规则
return (Map<String, Object> model, Workbook workbook) -> {
//获取用户列表
List<Role> roleList = (List<Role>) model.get("roleList");
//生成Sheet
Sheet sheet= workbook.createSheet("所有角色");
//加载标题
Row title = sheet.createRow(0);
title.createCell(0).setCellValue("编号");
title.createCell(1).setCellValue("名称");
title.createCell(2).setCellValue("备注");
//便利角色列表，生成一行行的数据
for (int i=0; i<roleList.size(); i++) {
Role role = roleList.get(i);
int rowIdx = i + 1;
Row row = sheet.createRow(rowIdx);
row.createCell(0).setCellValue(role.getId());
row.createCell(1).setCellValue(role.getRoleName());
row.createCell(2).setCellValue(role.getNote());
}
};
}

（6）测试：在浏览器中输入：http://localhost:8080/Chapter14/role/export.do就可以下载到一个名为“所有角色.xlsx”的Excel文件，打开该文件，可以看到正确显示了数据库中的记录：

八、上传文件

Spring MVC 为上传文件提供了良好的支持。首先 Spring MVC 的文件上传是通过MultipartResolver处理的，对于MultipartResolver而言它只是一个接口，它有两个实现类：CommonMultipartResovler和StandardMultipartResolver。其中，StandardMultipartResolver不需要引入任何第三方包即可实现。无论使用哪个类，都需要配置一个MultipartResolver

1.MultipartResolver配置

（1）通过注解配置StandardMultipartResolver

对于StandardMultipartResolver来说，其构造方法没有参数，因此很容易对其进行初始化。

@Bean(name = "multipartResolver")
public MultipartResolver initMultipartResolver() {
return new StandardServletMultipartResolver();
}

但是，仅仅这样配置是不够的，还需要对上传文件进行配置，例如限制单个文件的大小，设置上传路径等，为了进行设置，可以在Spring MVC 初始化的时候对MultipartResolver进行配置：

如果需要通过Java配置 Spring MVC 的初始化，只需要继承AbstractAnnotationConfigDispatcherServletInitializer 类就可以了，通过继承它就可以进行注解配置了，这个类中可以覆盖customizeRegistration方法，它是一个用于初始化DispatcherServlet设置的方法。

package com.ssm.chapter15.config;import javax.servlet.MultipartConfigElement;
import javax.servlet.ServletRegistration.Dynamic;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;public class MyWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
//Spring IoC容器配置
@Override
protected Class<?>[] getRootConfigClasses() {
//可以返回Spring的Java配置文件数组
return new Class<?>[] {};
} //DispatcherServlet的URI映射关系配置
@Override
protected Class<?>[] getServletConfigClasses() {
//可以返回Spring的Java配置文件数组
return new Class<?>[] { WebConfig.class };
} //DispatchServlet[修改为：DispatcherServlet]拦截请求匹配
@Override
protected String[] getServletMappings() {
return new String[] { "*.do" };
} /**
* @param dynamic Servlet动态加载配置
*/
@Override
protected void customizeRegistration(Dynamic dynamic) {
//文件上传路径
String filepath = "d:/mvc/upload";
//5MB
Long singleMax = (long) (5*Math.pow(2, 20));
//10MB
Long totalMax = (long) (10*Math.pow(2, 20));
//配置MultipartResolver，限制请求，单个文件5MB，总共文件10MB
dynamic.setMultipartConfig(new MultipartConfigElement(filepath, singleMax, totalMax, 0));
}}

其中，customizeRegistration方法中设置了MultipartResolver的属性，包括文件路径、单个文件大小、全部文件大小。

（2）通过XML配置StandardMultipartResolver

还可以通过在Web.xml中实现对MultipartResolver的初始化，然后通过XML或者注解生成一个AbstractAnnotationConfigDispatcherServletInitializer即可。

<multipart-config>
<location>e:/mvc/uploads/</location>
<max-file-size>5242880</max-file-size>
<max-request-size>10485760</max-request-size>
<file-size-threshold>0</file-size-threshold>
</multipart-config>

（3）通过注解配置CommonMultipartResovler，但是这种方式需要依赖于第三方的包

@Bean(name = "multipartResolver")
public MultipartResolver initCommonsMultipartResolver() {
//文件上传路径
String filepath = "d:/mvc/uploads";
//5MB
Long singleMax = (long) (5 * Math.pow(2, 20));
//10MB
Long totalMax = (long) (10 * Math.pow(2, 20));
CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
multipartResolver.setMaxUploadSizePerFile(singleMax);
multipartResolver.setMaxUploadSize(totalMax);
try {
multipartResolver.setUploadTempDir(new FileSystemResource(filepath));
} catch (IOException e) {
e.printStackTrace();
}
return multipartResolver;
}

2.提交上传文件表单

需要将enctype="multipart/form-data设置成这样，否则 Spring MVC 会解析失败。

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>文件上传</title>
</head>
<body>
<form method="post" action="./file/upload.do" enctype="multipart/form-data" >
<input type="file" name="file" value="请选择上传的文件"/>
<input type="submit" value="提交"/>
</form>
</body>
</html>

3.与之对应，需要有一个upload控制器方法

package com.ssm.chapter15.controller;import @Controller
@RequestMapping("/file")
public class FileController implements ApplicationContextAware { @RequestMapping("/upload")
public ModelAndView upload(HttpServletRequest request) {
// 进行转换
MultipartHttpServletRequest mhsr = (MultipartHttpServletRequest) request;
// 获得请求上传的文件
MultipartFile file = mhsr.getFile("file");
// 设置视图为JSON视图
ModelAndView mv = new ModelAndView();
mv.setView(new MappingJackson2JsonView());
// 获取原始文件名
String fileName = file.getOriginalFilename();
// 目标文件
File dest = new File(fileName);
try {
// 保存文件
file.transferTo(dest);
// 保存成功
mv.addObject("success", true);
mv.addObject("msg", "上传文件成功");
} catch (IllegalStateException | IOException e) {
// 保存失败
mv.addObject("success", false);
mv.addObject("msg", "上传文件失败");
e.printStackTrace();
}
return mv;
}
}

4.测试

项目目录为：

其中，采用1（1）中的配置，然而首先需要创建目录，d:/mvc/upload，然后在浏览器中输入：http://localhost:8080/Chapter15.2/file.jsp

选择文件后，点击提交，跳转到下面的页面，同时，d:/mvc/upload下也发现了之前选择的文件：

5.问题分析

这里会有一个问题，就是控制器中的upload方法的参数是HttpServletRequest request，这样会造成API侵入，即调用了Servlet的API

@RequestMapping("/upload")
public ModelAndView upload(HttpServletRequest request) {....}

解决方法是，将参数修改成MultipartFile或者Part类对象，这样做的好处是把代码从Servlet API 中解放出来，这体现了Spring 的思维，即高度的解耦合性。

下面两个方法都通过了测试。

// 使用MultipartFile
@RequestMapping("/uploadMultipartFile")
public ModelAndView uploadMultipartFile(MultipartFile file) {
// 定义JSON视图
ModelAndView mv = new ModelAndView();
mv.setView(new MappingJackson2JsonView());
// 获取原始文件名
String fileName = file.getOriginalFilename();
file.getContentType();
// 目标文件
File dest = new File(fileName);
try {
// 保存文件
file.transferTo(dest);
mv.addObject("success", true);
mv.addObject("msg", "上传文件成功");
} catch (IllegalStateException | IOException e) {
mv.addObject("success", false);
mv.addObject("msg", "上传文件失败");
e.printStackTrace();
}
return mv;
} // 使用Part
@RequestMapping(value="/uploadPart", method=RequestMethod.POST)
public ModelAndView uploadPart(Part file) {
ModelAndView mv = new ModelAndView();
mv.setView(new MappingJackson2JsonView());
// 获取原始文件名
String fileName = file.getSubmittedFileName();
try {
// 保存文件
file.write("d:/mvc/upload/" + fileName);
mv.addObject("success", true);
mv.addObject("msg", "上传文件成功");
} catch (IllegalStateException | IOException e) {
mv.addObject("success", false);
mv.addObject("msg", "上传文件失败");
e.printStackTrace();
}
return mv;
}