一篇文章搞懂SpringMVC及其用法

最新推荐文章于 2025-03-27 15:22:27 发布

Dr_RR

最新推荐文章于 2025-03-27 15:22:27 发布

阅读量955

点赞数 25

文章标签： java mvc

本文链接：https://blog.youkuaiyun.com/Dr_RR/article/details/142487986

版权

文章包括：

SpringMVC的使用

SpringMVC的第一个入门程序

SpringMVC的一个web小项目

SpringMVC的底层源码分析

SSM三大框架的结合使用

SpringMVC是一个实现了MVC架构模式的web kuangjia，底层基于Servlet实现，SpringMVC已经将MVC架构模式实现了，因此只要我们基于SpringMVC框架写代码，编写的程序就是符合MVC架构模式的。

SpringMVC帮我们做了什么？

1. 入口控制：SpringMVC框架通过DispatcherServlet作为入口控制器，负责接收请求和分发请求。而在Servlet开发中，需要自己编写Servlet程序，并在web.xml中进行配置，才能接受和处理请求。

2. 在SpringMVC中，表单提交时可以自动将表单数据绑定到相应的JavaBean对象中，只需要在控制器方法的参数列表中声明该JavaBean对象即可，无需手动获取和赋值表单数据。而在纯粹的Servlet开发中，这些都是需要自己手动完成的。

3. IoC容器：SpringMVC框架通过IoC容器管理对象，只需要在配置文件中进行相应的配置即可获取实例对象，而在Servlet开发中需要手动创建对象实例。

4. 统一处理请求：SpringMVC框架提供了拦截器、异常处理器等统一处理请求的机制，并且可以灵活地配置这些处理器。而在Servlet开发中，需要自行编写过滤器、异常处理器等，增加了代码的复杂度和开发难度。

5. 视图解析：SpringMVC框架提供了多种视图模板，如JSP、Freemarker、Velocity等，并且支持国际化、主题等特性。而在Servlet开发中需要手动处理视图层，增加了代码的复杂度。

第一个SpringMVC入门程序

1，首先我们需要先创建一个Web项目，在web项目下的web.xml文件中进行配置前端控制器（SpringMVC内置的一个类：DispatcherServlet），所有的请求都应该经过这个DispatcherServlet的处理。配置如下：

    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

** DispatcherServlet的职责是什么：

(1) 接收客户端的HTTP请求：DispatcherServlet监听来自Web浏览器的HTTP请求，然后根据请求的URL将请求数据解析为Request对象。

(2) 处理请求的URL：DispatcherServlet将请求的URL（Uniform Resource Locator）与处理程序进行匹配，确定要调用哪个控制器（Controller）来处理此请求。

(3) 调用相应的控制器：DispatcherServlet将请求发送给找到的控制器处理，控制器将执行业务逻辑，然后返回一个模型对象（Model）。

(4) 渲染视图：DispatcherServlet将调用视图引擎，将模型对象呈现为用户可以查看的HTML页面。

(5) 返回响应给客户端：DispatcherServlet将为用户生成的响应发送回浏览器，响应可以包括表单、JSON、XML、HTML以及其它类型的数据

2，FirstController

我们在类上加上@Controller注解让Service，Dao等纳入IoC容器管理。

3，配置SpringMVC-servlet.xml文件

注意：这里的springmvc-servlet.xml文件名取决于<servlet-name>的别名，配置在WEB-INF下。

（1）组件扫描

<context:component-scan base-package="com.ryy.springmvc.Controller"/>

