SpringMVC

Java SSM SpringMVC
SSM
发布日期:   2024-03-17
更新日期:   2024-05-03
文章字数:   9.1k
阅读时长:   39 分
阅读次数:  

SpringMVC

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

SpringMVC 的特点

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

开发环境

相关依赖：

<dependencies>
    <!-- 引入web框架 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>6.0.6</version>
    </dependency>

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

    <!-- servletAPI -->
    <dependency>
    	<groupId>jakarta.servlet</groupId>
    	<artifactId>jakarta.servlet-api</artifactId>
    	<version>6.0.0</version>
    </dependency>

    <!-- spring和thymeleaf整合包 -->
    <dependency>
        <groupId>org.thymeleaf</groupId>
        <artifactId>thymeleaf-spring6</artifactId>
        <version>3.1.2.RELEASE</version>
    </dependency>

</dependencies>

配置web.xml，默认配置方式（配置文件位置默认，在WEB-INF下）如下：

<?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">
	<!-- 配置SpringMVC前端控制器，对浏览器发送的请求进行统一处理 -->
	<servlet>
		<servlet-name>SpringMVC</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>SpringMVC</servlet-name>
		<!--
			/可以匹配的请求是/login或.js或.css方式的请求路径
			但是/不能匹配.jsp请求路径的请求
		-->
		<url-pattern>/</url-pattern>
	</servlet-mapping>
</web-app>

扩展配置方式如下：

<?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">
	<!-- 配置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>
		<!-- 提前前端控制器初始化时间 -->
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>SpringMVC</servlet-name>
		<!--
			/可以匹配的请求是/login或.js或.css方式的请求路径
			但是/不能匹配.jsp请求路径的请求
		-->
		<url-pattern>/</url-pattern>
	</servlet-mapping>
</web-app>

SpringMVC 入门

首先，按照上方的配置文件进行配置。

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

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

控制器需要交由 Spring 容器管理。

@Controller
public class HelloController {

}

此外，还需要配置视图解析器：

<!-- 视图解析器 -->
<bean id="viewResolver" class="org.thymeleaf.spring6.view.ThymeleafViewResolver">
    <property name="order" value="1"/>
    <property name="characterEncoding" value="UTF-8"/>
    <property name="templateEngine" ref="templateEngine"/>
</bean>

<bean id="templateResolver"
      class="org.thymeleaf.spring6.templateresolver.SpringResourceTemplateResolver">
    <property name="prefix" value="/WEB-INF/templates/" />
    <property name="suffix" value=".html" />
    <property name="templateMode" value="HTML" />
    <property name="cacheable" value="true" />
</bean>

<bean id="templateEngine"
      class="org.thymeleaf.spring6.SpringTemplateEngine">
    <property name="templateResolver" ref="templateResolver" />
    <property name="enableSpringELCompiler" value="true" />
</bean>

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

控制器编写具体控制方法：

@Controller
public class HelloController {
    //请求路径(/WEB-INF/templates/index.html)
    //使用@RequestMapping配置映射路径
    @RequestMapping("/")
    public String index() {
        //返回视图名称
        return "index";
    }
}

总结

浏览器发送请求，若请求地址符合前端控制器的 url-pattern，该请求就会被前端控制器 DispatcherServlet 处理。

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

@RequestMapping 注解

@RequestMapping 注解的作用就是将请求和处理请求的控制器方法关联起来，建立映射关系。SpringMVC 接收到指定的请求，就会来找到在映射关系中对应的控制器方法来处理这个请求。

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

如果映射路径冲突，会报错。

@Controller
@RequestMapping("/hello")
//加在方法上，此时映射路径为/hello/testRequestMapping
public class RequestMappingController {
    @RequestMapping("/testRequestMapping")
    //加载方法上，映射路径为/testRequestMapping
    public String success() {
        return "success";
    }
}

Value 属性

在 @RequestMapping 注解中，Value 属性是一个字符串数组。Value 属性必须设置。

@Controller
@RequestMapping("/hello")
public class RequestMappingController {
    //通过以下三种映射路径都可以访问到success.html
    @RequestMapping({"/test", "/target", "/testRequestMapping"})
    public String success() {
        return "success";
    }
}

