SpringMVC

SpringMVC

简介

MVC

MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分

M：Model，模型层，指工程中的JavaBean，作用是处理数据

  • JavaBean分为两类：
    • 一类称为实体类Bean：专门存储业务数据的，如Student、User等
    • 一类称为业务处理Bean：指Service或Dao对象，专门用于处理业务逻辑和数据访问

V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据

C：Controller，控制层，指工程中的servlet，作用是接收请求和响应浏览器

MVC的工作流程：用户通过视图层发送请求到服务器，在服务器中请求被Controller接收，Controller调用相应的Model层处理请求，处理完毕将结果返回到Controller，Controller再根据请求处理的结果找到相应的View视图，渲染数据后最终响应给浏览器

SpringMVC

SpringMVC是Spring的一个后续产品，是Spring的一个子项目

SpringMVC是Spring为表述层开发提供的一整套完备的解决方案。在表述层框架历经Strust、WebWork、Strust2等诸多产品的历代更迭之后，目前业界普遍选择了SpringMVC作为JavaEE项目表述层开发的首选方案

  • 三层架构分为表述层（或表示层）、业务逻辑层、数据访问层，表述层表示前台页面和后台servlet

特点：

  • Spring家族原生产品，与IOC容器等基础设施无缝对接
  • 基于原生的Servlet，通过了功能强大的前端控制器DispatcherServlet，对请求和响应进行统一处理
  • 表述层各细分领域需要解决的问题全方位覆盖，提供全面解决方案
  • 代码清新简洁，大幅度提升开发效率
  • 内部组件化程度高，可插拔式组件即插即用，想要什么功能配置相应组件即可
  • 性能卓著，尤其适合现代大型、超大型互联网项目要求

创建过程

maven工程

web模块

war打包方式

1
<packaging>war</packaging>

引入依赖

由于Maven的传递性，我们不必将所有需要的包全部配置依赖，而是配置最顶端的依赖，其他靠传递性导入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<dependencies>
    <!-- SpringMVC -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.1</version>
    </dependency>

    <!-- 日志 -->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
    </dependency>

    <!-- ServletAPI -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
      	<!--
				compile:默认的scope，表示 dependency 都可以在生命周期中使用。而且，这些dependencies 会传递到依赖的项目中。适用于所有阶段，会随着项目一起发布
				provided:跟compile相似，但是表明了dependency 由JDK或者容器提供，例如Servlet AP和一些Java EE APIs。这个scope 只能作用在编译和测试时，同时没有传递性。
				runtime:表示dependency不作用在编译时，但会作用在运行和测试时，如JDBC驱动，适用运行和测试阶段。test表示dependency作用在测试时，不作用在运行时。 只在测试时使用，用于编译和运行测试代码。不会随项目发布。 system跟provided 相似，但是在系统中要以外部JAR包的形式提供，maven不会在repository查找它
				-->
        <scope>provided</scope>
    </dependency>

    <!-- Spring5和Thymeleaf整合包 -->
    <dependency>
        <groupId>org.thymeleaf</groupId>
        <artifactId>thymeleaf-spring5</artifactId>
        <version>3.0.12.RELEASE</version>
    </dependency>
</dependencies>

配置web.xml

注册SpringMVC的前端控制器DispatcherServlet

默认配置方式

此配置作用下，SpringMVC的配置文件默认位于WEB-INF下，默认名称为<servlet-name>-servlet.xml

  • 例如：以下配置所对应SpringMVC的配置文件位于WEB-INF下，文件名为springMVC-servlet.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!--配置SpringMVC的前端控制器，对浏览器发送的请求统一进行处理-->
<servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <!--
    设置springMVC的核心控制器所能处理的请求的请求路径
    /所匹配的请求可以是/login或.html或.js或.css方式的请求路径
    但是/不能匹配.jsp请求路径的请求
		/*匹配所有请求，包括.jsp
    -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

扩展配置方式

可通过init-param标签设置SpringMVC配置文件的位置和名称，通过load-on-startup标签设置SpringMVC前端控制器DispatcherServlet的初始化时间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<!--配置SpringMVC的前端控制器，对浏览器发送的请求统一进行处理-->
  <servlet>
      <servlet-name>SpringMVC</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <!--配置SpringMVC配置文件的位置和名称-->
      <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:springMVC.xml</param-value>
      </init-param>
      <!--
      将SpringMVC前端控制器DispatcherServlet的初始化时间提前到服务器启动时
      作为框架的核心组件，在启动过程中有大量的初始化操作要做
而这些操作放在第一次请求时才执行会严重影响访问速度
因此需要通过此标签将启动控制DispatcherServlet的初始化时间提前到服务器启动时
			-->
      <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
      <servlet-name>SpringMVC</servlet-name>
      <!--
      设置springMVC的核心控制器所能处理的请求的请求路径
      /所匹配的请求可以是/login或.html或.js或.css方式的请求路径
      但是/不能匹配.jsp请求路径的请求
      -->
      <url-pattern>/</url-pattern>
  </servlet-mapping>

标签中使用/和/*的区别：

  • /：所匹配的请求可以是/login或.html或.js或.css方式的请求路径，但是/不能匹配.jsp请求路径的请求
    • 因此就可以避免在访问jsp页面时，该请求被DispatcherServlet处理，从而找不到相应的页面
  • /*：匹配所有请求
    • 例如在使用过滤器时，若需要对所有请求进行过滤，就需要使用/*的写法

请求控制器

由于前端控制器对浏览器发送的请求进行了统一的处理，但是具体的请求有不同的处理过程，因此需要创建处理具体请求的类，即请求控制器

请求控制器中每一个处理请求的方法成为控制器方法

因为SpringMVC的控制器由一个POJO（普通的Java类）担任，因此需要通过@Controller注解将其标识为一个控制层组件，交给Spring的IOC容器管理，此时SpringMVC才能够识别控制器的存在

1
2
3
4
@Controller
public class HelloController {
    
}

配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<!-- 自动扫描包 -->
<context:component-scan base-package="com.atguigu.mvc.controller"/>

org.thymeleaf.spring5.view.ThymeleafViewResolver

<!-- 
   处理静态资源，例如html、js、css、jpg
  若只设置该标签，则只能访问静态资源，其他请求则无法访问
  此时必须设置<mvc:annotation-driven/>解决问题
 -->
<mvc:default-servlet-handler/>

<!-- 开启mvc注解驱动 -->
<mvc:annotation-driven>
    <mvc:message-converters>
        <!-- 处理响应中文内容乱码 -->
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <property name="defaultCharset" value="UTF-8" />
            <property name="supportedMediaTypes">
                <list>
                    <value>text/html</value>
                    <value>application/json</value>
                </list>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

测试

实现对首页的访问：

  • 在请求控制器中创建处理请求的方法
1
2
3
4
5
6
7
8
// @RequestMapping注解：处理请求和控制器方法之间的映射关系
// @RequestMapping注解的value属性可以通过请求地址匹配请求，/表示的当前工程的上下文路径
// localhost:8080/springMVC/
@RequestMapping("/")
public String index() {
    //设置视图名称
    return "index";
}

通过超链接跳转到指定页面：

  • 在主页index.html中设置超链接
1
2
3
4
5
6
7
8
9
10
11
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>
    <h1>首页</h1>
    <a th:href="@{/hello}">HelloWorld</a><br/>
</body>
</html>

在请求控制器中创建处理请求的方法

1
2
3
4
@RequestMapping("/hello")
public String HelloWorld() {
    return "target";
}

总结

浏览器发送请求，若请求地址符合前端控制器的url-pattern，该请求就会被前端控制器DispatcherServlet处理。前端控制器会读取SpringMVC的核心配置文件，通过扫描组件找到控制器，将请求地址和控制器中@RequestMapping注解的value属性值进行匹配，若匹配成功，该注解所标识的控制器方法就是处理请求的方法。处理请求的方法需要返回一个字符串类型的视图名称，该视图名称会被视图解析器解析，加上前缀和后缀组成视图的路径，通过Thymeleaf对视图进行渲染，最终转发到视图所对应页面

@RequestMapping

功能

从注解名称上我们可以看到，@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来，建立映射关系

SpringMVC接收到指定的请求，就会来找到在映射关系中对应的控制器方法来处理这个请求

RequestMapping值唯一，否则报错

位置

@RequestMapping标识一个类：设置映射请求的请求路径的初始信息

  • 通常用来分隔不同模块

@RequestMapping标识一个方法：设置映射请求请求路径的具体信息

1
2
3
4
5
6
7
8
9
10
11
@Controller
// 此时请求映射所映射的请求的请求路径为：/hello/testRequestMapping
@RequestMapping("/hello")
public class RequestMappingController {

    @RequestMapping("/testRequestMapping")
    public String success() {
        return "success";
    }

}
1
<a th:href="@{/hello/testRequestMapping}">success.html</a>

属性

value

通过请求的请求地址匹配请求映射

是一个字符串类型的数组，表示该请求映射能够匹配多个请求地址所对应的请求（满足数组中的任意一个）

1
2
3
4
@RequestMapping({"/testRequestMapping", "/test"})
public String success() {
    return "success";
}

value属性必须设置，至少通过请求地址匹配请求映射

1
2
<a th:href="@{/testRequestMapping}">value属性：/testRequestMapping</a><br/>
<a th:href="@{/test}">value属性：/test</a>

method

通过请求的请求方式（get或post）匹配请求映射

是一个RequestMethod类型的数组，表示该请求映射能够匹配多种请求方式的请求（满足数组中的任意一个）

若当前请求的请求地址满足请求映射的value属性，但是请求方式不满足method属性，则浏览器报错405：Request method ‘POST’ not supported

1
<a th:href="@{/test}">测试@RequestMapping的value属性-->/test</a><br><form th:action="@{/test}" method="post">    <input type="submit"></form>
1
2
3
4
@RequestMapping(
       value = {"/testRequestMapping", "/test"},
       method = {RequestMethod.GET, RequestMethod.POST}
)

对于处理指定请求方式的控制器方法，SpringMVC中提供了@RequestMapping的派生注解：

  • 处理get请求的映射：@GetMapping

  • 处理post请求的映射：@PostMapping

  • 处理put请求的映射：@PutMapping

  • 处理delete请求的映射：@DeleteMapping

常用的请求方式有get，post，put，delete

  • 但是目前浏览器只支持get和post，若在form表单提交时，为method设置了其他请求方式的字符串（put或delete），则按照默认的请求方式get处理

  • 若要发送put和delete请求，则需要通过spring提供的过滤器HiddenHttpMethodFilter，在RESTful部分会讲到

params

了解

通过请求的请求参数匹配请求映射

是一个字符串类型的数组，可以通过四种表达式设置请求参数和请求映射的匹配关系（必须全满足）

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

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

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

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

1
<a th:href="@{/testParams(username='admin',password=123456)">params属性：/test</a>
1
2
3
4
5
6
7
@RequestMapping(
    value = {"/testParams},
    params = {"username", "password=!123456"}
)
public String success() {
    return "success";
}

若当前请求满足@RequestMapping注解的value和method属性，但是不满足params属性，此时页面回报错400：Parameter conditions “username, password!=123456” not met for actual request parameters: username={admin}, password={123456}

headers

了解

通过请求的请求头信息匹配请求映射

是一个字符串类型的数组，可以通过四种表达式设置请求头信息和请求映射的匹配关系（必须全满足）

  • “header”：要求请求映射所匹配的请求必须携带header请求头信息

  • “!header”：要求请求映射所匹配的请求必须不能携带header请求头信息

  • “header=value”：要求请求映射所匹配的请求必须携带header请求头信息且header=value

  • “header!=value”：要求请求映射所匹配的请求必须携带header请求头信息且header!=value

1
2
3
4
5
6
7
@RequestMapping(
        value = "/testParams",
        headers = "Host=localhost:8081"
)
public String testHeaders() {
    return "success";
}

若当前请求满足@RequestMapping注解的value和method属性，但是不满足headers属性，此时页面显示404错误，即资源未找到

ant风格的路径

模糊匹配

？：表示任意的单个字符

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

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

  • 在使用**时，只能使用/**/xxx的方式

路径中的占位符

重点

原始方式：/deleteUser?id=1

rest方式：/deleteUser/1

SpringMVC路径中的占位符常用于RESTful风格中，当请求路径中将某些数据通过路径的方式传输到服务器中，就可以在相应的@RequestMapping注解的value属性中通过占位符{xxx}表示传输的数据，在通过@PathVariable注解，将占位符所表示的数据赋值给控制器方法的形参

1
<a th:href="@{/testRest/1/admin}">测试路径中的占位符-->/testRest</a><br>
1
2
3
4
5
6
7
@RequestMapping("/testRest/{id}/{username}")
// @PathVariable("")：将占位符中的值自动赋给形参
public String testRest(@PathVariable("id") String id, @PathVariable("username") String username) {
    // 最终输出的内容为-->id:1,username:admin
    System.out.println("id:" + id + ",username:" + username);
    return "success";
}

获取请求参数

ServletAPI

不常用

将HttpServletRequest作为控制器方法的形参，此时HttpServletRequest类型的参数表示封装了当前请求的请求报文的对象

1
<a th:href="@{/servletAPI(username='admin',password=123)}">通过ServletAPI获取</a><br/>
1
2
3
4
5
6
7
8
9
10
@RequestMapping("/servletAPI")
    // 形参位置的request表示当前请求
    // DispatcherServlet会自动为所对应形参赋值
    public String servletAPI(HttpServletRequest request) {
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        System.out.println("username: " + username);
        System.out.println("password: " + password);
        return "success";
}

控制器方法的形参

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

1
<a th:href="@{/controller(username='admin',password=123)}">通过控制器方法的形参获取</a><br/>
1
2
3
4
5
6
7
@RequestMapping("/controller")
 // 形参与请求参数同名
public String controller(String username, String password) {
        System.out.println("username: " + username);
        System.out.println("password: " + password);
        return "success";
}

若请求所传输的请求参数中有多个同名的请求参数，此时可以在控制器方法的形参中设置字符串数组或者字符串类型的形参接收此请求参数

  • 若使用字符串数组类型的形参，此参数的数组中包含了每一个数据

  • 若使用字符串类型的形参，此参数的值为每个数据中间使用逗号拼接的结果

@RequestParam

将请求参数和控制器方法的形参创建映射关系

属性：

  • value：指定为形参赋值的请求参数的参数名

  • required：设置是否必须传输此请求参数，默认值为true

    • true：当前请求必须传输value所指定的请求参数
      • 若没有传输该请求参数，且没有设置defaultValue属性，则页面报错400：Required String parameter ‘xxx’ is not present；
    • false：当前请求不是必须传输value所指定的请求参数
      • 若没有传输，则注解所标识的形参的值为null

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

1
<a th:href="@{/servletAPI(user_name='admin',password=123)}">@RequestParam</a><br/>
1
2
3
4
5
6
7
8
9
10
public String controller(
        @RequestParam(
                value = "user_name",
                required = false,
                defaultValue = "pz"
        ) String username,
        String password,
        String hobbies
) {
}

@RequestHeader

将请求头信息和控制器方法的形参创建映射关系

属性用法同@RequestParam

1
2
3
4
5
6
@RequestMapping("/controllerWithHeader")
// 请求头没有默认映射
public String controllerWithHeader(@RequestHeader("Host") String host) {
    System.out.println("host: " + host);
    return "success";
}

