SpringMVC

Posted 2023-05-30 wmrdbk

本次文章是我的springmvc学习的笔记，是观看尚硅谷的视频，欢迎大家去学习观看：https://www.bilibili.com/video/BV1Ry4y1574R/?vd_source=f38047c43021f07cf7a4e84b564bde02

一、SpringMVC简介

1.1 什么是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视图,渲染数据后最终响应给浏览器

1.2 什么是SpringMVC

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

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

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

1.3 SpringMVC的特点

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

二、初始项目HelloWorld

2.1 开发环境

IDE:idea 2022.1

构建工具:maven3.6.1

服务器:tomcat8

Spring版本:5.3.1

2.2 创建maven工程

1.添加web模块

2.打包方式:war

3.引入依赖

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

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

2.3 配置web.xml

注册SpringMVC的前端控制器DispatcherServlet

2.3.1 默认配置方式

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

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

2.3.2 扩展配置方式

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

<!-- 配置SpringMVC的前端控制器,对浏览器发送的请求统一进行处理 -->
<servlet>
    <servlet-name>springMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 通过初始化参数指定SpringMVC配置文件的位置和名称 -->
    <init-param>
        <!-- contextConfigLocation为固定值 -->
        <param-name>contextConfigLocation</param-name>
        <!-- 使用classpath:表示从类路径查找配置文件,例如maven工程中的src/main/resources -->
        <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>
    <!--
        设置springMVC的核心控制器所能处理的请求的请求路径
        /所匹配的请求可以是/login或.html或.js或.css方式的请求路径
        但是/不能匹配.jsp请求路径的请求
    -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

注:

\\<url-pattern>标签中使用/和/*的区别:

/所匹配的请求可以是/login或.html或.js或.css方式的请求路径,但是/不能匹配.jsp请求路径的请求

因此就可以避免在访问jsp页面时,该请求被DispatcherServlet处理,从而找不到相应的页面

/*则能够匹配所有请求,例如在使用过滤器时,若需要对所有请求进行过滤,就需要使用/\\*的写法

2.4 创建请求控制器

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

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

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

@Controller
public class HelloController 

2.5 创建spring MVC的配置文件

<!-- 自动扫描包 -->
<context:component-scan base-package="com.wmr.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>

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

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

2.6 测试Helloworld

2.6.1 实现对首页的访问

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

@Controller
public class HelloController 

    // @RequestMapping注解:处理请求和控制器方法之间的映射关系
    // @RequestMapping注解的value属性可以通过请求地址匹配请求,/表示的当前工程的上下文路径
    // localhost:8080/springMVC/
    @RequestMapping("/")
    public String index() 
        //设置视图名称
        return "index";
    

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

在主页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">访问目标页面target.html</a>
</body>
</html>

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

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

2.7 总结

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

三、@RequestMapping注解

3.1 @RequestMapping注解的功能

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

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

3.2 @RequestMapping注解的位置

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

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

<body>
<h1>首页</h1>
<a th:href="@/test/testRequestMapping">测试RequestMapping注解位置</a><br>
</body>

@Controller
@RequestMapping("/test")
public class RequestMappingController 

	//此时请求映射所映射的请求的请求路径为:/test/testRequestMapping
    @RequestMapping("/testRequestMapping")
    public String testRequestMapping()
        return "success";
    

3.3 @RequestMapping注解的value属性

@RequestMapping注解的value属性通过请求的请求地址匹配请求映射

@RequestMapping注解的value属性是一个字符串类型的数组,表示该请求映射能够匹配多个请求地址所对应的请求

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

<body>
<h1>首页</h1>
<a th:href="@/test/testRequestMapping">测试RequestMapping注解位置</a><br>
<a th:href="@/testRequestMapping">测试@RequestMapping的value属性-->/testRequestMapping</a><br>
<a th:href="@/test">测试@RequestMapping的value属性-->/test</a><br>
</body>

@RequestMapping(
        value = "/testRequestMapping", "/test"
)
public String testRequestMapping()
    return "success";

3.4 @RequestMapping注解的method属性

@RequestMapping注解的method属性通过请求的请求方式(get或post)匹配请求映射

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

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

<a th:href="@/test">测试@RequestMapping的value属性-->/test</a><br>
<form th:action="@/test" method="post">
    <input type="submit">
</form>

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

注:

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

处理get请求的映射-->@GetMapping

处理post请求的映射-->@PostMapping

处理put请求的映射-->@PutMapping

处理delete请求的映射-->@DeleteMapping

2、常用的请求方式有get,post,put,delete

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

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

3.5 @RequestMapping注解的params属性(了解)

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

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

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

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

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

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

<a th:href="@/testParamsAndHeaders(username=\'admin\',password=123)">测试RequestMapping注解的params属性-->/testParamsAndHeaders</a><br>

@RequestMapping(
        value = "/testParamsAndHeaders",
        params = "username"
)
public String testParamsAndHeaders() 
    return "success";

注:

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

3.6 @RequestMapping注解的headers属性(了解)

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

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

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

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

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

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

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

@RequestMapping(
        value = "/testParamsAndHeaders",
        params = "username",
        headers = "Host=localhost:8080"
)
public String testParamsAndHeaders() 
    return "success";

3.7 SpringMVC支持ant风格的路径

？:表示任意的单个字符

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

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

注意:在使用**时,只能使用/**/xxx的方式