Method 属性

Method 属性通过请求的请求方式（get 或 post）匹配请求映射，默认匹配任何请求。

@Controller
@RequestMapping("/hello")
public class RequestMappingController {
    @RequestMapping(
            value = {"/test", "/target", "/testRequestMapping"},
            method = {RequestMethod.POST})//只允许POST方法请求，否则报405请求不匹配
    public String success() {
        return "success";
    }
}

结合请求方式的派生注解

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

  • 处理 get 请求的映射：@GetMapping。
  • 处理 post 请求的映射：@PostMapping。
  • 处理 put 请求的映射：@PutMapping。
  • 处理 delete 请求的映射：DeleteMapping。

常用的请求有上述四个，但是目前浏览器只支持 get 和 post，若在 form 表单提交时，为 method 属性设置了其他的提交方式，则默认使用 get 请求。

@Controller
@RequestMapping("/hello")
public class RequestMappingController {
    @PostMapping({"/test", "/target", "/testRequestMapping"})
    public String success() {
        return "success";
    }
}

Params 属性（了解）

@RequestMapping 注解的 params 属性通过请求的请求参数匹配请求映射。

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

  • param：求请求映射所匹配的请求必须携带 param 请求参数。
  • !param：求请求映射所匹配的请求必须不能携带 param 请求参数。
  • param=value：求请求映射所匹配的请求必须携带 param 请求参数且 param = value。
  • param!=value：求请求映射所匹配的请求必须携带 param 请求参数但是 param != value。
@Controller
@RequestMapping("/hello")
public class RequestMappingController {
    @RequestMapping(
            value = {"/test", "/target", "/testRequestMapping"},
            //要求必须携带username参数，不能携带password参数
            //必须携带值为admin的nickname参数
            //必须携带age，但是age的参数不能为20
            params = {"username", "!password", "nickname=admin", "age!=20"}
    )

    public String success() {
        return "success";
    }
}

Headers 属性（了解）

@RequestMapping 注解的 headers 属性通过请求的请求头信息匹配请求映射。

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

  • header：求请求映射所匹配的请求必须携带 header请求头信息。
  • !header：求请求映射所匹配的请求必须不能携带 header 请求头信息。
  • header=value：求请求映射所匹配的请求必须携带 header 请求头信息且 header = value。
  • header!=value：求请求映射所匹配的请求必须携带 header 请求头信息但是 header != value。

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

Ant 风格路径

  • ?：表示任意单个字符。
  • *：表示任意的 0 个或多个字符。
  • **：表示任意的一层或多层目录。

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

@RequestMapping("/a?/testAnt")	//使用?匹配单个任意字符
public String testAnt() {
    return "success";
}

@RequestMapping("/a*/testAnt")	//使用*匹配0个或者多个字符
public String testAnt() {
    return "success";
}

@RequestMapping("/**/testAnt")	//使用**匹配多层目录
public String testAnt() {
    return "success";
}

路径中的占位符（重点）

原始方式：/deleteUser?id=1。

rest 方式：/deleteUser/1。

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

@RequestMapping("/testRest/{id}/{username}")
public String testRest(@PathVariable("id") String id, 
                       @PathVariable("username") String username) {
    System.out.println("id=" + id + " username=" + username);
    return "success";
}

获取请求参数

通过 servletAPI 获取

将 HttpServletRequest 作为控制器方法的形参，可以调用相关的 API 来获取参数。

@Controller
public class RequestParamController {
    @RequestMapping("/requestParam")
    //如果springmvc检测到这里有一个request对象，会把对应HttpServlet传过来
    public String testParam(HttpServletRequest request) {
        //获得单个参数值
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        //获得多个参数值（数组形式）
        String[] hobbies = request.getParameterValues("hobbies");
        System.out.println(username);
        System.out.println(password);
        System.out.println(Arrays.toString(hobbies));
        return "success";
    }
}

通过方法形参直接获取

@RequestMapping("/testParam")
//只要保证参数的key和形参的名称一致，就可以直接赋值
public String testParam(String username,
                        String password,
                        String[] hobbies) {
    System.out.println(username);
    System.out.println(password);
    System.out.println(Arrays.toString(hobbies));
    return "success";
}