@CookieValue

将cookie数据和控制器方法的形参创建映射关系

属性用法同@RequestParam

1
2
3
4
5
@RequestMapping("/controllerWithCookies")
public String controllerWithCookies(@CookieValue(value = "JSESSIONID", defaultValue = "12345") String session) {
    System.out.println("sessionID: " + session);
    return "success";
}

POJO

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

1
2
3
4
5
6
7
8
<form th:action="@{/testpojo}" method="post">    
  用户名：<input type="text" name="username"><br>    
  密码：<input type="password" name="password"><br>    
  性别：<input type="radio" name="sex" value="男">男<input type="radio" name="sex" value="女">女<br>    
  年龄：<input type="text" name="age"><br>    
  邮箱：<input type="text" name="email"><br>    
  <input type="submit">
</form>
1
2
3
4
5
6
@RequestMapping("/userTest")
// 只要形参位置的参数满足条件，都会被请求参数赋值
public String userTest(User user) {
    System.out.println(user);
    return "success";
}

解决乱码

解决获取请求参数的乱码问题，可以使用SpringMVC提供的编码过滤器CharacterEncodingFilter，但是必须在web.xml中进行注册

  • Get请求的乱码由Tomcat造成，需要在其配置文件conf/server.xml的中添加URIEncoding=”UTF-8”
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<!--配置springMVC的编码过滤器-->
<filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
        <param-name>forceResponseEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

SpringMVC中处理编码的过滤器一定要配置到其他过滤器之前，否则无效

域对象共享数据

request域

一次请求

ServletAPI

1
2
<!--html页面中只有th:里的{}才会被解析为thymeleaf-->
<h2 th:text="${username}"></h2>
1
2
3
4
5
@RequestMapping("/servletAPI")
public String requestByServletAPI(HttpServletRequest request) {
    request.setAttribute("username", "admin");
    return "success";
}

ModelAndView

建议使用

ModelAndView有Model和View的功能

  • Model主要用于向请求域共享数据
  • View主要用于设置视图，实现页面跳转
1
2
3
4
5
6
7
8
9
10
@RequestMapping("modelAndView")
public ModelAndView requestByModelAndView() {
    // 创建ModelAndView对象
    ModelAndView mav = new ModelAndView();
    // 处理模型数据，即向请求域request共享数据
    mav.addObject("scope", "ModelAndView");
    // 设置视图名称（返回的字符串即为视图名称）
    mav.setViewName("success");
    return mav;
}

Model

1
2
3
4
5
@RequestMapping("/model")
public String model(Model model) {
    model.addAttribute("scope", "Model");
    return "success";
}

Map

1
2
3
4
5
@RequestMapping("/map")
public String requestByMap(Map<String, Object> map) {
    map.put("scope", "Map");
    return "success";
}

ModelMap

1
2
3
4
5
@RequestMapping("/modelMap")
public String requestByModelMap(ModelMap modelMap) {
    modelMap.addAttribute("scope", "ModelMap");
    return "success";
}

Model/ModelMap/Map

Model、ModelMap、Map类型的参数其实本质上都是 BindingAwareModelMap类型的

1
2
3
4
5
6
7
8
9
10
11
public interface Model {
}

public class ModelMap extends LinkedHashMap<String, Object> {
}

public class ExtendedModelMap extends ModelMap implements Model {
}

public class BindingAwareModelMap extends ExtendedModelMap {
}

session域

一次对话：浏览器开启到浏览器关闭

1
2
3
4
5
@RequestMapping("/httpSession")
public String sessionByHttpSession(HttpSession session) {
    session.setAttribute("scope", "HttpSession");
    return "success";
}

application域

整个应用：服务器开启到服务器关闭

1
2
3
4
5
6
@RequestMapping("/application")
public String applicationByServletAPI(HttpSession session) {
    ServletContext context = session.getServletContext();
    context.setAttribute("scope", "Application");
    return "success";
}

视图

SpringMVC中的视图是View接口，视图的作用渲染数据，将模型Model中的数据展示给用户

SpringMVC视图的种类很多，默认有转发视图InternalResourceView和重定向视图RedirectView

当工程引入jstl的依赖，转发视图会自动转换为JstlView

若使用的视图技术为Thymeleaf，在SpringMVC的配置文件中配置了Thymeleaf的视图解析器，由此视图解析器解析之后所得到的是ThymeleafView

ThymeleafView

当控制器方法中所设置的视图名称没有任何前缀时，此时的视图名称会被SpringMVC配置文件中所配置的视图解析器解析，视图名称拼接视图前缀和视图后缀所得到的最终路径，会通过转发的方式实现跳转

1
2
3
4
@RequestMapping("/thymeleafView")
public String thymeleafView() {
    return "success";
}

转发视图

默认：InternalResourceView

当控制器方法中所设置的视图名称以”forward:”为前缀时，创建InternalResourceView视图，此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀”forward:”去掉，剩余部分作为最终路径通过转发的方式实现跳转

如”forward:/“，”forward:/employee”

1
2
3
4
5
6
7
8
9
10
11
12
@RequestMapping("/thymeleafView")
public String thymeleafView() {
    return "success";
}

@RequestMapping("/forward")
public String forward() {
  	// 转发不符合thymeleaf规则时使用
    // 转发到某个请求中
    // 用了thymeleaf后html页面必须通过转发访问
    return "forward:/thymeleafView";
}

重定向视图

默认：RedirectView

当控制器方法中所设置的视图名称以”redirect:”为前缀时，创建RedirectView视图，此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀”redirect:”去掉，剩余部分作为最终路径通过重定向的方式实现跳转

如”redirect:/“，”redirect:/employee”

1
2
3
4
5
6
7
@RequestMapping("/redirect")
public String redirect() {
    // WEB-INF下的页面不能被重定向访问
    // 现在的页面都要被thymeleaf进行解析
    // 必须通过转发请求页面
    return "redirect:/thymeleafView";
}

重定向视图在解析时，会先将redirect:前缀去掉，然后会判断剩余部分是否以/开头，若是则会自动拼接上下文路径

视图控制器view-controller

当控制器方法中，仅仅用来实现页面跳转，即只需要设置视图名称时，可以将处理器方法使用view-controller标签进行表示

1
2
3
4
5
6
<!--
path：设置处理的请求地址
view-name：设置请求地址所对应的视图名称
-->
<mvc:view-controller path="/" view-name="index"/>
<mvc:annotation-driven/>

当SpringMVC中设置任何一个view-controller时，其他控制器中的请求映射将全部失效，此时需要在SpringMVC的核心配置文件中设置开启mvc注解驱动的标签：

1
2
<!--开启MVC注解驱动-->
<mvc:annotation-driven/>

InternalResourceViewResolver

1
2
3
4
5
<!--SpringMVC中使用JSP不设置任何前缀也是转发效果-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/templates/"/>
    <property name="suffix" value=".jsp"/>
</bean>
1
<a href="${pageContext.request.contextPath}/success">SUCCESS</a>

由于使用的是archetype-webapp生成的web工程，默认创建的web版本为2.3导致在jsp中获取使用pageContext获取项目路径时被错误解析

将版本更改为2.3以上版本，或复制下面代码到web.xml文件中，改为4.0版本

或者通过project Structure来更改版本，记得备份web.xml的配置信息

1
2
3
4
5
6
7
8
9
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         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_4_0.xsd"
         version="4.0">
    <welcome-file-list>
      <welcome-file>login.jsp</welcome-file>
    </welcome-file-list>
</web-app>

RESTful

简介

REST：Representational State Transfer，表现层资源状态转移

资源

