SpringMVC全解

最新推荐文章于 2023-05-06 12:53:10 发布

Onism_DreamBoat

最新推荐文章于 2023-05-06 12:53:10 发布

阅读量353

点赞数

分类专栏：后端学习 springMVC 文章标签： java mvc 后端

本文链接：https://blog.csdn.net/qq_73574147/article/details/129918483

版权

后端学习同时被 2 个专栏收录

25 篇文章 0 订阅

订阅专栏

springMVC

1 篇文章 0 订阅

订阅专栏

文章目录

SpringMVC

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为表述层开发提供的一套完备的解决方案。

注：三层架构分为表述层(表示层)、业务逻辑层、数据访问层，表述层表示前台页面和后台servlet

特点

其是Spring家族中的原生产品，与IOC容器等基础设施可以做到无缝衔接。
基于原生的Servlet，通过了前端控制器DispatcherServlet，对请求和响应进行统一处理。
表述层各细分领域需要解决的问题全方位覆盖，提供了全面解决方案。
代码简洁，大幅度提高开发效率。

第一个程序：HelloWorld

创建步骤

创建maven工程(建议使用webapp模板创建)

首先先创建一个maven工程，然后进行配置pom.xml文件，打包方式为war包。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.example</groupId>
  <artifactId>springMVC-Day01</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>

  <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>
      <scope>provided</scope>
    </dependency>

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

配置web.xml

注册SpringMVC的前端控制器DispatcherServlet，分为两种配置方式：

默认配置方式：

<!-- 配置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请求路径的请求
    -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

此配置作用下，SpringMVC的配置文件默认位于WEB-INF下，默认名称为<servlet-name>-servlet.xml，例如，以下配置所对应SpringMVC的配置文件位于WEB-INF下，文件名为springMVC-servlet.xml。

该配置显然不符合maven的管理(配置文件统一放在resources路径下)，所以不建议使用默认配置方式。

扩展配置方式(推荐方式)：

<!--配置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>
<!--讲前端DispatcherServlet的初始化事件提前至服务器启动时-->
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

可通过init-param标签设置SpringMVC配置文件的位置和名称，通过load-on-startup标签设置SpringMVC前端控制器DispatcherServlet的初始化时间。此时根据param-value中所配置的配置文件，在resources创建一个相应的springMVC.xml的配置文件。

创建请求控制器

由于前端控制器(DispatcherServlet)对浏览器的请求进行统一的处理，但每个请求具体有不同的处理过程，因此需要创建处理具体请求的类，即为请求控制器。请求控制器中每一个处理请求的方法称为控制器方法。因为SpringMVC的控制器由一个POJO（普通的Java类）担任，因此需要@Controller注解将其标识为一个控制层组件，交给Spring的IoC容器管理，此时SpringMVC才能够识别控制器的存在。

@Controller
public class HelloController {
    
}

配置springMVC文件

<!-- 自动扫描包 -->
<context:component-scan base-package="com.atguigu.mvc.controller"/>

<!-- 配置Thymeleaf视图解析器 -->
<bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
    <property name="order" value="1"/>
    <property name="characterEncoding" value="UTF-8"/>
    <property name="templateEngine">
        <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
            <property name="templateResolver">
                <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
    
                    <!-- 视图前缀 -->
                    <property name="prefix" value="/WEB-INF/templates/"/>
    
                    <!-- 视图后缀 -->
                    <property name="suffix" value=".html"/>
                    <property name="templateMode" value="HTML5"/>
                    <property name="characterEncoding" value="UTF-8" />
                </bean>
            </property>
        </bean>
    </property>
</bean>

测试HelloWorld

实现对首页的访问

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

package code.Controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @创建人 HeXin
 * @所属包 HelloController
 * @所属项目 SpringMVC
 * @创建时间 2023/3/16 9:00
 * @描述  请求控制器
 */
@Controller
public class HelloController {
	@RequestMapping("/")
	public String index(){
		//设置视图名称
		return "index";
	}
}

通过超链接跳转至指定页面

先在主页index.html中设置超链接

<!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="@{/target}">点击跳转</a>
</body>
</html>

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

@RequestMapping("/target")
public String toTarget(){
    return "target";
}

注意：这里使用了Thymeleaf视图解析，所以要严格遵守其语法规定(href前面要加上th:，以及相对路径要用@{}包围，否则将无法识别)

<a th:href="@{/相对路径}">输入文本</a>

总结

第一个HelloWorld程序启动，浏览器开始发送请求，若请求地址与前端控制器的url-pattern中配置的地址相匹配，则该请求就会被前端控制器DispatcherServlet进行统一处理。DispatcherServlet会读取SpringMVC的核心配置文件，并通过组件扫描的方式找到控制器，将请求地址和控制器中的@RequestMapping注解的value属性值进行匹配。如果匹配成功，则该注释所标识的控制器方法就是处理该请求的方法。

处理请求的方法需要返回一个字符串类型的视图名称，该视图名称会被视图解析器解析，如果配置了Thymeleaf的视图前缀和视图后缀，则视图解析器会自动加上前缀和后缀组成视图的路径，通过Thymeleaf对视图进行渲染，最终转发到视图所对应的页面。

@RequestMapping注解

功能

从注解的名称得知，该注解意思为“请求映射”，@RequestMapping注解的作用就是将请求和处理请求的控制器关联起来，建立映射关系。当SpringMVC接收到指定的请求时，就会来找映射关系中对应的控制器来处理这个请求。

位置

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

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

如果一个类中类和方法上都有此注解，则其访问路径为：初识信息->具体信息

代码演示

package code.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/test")
public class RequestMappingTest {
	@RequestMapping("/target")
	public String test(){
		return "target";
	}
}

index.html

<!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="@{/test/target}">点击跳转</a>
</body>
</html>

从以上代码中可以看出，处理上述情况则需要以/初识信息/具体信息的两层路径的模式处理。这样做的好处是，防止以后出现相同的url地址而引发RequestMapping的映射冲突，此方法在日后开发中非常常用。

属性

通过查看@RequestMapping的源代码，可以知道@RequestMapping注解中有一下的属性
在这里插入图片描述

