第04篇_Spring_MVC

第01章_SpringMVC快速入门

第一节 SpringMVC简介

1. 什么是MVC?

MVC是一种通用软件架构，M是指业务模型，V是指用户界面，C则是控制器，使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。MVC架构的工作流程如下：

1. 用户发送请求到服务器的Controller(C)。

2. Controller调用相应的Model(M)处理请求。

3. 根据处理结果渲染对应的View视图(V)进行响应。

2. 什么是SpringMVC?

SpringMVC是MVC架构的一种具体实现，为表述层(web页面+Servlet)开发提供了一整套完备的解决方案。

SpringMVC的主要特点如下：

1. Spring系列产品，与Spring的IOC容器等基础设施无缝对接。

2. 基于原生的Servlet，通过了功能强大的前端控制器DispatcherServlet，对请求和响应进行统一处理。

3. 表述层各细分领域需要解决的问题全方位覆盖，提供全面解决方案。

4. 内部组件化程度高，可插拔式组件即插即用，想要什么功能配置相应组件即可。

5. 性能卓著，尤其适合现代大型、超大型互联网项目要求。

第二节 SpringMVC入门案例

1. 创建Maven工程

注意：

1. 默认会标记src\main\java为源代码根目录，src\main\resources为资源根目录，若没有则需手动标记。

2. 必须在pom.xml中修改打包方式为war包：<packaging>war</packaging>。

2. 配置web.xml

新建src\main\webapp\WEB-INF\web.xml文件，配置DispatcherServlet统一处理前端请求。

36
1
<?xml version="1.0" encoding="UTF-8"?>
2
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
3
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd
5
 "
6
         version="4.0">
7

8
    <!-- 配置SpringMVC的前端控制器，对浏览器发送的请求统一进行处理 -->
9
    <servlet>
10
        <servlet-name>dispatcherServlet</servlet-name>
11
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
12
        <!-- 通过初始化参数指定SpringMVC配置文件的位置和名称 -->
13
        <init-param>
14
            <!-- contextConfigLocation为固定值 -->
15
            <param-name>contextConfigLocation</param-name>
16
            <!-- 使用classpath:表示从类路径查找配置文件，例如maven工程中的src/main/resources -->
17
            <param-value>classpath:spring-mvc-config.xml</param-value>
18
        </init-param>
19
        <!--
20
            作为框架的核心组件，在启动过程中有大量的初始化操作要做，而这些操作放在第一次请求时才执行会严重影响访问速度
21
            因此需要通过此标签将启动控制DispatcherServlet的初始化时间提前到服务器启动时
22
        -->
23
        <load-on-startup>1</load-on-startup>
24
    </servlet>
25
    <servlet-mapping>
26
        <servlet-name>dispatcherServlet</servlet-name>
27
        <!--
28
            设置springMVC的核心控制器所能处理的请求的请求路径，一般为"/"。
29
            "/"可以匹配/login或.html或.js或.css方式的请求路径, 但是/不能匹配.jsp请求路径的请求。