资源是一种看待服务器的方式，即将服务器看作是由很多离散的资源组成。每个资源是服务器上一个可命名的抽象概念。因为资源是一个抽象的概念，所以它不仅仅能代表服务器文件系统中的一个文件、数据库中的一张表等等具体的东西，可以将资源设计的要多抽象有多抽象，只要想象力允许而且客户端应用开发者能够理解。与面向对象设计类似，资源是以名词为核心来组织的，首先关注的是名词。一个资源可以由一个或多个URI来标识。URI既是资源的名称，也是资源在Web上的地址。对某个资源感兴趣的客户端应用，可以通过资源的URI与其进行交互。

资源表述

资源的表述是一段对于资源在某个特定时刻的状态的描述。可以在客户端-服务器端之间转移（交换）。资源的表述可以有多种格式，例如HTML/XML/JSON/纯文本/图片/视频/音频等等。资源的表述格式可以通过协商机制来确定。请求-响应方向的表述通常使用不同的格式。

状态转移

状态转移说的是：在客户端和服务器端之间转移（transfer）代表资源状态的表述。通过转移和操作资源的表述，来间接实现操作资源的目的。

实现

HTTP协议里面的四个表示操作方式的动词：

  • GET：获取资源
  • POST：新建资源
  • PUT：更新资源
  • DELETE：删除资源

REST风格提倡URL地址使用统一的风格设计，从前到后各个单词使用斜杠分开，不使用问号键值对方式携带请求参数，而是将要发送给服务器的数据作为URL地址的一部分，以保证整体风格的一致性。

操作 传统方式 REST风格
查询操作 getUserById?id=1 user/1–>get请求方式
保存操作 saveUser user–>post请求方式
删除操作 deleteUser?id=1 user/1–>delete请求方式
更新操作 updateUser user–>put请求方式

HiddenHttpMethodFilter

SpringMVC提供HiddenHttpMethodFilter将 POST请求转换为DELETE或PUT请求

HiddenHttpMethodFilter 处理put和delete请求的条件：

  • 当前请求的请求方式必须为post

  • 当前请求必须传输请求参数_method

1
2
3
<form th:action="@{/user}" method="post">
    <input type="hidden" name="_method" value="put"/>
</form>

满足以上条件，HiddenHttpMethodFilter过滤器就会将当前请求的请求方式转换为请求参数_method的值，因此请求参数 _method的值才是最终的请求方式

在web.xml中注册HiddenHttpMethodFilter

1
2
3
4
5
6
7
8
9
<!--配置HiddenHttpMethodFilter-->
<filter>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

目前为止，SpringMVC中两个过滤器的顺序：

  1. CharacterEncodingFilter
  2. HiddenHttpMethodFilter

在CharacterEncodingFilter中通过 request.setCharacterEncoding(encoding)方法设置字符集的

request.setCharacterEncoding(encoding)方法要求前面不能有任何获取请求参数的操作

而 HiddenHttpMethodFilter恰恰有一个获取请求方式的操作：

1
String paramValue = request.getParameter(this.methodParam);

案例

准备工作

和传统 CRUD 一样，实现对员工信息的增删改查。

  • 搭建环境

  • 准备实体类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    package cc.mousse.bean;

    public class Employee {
        
        private Integer id;
        private String lastName;
        private String email;
        //1 male, 0 female  
        private Integer gender;

        public Integer getId() {
            return id;
        }

        public void setId(Integer id) {
            this.id = id;
        }

        public String getLastName() {
            return lastName;
        }

        public void setLastName(String lastName) {
            this.lastName = lastName;
        }

        public String getEmail() {
            return email;
        }

        public void setEmail(String email) {
            this.email = email;
        }

        public Integer getGender() {
            return gender;
        }

        public void setGender(Integer gender) {
            this.gender = gender;
        }

        public Employee(Integer id, String lastName, String email, Integer gender) {
            super();
            this.id = id;
            this.lastName = lastName;
            this.email = email;
            this.gender = gender;
        }

        public Employee() {
        }
        
    }

  • 准备dao模拟数据

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    package cc.mousse.dao;

    import cc.mousse.bean.Employee;

    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Map;

    @Repository
    public class EmployeeDao {
        
        private static Map<Integer, Employee> employees;

        static {
            employees = new HashMap<Integer, Employee>();
            employees.put(1001, new Employee(1001, "E-AA", "aa@163.com", 1));
            employees.put(1002, new Employee(1002, "E-BB", "bb@163.com", 1));
            employees.put(1003, new Employee(1003, "E-CC", "cc@163.com", 0));
            employees.put(1004, new Employee(1004, "E-DD", "dd@163.com", 0));
            employees.put(1005, new Employee(1005, "E-EE", "ee@163.com", 1));
        }

        private static Integer initId = 1006;

        public void save(Employee employee) {
            if (employee.getId() == null) {
                employee.setId(initId++);
            }
            employees.put(employee.getId(), employee);
        }

        public Collection<Employee> getAll() {
            return employees.values();
        }

        public Employee get(Integer id) {
            return employees.get(id);
        }

        public void delete(Integer id) {
            employees.remove(id);
        }
        
    }

功能清单

功能 URL 地址 请求方式
访问首页 / GET
查询全部数据 /employee GET
删除 /employee/2 DELETE
跳转到添加数据页面 /toAdd GET
执行保存 /employee POST
跳转到更新数据页面 /employee/2 GET
执行更新 /employee PUT

具体功能

首页

  1. 配置view-controller

    1
    2
    3
    4
    @RequestMapping("/")
    public String index() {
        return "index";
    }

  2. 创建页面

查询所有数据

  1. 控制器方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    @GetMapping("/employee")
    public ModelAndView getAll() {
        Collection<Employee> employeeList = employeeDao.getAll();
        employeeList.forEach(System.out::println);
        ModelAndView mav = new ModelAndView();
        mav.addObject("employeeList", employeeList);
        mav.setViewName("employee_list");
        return mav;
    }

  2. 创建employee_list.html

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    <!DOCTYPE html>
    <html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>EmployeeInfo</title>
        <link type="text/css" rel="stylesheet" th:src="@{/static/css/style.css}">
    </head>
    <body>
    <h1>EmployeeInfo</h1>
    <table id="dataTable" align="center">
        <tr>
            <th>ID</th>
            <th>LastName</th>
            <th>Email</th>
            <th>Gender</th>
            <th>Options</th>
        </tr>
        <tr th:each="employee : ${employeeList}">
            <td th:text="${employee.id}"></td>
            <td th:text="${employee.lastName}"></td>
            <td th:text="${employee.email}"></td>
            <td>
                <div th:if="${employee.gender}==1">
                    <p>male</p>
                </div>
                <div th:if="${employee.gender}==0">
                    <p>female</p>
                </div>
            </td>
            <td>
                <!--方式2：<a th:href="@{/employee/}+${employee.id}">delete</a>-->
                <a @click="deleteEmployee" th:href="@{'/employee/'+${employee.id}}">delete</a>
                <a>update</a>
            </td>
        </tr>
    </table>
    <form id="deleteForm" method="post">
        <input type="hidden" name="_method" value="delete">
    </form>
    <script type="text/javascript" th:src="@{/static/js/vue.js}"></script>
    <script type="text/javascript">
        let vue = new Vue({
            el: "#dataTable",
            methods: {
                deleteEmployee: function (event) {
                    // 根据id获取表单元素
                    let deleteForm = document.getElementById("deleteForm");
                    // 将触发点击事件的超链接的href属性赋值給表单的action
                    deleteForm.action = event.target.href;
                    // 提交表单
                    deleteForm.submit();
                    // 取消超链接默认行为
                    event.preventDefault();
                }
            }
        });
    </script>
    </body>
    </html>
