目录：
SpringMVC什么是MVC模型SpringMVC案例SpringMVC执行流程SpringMVC封装参数简单数据类型简单对象关联对象简单数据类型集合Map集合参数类型转换器编码过滤器Servlet原生对象
SpringMVC处理响应视图解析器返回值为void返回值为ModelAndView向request域设置数据向session域设置数据向context域设置数据请求转发&重定向
SpringMVC注解@Controlle r和 @RequestMapping@RequestParam@RequestHeader、@CookieValue@SessionAttributes@ModelAttributeRESTful风格支持@PathVariable@PostMapping、@GetMapping、@PutMapping、@DeleteMappingHiddenHttpMethodFilter@ResponseBody@RestController静态资源映射@RequestBody
SpringMVC上传原生方式上传SpringMVC方式上传上传多文件异步上传跨服务器上传查询可下载的文件下载文件
SpringMVC异常处理单个控制器异常处理全局异常处理自定义异常处理器
SpringMVC拦截器拦截器的使用全局拦截器拦截器链与执行顺序过滤敏感词
SpringMVC跨域请求同源策略跨域请求接收跨域请求
SpringMVC
什么是MVC模型
MVC全称Model View Controller，是一种设计创建Web应用程序的模式。这三个单词分别代表Web应用程序的三个部分：
Model（模型）：指数据模型。用于存储数据以及处理用户请求的业务逻辑。在Web应用中，JavaBean对象，业务模型等都属于Model。
View（视图）：用于展示模型中的数据的，一般为jsp或html文件。
Controller（控制器）：是应用程序中处理用户交互的部分。接受视图提出的请求，将数据交给模型处理，并将处理后的结果交给视图显示。
SpringMVC
SpringMVC是一个基于MVC模式的轻量级Web框架，是Spring框架的一个模块，和Spring可以直接整合使用，我们使用的版本是Spring6，所以JDK需要17以上。SpringMVC代替了Servlet技术，它通过一套注解，让一个简单的Java类成为处理请求的控制器，而无须实现任何接口。
案例
使用maven创建web项目，补齐包结构。
引入相关依赖
在web.xml中配置前端控制器DispatcherServlet。
4.编写SpringMVC核心配置文件springmvc.xml，该文件和Spring配置文件写法一样。
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
5.编写控制器
@Controller
public class MyController1 {
// 该方法的访问路径是/c1/hello1
@RequestMapping("/c1/hello1")
public void helloMVC(){
System.out.println("hello SpringMVC！");
}
}
配置tomcat10启动项目，访问 http://localhost:8080/c1/hello1
SpringMVC执行流程
SpringMVC的组件
DispatcherServlet：前端控制器，接受所有请求，调用其他组件。HandlerMapping：处理器映射器，根据配置找到方法的执行链。HandlerAdapter：处理器适配器，根据方法类型找到对应的处理器。ViewResolver：视图解析器，找到指定视图。
组件的工作流程
客户端将请求发送给前端控制器。前端控制器将请求发送给处理器映射器，处理器映射器根据路径找到方法的执行链，返回给前端控制器。前端控制器将方法的执行链发送给处理器适配器，处理器适配器根据方法类型找到对应的处理器。处理器执行方法，将结果返回给前端控制器。前端控制器将结果发送给视图解析器，视图解析器找到视图文件位置。视图渲染数据并将结果显示到客户端。
SpringMVC封装参数
简单数据类型
在Servlet中我们通过request.getParameter(name)获取请求参数。该方式存在两个问题：
请求参数较多时会出现代码冗余。与容器紧耦合。
而SpringMVC支持参数注入的方式用于获取请求数据，即将请求参数直接封装到方法的参数当中。用法如下：
编写控制器方法
// 封装为简单数据类型类型参数
@RequestMapping("/c1/param1")
public void simpleParam(String username,int age){
System.out.println(username);
System.out.println(age);
}
访问该方法时，请求参数名和方法参数名相同，即可完成自动封装。
http://localhost:8080/c1/param1?username=bz&age=10
简单对象
SpringMVC支持将参数直接封装为对象，写法如下：
编写实体类
public class Student {
private int id;
private String name;
private String sex;
// 省略getter/setter/tostring
}
编写控制器方法
// 封装为简单对象类型参数
@RequestMapping("/c1/param2")
public void objParam(Student student){
System.out.println(student);
}
访问该方法时，请求参数名和对象参数的属性名相同，即可完成自动封装。
http://localhost:8080/c1/param2?id=1&name=bz&sex=female
关联对象
SpringMVC还可以将请求参数封装为关联对象，即对象的属性也是一个对象。写法如下：
编写实体类
public class Student {
private int id;
private String name;
private String sex;
private Address address; // 地址对象
// 省略getter/setter/tostring
}
public class Address {
private String info; //地址信息
private String postcode; //邮编
// 省略getter/setter/tostring
}
编写控制器方法
// 获取关联对象类型参数
@RequestMapping("/c1/param3")
public void objParam2(Student student){
System.out.println(student);
}
访问该方法时，请求参数名和方法参数的属性名相同，即可完成自动封装。
http://localhost:8080/c1/param3?id=1&name=bz&sex=female&address.info=beijing&address.postcode=030000
我们也可以使用表单发送带有参数的请求：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
简单数据类型集合
1.编写控制器方法
// 封装为简单数据类型集合，参数前必须添加@RequestParam注解
@RequestMapping("/c1/param4")
public void listParam(@RequestParam List
System.out.println(users);
}
该方式也可以封装为简单数据类型数组：
@RequestMapping("/c1/param5")
public void listParam2(@RequestParam String[] users){
System.out.println(users[0]);
System.out.println(users[1]);
}
请求的参数写法
http://localhost:8080/c1/param4?users=bj&users=sxt
Map集合
同样，SpringMVC要想把参数封装到Map集合中，需要封装到有Map属性的对象中。
编写实体类
public class AddressMap {
private Map
// 省略getter/setter/tostring
}
编写控制器方法
// 对象中包含map属性
@RequestMapping("/c1/param7")
public void mapParam3(AddressMap addressMap){
System.out.println(addressMap.getAddress());
}
请求的参数写法
参数的写法为：map属性名[键].值中的属性，例如：address[one].info
请求的路径如下：
http://localhost:8080/c1/param7?address[one].info=bj&address[one].postcode=100010&address[two].info=sh&address[two].postcode=100011
编码后为：
http://localhost:8080/c1/param7?address%5Bone%5D.info=bj&address%5Bone%5D.postcode=100010&address%5Btwo%5D.info=sh&address%5Btwo%5D.postcode=100011
参数类型转换器
前端传来的参数全部为字符串类型，SpringMVC使用自带的转换器将字符串参数转为需要的类型。如：
// 获取简单类型参数
@RequestMapping("/c1/param1")
public void simpleParam(String username,int age){
System.out.println(username);
System.out.println(age);
}
但在某些情况下，无法将字符串转为需要的类型，如：
@RequestMapping("/c1/param8")
public void dateParam(Date birthday){
System.out.println(birthday);
}
由于日期数据有很多种格式，SpringMVC默认只能转换2050/1/1这样的日期格式。但假如前端传来的参数格式为2025-01-01时，SpringMVC就无法解析参数。此时需要自定义参数类型转换器。
定义类型转换器类，实现Converter接口
// 类型转换器必须实现Converter接口，两个泛型代表转换前的类型，转换后的类型
public class DateConverter implements Converter
/**
* 转换方法
* @param source 转换前的数据
* @return 转换后的数据
*/
@Override
public Date convert(String source) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date = null;
try {
date = sdf.parse(source);
} catch (ParseException e) {
e.printStackTrace();
}
return date;
}
}
0注册类型转换器对象
此时再访问http://localhost:8080/c1/param9?birthday=2025-01-01时，SpringMVC即可将请求参数封装为Date类型的参数。
编码过滤器
在传递参数时，tomcat10以上不会出现中文乱码，tomcat8以上能处理get请求的中文乱码，但不能处理post请求的中文乱码。
编写jsp表单
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
编写控制器方法
@RequestMapping("/cn/code")
public void code(String username){
System.out.println(username);
}
SpringMVC提供了处理中文乱码的过滤器，在web.xml中配置该过滤器即可解决中文乱码问题：
Servlet原生对象
SpringMVC的方法中已经封装好了Servlet原生对象，在方法参数中定义HttpServletRequest、HttpServletResponse、HttpSession等类型的参数即可直接在方法中使用。
// 使用Servlet原生对象
@RequestMapping("/c1/param9")
public void servletParam(HttpServletRequest request, HttpServletResponse response, HttpSession session){
// 原生对象获取参数
System.out.println(request.getParameter("name"));
System.out.println(response.getCharacterEncoding());
System.out.println(session.getId());
}
访问该方法即可：http://localhost:8080/c1/param9?name=bjsxt
一般情况下，在SpringMVC中都有对Servlet原生对象的方法的替代，推荐使用SpringMVC的方式代替Servlet原生对象。
SpringMVC处理响应
视图解析器
SpringMVC默认情况下会在控制器执行完成后跳转到视图页面，视图解析器能找到相应的视图，之前的404异常就是由于没有配置视图解析器导致找不到视图。
在SpringMVC中提供了13个视图解析器，用于支持不同的视图技术。InternalResourceViewResolver是SpringMVC的默认视图解析器，用来解析JSP视图。
返回值为void
我们可以通过控制器方法的返回值设置跳转的视图，控制器方法支持的返回值类型为void、String、ModelAndView，我们以此进行介绍。
当控制器方法的返回值为void时，会跳转到名字是 前缀+方法路径名+后缀 的jsp页面
编写控制器方法
// 路径是helloMVC，方法执行完后会跳转到/helloMVC.jsp
@RequestMapping("/helloMVC")
public void helloMVC(){
System.out.println("hello SpringMVC！");
}
编写helloMVC.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
欢迎来到SpringMVC
6
返回值为ModelAndView
ModelAndView是SpringMVC提供的对象，该对象可以向request域设置数据并指定跳转的页面。该对象中包含Model对象和View对象。
Model：向request域中设置数据。 View：指定跳转的页面。
编写控制器方法
// 返回值为ModelAndView
@RequestMapping("/c2/hello2")
public ModelAndView useMAV(){
System.out.println("返回值类型为ModelAndView");
// 1.创建ModelAndView对象
ModelAndView modelAndView = new ModelAndView();
// 2.获取Model对象，本质是一个Map
Map
// 3.使用Model对象向request域设置数据
model.put("name","jjy");
// 4.使用View对象设置跳转的路径为/baizhan.jsp
modelAndView.setViewName("jjy");
return modelAndView;
}
编写jsp页面
<%@ page contentType="text/html;charset=UTF-8" language="java"%>
你好！${requestScope.name}
修改web.xml命名空间，让jsp页面默认支持el表达式
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1">
向request域设置数据
当控制器返回值为ModelAndView时我们可以向request域设置数据，我们还有以下方法可以向request域设置数据：
使用原生的HttpServletRequest
@RequestMapping("/c2/hello3")
public String setRequestModel(HttpServletRequest request){
request.setAttribute("name","中北");
return "baizhan";
}
使用Model、ModelMap SpringMVC提供了Model接口和ModelMap类，控制器方法添加这两个类型的参数，使用该参数设置数据，该数据就会存到request域中。
@RequestMapping("/c2/hello4")
public String setRequestModel2(Model model, ModelMap modelMap){
// model.addAttribute("name","中北2");
modelMap.addAttribute("name","中北3");
return "baizhan";
}
使用Map集合 Model接口底层就是一个Map集合，我们可以给控制器方法设置Map类型的参数，向Map中添加键值对，数据也会存到request域中。
@RequestMapping("/c2/hello5")
public String setRequestModel3(Map map){
map.put("name","中北4");
return "baizhan";
}
向session域设置数据
Session作用域表示在当前会话中有效。我们可以在控制器方法的参数中使用HttpSession对象来向session域设置数据。
编写控制器方法
@RequestMapping("/c2/hello6")
public String setSeesionModel(HttpSession session){
session.setAttribute("address","北京");
return "baizhan";
}
编写jsp页面
<%@ page contentType="text/html;charset=UTF-8" language="java"%>
你好！${requestScope.name}
地址是！${sessionScope.address}
除了使用Servlet原生对象，我们也可以使用SpringMVC提供的注解向session域设置数据，后面我们会讲到。
向context域设置数据
context作用域表示在整个应用范围都有效。在SpringMVC中对context作用域传值，可以使用ServletContext对象来实现。但是该对象不能直接注入到方法参数中，需要通过HttpSession对象获取。
编写控制器方法
@RequestMapping("/c2/hello7")
public String setContextModel(HttpSession session){
ServletContext servletContext = session.getServletContext();
servletContext.setAttribute("age",10);
return "baizhan";
}
2.编写jsp页面
<%@ page contentType="text/html;charset=UTF-8" language="java"%>
你好！${requestScope.name}
地址是！${sessionScope.address}
年纪是！${applicationScope.age}
请求转发&重定向
之前的案例，我们发现request域中的值可以传到jsp页面中，也就是通过视图解析器跳转到视图的底层是请求转发。
如果我们跳转时不想使用视图解析器，可以使用原生HttpServletRequest进行请求转发或HttpServletResponse进行重定向：
@RequestMapping("/c2/hello8")
public void myForward1(HttpServletRequest request, HttpServletResponse response) throws Exception{
request.setAttribute("name","中北");
// 请求转发
// request.getRequestDispatcher("/c2/hello9").forward(request,response);
// 原生重定向
response.sendRedirect("/c2/hello9");
}
@RequestMapping("/c2/hello9")
public void myForward2(HttpServletRequest request){
System.out.println("hello");
System.out.println(request.getAttribute("name"));
}
SpringMVC还提供了一种更简单的请求转发和重定向的写法：
@RequestMapping("/c2/hello10")
public String myForward3(HttpServletRequest request){
request.setAttribute("name","中北");
// 请求转发
return "forward:/c2/hello9";
// 重定向
// return "redirect:/c2/hello9";
}
SpringMVC注解
@Controlle r和 @RequestMapping
@Controller
作用：标记控制器，将控制器交给Spring容器管理。
位置：类上方
@RequestMapping
作用：给控制器方法设置请求路径
位置：方法或类上方。用于类上，表示类中的所有控制器方法都是以该地址作为父路径。
属性：
value/path:请求路径method:指定请求方式params:规定必须发送的请求参数headers:规定请求必须包含的请求头
@Controller
@RequestMapping("/c3")
public class MyController3 {
/**
* 访问路径是 /c3/a1
* 支持post和get请求
* 请求必须带有username参数
* 请求必须带有User-agen请求头
*
*/
@RequestMapping(path = "/a1",
method = {RequestMethod.POST, RequestMethod.GET},
params = {"username"},
headers = {"User-agent"})
public String annotation1(String username) {
System.out.println(username);
return "baizhan";
}
}
@RequestParam
作用：在控制器方法中封装请求参数
位置：方法参数前
属性：
value/name：指定请求参数名称defaultValue： 为参数设置默认值required：设置是否是必须要传入的参数
/*
定义请求的参数名为name，默认值为sxt，不是必须的参数
*/
@RequestMapping("/a2")
public String annotation2(@RequestParam(name = "name",defaultValue = "sxt",required = false) String username) {
System.out.println(username);
return "baizhan";
}
请求URL的写法：http://localhost:8080/c3/a2?name=bz
@RequestHeader、@CookieValue
@RequestHeader
作用：将请求头数据封装到控制器方法参数中
位置：方法参数前
@CookieValue
作用：将Cookie数据封装到控制器方法参数中
位置：方法参数前
/*
获取User-Agent请求头
获取JSESSIONID的Cookie值
*/
@RequestMapping("/annotation3")
public String annotation3(@RequestHeader("User-Agent") String userAgent, @CookieValue("JSESSIONID") String jSessionId){
System.out.println(userAgent);
System.out.println(jSessionId);
return "baizhan";
}
@SessionAttributes
作用：将Model模型中的数据存到session域中
位置：类上方
@Controller
@RequestMapping("/c4")
// 将模型中的name数据保存到session中
@SessionAttributes("name")
public class MyController4 {
@RequestMapping("/t1")
public String t1(Model model){
// model中保存name数据
model.addAttribute("name","中北
1111");
return "baizhan";
}
@RequestMapping("/t2")
public String t2(HttpSession session){
// 从session中获取name数据
Object name = session.getAttribute("name");
System.out.println(name);
return "baizhan";
}
}
@ModelAttribute
作用1：设置指定方法在控制器其他方法前执行
位置： 方法上方
@Controller
@RequestMapping("/c5")
public class MyController5 {
@ModelAttribute
public void before(){
System.out.println("前置方法");
}
@RequestMapping("/t1")
public Stringt1(){
System.out.println("t1");
return "zb";
}
}
作用2： 从Model模型中获取数据给参数赋值 位置：方法参数前
@Controller
@RequestMapping("/c6")
public class MyController6 {
//前置方法向Model中设置数据
@ModelAttribute
public void before(Model model){
model.addAttribute("name","中北");
}
//该参数不是从请求中获取，而是从Model中获取
@RequestMapping("/t1")
public String t1(@ModelAttribute("name") String name){
System.out.println(name);
return "baizhan";
}
}
RESTful风格支持
RESTful风格是一种URL路径的设计风格。在RESTful风格的URL路径中，网络上的任意数据都可以看成一个资源，它可以是一段文本、一张图片，也可以是一个Java对象。而每个资源都会占据一个网络路径，无论对该资源进行增删改查，访问的路径是一致的。
传统URL：
查找id为1的学生：
http://localhost:8080/student/findById?id=30
删除id为1的学生：
http://localhost:8080/student/deleteById?id=30
RESTful风格URL：
查找id为30的学生：
http://localhost:8080/student/30
删除id为30的学生：
http://localhost:8080/student/30
那么如何区分对该资源是哪一种操作？通过请求方式不同，判断进行的是什么操作。
之前我们学过两种请求方式，GET请求和POST请求，而访问RESTful风格的URL一共有四种请求方式：
GET请求：查询操作POST请求：新增操作DELETE请求：删除操作PUT请求：修改操作
RESTful风格URL：
查找id为30的学生：
http://localhost:8080/student/30 GET方式请求
删除id为30的学生：
http://localhost:8080/student/30 DELETE方式请求
RESTful风格的优点:
结构清晰、符合标准、易于理解、扩展方便。
@PathVariable
作用：在RESTful风格的URL中获取占位符的值
位置：方法参数前
属性：
value：获取哪个占位符的值作为参数值，如果占位符和参数名相同，可以省略该属性。
@Controller
@RequestMapping("/student")
// 模拟学生的增删改查控制器
public class MyController6 {
// 路径中的/{id}表示占位符，最后会封装到方法的参数中使用
// 删除学生
@RequestMapping(value = "/{id}",method = RequestMethod.DELETE)
public String deleteStudent(@PathVariable("id") int id){
System.out.println("删除id为"+id+"的学生");
return "baizhan";
}
// 如果占位符和参数名相同，可以省略@PathVariable中的value属性
// 根据id查询学生
@RequestMapping(value = "/{id}",method = RequestMethod.GET)
public String findStudentById(@PathVariable int id){
System.out.println("查找id为"+id+"的学生");
return "baizhan";
}
// 新增学生
@RequestMapping(value = "/{id}",method = RequestMethod.POST)
public String addStudent(@PathVariable int id, Student student){
System.out.println("新增id为"+id+"的学生");
System.out.println(student);
return "baizhan";
}
// 修改学生
@RequestMapping(value = "/{id}",method = RequestMethod.PUT)
public String updateStudent(@PathVariable int id, Student student){
System.out.println("修改id为"+id+"的学生");
System.out.println(student);
return "baizhan";
}
}
访问方式：
新增学生：POST localhost:8080/student/100?name=百战&sex=女修改学生：PUT localhost:8080/student/100?name=百战1&sex=女1删除学生：DELETE localhost:8080/student/100查询学生：GET localhost:8080/student/100
@PostMapping、@GetMapping、@PutMapping、@DeleteMapping
作用：简化设置请求方式的@RequestMapping写法
位置：方法上方。
@Controller
@RequestMapping("/student")
public class StudentController {
// 删除学生
@DeleteMapping("/{id}")
public String deleteStudent(@PathVariable("id") int id){
System.out.println("删除id为"+id+"的学生");
return "baizhan";
}
// 根据id查询学生
@GetMapping("/{id}")
public String findStudentById(@PathVariable int id){
System.out.println(id);
System.out.println("根据id查询学生");
return "baizhan";
}
// 新增学生
@PostMapping("/{id}")
public String addStudent(@PathVariable int id, Student student){
System.out.println(id);
System.out.println(student);
System.out.println("新增学生");
return "baizhan";
}
// 修改学生
@PutMapping("/{id}")
public String updateStudent(@PathVariable int id, Student student){
System.out.println(id);
System.out.println(student);
System.out.println("修改学生");
return "baizhan";
}
}
HiddenHttpMethodFilter
由于浏览器的表单只支持GET与POST请求，不支持DELETE、PUT请求。所以SpringMVC提供了一个过滤器，可以将浏览器的POST请求改为指定的请求方式，发送给控制器的方法。
用法如下：
在web.xml中配置过滤器
编写控制器方法
@Controller
@RequestMapping("/c7")
public class MyController7 {
@DeleteMapping("/delete")
public String testDelete(){
System.out.println("删除方法");
return "baizhan";
}
@PutMapping("/put")
public String testPut(){
System.out.println("修改方法");
return "baizhan";
}
}
在jsp中编写表单
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%-- 提交DELETE、PUT请求，表单必须提交方式为post --%>
<%-- 表单中有一个隐藏域，name值为_method，value值为提交方式 --%>
@ResponseBody
作用：方法返回的对象转换为JSON格式，并将JSON数据直接写入到输出流中，使用此注解后不会再经过视图解析器。使用该注解可以处理Ajax请求。
位置：方法上方或方法返回值前
编写jsp页面，发送ajax请求
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
姓名：
性别：
由于jsp页面中引入jQuery的js文件，而SpringMVC会拦截所有资源，造成jquery.js失效，需要在SpringMVC核心配置文件中放行静态资源。
编写结果实体类，该实体类会封装一个请求的结果
// 请求的结果对象
public class Result {
private boolean flag; // 请求是否成功
private String message; // 请求提示信息
// 省略getter/setter/构造方法
}
编写控制器
@Controller
@RequestMapping("/c8")
public class MyController8 {
@GetMapping("/addStudent")
@ResponseBody
public Result addStudent(String name,String sex){
System.out.println(name+":"+sex);
Result result = new Result(true, "添加学生成功");
return result;
}
}
SpringMVC会将Result对象转为JSON格式写入输出流，而SpringMVC默认使用的JSON转换器是jackson，需要在pom中添加jackson依赖。
@RestController
如果一个控制器类下的所有控制器方法都返回JSON格式数据且不进行跳转，可以使用@RestController代替@Controller，此时每个方法上的@ResponseBody都可以省略。
@RestController
@RequestMapping("/c8")
public class MyController8 {
@GetMapping("/addStudent")
public Result addStudent(String name, String sex) {
// 输出接受到的参数，模拟添加学生
System.out.println(name+":"+sex);
// 返回结果
Result result = new Result(true, "添加学生成功！");
return result;
}
}
静态资源映射
当在DispatcherServlet的
配置静态资源筛查器 在SpringMVC的配置文件中配置
修改SpringMVC核心配置文件：
配置静态资源映射器 SpringMVC模块提供了静态资源映射器组件，通过
修改SpringMVC核心配置文件：
配置默认Servlet处理静态资源 在web.xml可以配置默认Servlet处理静态资源，该Servlet由tomcat提供，它会直接访问静态资源不进行其他操作。这样就避免了使用DispatcherServlet对静态资源的拦截：
修改web.xml:
@RequestBody
作用：将请求中JSON格式的参数转为JAVA对象
位置：写在方法参数前
AJAX请求发送JSON格式的参数
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
姓名：
性别：