30
            "/*"则可以匹配所有请求，例如在使用过滤器时，若需要对所有请求进行过滤，就需要使用/*的写法。
31
        -->
32
        <url-pattern>/</url-pattern>
33
    </servlet-mapping>
34
    
35
</web-app>
36

如需在Web工程启动时，加载Spring上下文配置，只需在web.xml中注册ContextLoaderListener监听器即可。

13
1
<!-- 配置Spring提供的监听器，用于启动服务时加载容器。默认加载WEB-INF/applicationContext.xml文件 -->
2
<listener>
3
    <listener-class>
4
    org.springframework.web.context.ContextLoaderListener
5
    </listener-class>
6
</listener>
7

8
<!-- 手动指定Spring配置文件位置 -->
9
<context-param>
10
    <param-name>contextConfigLocation</param-name>
11
    <param-value>classpath:applicationContext.xml</param-value>
12
</context-param>
13

3. 配置spring-mvc-config.xml

在资源根目录下新建spring-mvc-config.xml文件(与web.xml中对应即可)，配置表述层组件扫描和默认视图解析器。

22
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"
4
       xmlns:context="http://www.springframework.org/schema/context"
5
       xmlns:mvc="http://www.springframework.org/schema/mvc"
6
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
7

8
    <!-- 自动扫描包 -->
9
    <context:component-scan base-package="com.huangyuanxin.notes.springmvc.controller"/>
10

11
    <!-- 默认视图解析器，可用于处理jsp等视图 -->
12
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
13
        <property name="order" value="3"/>
14
        <property name="prefix" value="/WEB-INF/pages/"/>
15
        <property name="suffix" value=".jsp"/>
16
    </bean>
17

18
    <!--开启注解驱动支持(虽然入门案例可以省略，但一般项目都会进行配置)-->
19
    <mvc:annotation-driven></mvc:annotation-driven>
20

21
</beans>
22

4. 编写请求控制器

16
1
package com.huangyuanxin.notes.springmvc.controller;
2

3
import org.springframework.stereotype.Controller;
4
import org.springframework.web.bind.annotation.RequestMapping;
5

6
@Controller
7
public class IndexController {
8

9
    @RequestMapping("/")
10
    public String index() {
11
        //设置视图名称
12
        return "index";
13
    }
14

15
}
16

5. 编写视图页面

新建src\main\webapp\WEB-INF\pages\index.jsp文件(与视图解析器配置的前缀后缀以及视图名称相对应)，编写JSP页面如下。

10
1
<!DOCTYPE html>
2
<html lang="en">
3
<head>
4
    <meta charset="UTF-8">
5
    <title>Index</title>
6
</head>
7
<body>
8
<h1>Hello, SpringMVC!(Jsp)</h1>
9
</body>
10
</html>

6. 进行测试

添加一个Tomcat服务器，部署当前应用，设置上下文路径后进行启动。

启动完成后访问http://localhost:8080/页面，显示如下即代表测试成功。

第三节 入门案例扩展

1. DispatcherServlet的初始化参数

第02章_请求与响应详解

第一节 请求映射

请求映射指根据请求路径、请求方法、请求参数等信息，将请求映射到对应的控制器方法，一般使用@RequestMapping注解来配置。

1. 请求路径路由

1.1 声明请求路径

@RequestMapping注解的path(value)属性用来声明请求路径，类上为一级路径，方法上为二级路经，SpringMVC会自动进行拼接。

9
1
// /mapping/path
2
@Controller
3
@RequestMapping("mapping") // 一级路径
4
public class RequestMappingController {
5
    @RequestMapping("path") // 二级路径
6
    public String testMapping() {
7
        return "success";
8
    }
9
}

提示：

1. 一个控制器方法可以配置多个请求路径，用于将不同的请求映射到同一段处理逻辑。

2. Spring MVC默认开启.*后缀模式匹配，以便映射到/person的控制器也能映射到/person.*。

3. 建议设置useSuffixPatternMatching(false)和favorPathExtension(false)来关闭后缀匹配模式，并通过Accept请求头进行替代。

4. 请求路径还可以嵌入${…}占位符，这将在启动时从系统环境等其他属性源中解析替换。

1.2 请求路径通配符

可以通过Ant风格的通配符来模糊匹配请求路径：

• ？：表示任意的单个字符。

• *：表示任意的0个或多个字符。

• /**/：表示任意的一层或多层目录。

23
1
@Controller
2
@RequestMapping("mapping")
3
public class RequestMappingController {
4
    
5
    // /mapping/ant/a1b
6
    @RequestMapping("ant/a?b")
7
    public String testAntMapping01() {
8
        return "success";
9
    }
10

11
    // /mapping/ant/cd
12
    @RequestMapping("ant/c*d")
13
    public String testAntMapping02() {
14
        return "success";
15
    }
16

17
    // /mapping/ant/v1/v1.0/e
18
    @RequestMapping("ant/**/e")
19
    public String testAntMapping03() {
20
        return "success";
21
    }
22
}
23

2. 请求方式限定

2.1 声明请求方式

@RequestMapping注解的method属性用来声明请求方式，如果方式不匹配则报"405：Request method 'POST' not supported"错误。

5
1
@RequestMapping(value = "method/post", method = RequestMethod.POST)
2
public String testPostMethodMapping() {
3
    return "success";
4
}
5

2.2 请求方式组合注解

为了简化请求方法匹配，SpringMVC设计了一些组合注解，如@GetMapping、@PostMapping、@PutMapping和@DeleteMapping等。

4
1
@GetMapping(value = "method/get")
2
public String testGetMethodMapping() {
3
    return "success";
4
}

2.3 转换请求方式

浏览器默认只能发送GET和POST请求，如需发送其它类型请求，可用POST请求+_method参数进行伪造。

首先web.xml文件中配置过滤器如下：

10
1
<!--配合前端伪造PUT等其它类型请求-->
2
<filter>
3
    <filter-name>HiddenHttpMethodFilter</filter-name>
4
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
5
</filter>
6
<filter-mapping>
7
    <filter-name>HiddenHttpMethodFilter</filter-name>