（2）配置视图解析器

    <!--视图解析器-->
    <bean id="thymeleafViewResolver" class="org.thymeleaf.spring6.view.ThymeleafViewResolver">
        <!--作用于视图渲染的过程中，可以设置视图渲染后输出时采用的编码字符集-->
        <property name="characterEncoding" value="UTF-8"/>
        <!--如果配置多个视图解析器，它来决定优先使用哪个视图解析器，它的值越小优先级越高-->
        <property name="order" value="1"/>
        <!--当 ThymeleafViewResolver 渲染模板时，会使用该模板引擎来解析、编译和渲染模板-->
        <property name="templateEngine">
            <bean class="org.thymeleaf.spring6.SpringTemplateEngine">
                <!--用于指定 Thymeleaf 模板引擎使用的模板解析器。模板解析器负责根据模板位置、模板资源名称、文件编码等信息，加载模板并对其进行解析-->
                <property name="templateResolver">
                    <bean class="org.thymeleaf.spring6.templateresolver.SpringResourceTemplateResolver">
                        <!--设置模板文件的位置（前缀）-->
                        <property name="prefix" value="/WEB-INF/templates/"/>
                        <!--设置模板文件后缀（后缀），Thymeleaf文件扩展名不一定是html，也可以是其他，例如txt，大部分都是html-->
                        <property name="suffix" value=".thymeleaf"/>
                        <!--设置模板类型，例如：HTML,TEXT,JAVASCRIPT,CSS等-->
                        <property name="templateMode" value="HTML"/>
                        <!--用于模板文件在读取和解析过程中采用的编码字符集-->
                        <property name="characterEncoding" value="UTF-8"/>
                    </bean>
                </property>
            </bean>
        </property>
    </bean>

这里将class指定为ThymeleafResolver，如果是JSP就对应InternalResourceViewResolver

内部还有一个<bean>为SpringTemplateEngine，这段bean的核心就是将Thymeleaf模板字符串转换为HTML代码。

另一个<bean>SpringResourceTemplateResolver可以设置模板文件位置（前缀），模板文件后缀，设置模板类型，编码字符集。

（3）提供视图

在WEB-INF目录下新建templates目录，在templates目录中新建html文件，例如：first.html，并提供以下代码：

<!DOCTYPE html>
<!--指定 th 命名空间，让 Thymeleaf 标准表达式可以被解析和执行-->
<!--th不是固定的，可以指定其它的命名空间，只不过大部分情况下用th-->
<!--表示程序中出现的 th 开头的后面代码都是 Thymeleaf语法，需要被 Thymeleaf识别-->
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>first springmvc</title>
</head>
<body>
<h1>我的第一个Spring MVC程序</h1>
</body>
</html>

（4）编写Controller层的FirstControlelr

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

@Controller
public class FirstController {
    @RequestMapping(value="/first")
    public String First(){
        System.out.println("正在处理请求....");
        // 返回逻辑视图名称（决定跳转到哪个页面）
        return "first";
    }
}

这样我们的第一个SpringMVC程序就编写完成了，但是其中还有一些漏洞，比如我们要用thymeleaf动态获取web应用根路径，在.thymeleaf文件中:

在lang="en"后跟命名空间：xmlns:th="http://www.thymeleaf.org">

在有请求映射路径的标签中写：<a th:href="@{/请求映射路径}">... ...</a>，此时前面就不用加固定的项目名：springmvc了。

RESTFul的编程风格

RESTFul是WEB服务接口的一种设计风格。

RESTFul定义了一组约束条件和规范，可以让WEB服务接口更加简洁、易于理解、易于扩展、安全可靠。

RESTFul对一个WEB服务接口都规定了哪些东西？

对请求的URL格式有约束和规范
对HTTP的请求方式有约束和规范
对请求和响应的数据格式有约束和规范
对HTTP状态码有约束和规范
等 ......

REST对请求方式的约束是这样的：

查询必须发送GET请求
新增必须发送POST请求
修改必须发送PUT请求
删除必须发送DELETE请求

传统的URL的get请求：/springmvc/deleteUserById ? id=1

RESTFul风格：/springmvc/user/1

用RESTFul风格根据id查询（GET）

首页的<a>标签应该改为：

<a th:href="@{/api/user/1}">根据id查询用户信息</a><br>

然后来到Controller层：

@Controller
public class UserController {

    @RequestMapping(value = "/api/user/{id}", method = RequestMethod.GET)
    public String getById(@PathVariable("id") Integer id){
        System.out.println("根据用户id查询用户信息，用户id是" + id);
        return "ok";
    }

}

注意变化：这里value里用的是{id}

用RESTFul风格根据id查询（PUT）