删除数据

  1. 创建处理delete请求方式的表单

    1
    2
    3
    4
    5
    <!--通过超链接控制表单的提交，将post请求转换为delete请求-->
    <form id="delete_form" method="post">
        <!--必须传输_method请求参数，并且值为最终的请求方式-->
        <input type="hidden" name="_method" value="delete">
    </form>

  2. 删除超链接绑定点击事件

    1. 引入vue.js

      1
      <script type="text/javascript" th:src="@{/static/js/vue.js}"></script>

    2. 删除超链接

      1
      2
      <!--方式2：<a th:href="@{/employee/}+${employee.id}">delete</a>-->
      <a @click="deleteEmployee" th:href="@{'/employee/'+${employee.id}}">delete</a>

    3. 通过vue处理点击事件

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      <script type="text/javascript">
          let vue = new Vue({
              el: "#data_table",
              methods: {
                  // event表示当前事件
                  deleteEmployee: function (event) {
                      // 根据id获取表单元素
                      let deleteForm = document.getElementById("delete_form");
                      // 将触发点击事件的超链接的href属性赋值給表单的action
                      deleteForm.action = event.target.href;
                      // 提交表单
                      deleteForm.submit();
                      // 取消超链接默认行为
                      event.preventDefault();
                  }
              }
          });
      </script>

  3. 控制器方法

    1
    2
    3
    4
    5
    @DeleteMapping(value = "/employee/{id}")
    public String deleteById(@PathVariable("id") Integer id) {
        employeeDao.delete(id);
        return "redirect:/employee";
    }

  4. 开放对静态资源的访问

    • 静态资源不能被SpringMVC处理，需要使用DefaultServlet处理
    • 静态资源被访问时先被前端控制器处理，若在控制器中找不到相对应的请求映射则会交给默认Servlet处理
    1
    <mvc:default-servlet-handler/>
添加数据

  1. 配置view-controller

    1
    2
    3
    4
    @RequestMapping("/toAdd")
    public String toAdd() {
        return "employee_add";
    }

  2. 创建employee_add.html

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    <!DOCTYPE html>
    <html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>EmployeeAdd</title>
        <link type="text/css" rel="stylesheet" th:href="@{/static/css/style.css}"/>
    </head>
    <body>
    <h1>EmployeeAdd</h1>
    <form th:align="center" th:action="@{/employee}" method="post">
        <h2><label>lastname&ensp;<input type="text" name="lastName"/></label></h2>
        <h2><label>&ensp;&ensp;&ensp;email&ensp;<input type="text" name="email"/></label></h2>
        <h2><label>
            male&ensp;<input type="checkbox" name="gender" value="1"/>
            &ensp;&ensp;
            female&ensp;<input type="checkbox" name="gender" value="0"/>
        </label></h2>
        <h2><input type="submit" value="add"/></h2>
    </form>
    </body>
    </html>

  3. 控制器方法

    1
    2
    3
    4
    5
    @PostMapping
    public String insert(Employee employee) {
        employeeDao.save(employee);
        return "redirect:/employee";
    }
更新数据

  1. 修改超链接

    1
    <a th:href="@{'/employee/'+${employee.id}}">update</a>

  2. 控制器方法

    1
    2
    3
    4
    5
    6
    7
    8
    @GetMapping("/{id}")
    public ModelAndView selectById(@PathVariable Integer id) {
        Employee employee = employeeDao.get(id);
        ModelAndView mav = new ModelAndView();
        mav.addObject("employee", employee);
        mav.setViewName("/employee_update");
        return mav;
    }

  3. 创建employee_update.html

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    <!DOCTYPE html>
    <html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>EmployeeUpdate</title>
        <link type="text/css" rel="stylesheet" th:href="@{/static/css/style.css}"/>
    </head>
    <body>
    <h1>EmployeeUpdate</h1>
    <form th:align="center" th:action="@{/employee}" method="post">
        <input type="hidden" name="_method" value="put"/>
        <input type="hidden" name="id" th:value="${employee.id}"/>
        <h2><label>lastname&ensp;<input type="text" name="lastName" th:value="${employee.lastName}"/></label></h2>
        <h2><label>&ensp;&ensp;&ensp;email&ensp;<input type="text" name="email" th:value="${employee.email}"/></label></h2>
        <h2><label>
            <!--若th:field="${employee.gender}==1则为该标签添加checked标签-->
            male&ensp;<input type="radio" name="gender" value="1" th:field="${employee.gender}"/>
            &ensp;&ensp;
            female&ensp;<input type="radio" name="gender" value="0" th:field="${employee.gender}"/>
        </label></h2>
        <h2><input type="submit" value="update"/></h2>
    </form>
    </body>
    </html>

  4. 执行更新控制器方法

    1
    2
    3
    4
    5
    @PutMapping
    public String update(Employee employee) {
        employeeDao.save(employee);
        return "redirect:/employee";
    }

HttpMessageConverter

报文信息转换器:

  • 将请求报文转换为Java对象
  • 将Java对象转换为响应报文

提供了两个注解和两个类型：

  • @RequestBody
  • @ResponseBody
  • RequestEntity
  • ResponseEntity

@RequestBody

可以获取请求体，需要在控制器方法设置一个形参，使用@RequestBody进行标识，当前请求的请求体就会为当前注解所标识的形参赋值

1
2
3
4
5
6
7
8
9
<form th:action="@{/requestBody}" method="post">
    <label>username
        <input type="text" name="username" value="admin"/>
    </label>
    <label>password
        <input type="password" name="password" value="12345"/>
    </label>
    <input type="submit" value="@RequestBody"/>
</form>
1
2
3
4
5
@PostMapping("/requestBody")
public String requestBody(@RequestBody String requestBody) {
    System.out.println("requestBody: " + requestBody);
    return "success";
}

输出结果：

  • requestBody: username=admin&password=123

RequestEntity

封装请求报文的一种类型，需要在控制器方法的形参中设置该类型的形参，当前请求的请求报文就会赋值给该形参，可以通过getHeaders()获取请求头信息，通过getBody()获取请求体信息

1
2
3
4
5
6
7
@RequestMapping("/requestEntity")
public String requestEntity(RequestEntity<String> requestEntity) {
    // requestEntity表示整个请求报文信息
    System.out.println("requestHead: " + requestEntity.getHeaders());
    System.out.println("requestBody: " + requestEntity.getBody());
    return "success";
}