//@RequestMapping("/a?a/testAnt")
//@RequestMapping("/a*a/testAnt")
@RequestMapping("/**/testAnt")
public String testAnt() 
    return "success";

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

原始方式:/deleteUser?id=1

rest方式:/deleteUser/1

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

<a th:href="@/testPath/1/admin">测试@RequestMapping支持路径中的占位符-->/testPath</a><br>

@RequestMapping("/testPath/id/username")
    public String testPath(@PathVariable("id") Integer id,@PathVariable("username") String username) 
        System.out.println(id + username);
        return "success";
    
   //最终输出的内容为-->id:1,username:admin

四、SpringMVC获取请求参数

4.1 通过ServletAPI获取

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

@RequestMapping("/testServletAPI")
    //形参位置的request表示当前请求
    public String testServletAPI(HttpServletRequest request)
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        System.out.println("username:"+username+",password:"+password);
        return "success";
    

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

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

<form th:action="@/testParam" method="get">
    用户名:<input type="text" name="username"><br>
    密码:<input type="password" name="password"><br>
    爱好:<input type="checkbox" name="hobby" value="a">a
    <input type="checkbox" name="hobby" value="b">b
    <input type="checkbox" name="hobby" value="c">c<br>
    <input type="submit" value="测试使用控制器的形参获取请求参数">
</form>

@RequestMapping("/testParam")
public String testParam(String username, String password, String hobby) 
    //多请求参数中出现多个同名的请求参数,可以设置字符串或字符串数组来接收
    //若使用字符串类型的形参,最总结构是请求参数使用逗号隔开
    System.out.println("username:" + username + ",password:" + password + ",hobby" + hobby);
    return "success";

注:

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

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

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

4.3 @RequestParam

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

@RequestParam注解一共有三个属性:

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

required:设置是否必须传输此请求参数,默认值为true

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

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

<form th:action="@/testParam" method="get">
    用户名:<input type="text" name="user_name"><br>
    密码:<input type="password" name="password"><br>
    爱好:<input type="checkbox" name="hobby" value="a">a
    <input type="checkbox" name="hobby" value="b">b
    <input type="checkbox" name="hobby" value="c">c<br>
    <input type="submit" value="测试使用控制器的形参获取请求参数">
</form>

@RequestMapping("/testParam")
public String testParam(
        @RequestParam(value = "user_name", required = false, defaultValue = "hehe") String username,
        String password,
        String hobby) 
    //required = false表示有就赋值,没有就默认值
    //多请求参数中出现多个同名的请求参数,可以设置字符串或字符串数组来接收
    //若使用字符串类型的形参,最总结构是请求参数使用逗号隔开
    System.out.println("username:" + username + ",password:" + password + ",hobby" + hobby);
    return "success";

4.4 @RequestHeader

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

@RequestHeader注解一共有三个属性:value、required、defaultValue,用法同@RequestParam

@RequestMapping("/testParam")
public String testParam(
        @RequestParam(value = "user_name", required = false, defaultValue = "hehe") String username,
        String password,
        String hobby,
        @RequestHeader(value = "sayHaha", required = true, defaultValue = "haha") String host) 
    //required = true必须设置值,不然会报错,如果设置了默认值就会使用默认值
    //required = false表示有就赋值,没有就默认值
    //多请求参数中出现多个同名的请求参数,可以设置字符串或字符串数组来接收
    //若使用字符串类型的形参,最总结构是请求参数使用逗号隔开
    System.out.println("username:" + username + ",password:" + password + ",hobby" + hobby);
    System.out.println("host:" + host);
    return "success";