8
    <url-pattern>/*</url-pattern>
9
</filter-mapping>
10

然后前端发送请求时改为POST请求，并附带_method参数指定要伪造的请求方法。

5
1
<form action="mapping/method/put" method="post">
2
    <input type="hidden" name="_method" value="PUT">
3
    <input type="submit" value="提交">
4
</form>
5

这时就可以正确匹配控制器中的PUT方法了。

5
1
@RequestMapping(value = "method/put", method = RequestMethod.PUT)
2
@ResponseBody
3
public String testPutMethodMapping() {
4
    return "success!";
5
}

3. 请求参数与请求头匹配(不常用)

3.1 声明请求参数和请求头

@RequestMapping注解的params属性和headers属性分别用来声明控制器方法所需的请求参数和请求头，支持的格式如下：

• "param"：要求请求映射所匹配的请求必须携带param请求参数。

• "!param"：要求请求映射所匹配的请求必须不携带param请求参数。

• "param=value"：要求请求映射所匹配的请求必须携带param请求参数且param=value。

• "param!=value"：要求请求映射所匹配的请求必须携带param请求参数但是param!=value。

11
1
// 请求参数必须携带username、password和auth参数，不能携带limit参数，且password不能是123456，auth必须是ok。
2
@RequestMapping(value = "params", params = {"username", "password!=123456", "auth=ok", "!limit"})
3
public String testParamsMapping() {
4
    return "success";
5
}
6

7
// 请求头必须携带Origin参数，且必须为www.huangyuanxin.com
8
@RequestMapping(value = "headers", headers = {"Origin=www.huangyuanxin.com"})
9
public String testHeadersMapping() {
10
    return "success";
11
}

3.2 几个特殊的请求头

特别的，对于Content-Type和Accept请求头，可分别通过consumes和produces属性来匹配。

9
1
@PostMapping(path = "/pets", consumes = "application/json") 
2
public void addPet(@RequestBody Pet pet) {
3
}
4

5
@GetMapping(path = "/pets/{petId}", produces = "application/json;charset=UTF-8") 
6
@ResponseBody
7
public Pet getPet(@PathVariable String petId) {
8
    // ...
9
}

提示：MediaType常量类中提供了常用的Content-Type常量，例如APPLICATION_JSON_VALUE和APPLICATION_XML_VALUE。

4. 自定义请求映射逻辑

SpringMVC可对请求映射进行精确控制，主要有两种方式：

• 通过重写RequestMappingHandlerMapping的getCustomMethodCondition方法，返回自己的RequestCondition。

• 通过Java方式注册处理器映射：

  10
  1
  @Configuration
  2
  public class MyConfig {
  3
      @Autowired
  4
      public void setHandlerMapping(RequestMappingHandlerMapping mapping, UserController controller) throws NoSuchMethodException {
  5
          RequestMappingInfo info = RequestMappingInfo.paths("/user/{id}").methods(RequestMethod.GET).build(); 
  6
          Method method = UserController.class.getMethod("getUser", Long.class); 
  7
          mapping.registerMapping(info, controller, method); 
  8
      }
  9
  }
  10
  
  

5. 静态资源映射

默认情况下，前端不能访问服务器的静态资源(html/css/js/img等)，需要对其进行映射配置。

14
1
<!--静态资源映射(方式一)-->
2
<!-- location 表示路径，mapping 表示文件，**表示该目录下的文件以及子目录的文件 -->
3
<mvc:resources location="/html/" mapping="/html/**"/>
4
<mvc:resources location="/css/" mapping="/css/**"/>
5
<mvc:resources location="/js/" mapping="/js/**"/>
6
<mvc:resources location="/img/" mapping="/img/**"/>
7
<mvc:resources location="/public, classpath:/static/" mapping="/resources/**" cache-period="31556926" />
8

9
<!--静态资源映射(方式二)(注意开启MVC注解驱动)-->
10
<!--<mvc:default-servlet-handler/>-->
11

12
<!--开启注解驱动支持-->
13
<mvc:annotation-driven></mvc:annotation-driven>
14

提示：如需生成“版本化”的URL，可考虑配置VersionResourceResolver。

第二节 参数绑定

1. 控制器方法参数

控制器方法常用的参数类型如下：

• Servlet相关对象：HttpServletRequest、MultipartHttpServletRequest、HttpSession、InputStream、Reader、OutputStream、Writer、PushBuilder。

• Spring内部对象：RequestEntity<T>、WebRequest、NativeWebRequest、SessionStatus、HttpMethod、Errors、BindingResult、UriComponentsBuilder。

• 域数据共享对象：Map、Model、ModelMap、RedirectAttributes。

• 其它对象支持：Locale、TimeZone+ZoneId、Principal。

• 任何其他参数：将会根据类型转换器进行属性映射。

参数常用的注解如下：

• 用于获取参数：@RequestParam、@RequestHeader、@CookieValue、@PathVariable、@MatrixVariable、@RequestBody(读取请求正文并通过HttpMessageConverter反序列化为Object)、@RequestPart。

• 用于数据共享：@ModelAttribute、@SessionAttribute、@RequestAttribute。

2. 通过HttpServletRequest获取参数

将HttpServletRequest作为控制器方法的形参，框架在调用时会自动注入为当前请求对象，通过该对象即可获取参数和Cookie等。

8
1
@RequestMapping("servlet")
2
public String testServletApiParams(HttpServletRequest request) {
3
    // 获取请求参数、请求头和Cookie等
4
    System.out.println(request.getParameter("username"));
5
    System.out.println(request.getParameter("password"));
6

7
    return "success";
8
}

提示：可在控制器方法中注入的对象有：HttpServletRequest、HttpServletResponse、HttpSession、java.security.Principal、Locale、InputStream、OutputStream、Reader、Writer等。

3. 绑定请求参数

3.1 简单类型

在控制器方法的形参位置，设置和请求参数同名的形参，当浏览器发送请求，匹配到请求映射时，在DispatcherServlet中就会将请求参数赋值给相应的形参。

14
1
@Controller
2
@RequestMapping("params")
3
public class RequestParamsController {
4

5
    @RequestMapping("simple")
6
    public String testParamsBySimple(String username, String password) {
7
        System.out.println(username);
8
        System.out.println(password);
9

10
        return "success";
11
    }
12

13
}
14

注意：

1. 若有多个同名的请求参数，可以设置形参为字符串数组或者字符串类型。

   • 若使用字符串数组作为形参，则映射为多个数组元素。

   • 若使用字符串作为形参，则映射为一个逗号拼接的字符串。

2. 使用Map作为参数，它将接收所有未被其它方式映射的参数。

3.2 POJO类型

可以在控制器方法的形参位置设置一个POJO类型的形参，此时若浏览器传输的请求参数的参数名和实体类中的属性名一致，那么请求参数就会为此属性赋值。

27
1
public class Account implements Serializable {
2
    private String name;
3
    private Float money;
4
}
5

6
public class Address implements Serializable {
7
    private String provinceName;
8
    private String cityName;
9
}
10

11
public class User implements Serializable {
12
    private String username;
13
    private String password;
14
    private Integer age;
15
    private Address address;
16
    private List<Account> accountList;
17
    private Map<String, Account> accountMap;
18
}
19

20
// 控制器方法，带有User形参
21
@RequestMapping("pojo")
22
public String testParamsByPojo(User user) {
23
    System.out.println(user);
24

25
    return "success";
26
}
27
    

相应的HTML页面如下：

31
1
<!DOCTYPE html>
2
<html lang="en">
3
<head>
4
    <meta charset="UTF-8">
5
    <title>Index</title>
6
</head>
7
<body>
8
<h1>测试复杂POJO参数映射</h1>
9
<form action="/params/pojo" method="post">
10
    <!--简单属性映射-->
11
    用户名称: <input type="text" name="username"><br/>
12
    用户密码: <input type="password" name="password"><br/>
13
    用户年龄: <input type="text" name="age"><br/>
14
    <!--嵌套属性映射-->
15
    用户省份: <input type="text" name="address.provinceName"><br/>
16
    用户城市: <input type="text" name="address.cityName"><br/>
17
    <!--List属性映射-->
18
    账户1 名称: <input type="text" name="accountList[0].name"><br/>
19
    账户1 金额: <input type="text" name="accountList[0].money"><br/>
20
    账户2 名称: <input type="text" name="accountList[1].name"><br/>
21
    账户2 金额: <input type="text" name="accountList[1].money"><br/>
22
    <!--Map属性映射-->
23
    账户3 名称: <input type="text" name="accountMap['one'].name"><br/>
24
    账户3 金额: <input type="text" name="accountMap['one'].money"><br/>
25
    账户4 名称: <input type="text" name="accountMap['two'].name"><br/>
26
    账户4 金额: <input type="text" name="accountMap['two'].money"><br/>
27
    <input type="submit" value="提交">
28
</form>
29
</body>
30
</html>
31

3.3 @RequestParam注解

@RequestParam注解用来指定请求参数和控制器方法形参的映射关系。该注解一共有三个属性：

• value：请求参数的参数名。

• required：参数是否必传，默认值为true。如果未传且无默认值则报"400：Required String parameter 'xxx' is not present"错误。

• defaultValue：不管required属性值为true或false，当value所指定的请求参数没有传输或传输的值为""时，则使用默认值为形参赋值。

10
1
@RequestMapping("requestParam")
2
public String testParamsByRequestParam(
3
    @RequestParam(value = "user_name", required = true) String username,
4
    @RequestParam(value = "pass_word", required = false, defaultValue = "123456") String password
5
) {
6
    System.out.println(username);
7
    System.out.println(password);
8

9
    return "success";
10
}

注意：如果使用java.util.Optional作为方法参数，并且与@RequestParam和@RequestHeader等具有required属性的注解结合使用，该注解等效于required=false。

4. 绑定请求头和Cookie

@CookieValue注解用来指定Cookie数据和控制器方法形参的映射关系,@RequestHeader注解用来指定请求头信息与控制器方法形参的映射关系，其常用属性及使用方法和@RequestParam注解类似。

10
1
@RequestMapping("requestHeaderAndCookie")
2
public String testParamsByRequestHeader(
3
    @RequestHeader(value = "Origin", required = true) String origin,
4
    @CookieValue(value = "time-out", required = false, defaultValue = "60s") String timeOut
5
) {
6
    System.out.println(origin);
7
    System.out.println(timeOut);
8

9
    return "success";
10
}

5. 绑定路径变量

路径变量指在请求路径中通过{xxx}占位符声明的变量，常用于RESTful风格的请求中，可通过@PathVariable注解进行绑定。

11
1
// pathVariable?user_name=zhangsan&pass_word=123456  -> pathVariable/zhangsan/123456
2
@RequestMapping("pathVariable/{user_name}/{pass_word}")
3
public String testParamsByPathVariable(
4
    @PathVariable(value = "user_name", required = true) String username,
5
    @PathVariable(value = "pass_word", required = false) String password
6
) {
7
    System.out.println(username);
8
    System.out.println(password);
9

10
    return "success";
11
}

特别的，路径变量还可以使用正则表达式来进行路径匹配。

6
1
// ==> /spring-web-3.0.5.jar
2
@GetMapping("/{name:[a-z-]+}-{version:\\d\\.\\d\\.\\d}{ext:\\.[a-z]+}")
3
public void handle(@PathVariable String version, @PathVariable String ext) {
4
    // ...
5
}
6

6. 绑定矩阵变量

矩阵变量(Matrix Variable)以;开头，多个值之间用逗号隔开，SpringMVC中可通过设置<mvc:annotation-driven enable-matrix-variables="true"/>或removeSemicolonContent=false来开启矩阵变量功能。

23
1
// 矩阵变量以;开头，多个值之间用逗号隔开
2
/cars;color=red,green;year=2012
3
/cars;color=red;color=green;color=blue
4

5
// 对比路径变量和矩阵变量  GET /pets/42;q=11;r=22
6
@GetMapping("/pets/{petId}")
7
public void findPet(@PathVariable String petId, @MatrixVariable int q) {
8
    // petId:42,q:11
9
}
10

11
// 多个矩阵变量   GET /owners/42;q=11/pets/21;q=22
12
@GetMapping("/owners/{ownerId}/pets/{petId}")
13
public void findPet(@MatrixVariable(name="q", pathVar="ownerId") int q1,@MatrixVariable(name="q", pathVar="petId") int q2) {
14
    // q1:11,q:22
15
}
16

17
// 通过MultiValueMap获取所有的矩阵变量 GET /owners/42;q=11;r=12/pets/21;q=22;s=23
18
@GetMapping("/owners/{ownerId}/pets/{petId}")
19
public void findPet(@MatrixVariable MultiValueMap<String, String> matrixVars,@MatrixVariable(pathVar="petId") MultiValueMap<String, String> petMatrixVars) {
20
    // matrixVars: ["q" : [11,22], "r" : 12, "s" : 23]
21
    // petMatrixVars: ["q" : 22, "s" : 23]
22
}
23

7. 绑定请求体(JSON格式)

7.1 @RequestBody注解

@RequestBody注解用来将请求体内容绑定到控制器方法的形参。请求体的格式默认为&拼接的字符串，无需消息转换器，可直接使用String类型形参接收。

11
1
@Controller
2
@RequestMapping("message")
3
public class MessageContoller {
4

5
    @RequestMapping("req")
6
    public String reqConvert(@RequestBody String body) {
7
        System.out.println(body);
8
        return "success";
9
    }
10
}
11

如下页面，发送POST请求时，打印请求体的值：name=zhangsan&money=123。

19
1
<!DOCTYPE html>
2
<html lang="en">
3
<head>
4
    <meta charset="UTF-8">
5
    <title>测试HTTP消息转换</title>
6
</head>
7
<body>
8
<a href="/message/req?name=zhangsan&money=123">请求消息转换(Get)</a>
9
<hr/>
10

11
<form action="/message/req" method="post">
12
    账户名称: <input type="text" name="name"><br/>
13
    账户金额: <input type="number" name="money"><br/>
14
    <input type="submit" value="请求消息转换(Post)">
15
</form>
16

17
</body>
18
</html>
19

注意：如果请求体不存在(如GET请求方式)或形参类型不匹配(非String类型)，则响应400错误。

7.2 请求消息转换

如果请求体为JSON/XML等特殊字符串格式，除了使用String类型形参接收外，还可以通过HttpMessageConverter绑定到相应的实体类。

首先引入Jackson的依赖如下：

6
1
<dependency>
2
    <groupId>com.fasterxml.jackson.core</groupId>
3
    <artifactId>jackson-databind</artifactId>
4
    <version>2.12.1</version>
5
</dependency>
6

然后通过开启MVC注解驱动来自动配置MappingJackson2HttpMessageConverter。

1
1
<mvc:annotation-driven />

则可以控制器方法如下：

6
1
@RequestMapping("req2")
2
public String reqConvert2(@RequestBody Account account) {
3
    System.out.println(account);
4
    return "success";
5
}
6

使用Postman发送一个POST请求如下，请求体格式为JSON字符串，形参为Account类型，实现自动绑定。

注意：如果请求体格式为&拼接的字符串，则消息转换器不能将其绑定到POJO类，需要使用前面所述的请求参数绑定方式。

扩展：使用Jquery来发送POST请求示例如下：

17
1
<script type="text/javascript" src="${pageContext.request.contextPath}/js/jquery.min.js"></script>
2
<script type="text/javascript">
3
 $(function () {
4
     $("#testJson").click(function () {
5
         $.ajax({
6
             type: "post",
7
             url: "${pageContext.request.contextPath}/testResponseJson",
8
             contentType: "application/json;charset=utf-8",
9
             data: '{"id":1,"name":"test","money":999.0}',
10
             dataType: "json",
11
             success: function (data) {
12
                 alert(data);
13
             }
14
         });
15
     });
16
 })
17
</script>

5.3 RequestEntity

RequestEntity<T>类可作为控制器方法的形参，封装请求头和转换后的请求体，方便后续使用。

19
1
@RequestMapping("req2")
2
public String reqConvert2(RequestEntity<String> req) {
3
    System.out.println(req);
4
    System.out.println(req.getMethod());
5
    System.out.println(req.getUrl());
6
    System.out.println(req.getHeaders());
7
    System.out.println(req.getBody());
8
    return "success";
9
}
10

11
@RequestMapping("req4")
12
public String reqConvert4(RequestEntity<Account> req) {
13
    System.out.println(req.getMethod());
14
    System.out.println(req.getUrl());
15
    System.out.println(req.getHeaders());
16
    System.out.println(req.getBody());
17
    return "success";
18
}
19
    

前端通过POST方式请求http://localhost:8080/message/req2，打印信息如下：

4
1
POST
2
http://localhost:8080/message/req2
3
[host:"localhost:8080", connection:"keep-alive", content-length:"18", cache-control:"max-age=0", sec-ch-ua:""Chromium";v="104", " Not A;Brand";v="99", "Microsoft Edge";v="104"", sec-ch-ua-mobile:"?0", sec-ch-ua-platform:""Windows"", upgrade-insecure-requests:"1", origin:"http://localhost:8080", user-agent:"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.5112.81 Safari/537.36 Edg/104.0.1293.54", accept:"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9", sec-fetch-site:"same-origin", sec-fetch-mode:"navigate", sec-fetch-user:"?1", sec-fetch-dest:"document", referer:"http://localhost:8080/message_test", accept-encoding:"gzip, deflate, br", accept-language:"zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6", Content-Type:"application/x-www-form-urlencoded;charset=UTF-8"]
4
name=zhangsan&money=123

注意：使用RequestEntity作为形参时可以没有请求体，封装后的请求体数据为null。

8. 请求参数乱码问题

8.1 POST请求参数乱码

如果POST请求参数出现乱码，可在web.xml中配置SpringMVC提供的编码过滤器CharacterEncodingFilter。

18
1
<!--配置springMVC的编码过滤器，指定编码为UTF-8-->
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
    <init-param>
10
        <param-name>forceResponseEncoding</param-name>
11
        <param-value>true</param-value>
12
    </init-param>
13
</filter>
14
<filter-mapping>
15
    <filter-name>CharacterEncodingFilter</filter-name>
16
    <url-pattern>/*</url-pattern>
17
</filter-mapping>
18
    

注意：CharacterEncodingFilter一定要配置到其他过滤器之前，否则可能无效！

8.2 Get请求乱码

Tomcat8.0之前GET请求也可能会出现乱码问题，需修改Tomcat的server.xml配置文件useBodyEncodingForURI属性为true。

1
1
<Connector connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443" useBodyEncodingForURI="true" />

如果遇到Ajax请求仍然乱码，则把useBodyEncodingForURI="true"改为URIEncoding="UTF-8"。

9. 参数验证

若类路径存在Hibernate Validator或类似实现，则在全局注册LocalValidatorFactoryBean，以支持@Vaild注解和Validated接口。

你可以通过如下方式来配置全局Validator实例：

10
1
@Configuration
2
@EnableWebMvc
3
public class WebConfig implements WebMvcConfigurer {
4

5
    @Override
6
    public Validator getValidator(); {
7
        // ...
8
    }
9
}
10

也可注册自己的Validator实例：

9
1
@Controller
2
public class MyController {
3

4
    @InitBinder
5
    protected void initBinder(WebDataBinder binder) {
6
        binder.addValidators(new FooValidator());
7
    }
8

9
}

类似的XML配置如下：

2
1
<mvc:annotation-driven validator="globalValidator"/>
2

第三节 域数据共享

1. Request域数据共享

1.1 通过HttpServletRequest共享

将HttpServletRequest作为控制器方法的形参，框架在调用时会自动注入为当前请求对象，通过该对象即可在Request域共享数据等。

10
1
@Controller
2
@RequestMapping("share")
3
public class DataShareController {
4
    @RequestMapping("api")
5
    public String testDataShareByServletAPI(HttpServletRequest request) {
6
        request.setAttribute("username", "request_zhangsan");
7
        return "success";
8
    }
9
}
10

1.2 通过Model形参共享

6
1
@RequestMapping("model")
2
public String testDataShareByModel(Model model) {
3
    model.addAttribute("username", "request_zhangsan");
4
    return "success";
5
}
6

1.3 通过Map/ModelMap形参共享

12
1
@RequestMapping("map")
2
public String testMap(Map<String, Object> map) {
3
    map.put("username", "request_zhangsan");
4
    return "success";
5
}
6

7
@RequestMapping("modelMap")
8
public String testMap(ModelMap modelMap) {
9
    modelMap.put("username", "request_zhangsan");
10
    return "success";
11
}
12

1.4 通过响应ModelAndView共享

ModelAndView有Model和View的功能，Model主要用于向请求域共享数据，View主要用于设置视图，实现页面跳转。

10
1
@RequestMapping("mv")
2
public ModelAndView testDataShareByMv() {
3
    ModelAndView mv = new ModelAndView();
4
    // 共享数据
5
    mv.addObject("username", "request_zhangsan");
6
    // 页面跳转(默认转发)
7
    mv.setViewName("success");
8
    return mv;
9
}
10

1.5 通过@ModelAttribute共享(了解)

@ModelAttribute注解用来进行Request域数据共享，可以作用于普通方法或控制器方法参数之上。

• 当作用于普通方法时，则该方法会在此Controller的每个方法执行前被执行，如果有返回值，则自动将该返回值加入到ModelMap中。

16
1
@Controller
2
public class Hello2ModelController {
3
    
4
    @ModelAttribute 
5
    public User populateModel() {  
6
       User user=new User();
7
       user.setAccount("ray");
8
       return user;
9
    }  
10
    
11
    @RequestMapping(value = "/helloWorld2")  
12
    public String helloWorld() {  
13
       return "helloWorld.jsp";  
14
    }  
15
}
16

• 当作用于控制器方法参数时，自动将该参数值添加到ModelMap中。

7
1
@RequestMapping("/testModelAttribute")
2
public String testModelAttribute(@ModelAttribute("newUser")User user,Model model){
3
    System.out.println("testModelAttribute User:"+user);
4
    System.out.println("testModelAttribute model:"+model.toString());
5
    return "success";
6
}
7

1.6 @RequestAttribute(了解)

@RequestAttribute属性可以从Request域获取数据并映射到控制器方法参数。

4
1
@GetMapping("/")
2
public String handle(@RequestAttribute Client client) { 
3
    // ...
4
}

2. Session域数据共享

2.1 通过HttpSession共享

将HttpSession作为控制器方法的形参，框架在调用时会自动注入为当前会话对象，通过该对象即可在Session域共享数据等。

6
1
@RequestMapping("api2")
2
public String testDataShareByServletAPI(HttpSession session) {
3
    session.setAttribute("username", "session_zhangsan");
4
    return "success";
5
}
6
    

2.2 通过@SessionAttributes共享(了解)

@SessionAttributes注解可作用于控制器所在类上，其从Request域查找配置的属性，并共享到Session域。

11
1
@Controller
2
@RequestMapping("sc")
3
@SessionAttributes("name")
4
public class SessionController {
5
    @RequestMapping("session")
6
    public String sessions(Model model,HttpSession session){
7
        model.addAttribute("name", "winclpt");
8
        session.setAttribute("myName", "chke");
9
        return "session";
10
}
11

@SessionAttribute注解可从Session域获取数据并映射到控制器方法参数。

4
1
@RequestMapping("/")
2
public String handle(@SessionAttribute User user) { 
3
    // ...
4
}

3. Application域数据共享

获取会话对象(或请求对象)后，通过该对象可获取ServletContext对象，即可在Application域共享数据等。

6
1
@RequestMapping("api3")
2
public String testDataShareByServletAPI3(HttpSession session) {
3
    session.getServletContext().setAttribute("username", "servletContext_zhangsan");
4
    return "success";
5
}
6
    

第四节 结果响应

1. 控制器方法返回值

控制器方法常用的返回值类型如下：

• 响应视图和模型：ResponseEntity<T>、HttpHeaders、String、View、Map、Model、ModelAndView、void

• 异步响应类型：DeferredResult、Callable、ListenableFuture、ResponseBodyEmitter、SseEmitter、StreamingResponseBody

• 任何其他返回值：如果是String，将会被当作逻辑视图名称解析，其它类型将会被反序列化后进行响应。

返回值相关的注解如下：

• @ResponseBody：将返回值通过HttpMessageConverter序列化到响应主体。

• @ModelAttribute：将返回值共享到请求域。

2. 通过ServletAPI响应

将HttpServletRequest或HttpServletResponse作为控制器方法的形参，框架在调用时会自动注入为当前请求对象或响应对象，此时可以进行请求转发、重定向或直接发送响应数据等。

20
1
// 请求转发 -> /WEB-INF/pages/success.jsp
2
@RequestMapping("api2")
3
public void testServletApi2(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
4
    request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request, response);
5
}
6

7
// 重定向 -> http://baidu.com
8
@RequestMapping("api3")
9
public void testServletApi3(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
10
    response.sendRedirect("http://baidu.com");
11
}
12

13
// 直接发送响应数据 -> "这是一个响应数据！"
14
@RequestMapping("api")
15
public void testServletApi(HttpServletResponse response) throws IOException {
16
    response.setCharacterEncoding("utf-8");
17
    response.setContentType("application/json;charset=utf-8");
18
    response.getWriter().write("这是一个响应数据！");
19
}
20

提示：可在控制器方法中注入的对象还有：HttpServletRequest、HttpServletResponse、HttpSession、java.security.Principal、Locale、InputStream、OutputStream、Reader、Writer等。

3. 请求转发或重定向

3.1 通过forward进行请求转发

当控制器方法设置的视图名称以forward:为前缀时，创建InternalResourceView视图，然后直接通过:后面的路径进行转发，而不经过视图解析器拼接视图前后缀等过程。

6
1
// 请求转发 -> /WEB-INF/pages/success.jsp
2
@RequestMapping("/forward")
3
public String forward() {
4
    return "forward:/WEB-INF/pages/success.jsp";
5
}
6

注意：

1. 使用Forward进行转发时，写转发路径而非视图名称，相当于 request.getRequestDispatcher("url").forward(request,response)。

2. 转发路径以/开头时，则是基于Servlet上下文的绝对路径，否则是相对于当前请求的相对路径。

3. 可以转发到其它的控制器方法或JSP视图页面，但不能够转发到其它服务器。

4. 当工程引入了JSTL模板库的依赖时，转发视图会自动转换为JstlView。

3.2 通过redirect进行重定向

当控制器方法设置的视图名称以redirect:为前缀时，创建RedirectView视图，然后直接通过:后面的路径进行重定向，也不经过视图解析器拼接视图前后缀等过程。

6
1
// 重定向 -> http://baidu.com
2
@RequestMapping("/redirect")
3
public String redirect() {
4
    return "redirect:http://baidu.com";
5
}
6
    

注意：

1. 使用Redirect进行重定向时，写新路径而非视图名称，相当于response.sendRedirect(url)。

2. 同样的，路径以/开头时，则是基于Servlet上下文的绝对路径，否则是相对于当前请求的相对路径。

3. 可以重定向到任何可访问URL资源，但WEB-INF目录下的资源除外。

3.3 重定向数据共享

重定向时默认传递所有的Model属性，可以通过RequestMappingHandlerAdapter的ignoreDefaultModelOnRedirect标志来控制。

如果属性为String类型，则直接拼接在URL之后。如果非String类型，则通过RedirectAttributes的实现类RedirectAttributesModelMap进行传递。RedirectAttributesModelMap有一个flashAttributes属性，在重定向之前(通常在会话中)被临时保存，在重定向之后可供请求使用。

在每个请求上，都有一个具有从上一个请求(如果有)传递的属性的输入FlashMap，和一个具有为后续请求保存的属性的输出FlashMap，通过RequestContextUtils中的getInputFlashMap/getOutputFlashMap方法，可以从Spring MVC中的任何位置访问这两个FlashMap实例。

4. 响应视图页面

当控制器方法设置的视图名称没有任何前缀时，则由配置的视图解析器按优先级(order属性配置)进行解析，它会将视图名称拼接前后缀，然后以转发的方式实现跳转。

4.1 设置视图名称

在控制器方法结束时，可通过返回String或ModelAndView的形式设置视图名称。

13
1
// String
2
@RequestMapping("/view")
3
public String view() {
4
    return "success";
5
}
6

7
// ModelAndView
8
@RequestMapping("/mv")
9
public ModelAndView mv() {
10
    ModelAndView mv = new ModelAndView();
11
    mv.setViewName("success");
12
    return mv;
13
}

这里也可以直接返回视图的绝对路径，如/WEB-INF/pages/success.jsp，但一般会结合视图解析器使用，只需返回视图名称即可。

4.2 默认视图解析器(JSP)

SpringMVC提供了一个默认视图解析器InternalResourceViewResolver可用于解析JSP视图。

11
1
<!-- 默认视图解析器，可用于处理jsp等视图 -->
2
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
3
    <property name="order" value="1"/>
4
    <property name="prefix" value="/WEB-INF/pages/"/>
5
    <property name="suffix" value=".jsp"/>
6
</bean>
7

8
<!-- 简化方式配置(了解) -->
9
<mvc:view-resolvers>
10
    <mvc:jsp/>
11
</mvc:view-resolvers>

JSP视图的简单示例如下，文件路径为src\main\webapp\WEB-INF\pages\success.jsp。

16
1
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
2
<!DOCTYPE html>
3
<html lang="en">
4
<head>
5
    <meta charset="UTF-8">
6
    <title>Success</title>
7
</head>
8
<body>
9
<h1>Success!</h1>
10

11
request.username: <%=request.getAttribute("username")%>
12
session.username: <%=session.getAttribute("username")%>
13
application.username: <%=application.getAttribute("username")%>
14

15
</body>
16
</html>