@RequestParam

@RequestMapping("/testAnnotation")
//使用RequestParam使得提交的参数名和方法的参数名产生映射关系
public String testAnnotation(
        @RequestParam("user_name") String username,
    	//require=false意为这个参数可传可不传
    	//defaultValue的值是默认值，当参数不传入或者值为空的时候便默认填入这个值
        @RequestParam(value = "password", required = false) String password,
        String[] hobbies) {
    System.out.println(username);
    System.out.println(password);
    System.out.println(Arrays.toString(hobbies));
    return "success";
}

@RequestHeader

该注解是将请求头信息和形参创建映射关系。一共有三个属性：value、required、defaultValue，用法同 @RequestParam。

@CookieValue

该注解是将 cookie 数据和形参创建映射关系。一个有三个属性：value、required、defaultValue，用法同 @RequestParam。

通过 POJO 获取请求参数

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

乱码问题

有两种乱码问题，一种是 get 请求乱码，另一种是 post 请求的乱码。

get 请求的乱码是 Tomcat 导致的，需要去修改 Tomcat 的配置文件，在 tomcat/conf/server.xml文件第68行的标签中添加 URIencoding="GBK"，即更改后端的解码方式。

post 请求需要在过滤器中设置后端解码方式，因为服务器对象生成顺序是：监听器、过滤器、Servlet。我们需要在过滤器中设置对应的encoding，使得后面 Servlet 解码的时候按照指定方式解码，具体操作为在web.xml文件中添加如下配置：

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

解决乱码的过滤器需要放在最前面，否则会因为可能获取的参数而导致过滤器失效！

域对象共享数据

cookie 是一次请求中的，session 是一次会话中的（session 的关闭之和浏览器有关系。当浏览器不关闭的时候，服务器关闭，session 会被序列化到磁盘中，这个叫 session 的钝化；当服务器重启时，session 的数据从磁盘读入服务器，这个叫 session 的活化），servletcontext 可以跨多个会话。

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

@RequestMapping("/setAttribute")
public String testServletAPI1(HttpServletRequest req) {
    //使用原生servlet向request域对象共享数据
    req.setAttribute("username", "admin");
    req.setAttribute("password", "123456");
    return "success";
}

使用 thymeleaf 直接打印域对象内容：

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>跳转成功</h1><br>
<p th:text="${username}"></p><br>
<p th:text="${password}"></p>
</body>
</html>

使用 ModelAndView 向 request 域对象共享数据（建议使用）

Model 指向请求域中共享数据，View 指的是视图功能，可以进行页面跳转。

@RequestMapping("/testModelAndView")
//将ModelAndView返回给前端控制器，才能进行解析
public ModelAndView testModelAndView() {
    ModelAndView mav = new ModelAndView();
    //处理模型数据，即向请求域request共享数据
    mav.addObject("username", "admin");
    mav.addObject("password", "123456");
    //设置视图名称，即进行页面跳转
    mav.setViewName("success");
    return mav;
}

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

@RequestMapping("/testModel")
public String testModel(Model model) {
    model.addAttribute("username", "zhangsan");
    model.addAttribute("password", "890");
    return "success";
}

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

@RequestMapping("/testMap")
public String testMap(Map<String, String> map) {
    //往map中插入的数据，就是往域对象中存放的数据
    map.put("username", "lisi");
    map.put("password", "789");
    return "success";
}

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

@RequestMapping("/testModelMap")
public String testModelMap(ModelMap modelMap) {
    modelMap.addAttribute("username", "wangwu");
    modelMap.addAttribute("password", "abc");
    return "success";
}

Model、Map、ModelMap 的关系

三者本质上都是 BindingAwareModelMap 类型：

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

但是不管怎样，最后都会把数据封装到 ModelAndView 中。

向 session 域共享数据

向 session 域共享数据，推荐使用原生的 servlet，即使用 HttpSession。

@RequestMapping("/testSession")
public String testSession(HttpSession session) {
    session.setAttribute("username", "zhaoliu");
    session.setAttribute("password", "689");
    return "success";
}