4.5 @CookieValue

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

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

@RequestMapping("/testParam")
public String testParam(
        @RequestParam(value = "user_name", required = false, defaultValue = "hehe") String username,
        String password,
        String hobby,
        @RequestHeader(value = "sayHaha", required = true, defaultValue = "haha") String host,
        @CookieValue("JSESSIONID") String JSESSIONID) 
    //required = true必须设置值,不然会报错,如果设置了默认值就会使用默认值
    //required = false表示有就赋值,没有就默认值
    //多请求参数中出现多个同名的请求参数,可以设置字符串或字符串数组来接收
    //若使用字符串类型的形参,最总结构是请求参数使用逗号隔开
    System.out.println("username:" + username + ",password:" + password + ",hobby" + hobby);
    System.out.println("host:" + host);
    System.out.println("JSESSIONID:" + JSESSIONID);
    return "success";

4.6 通过POJO获取请求参数

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

<form th:action="@/testBean" method="post">
    用户名:<input type="text" name="username"><br>
    密码:<input type="password" name="password"><br>
    性别:<input type="radio" name="sex" value="男">男<input type="radio" name="sex" value="女">女<br>
    年龄:<input type="text" name="age"><br>
    邮箱:<input type="text" name="email"><br>
    <input type="submit" value="使用实体类接收请求参数">
</form>

public class User 

    private Integer id;
    private String username;
    private String password;
    private Integer age;
    private String sex;
    private String email;

    public User() 
    

    public User(Integer id, String username, String password, Integer age, String sex, String email) 
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
        this.sex = sex;
        this.email = email;
    

    public Integer getId() 
        return id;
    

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

    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;
    

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

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

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

解决获取请求参数的乱码问题,可以使用SpringMVC提供的编码过滤器CharacterEncodingFilter,但是必须在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>
<filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

注:

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

五、域对象共享数据

5.1 使用ServletAPI向request域对象共享数据

<a th:href="@/testRequestByServletAPI">通过servletAPI向request域对象共享数据</a><br>

<p th:text="$testRequestScope"></p>

//使用servletAPI向request域对象共享数据
@RequestMapping("/testRequestByServletAPI")
public String testRequestByServletAPI(HttpServletRequest request)
    request.setAttribute("testRequestScope","hell,servletAPI");
    return "success";

5.2 使用ModelAndView向request域对象共享数据

<a th:href="@/testModelAndView">通过ModelAndView向request域对象共享数据</a><br>

@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView()
    ModelAndView modelAndView = new ModelAndView();
    //处理模型数据.即向请求域request共享数据
    modelAndView.addObject("testRequestScope","hello,modelandview");
    //设置视图名称
    modelAndView.setViewName("success");
    return modelAndView;

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

<a th:href="@/testModel">通过Model向request域对象共享数据</a><br>

@RequestMapping("/testModel")
public String testModel(Model model) 
    model.addAttribute("testRequestScope", "hello,model");
    return "success";

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

<a th:href="@/testMap">通过Map向request域对象共享数据</a><br>

@RequestMapping("/testMap")
public String testMap(Map<String, Object> map) 
    map.put("testRequestScope", "hello,map");
    return "success";

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

<a th:href="@/testModelMap">通过ModelMap向request域对象共享数据</a><br>

@RequestMapping("/testModelMap")
public String testModelMap(ModelMap modelMap) 
    modelMap.addAttribute("testRequestScope", "hello,modelmap");
    return "success";

5.6 Model、ModelMap、Map的关系

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

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

5.7 向session域共享数据

<a th:href="@/testSession">通过testSessionAPI向session域对象共享数据</a><br>

<p th:text="$session.testSessionScope"></p>

@RequestMapping("/testSession")
public String testSession(HttpSession httpSession) 
    httpSession.setAttribute("testSessionScope","hello,session");
    return "success";

5.8 向application域共享数据

<a th:href="@/testApplication">通过servletAPI向application域对象共享数据</a><br>