其中，比较重要的有value()和method()，下面将对这两个属性进行学习。此外，还需要了解params()和headers()两个属性。

value()属性

从源码中的属性定义可以看出，该属性可以定义为一个String数组，说明请求映射匹配多个请求地址，换言之，可以处理多个不同的请求。

@RequestMapping注解的value属性必须设置，至少通过请求地址匹配请求映射。

<a th:href="@{/testRequestMapping}">点击跳转网页1</a><br>
<a th:href="@{/test}">点击跳转网页2</a><br>

@RequestMapping(
        value = {"/testRequestMapping", "/test"}
)
public String testRequestMapping(){
    return "target";
}

补充：

SpringMVC支持ant风格的路径

?：表示任意的单个(有且只能有一个)字符(除了特殊符号，如：?，/等)

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

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

注意：在使用**时，只能使用/**/xxx的方式，否则会被识别为两个单独的*的情况

@RequestMapping("/a?a/target")
public String toTarget(){
    return "target";
}

<a th:href="@{/a2a/target}">点击跳转</a>

SpringMVC支持路径中的占位符(重点)

原始方式：/updateUser?id=1

rest方式：/updateUser/1

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

@RequestMapping("/target/{username}/{password}")
public String toTarget(@PathVariable("username") String username,@PathVariable("username") String password){
    System.out.println("Username:"+username+" Password:"+password);
    return "target";
}

<a th:href="@{/target/admin/123456}">点击跳转</a>

如果当前的请求路径中有占位符，则匹配的请求地址中也必须要包含这一层内容，否则就会报错404

method()属性

@RequestMapping注解的method属性通过请求的请求方式(get或post，如果不设置，默认两者都可以)匹配请求映射。

@RequestMapping注解的method属性是一个RequestMethod类型的数组，表示该请求映射能够匹配多种请求方式的请求。

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

<a th:href="@{/test}">点击跳转</a>
<form th:action="@{/test}" method="post">
    <input type="提交">
</form>

@RequestMapping(
        value = {"/testRequestMapping", "/test"},
        method = {RequestMethod.GET, RequestMethod.POST}
)
public String testRequestMapping(){
    return "target";
}

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

@GetMapping：处理Get请求的映射
@PostMapping ：处理Post请求的映射
@PutMapping：处理Put请求的映射
@DeleteMapping：处理Delete请求的映射

以上四种是最常见的请求方法的派生注解。但是目前浏览器只支持Get和Post请求，若是在form表单提交时，为method设置了其他请求方式的字符串(put和delete)，则将会按照默认的Get请求方式处理(此时运行就会报405)。若要发送put和delete请求，则需要通过spring提供的过滤器HiddenHttpMethodFilter。

params()属性(了解)

该属性是通过请求的请求参数匹配请求映射，是一个字符串类型的数组，可以通过四种表达式设置请求参数和请求映射的匹配关系。

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

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

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

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

该属性要求其设置的所有条件必须同时满足，否则就会报错400

<a th:href="@{/target(username='admin',password=123456)">点击跳转</a><br>

@RequestMapping(
        value = {"/testRequestMapping", "/test"}
        ,method = {RequestMethod.GET, RequestMethod.POST}
        ,params = {"username","password!=123456"}
)
public String testRequestMapping(){
    return "target";
}

header()属性(了解)

该属性通过请求的请求头信息匹配请求映射，是一个字符串类型的数组，可以通过四种表达式设置请求头信息和请求映射的匹配关系。

"header"要求请求映射所匹配的请求必须携带header请求头信息。

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

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

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

该属性要求其设置的所有条件必须同时满足，否则就会报错404

获取请求参数

有三种方式获取请求参数，分别是：通过servletAPI获取、通过控制器方法的形参获取请求参数、通过POJO获取请求参数。下面将逐个进行学习。

通过servletAPI获取

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

@RequestMapping(value = "/testServlet")
public String testServlet(HttpServletRequest req){
    String username = req.getParameter("username");
    String password = req.getParameter("password");
    System.out.println("用户名："+username+" 密码："+password);
    return "testServlet";
}

通过控制器方法的形参获取请求参数

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

若请求参数中出现多个同名的请求参数，可以在控制器方法的形参位置设置字符串类型或字符串数组接收此参数。若使用字符串类型的形参，每一个请求参数会以逗号隔开进行拼接。

package code.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.Arrays;
@Controller
public class RequestMappingTest {
	@RequestMapping(value = "/testServlet")
	public String testServlet(String username,String password,String[] hobby){
		System.out.println("用户名："+username+" 密码："+password+" 爱好："+ Arrays.toString(hobby));
		return "testServlet";
	}
}

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>个人信息</title>
</head>
<body>
<form th:action="@{/testServlet}" method="post">
  用户名：<input type="text" name="username" placeholder="请输入用户名"><br/>
  密码：<input type="password" name="password" placeholder="请输入密码"><br/>
  爱好：<input type="checkbox" name="hobby" value="Java">Java
  <input type="checkbox" name="hobby" value="C++">C++
  <input type="checkbox" name="hobby" value="Go">Go
  <input type="checkbox" name="hobby" value="Python">Python
  <input type="checkbox" name="hobby" value="PHP">PHP
    <br/>
  <input type="submit" value="提交"/>
</form>
</body>
</html>

注意：这里方法上的形参名和获取的请求参数的name属性必须相同，否则无法获取参数并给形参进行赋值。或者使用@RequestParam注解将形参名和请求参数相匹配。

@RequestParam注解

该注解是将请求参数和控制器方法的形参创建映射关系。

它共有三个属性：

value：指定为形参赋值的请求参数的参数名。
required：设置是否必须传输此请求参数(默认值为true)。

当该属性设置为true时，则当前请求必须传输value所指定的请求参数，若没有传输该请求参数，且没有设置defaultValue属性，则页面报错400：Required String parameter 'xxx' is not present。

若设置为false，则当前请求不是必须传输value所指定的请求参数，若没有传输，则注解所标识的形参的值为null。

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

package code.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.Arrays;
@Controller
public class RequestMappingTest {
	@RequestMapping(value = "/testServlet")
	public String testServlet(@RequestParam("username") String username,
	                          @RequestParam("password") String password,
	                          @RequestParam("hobby") String[] hobby){
		System.out.println("用户名："+username+" 密码："+password+" 爱好："+ Arrays.toString(hobby));
		return "target";
	}
}