（1）首先form表单中的method必须设置为post为前提

（2）在<form>表单下添加隐藏域

<input type="hidden" name="_method" value="put">

（3）在web.xml中配置一个过滤器，它可以帮助将POST请求转换成PUT/DELETE请求

<!--隐藏的HTTP请求方式过滤器-->
<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>

注意：这个<filter>不能放在字符编码过滤器前面！！！

SpringMVC的一个web小项目

（1）页面准备（我这边直接使用thymeleaf的方式去编写了）

以下使用到了thymeleaf动态获取资源的方式，例如在现实用户列表信息的时候我们使用如 ${user.id}来获取，这里的属性都是pojo类中的属性。而底层就是通过Model接口来将包含用户信息的集合传递给视图的：（如下代码）
public String list(Model model){
//查询数据库，获取用户列表的List集合
List<User> users = userDao.selectAll();
//将用户列表存储到request域当中
model.addAttribute("users", users);
//转发到视图
return "user_list";
}

user.css

.header {
  background-color: #f2f2f2;
  padding: 20px;
  text-align: center;
}

ul {
  list-style-type: none;
  margin: 0;
  padding: 0;
  overflow: hidden;
  background-color: #333;
}

li {
  float: left;
}

li a {
  display: block;
  color: white;
  text-align: center;
  padding: 14px 16px;
  text-decoration: none;
}

li a:hover:not(.active) {
  background-color: #111;
}

.active {
  background-color: #4CAF50;
}

form {
  width: 50%;
  margin: 0 auto;
  padding: 20px;
  border: 1px solid #ddd;
  border-radius: 4px;
}

label {
  display: block;
  margin-bottom: 8px;
}

input[type="text"], input[type="email"], select {
  width: 100%;
  padding: 6px 10px;
  margin: 8px 0;
  box-sizing: border-box;
  border: 1px solid #555;
  border-radius: 4px;
  font-size: 16px;
}

button[type="submit"] {
  padding: 10px;
  background-color: #4CAF50;
  color: #fff;
  border: none;
  border-radius: 4px;
  cursor: pointer;
}

button[type="submit"]:hover {
  background-color: #3e8e41;
}

table {
  border-collapse: collapse;
  width: 100%;
}

th, td {
  border: 1px solid #ddd;
  padding: 8px;
  text-align: left;
}

th {
  background-color: #f2f2f2;
}

tr:nth-child(even) {
  background-color: #f2f2f2;
}

.header {
  background-color: #f2f2f2;
  padding: 20px;
  text-align: center;
}

a {
  text-decoration: none;
  color: #333;
}

.add-button {
  margin-bottom: 20px;
  padding: 10px;
  background-color: #4CAF50;
  color: #fff;
  border: none;
  border-radius: 4px;
  cursor: pointer;
}

.add-button:hover {
  background-color: #3e8e41;
}

user_index.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>用户管理系统</title>
    <link rel="stylesheet" th:href="@{/static/css/user.css}" type="text/css"></link>
</head>
<body>
<div class="header">
    <h1>用户管理系统</h1>
</div>
<ul>
    <li><a class="active" th:href="@{/user}">用户列表</a></li>
</ul>
</body>
</html>

user_list.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>用户列表</title>
    <link rel="stylesheet" th:href="@{/static/css/user.css}" type="text/css"></link>
</head>
<body>
<div class="header">
    <h1>用户列表</h1>
</div>
<div class="add-button-wrapper">
    <a class="add-button" th:href="@{/toAdd}">新增用户</a>
</div>
<table>
    <thead>
    <tr>
        <th>编号</th>
        <th>用户名</th>
        <th>性别</th>
        <th>邮箱</th>
        <th>操作</th>
    </tr>
    </thead>
    <tbody>

    <tr th:each="user : ${users}">
        <td th:text="${user.id}"></td>
        <td th:text="${user.username}"></td>
        <td th:text="${user.sex == 1 ? '男' : '女'}"></td>
        <td th:text="${user.email}"></td>
        <td>
            <a th:href="@{'/user/' + ${user.id}}">修改</a>
            <a th:href="@{'/user/' + ${user.id}}" onclick="del(event)">删除</a>
        </td>
    </tr>

    </tbody>