<p th:text="$application.testApplicationScope"></p>

@RequestMapping("/testApplication")
public String testApplication(HttpSession session) 
    ServletContext servletContext = session.getServletContext();
    servletContext.setAttribute("testApplicationScope", "hello,application");
    return "success";

六、SpringMVC视图

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

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

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

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

6.1 ThymeleafView

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

<a th:href="@testThymeleafView">测试ThymeleafView</a>

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

@RequestMapping("/test_view")
public String testView() 
    return "test_view";

6.2 转发视图

SpringMVC中默认的转发视图是InternalResourceView

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

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

例如"forward:/","forward:/employee"

<a th:href="@testForword">测试InternalResourceView</a><br>

@RequestMapping("/testForword")
public String testForword() 
    return "forward:/testThymeleafView";

6.3 重定向视图

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

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

例如"redirect:/","redirect:/employee"

<a th:href="@testRedirect">测试RedirectView</a><br>

@RequestMapping("/testRedirect")
public String testRedirect() 
    return "redirect:/testThymeleafView";

注:

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

6.4 视图控制器view-controller

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

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

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

注:

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

<mvc:annotation-driven />

七、RESTful

7.1 RESTful简介

REST:Representational State Transfer,表现层资源状态转移。

7.1.1 资源

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

7.1.2 资源的表述

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

7.1.3 状态转移

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

7.2 RESTful的实现

具体说,就是 HTTP 协议里面,四个表示操作方式的动词:GET、POST、PUT、DELETE。

它们分别对应四种基本操作: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请求方式

<a th:href="@/user">查询所有用户信息</a><br>
<a th:href="@/user/1">根据id查询用户信息</a><br>
<form th:action="@/user" method="post">
    用户名:<input type="text" name="username"><br>
    密码:<input type="password" name="password"><br>
    用户名:<input type="submit" name="添加"><br>
</form><br>
<form th:action="@/user" method="post">
    <input type="hidden" name="_method" value="put">
    用户名:<input type="text" name="username"><br>
    密码:<input type="password" name="password"><br>
    用户名:<input type="submit" name="修改"><br>
</form><br>

@Controller
public class UserController 

    /*
     * 使用restful模拟用户资源的增删改查
     * /user     GET       查询所有用户信息
     * /user/1   GET       根据用户id查询所有用户信息
     * /user     POST      添加用户信息
     * /user/1   DELETE    删除用户信息
     * /user     PUT       修改用户信息
     * */

    @RequestMapping(value = "/user", method = RequestMethod.GET)
    public String getAllUser() 
        System.out.println("查询所有用户信息");
        return "success";
    

    @RequestMapping(value = "/user/id", method = RequestMethod.GET)
    public String getUserById() 
        System.out.println("根据id查询用户信息");
        return "success";
    

    @RequestMapping(value = "/user", method = RequestMethod.POST)
    public String insertUser(String username, String password) 
        System.out.println("添加用户信息:" + username + "," + password);
        return "success";
    

    @RequestMapping(value = "/user", method = RequestMethod.PUT)
    public String updateUser(String username, String password) 
        System.out.println("修改用户信息:" + username + "," + password);
        return "success";
    

7.3 HiddenHttpMethodFilter

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

SpringMVC 提供了 HiddenHttpMethodFilter 帮助我们将 POST 请求转换为 DELETE 或 PUT 请求

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

a>当前请求的请求方式必须为post

b>当前请求必须传输请求参数_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

原因:
1.在 CharacterEncodingFilter 中通过 request.setCharacterEncoding(encoding) 方法设置字符集的 
2.request.setCharacterEncoding(encoding) 方法要求前面不能有任何获取请求参数的操作
3.而 HiddenHttpMethodFilter 恰恰有一个获取请求方式的操作:
4.String paramValue = request.getParameter(this.methodParam);

八、RESTful案例

8.1 准备工作

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

• 搭建环境
• 准备实体类

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模拟数据