输出结果：

  • requestHead: [host:”localhost:8080”, origin:”http://localhost:8080“, accept-encoding:”gzip, deflate”, connection:”keep-alive”, upgrade-insecure-requests:”1”, accept:”text/html,application/xhtml+xml,application/xml;q=0.9,/;q=0.8”, user-agent:”Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.2 Safari/605.1.15”, referer:”http://localhost:8080/httpMessageConverter/“, content-length:”29”, accept-language:”zh-cn”, Content-Type:”application/x-www-form-urlencoded;charset=UTF-8”]
  • requestBody: username=admin&password=12345

@ResponseBody

用于标识一个控制器方法，可以将该方法的返回值直接作为响应报文的响应体响应到浏览器

1
2
3
4
5
6
7
@RequestMapping("/responseBody")
// 有@ResponseBody时，返回值作为响应到浏览器的数据
// 无@ResponseBody时，返回值作为视图名称被解析
@ResponseBody
public String responseBody() {
    return "success";
}

结果：浏览器页面显示success

JSON

{ }：JSON对象

[ ]：JSON数组

  1. 导入jackson依赖

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

  2. 在SpringMVC的核心配置文件中开启mvc的注解驱动，此时在HandlerAdaptor中会自动装配一个消息转换器：

    • MappingJackson2HttpMessageConverter：可以将响应到浏览器的Java对象转换为Json格式的字符串
    1
    <mvc:annotation-driven/>

  3. 在处理器方法上使用@ResponseBody注解进行标识

  4. 将Java对象直接作为控制器方法的返回值返回，就会自动转换为Json格式的字符串

    1
    2
    3
    4
    5
    @RequestMapping("/responseUser")
    @ResponseBody
    public User responseUser() {
        return new User(10001, "admin", "12345", 18, "male");
    }

浏览器的页面中展示的结果：

  • {“id”:10001,”username”:”admin”,”password”:”12345”,”age”:18,”gender”:”male”}

AJAX

  1. 请求超链接

    1
    2
    3
    <div id="app">
        <h2><a th:href="@{/ajax}">使用SpringMVC处理AJAX</a></h2>
    </div>

  2. 通过vue和axios处理点击事件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    <script type="text/javascript" th:src="@{/static/js/vue.js}"></script>
    <script type="text/javascript" th:src="@{/static/js/axios.min.js}"></script>
    <script type="text/javascript">
        var vue = new Vue({
            el: "#app", methods: {
                axios: function (event) {
                    axios({
                        method: "post",
                        url: event.target.href,
                        params: {username: "admin", password: "123456"}
                    }).then(function (response) {
                        alert(response.data);
                    });
                    event.preventDefault();
                }
            }
        });
    </script>

  3. 控制器方法

    1
    2
    3
    4
    5
    6
    7
    @PostMapping("/axios")
    @ResponseBody
    public String axios(String username, String password) {
        System.out.println("username: " + username);
        System.out.println("password: " + password);
        return "axios";
    }

@RestController

springMVC提供的一个复合注解，标识在控制器的类上，就相当于为类添加了@Controller注解，并且为其中的每个方法添加了@ResponseBody注解

ResponseEntity

用于控制器方法的返回值类型，该控制器方法的返回值就是响应到浏览器的响应报文

使用场景：文件下载

文件传输

文件下载

使用ResponseEntity实现下载文件的功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@RequestMapping("/download")
public ResponseEntity<byte[]> responseEntity(HttpSession session) throws IOException {
    // 获取ServletContext对象
    ServletContext servletContext = session.getServletContext();
    // 获取服务器中文件的真实路径
    String realPath = servletContext.getRealPath("/static/img/1.jpg");
    // 创建输入流
    InputStream is = new FileInputStream(realPath);
    // 创建字节数组
 		// .available()：获取该输入流的所有字节数
    byte[] bytes = new byte[is.available()];
    // 将流读到字节数组中
    is.read(bytes);
    // 创建HttpHeaders对象设置响应头信息
    MultiValueMap<String, String> headers = new HttpHeaders();
    // 设置要下载方式以及下载文件的名字
    headers.add("Content-Disposition", "attachment;filename=1.jpg");
    // 设置响应状态码
    HttpStatus statusCode = HttpStatus.OK;
    // 创建ResponseEntity对象
    ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers, statusCode);
    // 关闭输入流
    is.close();
    return responseEntity;
}

文件上传

文件上传要求form表单的请求方式必须为post，并且添加属性**enctype=”multipart/form-data”**（不再以键值对的方式上传，而是以二进制的方式上传）

SpringMVC中将上传的文件封装到MultipartFile对象中，通过此对象可以获取文件相关信息

  1. 添加依赖

    1
    2
    3
    4
    5
    <dependency>
        <groupId>commons-fileupload</groupId>
        <artifactId>commons-fileupload</artifactId>
        <version>1.4</version>
    </dependency>

  2. 在SpringMVC的配置文件中添加配置

    1
    2
    3
    <!--必须通过文件解析器的解析才能将文件转换为MultipartFile对象-->
    <!--SpringMVC通过id获取类-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"/>

  3. 控制器方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    @PostMapping("/upload")
    public String upload(MultipartFile photo, HttpSession session) throws IOException {
        // 获取上传的文件的文件名
        String fileName = photo.getOriginalFilename();
        // 处理文件重名问题[)
        String suffixName = fileName.substring(fileName.lastIndexOf("."));
        fileName = UUID.randomUUID() + suffixName;
        // 获取服务器中photo目录的路径
        ServletContext servletContext = session.getServletContext();
        String photoPath = servletContext.getRealPath("photo");
        File file = new File(photoPath);
        if (!file.exists()) {
            file.mkdir();
        }
        String finalPath = photoPath + File.separator + fileName;
        // 实现上传功能
        photo.transferTo(new File(finalPath));
        return "success";
    }

拦截器

配置

用于拦截控制器方法的执行

需要实现HandlerInterceptor

必须在SpringMVC的配置文件中进行配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<!--方式1-->
<mvc:interceptors>
    <bean class="cc.mousse.interceptor.FirstInterceptor"/>
</mvc:interceptors>

<!--方式2-->
<mvc:interceptors>
    <ref bean="firstInterceptor"/>
</mvc:interceptors>

<!--方式3-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--设置需要拦截的请求-->
        <!--
        /*：上下文路径下的一层目录的所有内容
        /**：所有内容
        -->
        <mvc:mapping path="/*"/>
        <!--设置需要排除的请求-->
        <mvc:exclude-mapping path="/"/>
        <ref bean="firstInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

/*：上下文路径下的一层目录的所有内容
/**：所有内容

抽象方法

preHandle：控制器方法执行之前执行，其boolean类型的返回值表示是否拦截或放行：

  • true为放行，即调用控制器方法
  • false表示拦截，即不调用控制器方法

postHandle：控制器方法执行之后执行

afterComplation：处理完视图和模型数据，渲染视图完毕之后执行

执行顺序

若每个拦截器的preHandle()都返回true：

  • 此时多个拦截器的执行顺序和拦截器在SpringMVC的配置文件的配置顺序有关：

    • preHandle()会按照配置的顺序执行
    • postHandle()和afterComplation()会按照配置的反序执行
    1. FirstInterceptor: preHandle
    2. SecondInterceptor: preHandle
    3. SecondInterceptor: postHandle
    4. FirstInterceptor: postHandle
    5. SecondInterceptor: afterCompletion
    6. FirstInterceptor: afterCompletion

若某个拦截器的preHandle()返回了false：

  • 返回false和它之前的拦截器的preHandle()都会执行

  • postHandle()都不执行

  • 返回false的拦截器之前的拦截器的afterComplation()会执行

  • SecondInterceptor返回false：

    1. FirstInterceptor: preHandle
    2. SecondInterceptor: preHandle
    3. FirstInterceptor: afterCompletion

异常处理器

基于配置

SpringMVC提供了一个处理控制器方法执行过程中所出现的异常的接口：HandlerExceptionResolver

  • 其接口的实现类有：
    • DefaultHandlerExceptionResolver：SpringMVC默认使用的异常处理器
    • SimpleMappingExceptionResolver：自定义的异常处理器
      • 使用方式：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <!--配置异常映射-->
    <property name="exceptionMappings">
        <props>
            <!--
            properties的键表示处理器方法执行过程中出现的异常
            properties的值表示若出现指定异常时，设置一个新的视图名称，跳转到指定页面
            -->
            <!--value为视图名称-->
            <prop key="java.lang.ArithmeticException">error</prop>
        </props>
    </property>
    <!--
    exceptionAttribute属性设置一个属性名，将出现的异常信息在请求域中进行共享
    以value为键，当前错误信息为值放入请求域中
    -->
    <property name="exceptionAttribute" value="exception"/>
</bean>

基于注解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 将当前类标识为异常处理的组件
@ControllerAdvice
public class ExceptionController {

    // 用于设置所标识方法处理的异常，value以数组类型存放
    @ExceptionHandler({ArithmeticException.class, NullPointerException.class})
    // exception表示当前请求处理中出现的异常对象
    public ModelAndView handleArithmeticException(Exception exception) {
        ModelAndView mav = new ModelAndView();
        mav.addObject("exception", exception);
        mav.setViewName("error");
        return mav;
    }

}

注解配置SpringMVC

使用配置类和注解代替web.xml和SpringMVC配置文件的功能

创建初始化类

代替web.xml

在Servlet3.0环境中，容器会在类路径中查找实现javax.servlet.ServletContainerInitializer接口的类，如果找到的话就用它来配置Servlet容器。

Spring提供了这个接口的实现，名为SpringServletContainerInitializer，这个类反过来又会查找实现WebApplicationInitializer的类并将配置的任务交给它们来完成。

Spring3.2引入了一个便利的WebApplicationInitializer基础实现，名为AbstractAnnotationConfigDispatcherServletInitializer，当我们的类扩展了AbstractAnnotationConfigDispatcherServletInitializer并将其部署到Servlet3.0容器的时候，容器会自动发现它，并用它来配置Servlet上下文。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {

    /**
     * 指定spring的配置类
     */
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    /**
     * 指定SpringMVC的配置类
     */
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }

    /**
     * 指定DispatcherServlet的映射规则，即url-pattern
     */
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    /**
     * 添加过滤器
     */
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter();
        encodingFilter.setEncoding("UTF-8");
        encodingFilter.setForceRequestEncoding(true);
        HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
        return new Filter[]{encodingFilter, hiddenHttpMethodFilter};
    }

}