使用 thymeleaf 直接打印域对象内容：

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>跳转成功</h1><br>
<p th:text="${session.username}"></p><br>
<p th:text="${session.password}"></p>
</body>
</html>

向 application 域共享数据

依旧推荐使用原生的 servelt，即使用 ServletContext。

@RequestMapping("/testApplication")
public String testApplication(HttpSession session) {
    ServletContext servletContext = session.getServletContext();
    servletContext.setAttribute("username", "admin");
    servletContext.setAttribute("password", "444");
    return "success";
}

使用 thymeleaf 直接打印域对象内容：

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>跳转成功</h1><br>
<p th:text="${application.username}"></p><br>
<p th:text="${application.password}"></p>
</body>
</html>

SpringMVC 的视图

SpringMVC 中的视图是 View 接口，视图的作用渲染数据，将模型 Model 中的数据展示给用户。SpringMVC 视图的种类很多，默认有转发视图和重定向视图。

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

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

ThymeleafView

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

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

转发视图

SpringMVC 中默认的转发视图是 InternalResourceView。

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

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

例如：forward:/，forward:/employee。

@RequestMapping("/testForward")
public String testForward() {
    //利用forward进行视图的请求转发
    return "forward:/testThymeleafView";
}

重定向视图

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

例如：redirect:/，redirect:/employee。

@RequestMapping("/testRedirect")
public String testRedirect() {
    //利用redirect进行视图的重定向
    return "redirect:/testThymeleafView";
}

视图控制器

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

在 spring 的配置文件中添加如下格式的配置代码即可使用视图控制器（需要在头部添加 mvc 的命名空间）：

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

注意：如果在配置文件中配置了view-controller，那么在控制器中写的所有请求映射将全部失效。为此，我们需要开启注解驱动：

<mvc:annotation-driven/>

InternalResourceViewResolver

在用 JSP 进行页面跳转的时候可以使用该视图解析器。

RESTFul

RESTFul 是一种软件开发的风格、架构。

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

  • 资源：资源是一种看待服务器的方式，即，将服务器看作是由很多离散的资源组成。一个文件、页面、图片都可以叫做资源。
  • 资源的状态：指当前的表现形式。例如 HTML / XML / JSON / 纯文本 / 图片 / 视频 / 音频等。
  • 状态转移：客户端和服务端之间资源的传递。

RESTFul 的实现

RESTFul 服务往往利用 HTTP 动词实现资源的创建、读取、更新和删除操作（CRUD）：

  • GET：读取或检索资源。
  • POST：创建新资源。
  • PUT：更新现有资源。
  • DELETE：删除资源。

可以理解为，同一个请求地址，不同的请求方式，调用不同的CRUD操作。我们不再使用?来传参数，均使用占位符 + /的方式来传参。

操作 传统方式 REST 风格
查询 getUserById?id=1 user/1 + GET 请求
保存 saveUser user + POST 请求
删除 deleteUser?id=1 user/1 + DELETE 请求
更新 updateUser user + PUT 请求

处理 GET 和 POST 请求

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<!-- 超链接处理get请求 -->
<a href="/user">查询所有用户信息</a>
<a href="/user/1">根据用户id查询信息</a>
<!-- 表单处理post请求 -->
<form action="user" method="post">
    用户名:<input type="text" name="username"><br>
    密码:<input type="password" name="password"><br>
    <input type="submit" name="添加"><br>
</form>
</body>
</html>
@Controller
public class UserController {
    /**
     * 使用RESTFul模拟用户资源的CRUD
     * /user    GET 查询所有用户信息
     * /user/1  GET 根据id查询用户信息
     * /user    POST 添加用户信息
     * /user/1  DELETE 根据id删除用户信息
     * /user    PUT 更新用户信息
     */
    @RequestMapping(value = {"/user"}, method = RequestMethod.GET)
    public String getAllUser() {
        System.out.println("查询所有用户信息");
        return "success";
    }

    //利用占位符获取id
    @RequestMapping(value = {"/user/{id}"}, method = RequestMethod.GET)
    public String getSingleUser(@PathVariable String id) {
        System.out.println("查询单个用户信息" + id);
        return "success";
    }