此时，还有两个类似的注解：

@RequestHeader注解

该注解将请求头信息和控制器方法的形参创建映射关系。它跟@RequestParam注解一样，拥有value、required、defaultValue三个属性，用法也相同。

@CookieValue注解

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

@CookieValue注解一共有三个属性：value、required、defaultValue，用法同@RequestParam

通过POJO获取请求参数

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

代码演示

HTML页面

<form th:action="@{/testBean}" method="post">
  用户名：<input type="text" name="username" placeholder="请输入用户名"><br/>
  密码：<input type="password" name="password" placeholder="请输入密码"><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" value="提交"/>
</form>

控制器类

@RequestMapping("/testBean")
public String testBean(User user){
    System.out.println(user);
    return "target";
}

实体类

package code.controller.bean;
/**
 * @创建人 HeXin
 * @所属包 User
 * @所属项目 SpringMVC
 * @创建时间 2023/3/18 19:56
 * @描述 User实体类
 */
public class User {
	private String username;
	private String password;
	private Integer age;
	private String sex;
	private String email;
	
	public String getUsername () {
		return username;
	}
	
	public void setUsername (String username) {
		this.username = username;
	}
	
	public String getPassword () {
		return password;
	}
	
	public void setPassword (String password) {
		this.password = password;
	}
	
	public Integer getAge () {
		return age;
	}
	
	public void setAge (Integer age) {
		this.age = age;
	}
	
	public String getSex () {
		return sex;
	}
	
	public void setSex (String sex) {
		this.sex = sex;
	}
	
	public String getEmail () {
		return email;
	}
	
	public void setEmail (String email) {
		this.email = email;
	}
	
	public User () {
	}
	
	@Override
	public String toString () {
		return "User{" +
				"username='" + username + '\'' +
				", password='" + password + '\'' +
				", age=" + age +
				", sex='" + sex + '\'' +
				", email='" + email + '\'' +
				'}';
	}
}

解决获取请求参数的乱码问题

Get请求的乱码问题一般是由Tomcat造成的，只需要在Tomcat的配置文件server.xml(在Tomcat的conf文件夹下)中添加如图所示的配置即可一键解决
在这里插入图片描述

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

<!--配置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>

域对象共享数据

当有数据需要发送给页面时，则需要将这些数据在域对象中共享。下面将学习五种共享方式

使用servletAPI向request域对象共享数据

控制器方法

//使用servletAPI向request域对象共享数据
@RequestMapping("/requestServlet")
public String testRequestServlet(HttpServletRequest request){
    request.setAttribute("test","Hello! RequestAPI");
    return "target";
}

通过原生的ServletAPI调用其setAttribute方法将数据存入request域中，共享到页面，方便页面使用其中的数据。该方式比较原生，一般不建议使用此方法共享数据，因为SpringMVC为我们提供了四种更好的方式。

使用ModelAndView向request域对象共享数据(建议使用)

@RequestMapping("/modelAndView")
public ModelAndView testModelAndView(){
    //Model主要用于请求域共享数据
    //View主要用于设置视图，实现页面跳转
    ModelAndView modelAndView = new ModelAndView();
    //处理模型数据，即向请求域共享数据
    modelAndView.addObject("modelAndView","Hello! ModelAndView");
    //设置视图名称,相当于返回的字符串，实现页面跳转
    modelAndView.setViewName("target");
    return modelAndView;
}

使用Model向request域对象共享数据

@RequestMapping("/model")
public String testModel(Model model){
    model.addAttribute("model","Hello! Model");
    return "target";
}

该model就是ModelAndView中的Model。

使用map向request域对象共享数据

@RequestMapping("/map")
public String testMap(Map<String,Object> map){
    map.put("map","Hello! Map");
    return "target";
}

使用的Map其实就是java.util包下的Map映射。

使用ModelMap向request域对象共享数据

@RequestMapping("/modelMap")
public String testModelMap(ModelMap modelMap){
    modelMap.addAttribute("modelMap","Hello! ModelMap");
    return "target";
}

Model、Map、ModelMap之间的关系

通过查看三者的源代码得知，Model是SpringMVC提供共享数据类的最顶层的类(因为它没有继承任何其他类)，而ModelMap继承了LinkedHashMap类，实现的其中的方法，而Map其实就是原生JDK中的Map。

public interface Model{}
public class ModelMap extends LinkedHashMap<String, Object> {}
public class ExtendedModelMap extends ModelMap implements Model {}
public class BindingAwareModelMap extends ExtendedModelMap {}

通过打印三者的实参，发现它们重写了一样的toString方法。利用反射的机制(类.getClass().getName()可以获取到当前类的全类名)，查看其全类名。

org.springframework.validation.support.BindingAwareModelMap
org.springframework.validation.support.BindingAwareModelMap
org.springframework.validation.support.BindingAwareModelMap

结果发现它们本支行都是BindingAwareModelMap类型

向session域共享数据

向Session域中共享数据时，选择使用原生的API反而比SpringMVC提供的注解更加方便。

在Thymeleaf中，通过session.共享数据的键来访问session里面的共享数据

@RequestMapping("/session")
public String testSession(HttpSession session){
    session.setAttribute("session","Hello! Session");
    return "target";
}

向application域共享数据

同样的，它在访问数据时，也需要通过application.共享数据的键来进行访问。

@RequestMapping("/application")
public String testApplication(HttpSession session){
    ServletContext application = session.getServletContext();
    application.setAttribute("application","Hello! Application");
    return "target";
}

SpringMVC的视图

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

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

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

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

ThymeleafView

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

转发视图(InternalResourceView)

SpringMVC中默认的转发视图是InternalResourceView

SpringMVC中会创建转发视图的情况

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

注意：只能跳转至别的HTML请求，而不能直接跳转至其中某一个页面。所以"forward:“前缀之后只能加上”/html请求"。

@RequestMapping("/forward")
public String testForward(){
    return "forward:/thymeleafView";
}

重定向视图(RedirectView)

SpringMVC中默认的重定向视图是RedirectView

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