创建SpringConfig配置类

代替spring的配置文件

1
2
3
4
5
6
@Configuration
public class SpringConfig {
    
    // ssm整合之后，spring的配置信息写在此类中
    
}

创建WebConfig配置类

代替SpringMVC的配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
// 将当前类标识为一个配置类
@Configuration
// 扫描组件
@ComponentScan("cc.mousse")
// 开启MVC注解驱动@EnableWebMvc
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    // 使用默认的servlet处理静态资源
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    // 配置文件上传解析器
    @Bean
    public CommonsMultipartResolver multipartResolver() {
        return new CommonsMultipartResolver();
    }

    // 配置拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        FirstInterceptor firstInterceptor = new FirstInterceptor();
        registry.addInterceptor(firstInterceptor).addPathPatterns("/**");
    }

    // 配置视图控制
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("index");
    }

    // 配置异常映射
    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
        Properties prop = new Properties();
        prop.setProperty("java.lang.ArithmeticException", "error");
        // 设置异常映射
        exceptionResolver.setExceptionMappings(prop);
        // 设置共享异常信息的键
        exceptionResolver.setExceptionAttribute("ex");
        resolvers.add(exceptionResolver);
    }

    // 配置生成模板解析器
    @Bean
    public ITemplateResolver templateResolver() {
        WebApplicationContext webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
        // ServletContextTemplateResolver需要一个ServletContext作为构造参数，可通过WebApplicationContext的方法获得
        ServletContextTemplateResolver templateResolver = new ServletContextTemplateResolver(webApplicationContext.getServletContext());
        templateResolver.setPrefix("/WEB-INF/templates/");
        templateResolver.setSuffix(".html");
        templateResolver.setCharacterEncoding("UTF-8");
        templateResolver.setTemplateMode(TemplateMode.HTML);
        return templateResolver;
    }

    // 生成模板引擎并为模板引擎注入模板解析器
    // 形参templateResolver属于自动装配
    @Bean
    public SpringTemplateEngine templateEngine(ITemplateResolver templateResolver) {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(templateResolver);
        return templateEngine;
    }

    // 生成视图解析器并未解析器注入模板引擎
    @Bean
    public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
        ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
        viewResolver.setCharacterEncoding("UTF-8");
        viewResolver.setTemplateEngine(templateEngine);
        return viewResolver;
    }

}

SpringMVC执行流程

常用组件

DispatcherServlet：前端控制器，不需要工程师开发，由框架提供

  • 作用：统一处理请求和响应，整个流程控制的中心，由它调用其它组件处理用户的请求

HandlerMapping：处理器映射器，不需要工程师开发，由框架提供

  • 作用：根据请求的url、method等信息查找Handler，即控制器方法

Handler：处理器，需要工程师开发

  • 作用：在DispatcherServlet的控制下Handler对具体的用户请求进行处理

HandlerAdapter：处理器适配器，不需要工程师开发，由框架提供

  • 作用：通过HandlerAdapter对处理器（控制器方法）进行执行

ViewResolver：视图解析器，不需要工程师开发，由框架提供

  • 作用：进行视图解析，得到相应的视图，例如ThymeleafView、InternalResourceView、RedirectView

View：视图

  • 作用：将模型数据通过页面展示给用户

DispatcherServlet

初始化过程

DispatcherServlet本质上是一个Servlet，所以天然的遵循Servlet的生命周期。所以宏观上是Servlet 生命周期来进行调度。

  1. 初始化WebApplicationContext

    • 所在类：org.springframework.web.servlet.FrameworkServlet
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    protected WebApplicationContext initWebApplicationContext() {
        WebApplicationContext rootContext =
            WebApplicationContextUtils.getWebApplicationContext(getServletContext());
        WebApplicationContext wac = null;

        if (this.webApplicationContext != null) {
            // A context instance was injected at construction time -> use it
            wac = this.webApplicationContext;
            if (wac instanceof ConfigurableWebApplicationContext) {
                ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
                if (!cwac.isActive()) {
                    // The context has not yet been refreshed -> provide services such as
                    // setting the parent context, setting the application context id, etc
                    if (cwac.getParent() == null) {
                        // The context instance was injected without an explicit parent -> set
                        // the root application context (if any; may be null) as the parent
                        cwac.setParent(rootContext);
                    }
                    configureAndRefreshWebApplicationContext(cwac);
                }
            }
        }
        if (wac == null) {
            // No context instance was injected at construction time -> see if one
            // has been registered in the servlet context. If one exists, it is assumed
            // that the parent context (if any) has already been set and that the
            // user has performed any initialization such as setting the context id
            wac = findWebApplicationContext();
        }
        if (wac == null) {
            // No context instance is defined for this servlet -> create a local one
            // 创建WebApplicationContext
            wac = createWebApplicationContext(rootContext);
        }

        if (!this.refreshEventReceived) {
            // Either the context is not a ConfigurableApplicationContext with refresh
            // support or the context injected at construction time had already been
            // refreshed -> trigger initial onRefresh manually here.
            synchronized (this.onRefreshMonitor) {
                // 刷新WebApplicationContext
                onRefresh(wac);
            }
        }

        if (this.publishContext) {
            // Publish the context as a servlet context attribute.
            // 将IOC容器在应用域共享
            String attrName = getServletContextAttributeName();
            getServletContext().setAttribute(attrName, wac);
        }

        return wac;
    }

  2. 创建WebApplicationContext

    • 所在类：org.springframework.web.servlet.FrameworkServlet
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
        Class<?> contextClass = getContextClass();
        if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
            throw new ApplicationContextException(
                "Fatal initialization error in servlet with name '" + getServletName() +
                "': custom WebApplicationContext class [" + contextClass.getName() +
                "] is not of type ConfigurableWebApplicationContext");
        }
        // 通过反射创建 IOC 容器对象
        ConfigurableWebApplicationContext wac =
            (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);

        wac.setEnvironment(getEnvironment());
        // 设置父容器
        wac.setParent(parent);
        String configLocation = getContextConfigLocation();
        if (configLocation != null) {
            wac.setConfigLocation(configLocation);
        }
        configureAndRefreshWebApplicationContext(wac);

        return wac;
    }

  3. DispatcherServlet初始化策略

    • FrameworkServlet创建WebApplicationContext后，刷新容器，调用onRefresh(wac)，此方法在DispatcherServlet中进行了重写，调用了initStrategies(context)方法，初始化策略，即初始化DispatcherServlet的各个组件

    • 所在类：org.springframework.web.servlet.DispatcherServlet

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    protected void initStrategies(ApplicationContext context) {
       initMultipartResolver(context);
       initLocaleResolver(context);
       initThemeResolver(context);
       initHandlerMappings(context);
       initHandlerAdapters(context);
       initHandlerExceptionResolvers(context);
       initRequestToViewNameTranslator(context);
       initViewResolvers(context);
       initFlashMapManager(context);
    }