    //方法形参直接获取参数
    @RequestMapping(value = {"/user"}, method = RequestMethod.POST)
    public String addUser(String username, String password) {
        System.out.println("添加用户信息" + username + " " + password);
        return "success";
    }
}

处理 PUT 和 DELETE 请求

超链接是处理 GET 请求，表单可以处理 POST 请求，但是表单在处理 PUT 和 DELETE 请求的时候会默认转换成 GET 请求。所以，如果要处理 PUT 和 DELETE 请求，我们需要额外的操作。

使用 HiddenHttpMethodFilter 来进行请求过滤，即可发送对应请求。

在web.xml下进行配置：

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

源代码分析：

private static final List<String> ALLOWED_METHODS;
public static final String DEFAULT_METHOD_PARAM = "_method";
private String methodParam = "_method";

static {
    ALLOWED_METHODS = List.of(HttpMethod.PUT.name(), 
                              HttpMethod.DELETE.name(), 
                              HttpMethod.PATCH.name());
}

protected void doFilterInternal(HttpServletRequest request, 
                                HttpServletResponse response, 
                                FilterChain filterChain) 
    throws ServletException, IOException {
    HttpServletRequest requestToUse = request;
    //首先请求必须得是POST
    if ("POST".equals(request.getMethod()) && 
        request.getAttribute("jakarta.servlet.error.exception") == null) {
        //获取_method参数进行判定
        String paramValue = request.getParameter(this.methodParam);
        if (StringUtils.hasLength(paramValue)) {
            String method = paramValue.toUpperCase(Locale.ENGLISH);
            //如果_method的参数符合PUT、DELETE、PATCH，则会更换request对象
            if (ALLOWED_METHODS.contains(method)) {
                requestToUse = new HttpMethodRequestWrapper(request, method);
            }
        }
    }

    //最终放行
    filterChain.doFilter((ServletRequest)requestToUse, response);
    
    //所以，如果要发送PUT或者DELETE请求，除了用ajax(对部分浏览器可能会失效)
    //还可以在提交POST请求，并携带一个_method参数
}

html 代码如下：

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<!-- 利用post请求+_method发送put和delete请求 -->
<form action="user/1" method="post">
    <!-- 利用hidden和_method发送真正的put请求 -->
    <input type="hidden" name="_method" value="put"/>
    <input type="submit" value="修改"/>
</form>
</body>
</html>

HttpMessageConverter

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

HttpMessageConverter 提供了两个注解和两个类型：@RequestBody，@ResponseBody，RequestEntity， ResponseEntity。

@RequestBody

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

@Controller
public class HttpController {
    @PostMapping("/testRequestBody")
    public String testRequestBody(@RequestBody String requestBody) {
        System.out.println(requestBody);
        //username=zhangsan&password=123
        return "success"; 
    }
}

RequestEntity

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

@PostMapping("/testRequestEntity")
public String testRequestEntity(RequestEntity<String> requestEntity) {
    System.out.println(requestEntity.getHeaders()); //获取请求头
    System.out.println(requestEntity.getBody());    //获取请求体
    return "success";
}

@ResponseBody（重点）

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

//原生servlet api响应报文到浏览器
@RequestMapping("/testResponse")
public void testResponse(HttpServletResponse res) throws IOException {
    res.getWriter().write("hello world");
}

//使用注解将hello world写入响应报文
@RequestMapping("/testResponseBody")
@ResponseBody
public String testResponseBody() {
    return "hello world";
}

处理 JSON

需要引入 jackson 依赖：

<!-- jackson依赖 -->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.16.1</version>
</dependency>

如果是配置文件，还需要加入注解驱动：

<mvc:annotation-driven />

接着加上 @ResponseBody 注解返回对象即可：

@RequestMapping("/testResponseUser")
@ResponseBody
public User testResponseUser() {
    return new User(1001, "admin", "123456", 18, "男");
}

处理 ajax

ajax 就是页面不发生跳转的情况下进行页面数据交互：

@RequestMapping("/testAxios")
@ResponseBody
public String testAxios(String username, String password) {
    //输出前端传递过来的参数
    System.out.println(username);
    System.out.println(password);
    //向前端写出json串
    return "hello world";
}

@RestController