@RequestMapping("/redirect")
public String testRedirect(){
	return "redirect:/thymeleafView";
}

视图控制器(view-controller)

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

<!--
	path：设置处理的请求地址
	view-name：设置请求地址所对应的视图名称
-->
<mvc:view-controller path="/" view-name="index"/>

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

<mvc:annotation-dirven/>

InternalReourceViewRessolver

这是适用于jsp文件的视图解析器。接下来将学习如何配置并使用。

首先先创建一个模块(建议使用webapp模板创建)

配置pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.example</groupId>
  <artifactId>springMVC-Day04</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>

  <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>
      <scope>provided</scope>
    </dependency>

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

  <build>
    <finalName>springMVC-Day04</finalName>
  </build>
</project>

配置web.xml

<?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">
    <!--    配置编码过滤器-->
    <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>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!--    配置springMVC的前端控制器DispatcherServlet-->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springMVC.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

创建并配置springMVC.xml(配置视图的关键部分)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       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">
    <!--组件扫描-->
    <context:component-scan base-package="code"></context:component-scan>
    <!--配置InternalResourceViewResolver视图-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/templates/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>
</beans>

进行测试

JspController类

package code.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @创建人 HeXin
 * @所属包 code.controller.JspController
 * @所属项目 SpringMVC
 * @创建时间 2023/3/22 21:25
 * @描述 控制类方法
 */
@Controller
public class JspController {
	@RequestMapping("/target")
	public String testTarget(){
		return "target";
	}
}

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>首页</h1>
<a href="${pageContext.request.contextPath}/target">点击跳转</a>
</body>
</html>

target.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>目标页面</title>
</head>
<body>
<h2>成功跳转！</h2>
</body>
</html>

最后配置并启动Tomcat，完成测试~

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

由于浏览器默认只支持发送get和post方式的请求，那么应该如何发送put和delete请求呢？

贴心的SpringMVC为我们提供了HiddenHttpMethodFilter过滤器帮助我们将POST请求转换成PUT或DELETE请求。

该过滤器处理put和delete请求的条件为：

当前请求的请求方式必须是post
当前请求必须传输_method参数(表单中可以将此参数进行隐藏)

只有满足以上的两个基本条件，HiddenHttpMethodFilter过滤器就会将当前请求的方法转换成请求参数_method的值，因此请求参数_method的值才是最终的请求方式。

代码实现：

在web.xml中注册HiddenHttpMethodFilter

<!--配置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提供了两个过滤器(CharacterEncodingFilter和HiddenHttpMethodFilter)，在web.xml中注册时，必须先注册CharacterEncodingFilter，再注册HiddenHttpMethodFilter(Filter是根据过滤器在web.xml中的配置位置而决定执行的先后顺序(放在上面的过滤器先执行))。原因是：

在 CharacterEncodingFilter 中通过 request.setCharacterEncoding(encoding) 方法设置字符集的
request.setCharacterEncoding(encoding) 方法要求前面不能有任何获取请求参数的操作
而 HiddenHttpMethodFilter 恰恰有一个获取请求方式的操作：

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

所以在注册过滤器时，应当先写CharacterEncodingFilter，后写HiddenHttpMethodFilter

RESTful案例

实现的是一个非常常规的案例，与传统的CRUD一样，实现对员工信息的增删改查。

实现步骤

搭建环境：非常常规的搭建maven工程，这里便不过多赘述了
准备员工信息实体类

package code.controller.bean;

/**
 * @创建人 HeXin
 * @所属包 Employee
 * @所属项目 SpringMVC
 * @创建时间 2023/3/25 21:57
 * @描述 员工实体类
 */
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层，准备模拟数据

package code.controller.dao;

import code.controller.bean.Employee;
import org.springframework.stereotype.Repository;

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

/**
 * @创建人 HeXin
 * @所属包 EmplayeeDao
 * @所属项目 SpringMVC
 * @创建时间 2023/3/25 21:59
 * @描述 数据持久层
 */
@Repository
public class EmplayeeDao {
	private static Map<Integer, Employee> employees = null;
	
	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);
	}
}

配置springMVC.xml和web.xml

springMVC.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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">
    <!--    扫描组件-->
    <context:component-scan base-package="code"/>
    <!--    配置视图解析器-->
    <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
        <property name="order" value="1"/>
        <property name="characterEncoding" value="UTF-8"/>
        <property name="templateEngine">
            <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
                <property name="templateResolver">
                    <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">

                        <!-- 视图前缀 -->
                        <property name="prefix" value="/WEB-INF/templates/"/>

                        <!-- 视图后缀 -->
                        <property name="suffix" value=".html"/>
                        <property name="templateMode" value="HTML5"/>
                        <property name="characterEncoding" value="UTF-8" />
                    </bean>
                </property>
            </bean>
        </property>
    </bean>
    <!--配置视图控制器-->
    <mvc:view-controller path="/" view-name="index"></mvc:view-controller>
    <mvc:view-controller path="/toAdd" view-name="add"></mvc:view-controller>
    <!--开放对静态资源的访问-->
    <mvc:default-servlet-handler/>
    <!--开启mvc注解驱动-->
    <mvc:annotation-driven/>
</beans>

web.xml

<?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">
    <!--    配置编码过滤器-->
    <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>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!--配置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的前端控制器DispatcherServlet-->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springMVC.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

分析需要实现的功能并给出其清单

功能	URL地址	请求方式
访问首页	/	GET
查询员工全部数据	/employee	GET
删除员工数据	/employee/{id}	DELETE
添加员工数据	/toAdd	GET
执行保存	/employee	POST
更新员工数据	/employee/{id}	GET
执行更新	/employee	PUT

依次实现清单中的功能

访问首页

配置springMVC时，添加了视图控制器为首页，所以这一步很简单

<mvc:view-controller path="/" view-name="index"></mvc:view-controller>
<!--开启mvc注解驱动-->
<mvc:annotation-driven/>

实现index.html页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>
<a th:href="@{/employee}">查询所有员工信息</a><br/>
</body>
</html>

查询所有员工的数据