调用组件处理请求

  1. processRequest()：

    • FrameworkServlet重写HttpServlet中的service()和doXxx()，这些方法中调用了processRequest(request, response)
    • 所在类：org.springframework.web.servlet.FrameworkServlet
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {

        long startTime = System.currentTimeMillis();
        Throwable failureCause = null;

        LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
        LocaleContext localeContext = buildLocaleContext(request);

        RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);

        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
        asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());

        initContextHolders(request, localeContext, requestAttributes);

        try {
    		// 执行服务，doService()是一个抽象方法，在DispatcherServlet中进行了重写
            doService(request, response);
        }
        catch (ServletException | IOException ex) {
            failureCause = ex;
            throw ex;
        }
        catch (Throwable ex) {
            failureCause = ex;
            throw new NestedServletException("Request processing failed", ex);
        }

        finally {
            resetContextHolders(request, previousLocaleContext, previousAttributes);
            if (requestAttributes != null) {
                requestAttributes.requestCompleted();
            }
            logResult(request, response, failureCause, asyncManager);
            publishRequestHandledEvent(request, response, startTime, failureCause);
        }
    }

  2. doService()：

    • 所在类：org.springframework.web.servlet.DispatcherServlet
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    @Override
    protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
        logRequest(request);

        // Keep a snapshot of the request attributes in case of an include,
        // to be able to restore the original attributes after the include.
        Map<String, Object> attributesSnapshot = null;
        if (WebUtils.isIncludeRequest(request)) {
            attributesSnapshot = new HashMap<>();
            Enumeration<?> attrNames = request.getAttributeNames();
            while (attrNames.hasMoreElements()) {
                String attrName = (String) attrNames.nextElement();
                if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
                    attributesSnapshot.put(attrName, request.getAttribute(attrName));
                }
            }
        }

        // Make framework objects available to handlers and view objects.
        request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
        request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
        request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
        request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());

        if (this.flashMapManager != null) {
            FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
            if (inputFlashMap != null) {
                request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
            }
            request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
            request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
        }

        RequestPath requestPath = null;
        if (this.parseRequestPath && !ServletRequestPathUtils.hasParsedRequestPath(request)) {
            requestPath = ServletRequestPathUtils.parseAndCache(request);
        }

        try {
            // 处理请求和响应
            doDispatch(request, response);
        }
        finally {
            if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
                // Restore the original attribute snapshot, in case of an include.
                if (attributesSnapshot != null) {
                    restoreAttributesAfterInclude(request, attributesSnapshot);
                }
            }
            if (requestPath != null) {
                ServletRequestPathUtils.clearParsedRequestPath(request);
            }
        }
    }

  3. doDispatch()：

    • 所在类：org.springframework.web.servlet.DispatcherServlet
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;

        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

        try {
            ModelAndView mv = null;
            Exception dispatchException = null;

            try {
                processedRequest = checkMultipart(request);
                multipartRequestParsed = (processedRequest != request);

                // Determine handler for the current request.
                /*
                	mappedHandler：调用链
                    包含handler、interceptorList、interceptorIndex
                	handler：浏览器发送的请求所匹配的控制器方法
                	interceptorList：处理控制器方法的所有拦截器集合
                	interceptorIndex：拦截器索引，控制拦截器afterCompletion()的执行
                */
                mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }

                // Determine handler adapter for the current request.
               	// 通过控制器方法创建相应的处理器适配器，调用所对应的控制器方法
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

                // Process last-modified header, if supported by the handler.
                String method = request.getMethod();
                boolean isGet = "GET".equals(method);
                if (isGet || "HEAD".equals(method)) {
                    long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                    if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                        return;
                    }
                }
    			
                // 调用拦截器的preHandle()
                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }

                // Actually invoke the handler.
                // 由处理器适配器调用具体的控制器方法，最终获得ModelAndView对象
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

                if (asyncManager.isConcurrentHandlingStarted()) {
                    return;
                }

                applyDefaultViewName(processedRequest, mv);
                // 调用拦截器的postHandle()
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            }
            catch (Exception ex) {
                dispatchException = ex;
            }
            catch (Throwable err) {
                // As of 4.3, we're processing Errors thrown from handler methods as well,
                // making them available for @ExceptionHandler methods and other scenarios.
                dispatchException = new NestedServletException("Handler dispatch failed", err);
            }
            // 后续处理：处理模型数据和渲染视图
            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        }
        catch (Exception ex) {
            triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
        }
        catch (Throwable err) {
            triggerAfterCompletion(processedRequest, response, mappedHandler,
                                   new NestedServletException("Handler processing failed", err));
        }
        finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                // Instead of postHandle and afterCompletion
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            }
            else {
                // Clean up any resources used by a multipart request.
                if (multipartRequestParsed) {
                    cleanupMultipart(processedRequest);
                }
            }
        }
    }

  4. processDispatchResult()：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
                                       @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
                                       @Nullable Exception exception) throws Exception {

        boolean errorView = false;

        if (exception != null) {
            if (exception instanceof ModelAndViewDefiningException) {
                logger.debug("ModelAndViewDefiningException encountered", exception);
                mv = ((ModelAndViewDefiningException) exception).getModelAndView();
            }
            else {
                Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
                mv = processHandlerException(request, response, handler, exception);
                errorView = (mv != null);
            }
        }

        // Did the handler return a view to render?
        if (mv != null && !mv.wasCleared()) {
            // 处理模型数据和渲染视图
            render(mv, request, response);
            if (errorView) {
                WebUtils.clearErrorRequestAttributes(request);
            }
        }
        else {
            if (logger.isTraceEnabled()) {
                logger.trace("No view rendering, null ModelAndView returned.");
            }
        }

        if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
            // Concurrent handling started during a forward
            return;
        }

        if (mappedHandler != null) {
            // Exception (if any) is already handled..
            // 调用拦截器的afterCompletion()
            mappedHandler.triggerAfterCompletion(request, response, null);
        }
    }

执行流程

  1. 用户向服务器发送请求，请求被SpringMVC 前端控制器DispatcherServlet捕获。
  2. DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI），判断请求URI对应的映射
    • 若不存在：判断是否配置了mvc:default-servlet-handler
      • 若没配置：则控制台报映射查找不到，客户端展示404错误
      • 若有配置：则访问目标资源（一般为静态资源，如：JS,CSS,HTML），找不到客户端也会展示404错误
    • 若存在：
      1. 根据该URI调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain执行链对象的形式返回。
      2. DispatcherServlet根据获得的Handler选择一个合适的HandlerAdapter。
      3. 如果成功获得HandlerAdapter，此时将开始执行拦截器的preHandler(…)方法【正向】
      4. 提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller）方法，处理请求。在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作：
        1. HttpMessageConveter： 将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息
        2. 数据转换：对请求消息进行数据转换。如String转换成Integer、Double等
        3. 数据格式化：对请求消息进行数据格式化。 如将字符串转换成格式化数字或格式化日期等
        4. 数据验证： 验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中
      5. Handler执行完成后，向DispatcherServlet返回一个ModelAndView对象。
      6. 此时将开始执行拦截器的postHandle(…)方法【逆向】。
      7. 根据返回的ModelAndView（此时会判断是否存在异常：如果存在异常，则执行HandlerExceptionResolver进行异常处理）选择一个适合的ViewResolver进行视图解析，根据Model和View，来渲染视图。
      8. 渲染视图完毕执行拦截器的afterCompletion(…)方法【逆向】。
      9. 将渲染结果返回给客户端。