考虑到后期使用 SpringBoot 做微服务项目，每一个小型项目之间都要进行数据的交互，这使得 @ResponseBody 注解的使用频率大幅提高。而 @RestController 是一个复合注解，标识在控制器的类上，就相当于为类添加了 @Controller 注解，使得该类的每一个方法都添加上 @ResponseBody 注解。

ResponseEntity

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

文件上传和下载

文件下载

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

@Controller
public class FileUpAndDownController {
    @RequestMapping("/testDown")
    public ResponseEntity<byte[]> testResponseEntity(HttpSession session) 
        throws IOException {
        //获取ServletContext
        ServletContext servletContext = session.getServletContext();
        //获取资源在服务器的真实部署路径
        String realPath = servletContext.getRealPath("/static/img/Elieen2.jpg");

        //创建输入流读取文件信息
        InputStream is = new FileInputStream(realPath);
        //available获取当前文件的所有字节数
        byte[] bytes = new byte[is.available()];
        is.read(bytes);

        //设置响应头信息
        MultiValueMap<String ,String> headers = new HttpHeaders();
        //设置下载的方式以及下载文件的名字(attachment以附件的方式下载)
        headers.add("Content-Disposition", "attachment;filename=Elieen2.jpg");
        //设置响应状态码
        HttpStatus statusCode = HttpStatus.OK;

        //创建ResponseEntity对象
        ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers, statusCode);

        //关闭输入流，返回响应报文
        is.close();
        return responseEntity;
    }
}

文件上传

html 网页利用file实现文件上传功能：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>File</title>
</head>
<body>
<!-- enctype="multipart/form-data"使数据以二进制的方式传输 -->
<form action="/testUp" method="post" enctype="multipart/form-data">
    上传文件:<input type="file" name="photo"><br>
    <input type="submit" value="上传"/>
</form>
</body>
</html>

添加依赖（新版本已经不是必须的了）：

<!-- 文件上传依赖 -->
<dependency>
  <groupId>commons-fileupload</groupId>
  <artifactId>commons-fileupload</artifactId>
  <version>1.4</version>
</dependency>

配置文件上传解析器，将上传的文件封装为MultipartFile对象。首先在 DispatcherServlet 配置类中添加下述代码：

public class MyWebApplicationInitializer
        extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected void customizeRegistration(ServletRegistration.Dynamic registration) {
        //第二个参数表示配置上传文件的最大大小
        //第三个参数表示配置请求的最大大小（包括文件和表单数据
        //第四个参数表示最大内存大小）
        MultipartConfigElement multipartConfig = new MultipartConfigElement("", 5242880, 104857600, 0);
        registration.setMultipartConfig(multipartConfig);
    }

}

然后在 Web 配置类中注册StandardServletMultipartResolver：

@Configuration
@EnableWebMvc
@ComponentScan({"cn.hnu.mvc"})
@Import({ThymeleafConfig.class})
public class WebMvcConfig implements WebMvcConfigurer {

    //这里的name一定要是multipartResolver
    @Bean(name = "multipartResolver")
    public StandardServletMultipartResolver multipartResolver() {
        return new StandardServletMultipartResolver();
    }

}

接下来就是在控制器中添加上传文件的代码：

@Controller
public class FileUpAndDownController {
    @RequestMapping("/testUp")
    //springmvc把文件上传需要的功能封装到了MultipartFile中
    public String testUp(MultipartFile photo, HttpSession session) 
        throws IOException {
        //获取文件名
        String filename = photo.getOriginalFilename();
        //获取上传文件的后缀名，注意从后索引，防止文件名中包含.
        String suffixName = filename.substring(filename.lastIndexOf("."));

        //创建UUID，和当前的文件名后缀拼接成唯一文件名，防止文件名重复上传
        String uuid = UUID.randomUUID().toString();
        filename = uuid + suffixName;

        //获取真实路径
        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 "redirect:/success";
    }
}

拦截器

拦截器在 SpringMVC 中用于拦截控制器方法的执行，拦截器需要实现HandlerInterceptor或者继承HandlerInterceptorAdapter类。（过滤器是作用在请求和 DispatcherServlet 之间，拦截器是作用在 DispatcherServlet 和 controller 之间）