DAO中使用的是集合中的list来接收所有员工的数据，所以可以用list.html页面来实现数据的展示

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>员工信息</title>
    </head>
    <body>
        <table id="dataTable" border="1" cellspacing="0" cellpadding="0">
            <tr>
                <th colspan="5">员工个人信息</th>
            </tr>
            <tr>
                <th>ID</th>
                <th>LastName</th>
                <th>Email</th>
                <th>Gender</th>
                <th>Options (<a th:href="@{/toAdd}">add</a>)</th>
            </tr>
            <tr th:each="employee : ${employeelist}">
                <th th:text="${employee.id}"></th>
                <th th:text="${employee.lastName}"></th>
                <th th:text="${employee.email}"></th>
                <th th:text="${employee.gender}"></th>
                <th>
                    <a href="">update</a>
                    <a href="">delete</a>
                </th>
            </tr>
        </table>
    </body>
</html>

此时，需要控制器方法将获取到的数据进行共享看，html页面才能展示

@GetMapping("/employee")
public String getEmployees(Model model){
    Collection<Employee> employeelist = emplayeeDao.getAll();
    model.addAttribute("employeelist",employeelist);
    return "list";
}

删除员工数据

创建一个处理delete请求方式的表单

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

这里使用的是vue实现删除的点击事件，所以先将vue.js配置文件引入到web目录下的static中的js目录下。

将删除的超链接补充至上面的list.html中即可。

<a @click="deleteEmployee" th:href="@{'/employee/'+${employee.id}}">delete</a>

通过vue处理点击事件

<script type="text/javascript" th:src="@{/static/js/vue.js}"></script>
<script type="text/javascript">
  var vue = new Vue({
    el:"#dataTable",
    methods:{
      deleteEmployee:function(e){
        var deleteForm = document.getElementById("deleteForm");
        deleteForm.action = e.target.href;
        deleteForm.submit();//提交表单
        e.preventDefault(); //取消超链接的默认行为
      }
    }
  });
</script>

配置相应的控制器方法

@DeleteMapping(value = "/employee/{id}")
public String deleteEmployee(@PathVariable("id") Integer id){
    emplayeeDao.delete(id);
    return "redirect:/employee";
}

添加员工数据

配置view-controller

<mvc:view-controller path="/toAdd" view-name="add"></mvc:view-controller>

创建一个添加数据的html页面(add.html)

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Add Employee</title>
</head>
<body>

<form th:action="@{/employee}" method="post">
    lastName:<input type="text" name="lastName"><br>
    email:<input type="text" name="email"><br>
    gender:<input type="radio" name="gender" value="1">male
    <input type="radio" name="gender" value="0">female<br>
    <input type="submit" value="add"><br>
</form>

</body>
</html>

执行保存

续上述添加功能，这个是专门用于保存数据的控制器方法。

@PostMapping("/employee")
public String addEmployee(Employee employee){
    emplayeeDao.save(employee);
    return "redirect:/employee";
}

更新员工数据

更新的超链接(与删除的超链接一样，补充至list.html即可)

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

创建一个更新数据的html页面(update.html)

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Update Employee</title>
</head>
<body>

<form th:action="@{/employee}" method="post">
    <input type="hidden" name="_method" value="put">
    <input type="hidden" name="id" th:value="${employee.id}">
    lastName:<input type="text" name="lastName" th:value="${employee.lastName}"><br>
    email:<input type="text" name="email" th:value="${employee.email}"><br>
    <!--
        th:field="${employee.gender}"可用于单选框或复选框的回显
        若单选框的value和employee.gender的值一致，则添加checked="checked"属性
    -->
    gender:<input type="radio" name="gender" value="1" th:field="${employee.gender}">male
    <input type="radio" name="gender" value="0" th:field="${employee.gender}">female<br>
    <input type="submit" value="update"><br>
</form>

</body>
</html>

实现更新的控制器方法

//得到员工的数据，用于回显
@GetMapping("/employee/{id}")
public String getEmployee(@PathVariable("id")Integer id,Model model){
    Employee employee = emplayeeDao.get(id);
    model.addAttribute("employee",employee);
    return "update";
}
//执行更新的方法
@PutMapping("/employee")
public String updateEmployee(Employee employee){
    emplayeeDao.save(employee);
    return "redirect:/employee";
}

实例演示完毕~

HttpMessageConverter

HttpMessageConverter是报文信息转换器，将请求报文转换为Java对象，或将Java对象转换为响应报文。

HttpMessageConverter提供了两个注解和两个类型：@RequestBody、@ResponseBody、RequestEntity、ResponseEntity。下面将逐个进行学习

@RequestBody

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

代码演示

简单实现index.html页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>
<h1>首页</h1>
<form th:action="@{/requestBody}" method="post">
    账号：<input type="text" name="username"><br/>
    密码：<input type="text" name="password"><br/>
    <input type="submit" value="提交">
</form>
</body>
</html>

实现控制器方法

@RequestMapping("/requestBody")
public String testRequestBody(@RequestBody String requestBody) {
    System.out.println("requestBody：" + requestBody);
    return "target";
}

RequestEntity

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

代码演示

index.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>
<h1>首页</h1>
<form th:action="@{/requestEntity}" method="post">
    账号：<input type="text" name="username"><br/>
    密码：<input type="text" name="password"><br/>
    <input type="submit" value="提交">
</form>
</body>
</html>

实现的控制器方法

@RequestMapping("/requestEntity")
public String testRequestEntity(RequestEntity<String> requestEntity) {
    //当前requestEntity表示整个请求报文的信息
    System.out.println("请求头："+requestEntity.getHeaders());
    System.out.println("请求体："+requestEntity.getBody());
    return "target";
}

代码执行后，控制台输出的结果为：