</table>

<div style="display: none">
    <form id="delForm" method="post">
        <input type="hidden" name="_method" value="delete">
    </form>
</div>

<script>

    function del(event) {
        //获取表单
        let delForm = document.getElementById("delForm");
        //设置form的action
        delForm.action = event.target.href;
        if (window.confirm("您确定要删除表单吗？")) {
            //提交表单
            delForm.submit();
        }
        //组织超链接的默认行为
        event.preventDefault();
    }

</script>
</body>
</html>

user_add.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>新增用户</title>
    <link rel="stylesheet" th:href="@{/static/css/user.css}" type="text/css"></link>
</head>
<body>
<h1>新增用户</h1>
<form th:action="@{/user}" method="post">
    <label>用户名:</label>
    <input type="text" name="username" required>

    <label>性别:</label>
    <select name="sex" required>
        <option value="">-- 请选择 --</option>
        <option value="1">男</option>
        <option value="0">女</option>
    </select>

    <label>邮箱:</label>
    <input type="email" name="email" required>

    <button type="submit">保存</button>
</form>
</body>
</html>

user_edit.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>修改用户</title>
    <link rel="stylesheet" th:href="@{/static/css/user.css}" type="text/css"></link>
</head>
<body>
<h1>修改用户</h1>
<form th:action="@{/user}", method="post">

    <!--隐藏域，设置请求方式-->
    <input type="hidden" name="_method" value="PUT">
    <!--隐藏域，提交id-->
    <input type="hidden" name="id" th:value="${user.id}">

    <label>用户名:</label>
    <input type="text" name="username" th:value="${user.username}" required>

    <label>性别:</label>
    <select name="sex" required>
        <option value="">-- 请选择 --</option>
        <option value="1" th:field="${user.sex}">男</option>
        <option value="0" th:field="${user.sex}">女</option>
    </select>

    <label>邮箱:</label>
    <input type="email" name="email" th:value="${user.email}" required>

    <button type="submit">修改</button>
</form>
</body>
</html>

（2）配置web.xml和springmvc.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_0.xsd"
         version="6.0">

    <!--HTTP请求方式过滤器-->
    <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>
    
    <!--前端控制器-->
    <servlet>
        <servlet-name>springmvc</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>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

<?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="com.ryy.usermgt"/>

    <!--视图解析器-->
    <bean id="thymeleafViewResolver" class="org.thymeleaf.spring6.view.ThymeleafViewResolver">
        <!--作用于视图渲染的过程中，可以设置视图渲染后输出时采用的编码字符集-->
        <property name="characterEncoding" value="UTF-8"/>
        <!--如果配置多个视图解析器，它来决定优先使用哪个视图解析器，它的值越小优先级越高-->
        <property name="order" value="1"/>
        <!--当 ThymeleafViewResolver 渲染模板时，会使用该模板引擎来解析、编译和渲染模板-->
        <property name="templateEngine">
            <bean class="org.thymeleaf.spring6.SpringTemplateEngine">
                <!--用于指定 Thymeleaf 模板引擎使用的模板解析器。模板解析器负责根据模板位置、模板资源名称、文件编码等信息，加载模板并对其进行解析-->
                <property name="templateResolver">
                    <bean class="org.thymeleaf.spring6.templateresolver.SpringResourceTemplateResolver">
                        <!--设置模板文件的位置（前缀）-->
                        <property name="prefix" value="/WEB-INF/thymeleaf/"/>
                        <!--设置模板文件后缀（后缀），Thymeleaf文件扩展名不一定是html，也可以是其他，例如txt，大部分都是html-->
                        <property name="suffix" value=".html"/>
                        <!--设置模板类型，例如：HTML,TEXT,JAVASCRIPT,CSS等-->
                        <property name="templateMode" value="HTML"/>
                        <!--用于模板文件在读取和解析过程中采用的编码字符集-->
                        <property name="characterEncoding" value="UTF-8"/>
                    </bean>
                </property>
            </bean>
        </property>
    </bean>

    <!--视图控制器-->
    <mvc:view-controller path="/" view-name="user_index"/>
    <mvc:view-controller path="/toAdd" view-name="user_add"/>

    <!--处理静态资源：开启默认的Servlet处理-->
    <mvc:default-servlet-handler/>

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