准备拦截器：

@Component
public class FirstInterceptor implements HandlerInterceptor {
    //在控制器方法执行前执行
    //此方法如果返回false，则会直接拦截请求
    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {
        System.out.println("preHandle");
        return HandlerInterceptor.super.preHandle(request, response, handler);
    }

    //在控制器方法执行后执行
    @Override
    public void postHandle(HttpServletRequest request,
                           HttpServletResponse response,
                           Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle");
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

    //在视图渲染之后执行
    @Override
    public void afterCompletion(HttpServletRequest request,
                                HttpServletResponse response,
                                Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion");
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

spring.xml三种配置如下：

<!-- 配置拦截器 -->
<mvc:interceptors>
    <bean class="cn.hnu.mvc.interceptor.FirstInterceptor"/>
</mvc:interceptors>


<!-- 或者这么配置 -->
<mvc:interceptors>
    <ref bean="firstInterceptor"/>
</mvc:interceptors>


<!-- 设置拦截路径 -->
<mvc:interceptors>
    <mvc:interceptor>
        <!-- 设置要拦截的路径，/**拦截所有路径 -->
        <mvc:mapping path="/**"/>
        <!-- 设置要排除拦截的路径 -->
        <mvc:exclude-mapping path="/testInterceptor"/>
        <!-- 设置拦截器 -->
        <ref bean="firstInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

多个拦截器的拦截顺序

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

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

boolean applyPreHandle(HttpServletRequest request, 
                       HttpServletResponse response) throws Exception {
    //正序执行
    //interceptorList存放着所有拦截器
    for(int i = 0; i < this.interceptorList.size(); this.interceptorIndex = i++) {
        HandlerInterceptor interceptor = (HandlerInterceptor)this.interceptorList.get(i);
        if (!interceptor.preHandle(request, response, this.handler)) {
            this.triggerAfterCompletion(request, response, (Exception)null);
            return false;
        }
    }

    return true;
}

void applyPostHandle(HttpServletRequest request, 
                     HttpServletResponse response, 
                     @Nullable ModelAndView mv) throws Exception {
    //倒序执行
    for(int i = this.interceptorList.size() - 1; i >= 0; --i) {
        HandlerInterceptor interceptor = (HandlerInterceptor)this.interceptorList.get(i);
        interceptor.postHandle(request, response, this.handler, mv);
    }

}

void triggerAfterCompletion(HttpServletRequest request, 
                            HttpServletResponse response, 
                            @Nullable Exception ex) {
    //倒序执行
    for(int i = this.interceptorIndex; i >= 0; --i) {
        HandlerInterceptor interceptor = (HandlerInterceptor)this.interceptorList.get(i);

        try {
            interceptor.afterCompletion(request, response, this.handler, ex);
        } catch (Throwable var7) {
            logger.error("HandlerInterceptor.afterCompletion threw exception", var7);
        }
    }

}

异常处理器

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

HandlerExceptionResolver 接口的实现类有：DefaultHandlerExceptionResolver 和 SimpleMappingExceptionResolver。

基于配置的异常处理器

Spring 配置方式（SimpleMappingExceptionResolver）：

<!-- 配置异常处理 -->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <property name="exceptionMappings">
        <props>
            <!-- key是异常，value是视图名称 -->
            <prop key="java.lang.ArithmeticException">error</prop>
        </props>
    </property>
    <!-- 存储异常信息到请求域中 -->
    <property name="exceptionAttribute" value="ArithmeticException"/>
</bean>

可以在页面打印错误信息：

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>出现错误</h1>
<p th:text="${ArithmeticException}"></p>
</body>
</html>

基于注解的异常处理器

//将ExceptionController标记为异常处理控件
//该注解作用与@Controller一致
@ControllerAdvice
public class ExceptionController {
    //标注当前可能出现的异常
    @ExceptionHandler({ArithmeticException.class, NullPointerException.class})
    public String testException(Exception exception, Model model) {
        model.addAttribute("ArithmeticException", exception);
        return "error";
    }
}

注解配置 SpringMVC

创建初始化类

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

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

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

//web工程的初始化类，用来代替web.xml
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 characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        characterEncodingFilter.setForceResponseEncoding(true);

        //注册restful过滤器
        HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
        return new Filter[] {characterEncodingFilter, hiddenHttpMethodFilter};
    }
    
    //文件上传解析器
    @Override
    protected void customizeRegistration(ServletRegistration.Dynamic registration) {
        //第二个参数表示配置上传文件的最大大小
        //第三个参数表示配置请求的最大大小（包括文件和表单数据
        //第四个参数表示最大内存大小）
        MultipartConfigElement multipartConfig = new MultipartConfigElement("", 5242880, 104857600, 0);
        registration.setMultipartConfig(multipartConfig);
    }
}

创建视图解析器

public class ThymeleafConfig {

    @Bean
    public ITemplateResolver templateResolver() {
        SpringResourceTemplateResolver resolver = new SpringResourceTemplateResolver();
        resolver.setPrefix("/WEB-INF/templates/");
        resolver.setSuffix(".html");
        resolver.setTemplateMode(TemplateMode.HTML);
        resolver.setCacheable(true);
        return resolver;
    }

    @Bean
    public SpringTemplateEngine templateEngine(ITemplateResolver templateResolver) {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(templateResolver);
        templateEngine.setEnableSpringELCompiler(true);
        return templateEngine;
    }

    @Bean
    public ThymeleafViewResolver viewResolver(SpringTemplateEngine templateEngine) {
        ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
        viewResolver.setOrder(1);
        viewResolver.setCharacterEncoding("UTF-8");
        viewResolver.setTemplateEngine(templateEngine);
        return viewResolver;
    }
}

配置 WebConfig

//springmvc.xml的配置文件代替
/*
    扫描组件
    视图解析器
    view-controller
    default-servlet-handler
    mvc注解驱动
    异常处理
    拦截器
*/
@Configuration
@ComponentScan({"cn.hnu.mvc"})
@EnableWebMvc   //mvc注解驱动
@Import({ThymeleafConfig.class})	//视图解析器
public class WebConfig implements WebMvcConfigurer {

    //view-controller
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("index");
    }

    //handler
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TestInterceptor())
                .addPathPatterns("/**") //添加拦截路径
                .excludePathPatterns("/index"); //排除拦截路径
    }