请求头：[host:"localhost:8080", connection:"keep-alive", content-length:"31", cache-control:"max-age=0", sec-ch-ua:""Microsoft Edge";v="111", "Not(A:Brand";v="8", "Chromium";v="111"", 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/111.0.0.0 Safari/537.36 Edg/111.0.1661.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.7", sec-fetch-site:"same-origin", sec-fetch-mode:"navigate", sec-fetch-user:"?1", sec-fetch-dest:"document", referer:"http://localhost:8080/Day06/", 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", cookie:"Phpstorm-f2a8a013=0a654c8e-c701-4e2c-995d-1181337831c2; Idea-8e8be971=ddf03884-e789-4ac3-a498-7b3dea3ff308", Content-Type:"application/x-www-form-urlencoded;charset=UTF-8"]
请求体：username=admin&password=1111111

@ResponseBody(用的最多)

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

下面将使用HttpServletResponse和@ResponBody两种方式对比实现响应报文

代码实现

HttpServletResponse方式的超链接

<a th:href="@{/response}">通过ServletAPI的response对象响应浏览器数据</a>

@ResponseBody方式的超链接

<a th:href="@{/responseBody}">通过@ResponseBody对象响应浏览器数据</a>

HttpServletResponse方式的控制器方法

@RequestMapping("/response")
public void testResponse(HttpServletResponse response){
    try {
        response.getWriter().write("Hello Response!");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

@ResponseBody方式的控制器方法

@RequestMapping("/responseBody")
@ResponseBody
public String testResponseBody(){
    return "target";
}

SpringMVC处理json

@ResponseBody处理json的步骤：

导入jackson的依赖

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.12.1</version>
</dependency>

在SpringMVC的核心配置文件中开启mvc的注解驱动，此时在HandlerAdaptor中会自动装配一个消息转换器：MappingJackson2HttpMessageConverter，可以将响应到浏览器的Java对象转换为Json格式的字符串

<mvc:annotation-driven />

在处理器方法上使用@ResponseBody注解进行标识
将对象直接作为控制器方法的返回值返回，就会自动转换为JSON格式的字符串

@RequestMapping("/responseUser")
@ResponseBody
public User testResponseUser(){
    return new User("xiaoming","123456","xiaoming@sina.com","13677228229");
}

运行结果

{"username":"xiaoming","password":"123456","email":"xiaoming@sina.com","phone":"13677228229"}

SpringMVC处理ajax

请求的超链接

<div id="app">
    <a @click="axios" th:href="@{/axios}">SpringMVC处理ajax</a>
</div>

通过axios与vue处理点击事件

<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">
    new Vue({
        el:"#app",
        methods:{
            axios:function(e){
                axios({
                    method:"post",
                    url:e.target.href,
                    params:{
                        username:"admin",
                        password:"123456"
                    }
                }).then(function(response){
                    alert(response.data);
                });
                e.preventDefault();
            }
        }
    });
</script>

控制器方法

@RequestMapping("/axios")
@ResponseBody
public String testAxios(String username,String password){
    System.out.println(username+","+password);
    return "Hello Axios!";
}

@RestController

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

ResponseEntity

ResponseEntity用于控制器方法的返回值类型，该控制器方法的返回值就是响应到浏览器的响应报文。其使用的场景是文件下载。

文件的上传与下载

文件的下载

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

代码实现

用ResponseEntity实现下载

@RequestMapping("/download")
public ResponseEntity<byte[]> testDownload(HttpSession session){
    //获取ServletContext对象
    ServletContext servletContext = session.getServletContext();
    //获取服务器中文件的真实路径
    String realPath = servletContext.getRealPath("/static/img/1.png");
    byte[] buffer;
    MultiValueMap<String,String> headers;
    ResponseEntity<byte[]> responseEntity = null;
    try {
        //创建输入流
        FileInputStream inputStream = new FileInputStream(realPath);
        //创建字节数组
        buffer = new byte[inputStream.available()];
        //将流读到字节数组中
        inputStream.read(buffer);
        //创建HttpHeaders对象设置影响头信息
        headers = new HttpHeaders();
        //设置要下载方式以及下载文件的名字(attachment：以附件的形式下载)
        headers.add("Content-Disposition","attachment;filename=1.png");
        //设置响应状态码
        HttpStatus status = HttpStatus.OK;
        //创建ResponseEntity对象
        responseEntity = new ResponseEntity<byte[]>(buffer, headers, status);
        inputStream.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return responseEntity;
}

文件上传

文件上传要求form表单的请求方式必须为post，并且添加属性enctype=“multipart/form-data”

<form th:action="@{/upload}" method="post" enctype="multipart/form-data">
    图片：<input type="file" name="photo"><br/>
    <input type="submit" value="上传">
</form>

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

上传步骤

添加依赖

<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
</dependency>

在springMVC.xml中添加配置

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

实现控制器方法

@RequestMapping("/upload")
public String testUpload(MultipartFile photo,HttpSession session){
    //获取上传的文件名
    String filename = photo.getOriginalFilename();
    //获取上传文件的后缀名
    String suffixName = filename.substring(filename.lastIndexOf("."));
    //将UUID作为文件名
    String uuid = UUID.randomUUID().toString().replaceAll("-", "");
    //将uuid和后缀名拼接后的结果作为最终的文件名
    filename = uuid + suffixName;
    //通过ServletContext获取服务器中的photo目录的路径
    ServletContext context = session.getServletContext();
    String photoPath = context.getRealPath("photo");
    File file = new File(photoPath);
    //判断photoPath所对应的路径是否存在
    if(!file.exists()){
        //若不存在则创建目录
        file.mkdirs();
    }
    //最终文件上传的地址
    String finalPath = photoPath+File.separator + filename;
    try {
        photo.transferTo(new File(finalPath));
    } catch (IOException e) {
        e.printStackTrace();
    }
    return "target";
}

拦截器

拦截器的配置

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

SpringMVC中的拦截器需要实现HandlerInterceptor接口

SpringMVC的拦截器必须在SpringMVC的配置文件(springMVC.xml)中进行配置：

<!--配置拦截器-->
<mvc:interceptors>
    <!--这两种方式会对DispatcherServlet处理的所有请求进行拦截-->
    <bean class="code.interceptors.MyInterceptor"></bean>
    <ref bean="myInterceptor"></ref>
    <!--此方法可以设置当前的拦截路径-->
    <mvc:interceptor>
        <!--拦截路径：/**表示拦截所有页面-->
        <mvc:mapping path="/**"/>
        <!--排除拦截-->
        <mvc:exclude-mapping path="/"/>
        <bean class="code.interceptors.MyInterceptor"></bean>
    </mvc:interceptor>
</mvc:interceptors>

抽象方法

SpringMVC中的拦截器有三个抽象方法：

preHandle：控制器方法执行之前执行preHandle()，其boolean类型的返回值表示是否拦截或放行，返回true为放行，即调用控制器方法；返回false表示拦截，即不调用控制器方法

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

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

代码演示

package code.interceptors;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @创建人 HeXin
 * @所属包 FirstInterceptor
 * @所属项目 SpringMVC
 * @创建时间 2023/3/27 11:11
 * @描述  拦截器
 */
@Component
public class MyInterceptor implements HandlerInterceptor {
	@Override
	public boolean preHandle (HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
		System.out.println("FirstInterceptor中的preHandle方法");
		//返回值表示是否放行
		return false;
	}
	
	@Override
	public void postHandle (HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
		System.out.println("FirstInterceptor中的postHandle方法");
	}
	
	@Override
	public void afterCompletion (HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
		System.out.println("FirstInterceptor中的afterCompletion方法");
	}
}

多个拦截器的执行顺序

此时根据多个拦截器的preHandle的返回值分为了两种情况：

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

此时多个拦截器的执行顺序和拦截器在SpringMVC的配置文件的配置顺序有关，此时的preHandle()会按照配置的顺序执行，而postHandle()和afterComplation()会按照配置的反序执行。

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

preHandle()返回false和它之前的拦截器的preHandle()都会执行，postHandle()都不执行，返回false的拦截器之前的拦截器的afterComplation()会执行

异常处理器

当控制器方法在执行过程中发生了异常，此时发生的这个异常就将由异常处理器处理。

异常处理器分为两种，一种是基于配置的异常处理，另一种是基于注解的异常处理。

下面将分别进行学习

基于配置的异常处理

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

HandlerExceptionResolver接口的实现类有：DefaultHandlerExceptionResolver(默认的异常处理器，根据各个不同类型的异常，返回不同的异常视图)和SimpleMappingExceptionResolver(简单的映射异常处理器，可以通过配置异常类和view的关系来解析异常)

SpringMVC提供了自定义的异常处理器SimpleMappingExceptionResolver，需要在springMVC.xml中进行配置，配置如下：

<!--配置异常处理-->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <property name="exceptionMappings">
        <props>
            <!--key中为指定异常类型的全类名
双标签中(value值)为一个新的视图名称(代表出现该指定异常后，跳转到的页面)-->
            <prop key="java.lang.ArithmeticException">error</prop>
        </props>
    </property>
    <!--设置可以将异常信息放置请求域中(形参名为value->e)的键，便于获取-->
    <property name="exceptionAttribute" value="e"></property>
</bean>

基于注解的异常处理

只需要一个控制器方法即可，非常的简便，所以推荐使用注解方式进行异常处理，尤其是@ExceptionHandler注解，使用的次数是最多的。

//@ControllerAdvice将当前类标识为异常处理的组件
@ControllerAdvice
public class ExceptionController {
    //@ExceptionHandler用于设置所标识方法处理的异常
    @ExceptionHandler(ArithmeticException.class)
    //ex表示当前请求处理中出现的异常对象
    public String handleArithmeticException(Exception e, Model model){
        model.addAttribute("e", e);
        return "error";
    }

}

注解配置SpringMVC

每次在创建SpringMVC工程的时候都需要配置web.xml和SpringMVC.xml这两个配置文件，效率很低。所以接下来将学习使用配置类和注解代替web.xml和SpringMVC配置文件的功能。

实现步骤分为四步：

创建初始化类(代替web.xml)
创建SpringConfig配置类(代替Spring的配置文件)
创建WebConfig配置类(代替SpringMVC的配置文件)

下面将逐个进行实现

创建初始化类

在Servlet3.0环境中，容器会在类路径中查找实现javax.servlet.ServletContainerInitializer接口的类，如果找到的话就用它来配置Servlet容器。
Spring提供了这个接口的实现，名为SpringServletContainerInitializer，这个类反过来又会查找实现WebApplicationInitializer的类并将配置的任务交给它们来完成。Spring3.2引入了一个便利的WebApplicationInitializer基础实现，名为AbstractAnnotationConfigDispatcherServletInitializer，当我们的类扩展了AbstractAnnotationConfigDispatcherServletInitializer并将其部署到Servlet3.0容器的时候，容器会自动发现它，并用它来配置Servlet上下文。

代码演示

package config;

import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.filter.HiddenHttpMethodFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

import javax.servlet.Filter;

/**
 * @创建人 HeXin
 * @所属包 WebInit
 * @所属项目 SpringMVC
 * @创建时间 2023/3/28 11:30
 * @描述 web工程的初始化类
 */
public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {
	/**
	    * @Description: 指定Spring的配置类
	    * @CreateTime: 2023/3/28 11:33
	    * @Author: HeXin
	    */
	@Override
	protected Class<?>[] getRootConfigClasses () {
		//将配置类放入数组中返回
		return new Class[]{SpringConfig.class};
	}
	/**
	    * @Description: 指定SpringMVC的配置类
	    * @CreateTime: 2023/3/28 11:33
	    * @Author: HeXin
	    */
	@Override
	protected Class<?>[] getServletConfigClasses () {
		return new Class[]{WebConfig.class};
	}
	/**
	    * @Description:指定DispatcherServlet的映射规则(即url-pattern)
	    * @CreateTime: 2023/3/28 11:34
	    * @Author: HeXin
	    */
	@Override
	protected String[] getServletMappings () {
		return new String[]{"/"};
	}
	/**
	    * @Description: 注册过滤器
	    * @CreateTime: 2023/3/28 11:44
	    * @Author: HeXin
	    */
	@Override
	protected Filter[] getServletFilters () {
		CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
		characterEncodingFilter.setEncoding("UTF-8");
		characterEncodingFilter.setForceResponseEncoding(true);
		HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
		return new Filter[]{characterEncodingFilter,hiddenHttpMethodFilter};
	}
}

创建SpringConfig配置类

废话不多说，直接上代码

@Configuration
public class SpringConfig {
	//ssm整合之后，spring的配置信息将会写在此类中
}

创建WebConfig配置类

这里需要实现WebMvcConfigurer接口中的一些方法，才能完成相应的配置

代码实现

package config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.*;
import org.springframework.web.servlet.handler.SimpleMappingExceptionResolver;
import org.thymeleaf.spring5.SpringTemplateEngine;
import org.thymeleaf.spring5.view.ThymeleafViewResolver;
import org.thymeleaf.templatemode.TemplateMode;
import org.thymeleaf.templateresolver.ITemplateResolver;
import org.thymeleaf.templateresolver.ServletContextTemplateResolver;

import java.util.List;
import java.util.Properties;

/**
 * @创建人 HeXin
 * @所属包 WebConfig
 * @所属项目 SpringMVC
 * @创建时间 2023/3/28 11:40
 * @描述 代替SpringMVC的配置文件(SpringMVC配置类)
 */
//将当前类标识为一个配置类
@Configuration
//扫描组件
@ComponentScan
//MVC的注解驱动
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
	/**
	 * @Description: 使用默认的servlet处理静态资源
	 * @CreateTime: 2023/3/28 12:20
	 * @Author: HeXin
	 */
	@Override
	public void configureDefaultServletHandling (DefaultServletHandlerConfigurer configurer) {
		configurer.enable();
	}
	
	/**
	    * @Description: 配置拦截器
	    * @CreateTime: 2023/3/28 12:17
	    * @Author: HeXin
	    */
	@Override
	public void addInterceptors (InterceptorRegistry registry) {
		FirstInterceptor firstInterceptor = new FirstInterceptor();
		registry.addInterceptor(firstInterceptor).addPathPatterns("/**");
	}
	
	/**
	    * @Description: 配置文件上传解析器
	    * @CreateTime: 2023/3/28 12:20
	    * @Author: HeXin
	    */
	@Bean
	public CommonsMultipartResolver multipartResolver(){
		return new CommonsMultipartResolver();
	}
	/**
	    * @Description: 配置视图控制器
	    * @CreateTime: 2023/3/28 12:17
	    * @Author: HeXin
	    */
	@Override
	public void addViewControllers (ViewControllerRegistry registry) {
		registry.addViewController("/").setViewName("index");
	}
	
	/**
	    * @Description: 配置异常映射
	    * @CreateTime: 2023/3/28 12:18
	    * @Author: HeXin
	    */
	@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("e");
		resolvers.add(exceptionResolver);
	}
	
	/**
	    * @Description: 配置视图解析器
	    * @CreateTime: 2023/3/28 11:57
	    * @Author: HeXin
	    */
	@Bean
	public ITemplateResolver templateResolver(){
		/**
		    * @Description: 配置生成的模板解析器
		    * @CreateTime: 2023/3/28 12:00
		    * @Author: HeXin
		    */
		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;
	}
	
	@Bean
	public SpringTemplateEngine templateEngine(ITemplateResolver templateResolver) {
		/**
		    * @Description: 生成模板引擎并为模板引擎注入模板解析器
		    * @CreateTime: 2023/3/28 12:05
		    * @Author: HeXin
		    */
		SpringTemplateEngine templateEngine = new SpringTemplateEngine();
		templateEngine.setTemplateResolver(templateResolver);
		return templateEngine;
	}
	
	@Bean
	public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
		/**
		    * @Description: 生成视图解析器并为解析器注入模板引擎
		    * @CreateTime: 2023/3/28 12:21
		    * @Author: HeXin
		    */
		ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
		viewResolver.setCharacterEncoding("UTF-8");
		viewResolver.setTemplateEngine(templateEngine);
		return viewResolver;
	}
}

SpringMVC执行流程

springMVC执行流程分为四个部分进行学习：常用组件、初始化过程

SpringMVC常用组件

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

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

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

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

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

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

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

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

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

作用：进行视图解析，得到相应的视图，例如：ThymeleafView、InternalResourceView(转发)、RedirectView(重定向)

View：视图

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

DispatcherServlet初始化过程

DispatcherServlet 本质上是一个 Servlet，所以天然的遵循 Servlet 的生命周期。所以宏观上是 Servlet 生命周期来进行调度。
在这里插入图片描述

初始化WebApplicationContext

其所在类：org.springframework.web.servlet.FrameworkServlet

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;
}

创建WebApplicationContext

其所在类：org.springframework.web.servlet.FrameworkServlet

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;
}