</beans>

（3）然后我们编写Java类来实现三层架构模式

以下就是Controller层采用SpringMVC框架之后的样子：

import com.ryy.usermgt.bean.User;
import com.ryy.usermgt.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import java.util.List;

@Controller
public class UserController {

    @Autowired
    private UserDao userDao;

    @RequestMapping(value = "/user", method = RequestMethod.GET)
    public String list(Model model){
        //查询数据库，获取用户列表的List集合
        List<User> users = userDao.selectAll();
        //将用户列表存储到request域当中
        model.addAttribute("users", users);
        //转发到视图
        return "user_list";
    }

    @RequestMapping(value = "/user", method = RequestMethod.POST)
    public String save(User user){
        //调用UserDao保存用户信息
        userDao.insert(user);
        //重定向到用户列表页面（重新让浏览器发送一次全新的请求，去请求列表页面）
        return "redirect:/user";
    }

    @RequestMapping(value = "/user/{id}", method = RequestMethod.GET)
    public String detail(@PathVariable("id")Long id, Model model){
        //通过id查找用户信息
        User user = userDao.selectById(id);
        //将用户信息存储到request域
        model.addAttribute("user", user);
        //转发到视图
        return "user_edit";
    }

    @RequestMapping(value = "/user", method = RequestMethod.PUT)
    public String modify(User user){
        //修改用户信息
        userDao.update(user);
        //重定向到用户列表
        return "redirect:/user";
    }

    @RequestMapping(value = "/user/{id}", method = RequestMethod.DELETE)
    public String del(@PathVariable("id")Long id){
        //调用dao删除用户
        userDao.deleteById(id);
        //重定向到列表
        return "redirect:/user";
    }
}

Pojo类：

public class User {
    private Long id;
    private String username;
    private Integer sex;
    private String email;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", sex=" + sex +
                ", email='" + email + '\'' +
                '}';
    }

    public User() {
    }

    public User(Long id, String username, Integer sex, String email) {
        this.id = id;
        this.username = username;
        this.sex = sex;
        this.email = email;
    }

    public Long getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Integer getSex() {
        return sex;
    }

    public void setSex(Integer sex) {
        this.sex = sex;
    }

    public String getEmail() {
        return email;
    }

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

UserDao类：（这里我们用一个集合来模拟数据库，就不再去新建数据库了）

import com.ryy.usermgt.bean.User;
import org.springframework.stereotype.Repository;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

@Repository
public class UserDao {

    private static List<User> users = new ArrayList<>();

    static {
        //类加载时初始化数据
        //创建User对象
        User user1 = new User(1001L, "张三", 1, "zhangsan@ryy.com");
        User user2 = new User(1002L, "孙悟空", 1, "wukong@ryy.com");
        User user3 = new User(1003L, "猪八戒", 1, "bajie@ryy.com");
        User user4 = new User(1004L, "白骨精", 0, "bgj@ryy.com");
        User user5 = new User(1005L, "武松", 1, "ws@ryy.com");
        //将User对象存储到List集合中
        users.add(user1);
        users.add(user2);
        users.add(user3);
        users.add(user4);
        users.add(user5);
    }

    /**
     * 查询所有用户信息并返回用户列表
     * @return
     */
    public List<User> selectAll(){
        return users;
    }

    public void insert(User user){
        //生成id
        Long id = generateId();
        //给user对象id属性赋值
        user.setId(id);
        //保存
        users.add(user);
    }

    public Long generateId(){
        //使用Comparator比较器排序（根据id进行排序）获取最大的id值
        users.sort(Comparator.comparing(User::getId));
        Long maxId = users.get(users.size() - 1).getId();
        return maxId + 1;
    }