    //文件上传解析器
    //这里的name一定要是multipartResolver
    @Bean(name = "multipartResolver")
    public StandardServletMultipartResolver multipartResolver() {
        return new StandardServletMultipartResolver();
    }

    //异常解析器
    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
        //设置异常-页面映射
        Properties prop = new Properties();
        prop.setProperty("java.lang.ArithmeticException", "error");
        exceptionResolver.setExceptionMappings(prop);
        //设置在请求域中共享的键，在请求域中我们可以通过exception获取异常信息
        exceptionResolver.setExceptionAttribute("exception");
        resolvers.add(exceptionResolver);
        WebMvcConfigurer.super.configureHandlerExceptionResolvers(resolvers);
    }
}

SpringMVC 各个组件

  • DispatcherServlet：前端控制器，不需要工程师开发，由框架提供。作用：统一处理请求和响应，整个流程控制的中心，由它调用其它组件处理用户的请求。
  • HandlerMapping：处理器映射器，不需要工程师开发，由框架提供。作用：根据请求的 url、method 等信息查找 Handler，即控制器方法。
  • Handler：处理器，需要工程师开发。作用：在 DispatcherServlet 的控制下 Handler 对具体的用户请求进行处理。
  • HandlerAdapter：处理器适配器，不需要工程师开发，由框架提供。作用：通过 HandlerAdapter 对处理器（控制器方法）进行执行。
  • ViewResolver：视图解析器，不需要工程师开发，由框架提供。作用：进行视图解析，得到相应的视图，例如：ThymeleafView、InternalResourceView、RedirectView。
  • View：视图，不需要工程师开发，由框架或视图技术提供。作用：将模型数据通过页面展示给用户。

SpringMVC 的执行流程

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

文章作者: 热心市民灰灰
文章链接: http://example.com/2024/03/17/springmvc/
版权声明: 本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 热心市民灰灰 !
Java SSM SpringMVC
  目录