DispatcherServlet初始化策略

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

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

protected void initStrategies(ApplicationContext context) {
   initMultipartResolver(context);
   initLocaleResolver(context);
   initThemeResolver(context);
   initHandlerMappings(context);
   initHandlerAdapters(context);
   initHandlerExceptionResolvers(context);
   initRequestToViewNameTranslator(context);
   initViewResolvers(context);
   initFlashMapManager(context);
}

由此可以看出，如果DispatcherServlet中所有的组件都会在第一次访问时初始化，如果不将一些功能提前初始化，则第一次访问的速度会非常的慢。

DispatcherServlet调用组件处理请求

FrameworkServlet重写HttpServlet中的service()和doXxx()，这些方法中调用了processRequest(request, response)

所在类：org.springframework.web.servlet.FrameworkServlet

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);
    }
}

doService()

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

@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);
        }
    }
}

doDispatch()

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

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);
            }
        }
    }
}

processDispatchResult()

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);
    }
}

SpringMVC的执行流程

将从头(服务器启动)分析其执行流程：

用户向服务器发送请求，请求被SpringMVC 前端控制器 DispatcherServlet捕获。
DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI），判断请求URI对应的映射：

此时存在两种情况：

存在映射：
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. 将渲染结果返回给客户端。
不存在映射
1. 再判断是否配置了mvc:default-servlet-handler
2. 如果没配置，则控制台报映射查找不到，客户端展示404错误。
3. 如果有配置，则访问目标资源（一般为静态资源，如：JS,CSS,HTML），找不到客户端也会展示404错误。

Onism_DreamBoat

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC全解

MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分 M：Model，模型层，指工程中的JavaBean，作用是处理数据 JavaBean分为两类： V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据 C：Controller，控制层，指工程中的servlet，作用是接收请求和响应浏览器 MVC的工作流程：用户通过视图层发送请求到服务器，在服务器中请求被Controller接收，Controller调用相应的Model层处理请求，处理完毕将结果返回
复制链接

扫一扫