    public User selectById(Long id){
        //Stream API
        return users.stream().filter(user -> user.getId().equals(id)).findFirst().get();
    }

    public void update(User user){
        for (int i = 0; i < users.size(); i++){
            if(users.get(i).getId().equals(user.getId())){
                users.set(i, user);
                return;
            }
        }
    }

    public void deleteById(Long id){
        for (int i = 0; i < users.size(); i++){
            if(users.get(i).getId().equals(id)){
                users.remove(i);
                return;
            }
        }
    }
}

以上代码就是全部的使用SpringMVC开发的web小项目，但是在看完代码之后对于其中的细节一定也有所提问，我这里也对大家可能遇到的问题进行了自己的解答：

一，为什么save方法要进行重定向操作？
（1）当用户提交表单（使用 POST 请求）后，如果直接返回页面，用户刷新页面时，浏览器可能会再次发送 POST 请求，导致表单被重复提交。
使用重定向可以将用户引导到一个新的 GET 请求，从而避免重复提交的风险。
（2）如果直接返回视图（例如返回 user_list 页面），页面上可能显示的用户列表并没有反映最新的变化（除非手动再从数据库获取一次）。
通过重定向到 /user，可以确保浏览器发送新的 GET 请求，此时页面会重新从数据库中获取最新的用户列表，确保页面内容是实时更新的。

我们在执行完新增操作之后马上就能在页面上看到我们新增的一条数据，这就是重定向带来的好处（实时更新数据）

二，为什么要将用户信息存储到request域中？
在Spring MVC框架中，将用户信息存储到request域（通过Model对象）是为了让视图（即前端页面）能够访问和显示这些数据。
Spring MVC的控制器方法通常处理请求后会返回视图名称，而视图本身无法直接访问Controller中的数据。通过将数据存储在request域中，Controller可以将用户列表或用户详细信息传递给前端视图模板（如JSP、Thymeleaf等）。这样，视图层在渲染时可以使用这些数据。${user.id}就是因为将用户信息存储在request中才能使用的（通常用在查询操作）。

三，return "redirect:/user"的/user指向的是什么资源？
当我们调用 POST /user 时，对应的是 save(User user) 方法，代码会将传入的用户信息保存到数据库，然后通过 return "redirect:/user" 进行重定向。这个重定向会让浏览器发送一个新的 GET /user 请求，从而重新获取并展示最新的用户列表页面。
所以，/user 资源指向的就是用户列表页面，它会显示数据库中所有用户的信息。

四，页面跳转之间的关系

我们在user_list.html中看到了：

<div class="add-button-wrapper">
    <a class="add-button" th:href="@{/toAdd}">新增用户</a>
</div>

这表示页面跳转，而我们需要跳转的页面需要在Springmvc.xml文件中进行配置，配置如下：

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

SpringMVC核心源码分析

从源码角度看执行流程

我们从源码的角度出发去看执行流程，这里我们把源码中几个重要的方法摘录出来进行分析，这对于我们后续手写SpringMVC框架有着重要的帮助。

public class DispatcherServlet extends FrameworkServlet {
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
// 根据请求对象request获取
// 这个对象是在每次发送请求时都创建一个，是请求级别的
// 该对象中描述了本次请求应该执行的拦截器是哪些，顺序是怎样的，要执行的处理器是哪个
HandlerExecutionChain mappedHandler = getHandler(processedRequest);

// 根据处理器获取处理器适配器。（底层使用了适配器模式）
// HandlerAdapter在web服务器启动的时候就创建好了。（启动时创建多个HandlerAdapter放在List集合中）
// HandlerAdapter有多种类型：
// RequestMappingHandlerAdapter：用于适配使用注解 @RequestMapping 标记的控制器方法
// SimpleControllerHandlerAdapter：用于适配实现了 Controller 接口的控制器
// 注意：此时还没有进行数据绑定（也就是说，表单提交的数据，此时还没有转换为pojo对象。）
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

// 执行请求对应的所有拦截器中的 preHandle 方法
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}