@Repository
public class EmployeeDao 

    private static Map<Integer, Employee> employees = null;

    static 
        employees = new HashMap<Integer, Employee>();

        employees.put(1001, new Employee(1001, "E-AA", "[e-mail]", 1));
        employees.put(1002, new Employee(1002, "E-BB", "[e-mail]", 1));
        employees.put(1003, new Employee(1003, "E-CC", "[e-mail]", 0));
        employees.put(1004, new Employee(1004, "E-DD", "[e-mail]", 0));
        employees.put(1005, new Employee(1005, "E-EE", "[e-mail]", 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);
    

8.2 功能清单

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

8.3 具体功能:访问首页

8.3.1 配置view-controller

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

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

8.3.2 创建首页

<!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="@/employee">查看员工信息</a>
</body>
</html>

8.4 具体功能:查询所有员工数据

8.4.1 创建employee_list.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Employee Info</title>
    <script type="text/javascript" th:src="@/static/js/vue.js"></script>
</head>
<body>

<table border="1" cellpadding="0" cellspacing="0"  id="dataTable">
    <tr>
        <th colspan="5">Employee Info</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">
        <td th:text="$employee.id"></td>
        <td th:text="$employee.lastName"></td>
        <td th:text="$employee.email"></td>
        <td th:text="$employee.gender"></td>
        <td>
            <a href="">delete</a>
            <a href="">update</a>
        </td>
    </tr>
</table>
</body>
</html>

8.4.2 控制器方法

@RequestMapping(value = "/employee", method = RequestMethod.GET)
public String getAllEmployee(Model model) 
    Collection<Employee> employeeList = employeeDao.getAll();
    model.addAttribute("employeeList", employeeList);
    return "employee_list";

8.5 具体功能:删除

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

<form id="deleteForm" method="post">
    <input type="hidden" name="_method" value="delete">
</form>

8.5.2 删除超链接绑定点击事件

引入vue.js

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

删除超链接

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

通过vue处理点击事件

<script type="text/javascript">
    var vue = new Vue(
        el: "#dataTable",
        methods: 
            deleteEmployee: function (event) 
                //根据id获取表单行为
                var deleteForm = document.getElementById("deleteForm");
                //将触发点击事件的超链接的href属性赋值给表单的action
                deleteForm.action = event.target.href;
                //提交表单
                deleteForm.submit();
                //取消超链接的默认行为
                event.preventDefault();
            
        
    )
</script>

8.5.3 控制器方法

@RequestMapping(value = "/employee/id", method = RequestMethod.DELETE)
public String deleteEmployee(@PathVariable("id") Integer id) 
    employeeDao.delete(id);
    return "redirect:/employee";

8.6 具体功能:跳转到添加数据页面

8.6.1 配置view-controller

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

8.6.3 设置跳转到添加界面

<th>options(<a th:href="@/toAdd">add</a>)</th>

8.6.3 创建employee_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" name="add"><br>
</form>
</body>
</html>

8.6.4 控制器方法

@RequestMapping(value = "/employee", method = RequestMethod.POST)
public String addEmployee(Employee employee) 
    employeeDao.save(employee);
    return "redirect:/employee";

8.7 具体功能:跳转到更新数据页面

8.7.1 修改超链接

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

8.7.2 控制器方法

@RequestMapping(value = "/employee/id", method = RequestMethod.GET)
public String getEmployeeById(@PathVariable("id") Integer id, Model model) 
    Employee employee = employeeDao.get(id);
    model.addAttribute("employee", employee);
    return "employee_update";

8.7.3 创建employee_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>
    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" name="update"><br>
</form>
</body>
</html>

8.7.4 控制器方法

@RequestMapping(value = "/employee", method = RequestMethod.PUT)
public String updateEmployee(Employee employee) 
    employeeDao.save(employee);
    return "redirect:/employee";

九、HttpMessageConverter

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

HttpMessageConverter提供了两个注解和两个类型:@RequestBody,@ResponseBody,RequestEntity,

ResponseEntity

9.1 @RequestBody

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

<form th:action="@/testRequestBody" method="post">
    <input type="text" name="username"><br>
    <input type="text" name="password"><br>
    <input type="submit" value="测试@RequestBody">
</form>

@RequestMapping("/testRequestBody")
public String testRequestBody(@RequestBody String requestBody) 
    System.out.println("requestBody: " + requestBody);
    return "success";

9.2 RequestEntity

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

<form th:action="@/testRequestEntity" method="post">
    <input type="text" name="username"><br>
    <input type="text" name="password"><br>
    <input type="submit" value="测试RequestEntity">
</form>

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

输出结果:

请求头:[host:"localhost:8080", connection:"keep-alive", content-length:"25", cache-control:"max-age=0", sec-ch-ua:""Chromium";v="112", "Google Chrome";v="112", "Not:A-Brand";v="99"", 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/112.0.0.0 Safari/537.36", accept:"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,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/springMVC/", accept-encoding:"gzip, deflate, br", accept-language:"zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7", cookie:"Idea-b88940f1=1be05764-41da-4b77-88d0-b212d1dde1c1; Idea-1352b0e2=400e0d73-0c88-4977-b5a7-fb177e36c05f", Content-Type:"application/x-www-form-urlencoded;charset=UTF-8"]
请求体:username=wmr&password=123

9.3 @ResponseBody

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

<h1>success</h1>

@RequestMapping("/testResponseBody")
@ResponseBody
public String testResponseBody()
    return "success";

浏览器页面显示success

9.4 SpringMVC处理json

@ResponseBody处理json的步骤:

1.导入jackson的依赖

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

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

<mvc:annotation-driven />

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

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

@RequestMapping("/testResponseUser")
@ResponseBody
public User testResponseUser() 
    return new User(1001, "abc", "123", 24, "女");

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

"id":1001,"username":"abc","password":"123","age":24,"sex":"女"

9.5 SpringMVC处理ajax

9.5.1 请求超链接:

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

9.5.2 通过vue和axios处理点击事件:

<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:
            testAxios:function (event) 
                axios(
                    method:"post",
                    url:event.target.href,
                    params:
                        username:"admin",
                        password:"123456"
                    
                ).then(function (response) 
                    alert(response.data);
                );
                event.preventDefault();
            
        
    );
</script>

9.5.3 控制器方法:

@RequestMapping("/testAxios")
@ResponseBody
public String testAxios(String username, String password) 
    System.out.println(username + "," + password);
    return "hello,axios";

9.6 @RestController注解

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

9.7 ResponseEntity

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

十、文件上传和下载

10.1 文件下载

使用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/1.jpg");
        System.out.println(realPath);
        //创建输入流
        InputStream is = new FileInputStream(realPath);
        //创建字节数组
        byte[] bytes = new byte[is.available()];
        //将流读到字节数组中
        is.read(bytes);
        //创建HttpHeaders对象设置响应头信息
        MultiValueMap<String, String> headers = new HttpHeaders();
        //设置要下载方式以及下载文件的名字
        headers.add("Content-Disposition", "attachment;filename=1.jpg");
        //设置响应状态码
        HttpStatus statusCode = HttpStatus.OK;
        //创建ResponseEntity对象
        ResponseEntity<byte[]> responseEntity = new ResponseEntity(bytes, headers, statusCode);
        //关闭输入流
        is.close();
        return responseEntity;
    

10.2 文件上传

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

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

上传步骤:

10.2.1 添加依赖

<depende
SpringMVC概述+SpringMVC运行流程+SpringMVC搭建


        
                

                    
                    


 
文章目录
 
SpringMVC
SpringMVC概述
SpringMVC的运行流程
搭建SpringMVC
1.导入SpringMVC的相关jar包
2.配置DispatcherServlet
3.开启SpringMVC注解
4.配置视图解析器
5.控制器类的搭建
   
  
 

 
SpringMVC
 
SpringMVC概述
 
首先我们了解一下经典的MVC模式，MVC全称Model View Controller，M指业务模型，V指用户界面，C指控制器。使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。Spring MVC属于SpringFrameWork的后续产品。
 
SpringMVC是Spring框架的一个模块，SpringMVC和Spring无需通过中间整合层进行统一整合，已经融合在Spring Web Flow里面。SpringMVC是一个基于MVC的web框架，方便前后端进行数据的传输。SpringMVC拥有控制器，接收外部请求，解析参数传给服务层。
 
SpringMVC的运行流程
 
我们回顾一下我们使用Servlet来完成web项目，如下图：
 
 
使用Servlet来完成web项目时，我们通过Servlet来处理用户页面和数据库之间的数据交互，那时候我们所有的Servlet层代码都需要我们自己去写入，并且会有大量的“重复”代码，严重降低了我们开发的效率，使我们不能专注于业务，SpringMVC就可以很好的为我们解决这一问题。
 
 
1.用户向服务器发送请求，请求被Spring前置控制器DispatcherServlet捕获；
 
2.前端控制器DispatcherServlet接收到请求后，调用映射处理器HandlerMapping。处理器HandlerMapping根据请求的url找到处理该请求的处理器Handler（即Controller），将处理器Handler返回给前端控制器DispatcherServlet。
 
3.DispatcherServlet根据获得的Handler，选择一个合适的HandlerAdapter。在填充Handler的入参过程中，根据配置，Spring会做出一些额外的工作：
 
（1）HttpMessageConveter：将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应消息。
 
（2）数据转换：对请求消息进行数据转换。如String转换为Integer、Double等。
 
（3）数据格式化：对请求消息进行数据格式化。如将字符串转换为格式化数字或格式化日期等等。
 
（4）数据验证：验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中。
 
4.Handler控制器执行完毕后，会向DispatcherServlet返回一个ModelAndView对象。
 
5.根据返回的ModelAndView，选择一个适合的ViewResolver视图解析器（必须是已经注册到Spring中的视图解析器）返回给DispacherServlet；
 
6.ViewResolver结合Model和View来渲染视图；
 
7.将渲染后的结果响应给客户端。
 
搭建SpringMVC
 
搭建完整的SpringMVC项目需要在spring的基础上进行，大家可以阅读我的这几篇文章进行学习
 
学习Spring之前必读的文章，Spring框架第0章（Spring核心+优点+体系结构+简单搭建）
 
Spring框架的IOC设计思想+Spring的Bean管理
 
一文搞懂SpringAOP(面向切面编程)
 
Spring事务特征+Spring事务管理+实现+Spring七种事务传播行为+集成MyBatis
 
1.导入SpringMVC的相关jar包
 
<!--SpringMVC依赖的jar包-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>
 
如果使用jsp的el表达式，还需要导入jstl的jar包
 
<!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

<!--加servlet-->
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.0</version>
    <scope>provided</scope>
</dependency>
 
2.配置DispatcherServlet
 
DispatcherServlet是从HttpServlet中继承而来。所以它是一个标准的Servlet，因此我们需要在web.xml文件中进行配置，使它在启动时加载Spring配置文件。
 
在web.xml文件中配置：
 
	<!--配置spring核心请求分发的的DisPatcherServlet-->
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <!--把Spring的配置文件交给contextConfogLocation-->
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring.xml</param-value>
        </init-param>
        <!--服务器启动时就初始化DispatcherServlet和启动 spring-->
        <load-on-startup>0</load-on-startup>
    </servlet>
    <!--
        请求映射
        所有的请求都会进入DispatcherServlet(分发器)
    -->
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
 
3.开启SpringMVC注解
 
在Spring.xml文件中配置开启SpringMVC注解
 
<!--开启SpringMVC的注解功能-->
<mvc:annotation-driven></mvc:annotation-driven>
 
4.配置视图解析器
 
在Spring.xml文件中配置视图解析器
 
<!--配置视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"></property>
    <!--控制器返回的所有视图界面的prefix（前缀）都要为value-->
    <property name="prefix" value="/WEB-INF/pages/"></property>
    <!--控制器返回的所有视图界面的suffix（后缀）都要为value-->
    <property name="suffix" value=".jsp"></property>
</bean>
 
5.控制器类的搭建
 
我们使用@Controller注解标签标记SpringMVC的Controller对象，即控制器类。同时，我们也要使用RequestMapping注解来标记请求地址映射，可用在类或方法上。
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;


@Controller//扫描到这个类后交给IOC管理,用于创建对象,默认是单例的,多线程情况下线程不安全
@RequestMapping(path = "/user")//指定一个映射的地址,属性为value或path都一样,可以指定多个,
public class UserController {

    @RequestMapping(path = "/toLogin")//指定请求方式
    public ModelAndView toLogin() {
        System.out.println("toLogin");
        ModelAndView mv = new ModelAndView("login");;
        return mv;
    }

}
 
这时当我们要访问toLogin（）方法是的路径就是/user/toLogin
                
                
                
        
以上是关于SpringMVC的主要内容，如果未能解决你的问题，请参考以下文章
 
 springmvc的特点
 学习笔记——SpringMVC简介；SpringMVC处理请求原理简图；SpringMVC搭建框架
 SpringMVC
 springMVC学习笔记初识springmvc
 SpringMVC
 springMVC1  springmvc的基础知识