// 通过处理器适配器调用处理器方法
// 在调用处理器方法之前会进行数据绑定，将表单提交的数据绑定到处理器方法上。（底层是通过WebDataBinder完成的）
// 在数据绑定的过程中会使用到消息转换器：HttpMessageConverter
// 结束后返回ModelAndView对象
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

// 执行请求对应的所有拦截器中的 postHandle 方法
mappedHandler.applyPostHandle(processedRequest, response, mv);

// 处理分发结果（在这个方法中完成了响应）
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
}

// 根据每一次的请求对象来获取处理器执行链对象
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
       if (this.handlerMappings != null) {
// HandlerMapping在服务器启动的时候就创建好了，放到了List集合中。HandlerMapping也有多种类型
// RequestMappingHandlerMapping：将 URL 映射到使用注解 @RequestMapping 标记的控制器方法的处理器。
// SimpleUrlHandlerMapping：将 URL 映射到处理器中指定的 URL 或 URL 模式的处理器。
           for (HandlerMapping mapping : this.handlerMappings) {
// 重点：这是一次请求的开始，实际上是通过处理器映射器来获取的处理器执行链对象
// 底层实际上会通过 HandlerMapping 对象获取 HandlerMethod对象，将HandlerMethod 对象传递给 HandlerExecutionChain对象。
// 注意：HandlerMapping对象和HandlerMethod对象都是在服务器启动阶段创建的。
// RequestMappingHandlerMapping对象中有多个HandlerMethod对象。
               HandlerExecutionChain handler = mapping.getHandler(request);
               if (handler != null) {
                   return handler;
               }
           }
       }
       return null;
   }

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
@Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
@Nullable Exception exception) throws Exception {
// 渲染
render(mv, request, response);
// 渲染完毕后，调用该请求对应的所有拦截器的 afterCompletion方法。
mappedHandler.triggerAfterCompletion(request, response, null);
}

protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
// 通过视图解析器返回视图对象
view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
// 真正的渲染视图
view.render(mv.getModelInternal(), request, response);
}

protected View resolveViewName(String viewName, @Nullable Map<String, Object> model,
Locale locale, HttpServletRequest request) throws Exception {
// 通过视图解析器返回视图对象
View view = viewResolver.resolveViewName(viewName, locale);
}

//视图解析器接口，其下可以有很多实现类ThymeleafViewResolver,InternalResourceViewResolver

public interface ViewResolver {
View resolveViewName(String viewName, Locale locale) throws Exception;
}

//视图接口

public interface View {
void render(@Nullable Map<String, ?> model, HttpServletRequest request, HttpServletResponse response)
throws Exception;
}

从图片角度看执行流程

基于全注解开发的SSM框架整合

这是我们需要的整个SSM整合框架的结构。

（1）需要的依赖：springmvc，spring-jdbc，mybatis，mybatis整合spring框架，mysql驱动，druid连接池，jackson，servlet api，logback日志框架，thymeleaf和spring6的整合依赖。

（2）配置数据源，我们在config包下创建DataSourceConfig类，然后按照曾经mybatis的配置方法把driver,url,username,password四个jdbc属性配置好。

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;

public class DataSourceConfig {
    @Value("${jdbc.driver}")
    private String driver;

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.username}")
    private String username;

    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

（3）MyBatis的配置：需要一个SqlSessionFactoryBean和一个扫描器让dao包被自动代理。
SqlSessionFactoryBean中我们需要设置数据源和包的别名
mapperScannerConfigurer中我们需要指定dao包让其被自动代理。

import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class MyBatisConfig {

    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        sqlSessionFactoryBean.setTypeAliasesPackage("com.ryy.ssm.bean"); //设置包的别名
        return sqlSessionFactoryBean;
    }

    //配置扫描器让dao包被自动代理
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setBasePackage("com.ryy.ssm.dao");
        return mapperScannerConfigurer;
    }
}

（4）Spring的配置：创建一个SpringConfig类，其中一共需要四个注解，如下：
//标注该类是一个配置文件类
@Configuration
//组件扫描
@ComponentScan({"com.ryy.ssm.service"})
//属性配置文件位置
@PropertySource("classpath:jdbc.properties")
//导入其他配置到Spring配置（即刚才配置的MyBatisConfig等类）
@Import({MyBatisConfig.class, DataSourceConfig.class})

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.Transactional;

//标注该类是一个配置文件类
@Configuration
//组件扫描
@ComponentScan({"com.ryy.ssm.service"})
//属性配置文件位置
@PropertySource("classpath:jdbc.properties")
//导入其他配置到Spring配置（即刚才配置的MyBatisConfig等类）
@Import({MyBatisConfig.class, DataSourceConfig.class})
//开启事务管理机制
@EnableTransactionManagement
public class SpringConfig {
}

（5）Spring整合SpringMVC：在这里我们首先是需要代替web.xml配置文件，创建一个类去实现AbstractAnnotationConfigDispatcherServletInitializer，然后实现其下的三个方法。分别对应代替了Spring的配置文件，SpringMVC的配置文件，用来配置DispatcherServlet的<url-pattern>.
然后我们需要来编写SpringMvcConfig类，需要实现接口WebMvcConfigurer，然后分别对照配置文件编写方法：分别有配置视图解析器，开启静态资源处理，视图控制器，异常处理器，拦截器等方法。具体代码见SpringMvcConfig类。

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

public class WebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    /**
     * 配置过滤器
     * @return
     */
    @Override
    protected Filter[] getServletFilters() {
        // 配置字符编码过滤器
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        characterEncodingFilter.setForceResponseEncoding(true);
        characterEncodingFilter.setForceRequestEncoding(true);
        // 配置HiddenHttpMethodFilter
        HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
        return new Filter[]{characterEncodingFilter, hiddenHttpMethodFilter};
    }
}

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.config.annotation.*;
import org.thymeleaf.spring6.SpringTemplateEngine;
import org.thymeleaf.spring6.templateresolver.SpringResourceTemplateResolver;
import org.thymeleaf.spring6.view.ThymeleafViewResolver;
import org.thymeleaf.templatemode.TemplateMode;
import org.thymeleaf.templateresolver.ITemplateResolver;

import java.util.List;

/**
 * ClassName: SpringMvcConfig
 * Description:
 * Datetime: 2024/4/1 15:02
 * Author: 老杜@动力节点
 * Version: 1.0
 */
@Configuration
@ComponentScan("com.ryy.ssm.handler")
@EnableWebMvc
public class SpringMvcConfig implements WebMvcConfigurer {

    // 以下三个方法合并起来就是开启视图解析器
    @Bean
    public ThymeleafViewResolver getViewResolver(SpringTemplateEngine springTemplateEngine) {
        ThymeleafViewResolver resolver = new ThymeleafViewResolver();
        resolver.setTemplateEngine(springTemplateEngine);
        resolver.setCharacterEncoding("UTF-8");
        resolver.setOrder(1);
        return resolver;
    }

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

    @Bean
    public ITemplateResolver templateResolver(ApplicationContext applicationContext) {
        SpringResourceTemplateResolver resolver = new SpringResourceTemplateResolver();
        resolver.setApplicationContext(applicationContext);
        resolver.setPrefix("/WEB-INF/thymeleaf/");
        resolver.setSuffix(".html");
        resolver.setTemplateMode(TemplateMode.HTML);
        resolver.setCharacterEncoding("UTF-8");
        resolver.setCacheable(false);//开发时关闭缓存，改动即可生效
        return resolver;
    }

    // 开启静态资源处理，开启默认的Servlet处理
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

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

    // 配置异常处理器
    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
    }

    // 配置拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
    }
}

（6）添加事务控制：
第一步：在SpringConfig中开启事务管理器，添加注解：@EnableTransactionManagement
第二步：在DataSourceConfig中添加事务管理器对象

@Bean
public PlatformTransactionManager platformTransactionManager(DataSource dataSource){
    DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
    dataSourceTransactionManager.setDataSource(dataSource);
    return dataSourceTransactionManager;
}

第三步：在service类上添加如下注解：@Transactional

然后我们就可以编写测试程序了。下一节我将对SpringMVC的源码进行进一步刨析，一起手写一遍源码。