江小月不上頭

有容乃大，无欲则刚

0%

SpringMVC基础大全

发表于 更新于 分类于 ，

一、SpringMVC简介

1.1 什么是MVC

  • MVC：软件架构思想
  • M：模型层，指工程中的bean
  • V：视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据
  • C：控制层，指工程中的servlet，用于接收请求和响应数据
  • MVC工作流程：视图层发送请求到服务器，服务器请求被控制层接收，控制层调用响应的模型层处理请求，处理完之后将结果返回控制层，控制层，再根据请求处理的结果找到相应的视图层，渲染数据后最终相应给浏览器

二、一个案例

2.1 创建MAVEN工程

  • 在pom文件中设置打包方式为war包
1
<packaging>war</packaging>

2.2 引入依赖

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

    <!-- https://mvnrepository.com/artifact/ch.qos.logback/logback-classic -->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
        <scope>test</scope>
    </dependency>

    <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
        <scope>provided</scope>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.thymeleaf/thymeleaf-spring5 -->
    <dependency>
        <groupId>org.thymeleaf</groupId>
        <artifactId>thymeleaf-spring5</artifactId>
        <version>3.0.12.RELEASE</version>
    </dependency>

</dependencies>

2.3 创建webapp

  • 在mian目录下创建webapp文件夹
  • 在webapp下创建文件夹WEB-INF
  • 在项目结构窗口的modules窗口中添加web.xml配置，注意路径要在WEB-INF前添加上src/main/webapp
  • 在WEB-INF中创建templates/index.html

2.4 配置web.xml

2.4.1 默认配置方式

  • 此配置作用下，SpringMVC的配置文件默认位于WEB-INF下，默认名称为<servlet-name>-servlet.xml，例如以下配置所对应的SpringMVC的配置文件位于WEB-INF下，文件名为SpringMVC-servlet.xml
  • 不推荐，因为spring配置资源一般都是放在resources下的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!--  配置SpringMVC前端控制器，对浏览器发送的请求进行统一处理  -->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    </servlet>

    <servlet-mapping>
    <!--
        设置SpringMVC核心控制器所能处理的请求路径
        / 所匹配的请求可以是/login或.html/.css/.js等方式的请求路径
        但不匹配.jsp请求路径的请求

    -->
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

2.4.2 扩展配置方式（推荐）

  • 加入init-param，设置配置资源路径
  • 配置好init-param后，需要在resources中创建springMVC.xml配置文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<!--  配置SpringMVC前端控制器，对浏览器发送的请求进行统一处理  -->
<servlet>
    <servlet-name>springMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <!--    配置SpringMVC配置文件的位置和名称，然后在reources中创建xml配置文件    -->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springMVC.xml</param-value>
    </init-param>
    
            <!--    将前端控制器DispatcherServlet启动时间提前到服务器启动的时候    -->
    <!--    提升第一次访问的速度    -->
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<!--
    设置SpringMVC核心控制器所能处理的请求路径
    / 所匹配的请求可以是/login或.html/.css/.js等方式的请求路径
    但不匹配.jsp请求路径的请求

-->
    <servlet-name>springMVC</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

2.5 配置springMVC.xml

2.5.1 开启自动扫描

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

2.5.2 添加Thymeleaf视图解析器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<!-- 配置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>

2.5.3 静态资源处理配置

  • 暂时不需要配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<!--
   处理静态资源，例如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 控制层实现

  • 创建controller层实现类
1
2
3
4
5
6
7
8
9
10
@Controller
public class HelloController {
    
    // 请求地址映射，实现页面跳转
    @RequestMapping(value = "/")
    public String index(){
        return "index";
    }
}

2.7 编写页面

2.7.1 添加thymeleaf命名空间

  • 在html标签内写入xmlns:th="http://www.thymeleaf.org"
1
2
3
4
5
6
7
8
9
10
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>首页</h1>
</body>
</html>

2.8 配置服务器

  • 使用tomcat服务器部署项目并运行
  • 注意这些选项的配置
    • 简化访问路径和调试方式

三、RequestMapping注解

3.1 简介

  • 将请求和控制器方法联系起来

3.2 注解位置

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

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

3.3 注解属性

3.3.1 value

  • @RequestMapping注解的value属性是一个字符串类型的数组，表示该请求映射能够匹配多个请求地址所对应的请求
    • 一个方法可以对应多个请求
1
2
<a th:href="@{/testRequestMapping}">测试@RequestMapping的value属性-->/testRequestMapping</a><br>
<a th:href="@{/test}">测试@RequestMapping的value属性-->/test</a><br>
1
2
3
4
5
6
@RequestMapping(
        value = {"/testRequestMapping", "/test"}
)
public String testRequestMapping(){
    return "success";
}

3.3.2 method

  • 配置请求方式，如果浏览器请求方式与method方式不匹配，则会报错405
  • @RequestMapping注解的method属性是一个RequestMethod类型的数组，表示该请求映射能够匹配多种请求方式的请求
1
2
3
4
<a th:href="@{/test}">测试@RequestMapping的value属性-->/test</a><br>
<form th:action="@{/test}" method="post">
    <input type="submit">
</form>
1
2
3
4
5
6
7
@RequestMapping(
        value = {"/testRequestMapping", "/test"},
        method = {RequestMethod.GET, RequestMethod.POST}
)
public String testRequestMapping(){
    return "success";
}
  • @RequestMapping的派生注解
    • @GetMapping
    • @PostMapping
    • @PutMapping
    • @DeleteMapping

  • 常用的请求方式：get、post、put、delete

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

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

3.4 ant风格路径

  • RequestMapping设置的请求地址时会使用到以下匹配字符
    • ?：表示任意的单个字符
    • *：表示任意的0个或多个字符
    • **：表示任意的一层或多层目录

3.5 占位符（RESTful）

  • 原始请求路径：/deleteUser?id=1

  • RESTful风格请求地址：/deleteUser/{id}

    • 比如请求地址为/deleteUser/1，与原始请求路径方式作用一致
    • {xxx}匹配请求参数，可以使用多个，如：/deleteUser/{id}/{username}

  • 控制器获取RESTful风格请求的参数方式：

    • 需要使用注解@PathVariable，对应请求参数
  • 配置了RESTful风格请求路径，就无法使用原始请求路径进行访问了
1
2
3
4
@RequestMapping("/testRequestMapping/{id}",)
public String testRequestMapping(@PathVariable("id")Integer id){
    return "success";
}

四、获取请求参数

4.1 RequestParam注解

  • 配置需要的请求参数名
  • value可以配置参数名
  • required可以设置请求参数是否必须要传递，默认为true
    • 设置为false之后，没有传这个参数，方法形参得到的值就是null
  • defaultValue表示为形参设置默认值
    • 前端需要传递参数但没有传递值，如/user?id=&username=
1
2
3
4
@RequestMapping("/testRequestMapping")
public String testRequestMapping(@RequestParam(value="id",required = false，defaultValue = 1)Integer id){
    return "success";
}

4.2 RequestHeader注解

  • 同RequestParam，拥有value/required/defaultValue属性
  • 用于获取请求头信息

4.3 CookieValue注解

  • 同RequestParam，拥有value/required/defaultValue属性
  • 用于获取cookie信息

4.4 实体类获取请求参数

  • 当表单的name属性和实体类的属性一一对应时，使用实体类形参即可获取到请求信息
1
2
3
4
@RequestMapping("/testRequestMapping")
public String testRequestMapping(User user){
    return "success";
}
  • 以上方式可以接收表单请求数据，但是user数据在控制台打印时会出现乱码的问题
  • get请求数据乱码可以修改tomcat配置文件server.xml的URIEncoding属性
  • post请求乱码需要在web.xml中配置过滤器进行处理
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<!--  配置过滤器  -->
<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>

五、域对象共享数据

5.1 Servlet四大作用域

  • page：对应pageContext对象，JSP页面容器（page对象）,当前页面有效（重定向/请求转发都会使其无效）
  • request：对应HttpServletContext对象，请求对象，同一次请求有效（请求转发有效、重定向无效）
  • session：对应HttpSession对象，会话对象，同一次会话有效（请求转发/重定向有效，关闭/切换浏览器无效）
  • application：对应ServletContext对象，全局对象，全局有效（整个项目运行期间/切换浏览器都有效，关闭服务、其他项目中无效）
  • 有效的意思是说以上4个对象使用setAttribute()方法后的有效范围
  • 尽量使用最小的范围，作用域越大，系统开销越大
  • 经常改动的数据一般使用较小的作用域，不常变动的数据一般使用较大的作用域

5.2 request域对象共享数据

  • 控制器方法执行后都会统一返回ModelAndView对象，其中包含了页面view对象信息和向域对象model中共享的数据

  • 通过ServletAPI向request域共享对象

1
2
3
4
5
@RequestMapping("/testServletAPI")
public String testServletAPI(HttpServletRequest request){
    request.setAttribute("testScope", "hello,servletAPI");
    return "success";
}
  • thymeleaf/index页面
1
<a th:href="@{/success}">request域测试</a>
  • thymeleaf/success页面
1
<p th:text="${name}"></p>

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//返回ModelAndView提交前端控制器进行处理
@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView(){
    /**
     * ModelAndView有Model和View的功能
     * Model主要用于向请求域共享数据
     * View主要用于设置视图，实现页面跳转
     */
    ModelAndView mav = new ModelAndView();
    //向请求域共享数据
    mav.addObject("testScope", "hello,ModelAndView");
    //设置视图，实现页面跳转
    mav.setViewName("success");
    return mav;
}

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

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

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

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

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

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

5.7 Model、ModelMap、Map的关系

  • Model、ModelMap、Map类型的参数其实本质上都是 BindingAwareModelMap 类型的
  • BindingAwareModelMap可以实例化Model、ModelMap、Map

5.8 向session域共享数据

1
2
3
4
5
@RequestMapping("/testSession")
public String testSession(HttpSession session){
    session.setAttribute("testSessionScope", "hello,session");
    return "success";
}
  • 访问session域的共享数据
1
<p th:text="${session.name}"></p>

5.9 向application域共享数据

1
2
3
4
5
6
@RequestMapping("/testApplication")
public String testApplication(HttpSession session){
	ServletContext application = session.getServletContext();
    application.setAttribute("testApplicationScope", "hello,application");
    return "success";
}
  • 访问application域的共享数据
1
<p th:text="${application.name}"></p>

六、SpringMVC视图

6.1 介绍

  • SpringMVC中的视图是View接口，视图的作用是渲染页面，将模型Model中的数据展示给用户
  • SpringMVC中的视图种类很多，默认有转发视图InternalResourceView和重定向视图RedirectView
  • 当工程引入jstl的依赖，转发视图会自动转换为jstlView
  • 若使用的视图技术为Thymeleaf，在SpringMVC的配置文件中配置了Thymeleaf的视图解析器，由此视图解析器解析之后得到的是ThymeleafView

6.2 请求转发和重定向

  • 以下示例，客户端登录需要经过后端校验，然后进行页面跳转
区别 请求转发 重定向
地址栏是否改变 不变check.jsp 改变success.jsp
是否保留第一次请求的数据 保留 不保留
请求次数 1 2
跳转发生的位置 服务端 客户端发出的第二次跳转

6.2.1 请求转发和重定向的使用情况

  • 请求转发时，如果是一个表单提交数据（如用户登录），地址栏会保持在check
    • 这时如果用户刷新页面，就会出现用户需要重新提交表单的情况
  • 对于需要频繁的提交数据的情况，使用请求转发就又可能出现重复提交数据的情况

6.2.2 示例

（1）分析

  • 写了一个index登录表单，success和error页面，比较下请求转发和重定向的区别
  • index用户登录表单发起/check，地址栏先显示/check，后端处理请求
  • 注：请求转发和重定向都要写出对应的请求方法，比如下面的/success和/error都需要写出来，如下图：
    • 从图中可以看到，请求转发是在服务器内部发生请求的调用，/check->/error
    • 重定向方式是浏览器行为，浏览器会重新发起一次请求才能进行页面的跳转

（2）实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@Controller
public class ShowController {
    @RequestMapping("/")
    public String index(){
        return "index";
    }

    @RequestMapping("/check")
    public String check(String username,String pwd){
        if(username.equals("zs") && pwd.equals("123123")){
            return "forward:/success";
        }
        else{
            return "forward:/error";
        }
    }

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

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

6.2.3 小结

  • 如果当前请求依赖其他请求，就需要用到请求转发和重定向的方式
  • 如果只是普通的页面跳转则不需要这些操作
  • SpringMVC有三个视图解析器：ThymeleafView、InternalResourceView（请求转发解析器）、RedirectView（重定向解析器）
    • return返回值中不加任何前缀的字段会交给ThymeleafView解析
    • return返回值中加前缀forward:的字段会交给InternalResourceView解析
    • return返回值中加前缀redirect:的字段会交给RedirectView解析

6.3 ThymeleafView

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

6.4 转发视图

  • SpringMVC中默认的转发视图是InternalResourceView
  • SpringMVC中创建转发视图的情况：
    • 当控制器方法中所设置的视图名称以”forward:”为前缀时，创建InternalResourceView视图，此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀”forward:”去掉，剩余部分作为最终路径通过转发的方式实现跳转
  • 示例：
1
2
3
4
@RequestMapping("/testForward")
public String testForward(){
    return "forward:/testHello";
}

6.5 重定向视图

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

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

  • 示例：
1
2
3
4
@RequestMapping("/testRedirect")
public String testRedirect(){
    return "redirect:/testHello";
}

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

6.6 视图控制器view-controller

  • 当控制器方法中，仅仅用来实现页面跳转，即只需要设置视图名称时，可以将处理器方法使用view-controller标签进行表示
  • 需要在springMVC.xml中添加
1
2
3
4
5
<!--
	path：设置处理的请求地址
	view-name：设置请求地址所对应的视图名称
-->
<mvc:view-controller path="/testView" view-name="success"></mvc:view-controller>

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

​

七、RESTful

7.1 RESTFul简介

  • 全称：Representational State Transfer，表现层状态转移

7.2 RESTFul的实现

  • RESTFul风格的URL请求地址
操作 传统方式 REST风格
查询 getUserById?id=1 user/1
保存 saveUser user
删除 deleteUser?id=1 user/1
更新 updateUser user

7.3 PUT和DELETE请求处理

7.3.1 简介

  • 由于浏览器只支持发送get和post方式的请求，那么该如何发送put和delete请求呢？
  • SpringMVC 提供了 HiddenHttpMethodFilter 帮助我们将 POST 请求转换为 DELETE 或 PUT 请求

7.3.2 HiddenHttpMethodFilter配置

  • 在web.xml中过滤器中注册HiddenHttpMethodFilter
1
2
3
4
5
6
7
8
<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>
  • 配置完HiddenHttpMethodFilter之后，如果是用表单进行修改，需要如下设置
  • HiddenHttpMethodFilter 处理put和delete请求的条件：
    • 当前请求的请求方式必须为post
    • 当前请求必须传输请求参数_method
1
2
3
4
5
6
7
8
9
10
11
12
<!--修改用户信息表单，method必须指定为post-->
<form th:action="@{/user}" method="post">
    <!-- 
	配置完过滤器后一定要在表单下添加_method字段，交给后端过滤器进行处理
	在value中指定修改操作所确定的PUT请求
	-->
    <input type="hidden" name="_method" value="PUT">
    
    用户名：<input type="text" name="username"><br/>
    密码：<input type="text" name="password"><br/>
    <input type="submit" value="修改"><br/>
</form>

7.3.3 小结

  • 过滤器的执行顺序：当配置有多个过滤器时，SpringMVC会按照filter-mapping的编写顺序进行配置
  • 对于之前写的CharacterEncodingFilter，如果前面写了处理请求的其他过滤器，那么处理编码的过滤器就会失效，所以我们要先配置编码过滤器，再编写请求过滤器

7.4 RESTFul案例

7.4.2 静态资源访问

  • springMVC.xml中没有配置静态资源时，在static目录中存放的css和js等静态文件就不会被访问到，前端就不会展示静态资源效果
  • 主要原因的SpringMVC的DispatchServlet找不到静态资源文件，所以需要配置springMVC.xml开启默认DefaultServlet来访问静态资源，这样在浏览器的地址栏中就可以访问到静态资源文件了
    • tomcat的配置目录conf中也有web.xml，里面就配置了DefaultServlet
  • 必须开启静态资源的访问才能保证静态资源能够被正确访问到，在springMVC.xml中添加如下标签
1
2
3
4
5
<!--开放对静态资源的访问-->
<mvc:default-servlet-handler/>

<!--开启mvc注解驱动-->
<mvc:annotation-driven/>
  • 同时需要注意的是，mvc注解驱动也要同时开启，不然控制器请求会全部被默认的Servlet获取到
  • 配置完两个标签后，前端请求会先被DispatchServlet获取到，DispatchServlet处理不了，就会把请求交给DefaultServlet处理，DefaultServlet再处理不了，浏览器就会报404

八、HttpMessageConverter报文信息转换器

8.1 简介

  • HttpMessageConverter，报文信息转换器，将请求报文转换为Java对象，或将Java对象转换为响应报文
  • HttpMessageConverter提供了两个注解和两个类型
    • 注解：@RequestBody，@ResponseBody
    • 类型：RequestEntity，ResponseEntity
  • RequestEntity可以接收整个请求报文

8.2 @RequestBody

  • @RequestBody可以获取请求体，需要控制器设置一个形参
  • @RequestBody标识形参后，形参就可以获取到请求体的信息
1
2
3
4
5
<form th:action="@{/testRequestBody}" method="post">
    用户名：<input type="text" name="username"><br>
    密码：<input type="password" name="password"><br>
    <input type="submit">
</form>
1
2
3
4
5
6
7
@RequestMapping("/testRequestBody")
public String testRequestBody(@RequestBody String requestBody){
    System.out.println("requestBody:"+requestBody);
    return "success";
}

// 输出结果：requestBody:username=admin&password=123456

8.3 RequestEntity

  • RequestEntity是封装请求报文的一种类型，控制器以RequestEntity对象作为形参接收请求信息
  • RequestEntity有一些方法可以获取到请求信息
    • getHeaders()：获取请求头信息
    • getBody()：获取请求体信息
1
2
3
4
5
6
@RequestMapping("/testRequestEntity")
public String testRequestEntity(RequestEntity<String> requestEntity){
    System.out.println("requestHeader:"+requestEntity.getHeaders());
    System.out.println("requestBody:"+requestEntity.getBody());
    return "success";
}

8.4 @ResponseBody

  • @ResponseBody用于标识一个控制器方法，可以将该方法的返回值直接作为响应报文的响应体响应到浏览器
  • 以下控制器方法会直接在页面打印出”success”，而不是作为success页面进行显示
  • 综上：@ResponseBody可以直接向浏览器响应数据，如果不使用该注解，则可以使用传统方式HttpServletResponse处理响应
1
2
3
4
5
@RequestMapping("/testResponseBody")
@ResponseBody
public String testResponseBody(){
    return "success";
}

8.5 SpringMVC处理Json

  • SpringMVC并不能直接使用将ReponseBody注解的控制器方法的返回值直接转换为Json数据，必须依赖其他包完成Java对象到Json数据的转换

8.5.1 Jackson包

  • 导入Jackson依赖
1
2
3
4
5
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.12.1</version>
</dependency>
  • 在SpringMVC的核心配置文件中开启mvc注解驱动，此时在HandlerAdaptor中会自动装配一个消息转换器：MappingJackson2HttpMessageConverter，可以将响应到浏览器的Java对象转换为Json格式的字符串，注意不是Json对象
1
<mvc:annotation-driven />
  • 在处理器方法上使用@ResponseBody注解进行标识
  • 将Java对象直接作为控制器方法的返回值返回，就会自动转换为Json格式的字符串
1
2
3
4
5
6
7
@RequestMapping("/testResponseUser")
@ResponseBody
public User testResponseUser(){
    return new User(1001,"admin","123456",23,"男");
}

// 浏览器响应结果：{"id":1001,"username":"admin","password":"123456","age":23,"sex":"男"}

8.6 @RestController注解

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

8.7 ResponseEntity

  • ResponseEntity用于控制器方法的返回值类型，该控制器方法的返回值就是响应到浏览器的响应报文
  • 可以实现文件下载

九、文件上传和下载

9.1 文件下载

  • 使用ResponseEntity实现下载文件的功能
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@RequestMapping("/testDown")
public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws IOException {
    //获取ServletContext对象
    ServletContext servletContext = session.getServletContext();
    //获取服务器中文件的真实路径，即项目resources目录下的文件地址
    String realPath = servletContext.getRealPath("/static/img/1.jpg");
    //创建输入流
    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;
}

9.2 文件上传

  • 文件上传要求form表单的请求方式必须为post，并且添加属性enctype=”multipart/form-data”
  • SpringMVC中将上传的文件封装到MultipartFile对象中，通过此对象可以获取文件相关信息

9.2.1 导入依赖

1
2
3
4
5
6
<!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
</dependency>

9.2.2 SpringMVC添加配置

  • 必须给这个bean配置id属性”multipartResolver” ，否则这个bean就访问不到
1
2
<!--必须通过文件解析器的解析才能将文件转换为MultipartFile对象-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>

9.2.3 控制器方法

  • 如果不处理重名情况，当重新上传时会覆盖掉原来上传的重名的文件，这不是我们想要的情况，所以要通过UUID处理重名的情况，为文件重命名
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@RequestMapping("/testUp")
public String testUp(MultipartFile photo, HttpSession session) throws IOException {
    //获取上传的文件的文件名
    String fileName = photo.getOriginalFilename();
    //处理文件重名问题，获取文件扩展名，包括"."
    String hzName = fileName.substring(fileName.lastIndexOf("."));
    fileName = UUID.randomUUID().toString() + hzName;
    //获取服务器中photo目录的路径
    ServletContext servletContext = session.getServletContext();
    String photoPath = servletContext.getRealPath("photo");
    File file = new File(photoPath);
    if(!file.exists()){
        file.mkdir();
    }
    // File.separator为文件分隔符
    String finalPath = photoPath + File.separator + fileName;
    //实现上传功能
    photo.transferTo(new File(finalPath));
    return "success";
}

十、拦截器

11.1 过滤器与拦截器

11.2 拦截器配置

  • 创建拦截器类FirstInterceptor，并重写三个方法
    • preHandle()
    • postHandle()
    • afterCompletion()
1
2
3
4
5
6
7
8
9
10
11
12
13
public class FirstInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return false;
    }

    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}
  • 在springMVC配置文件中注入我们创建的拦截器类
    • 方式一和方式二都可实现拦截器的注入
    • /**：表示拦截所有请求，包括/user/add、/user
    • /*：表示拦截所有根请求下的请求，如/user、/add，不包括/user/add
1
2
3
4
5
6
7
8
<mvc:interceptors>
    <mvc:interceptor>
        <!--方式一，这里的bean名称就是我们配置的拦截器类-->
        <ref bean="firstInterceptor"></ref>
        <!--方式二-->
        <bean class="com.atguigu.interceptor.FirstInterceptor"></bean>
    </mvc:interceptor>
</mvc:interceptors>
  • 或者直接在springMVC配置文件中配置拦截和放行的请求
1
2
3
4
5
6
7
8
9
10
11
12
<mvc:interceptors>
    <mvc:interceptor>
        <!--拦截的请求-->
        <mvc:mapping path="/**"/>

        <!--放行的请求-->
        <mvc:exclude-mapping path="/testRequestEntity"/>

        <!--拦截器类还是要配置的-->
        <ref bean="firstInterceptor"></ref>
    </mvc:interceptor>
</mvc:interceptors>

11.3 拦截器方法

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

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

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

11.4 拦截器执行顺序

  • 当我们创建了多个拦截器类，它们拦截了相同的请求，那么处理的顺序是怎么样的，需要我们了解下

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

  • 我们在springMVC中配置拦截器的顺序就是多个拦截器执行的顺序
  • 拦截器中的preHandle()会按照配置的顺序执行，而postHandle()和afterComplation()会按照配置的反序执行，如下：
  • 原理：在源码中，SpringMVC为每个拦截器提供了一个索引InterceptorIndex
    • 当拦截器拦截请求时，是顺序遍历拦截器并执行preHandle()方法，InterceptorIndex遍历一遍始终保存上一个拦截器的索引值，本质上是顺序遍历的自增的i值
    • 当执行postHandle()和AfterCompletion()时，则根据InterceptorIndex的值进行反向遍历（从大到小），因此postHandle()和AfterCompletion的执行顺序是反向的

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

  • preHandle()返回false的拦截器之前的拦截器的preHandle()和afterComplation()都会执行，但postHandle()不会执行
  • 原理：假设有5个拦截器，第3个拦截器prehandle()返回false对请求进行拦截
    • 顺序执行到第3个拦截器的preHandle()时返回false，SpringMVC经过判断后，则直接根据InterceptorIndex去处理第3个拦截器之前的拦截器的AfterCompletion()方法，而不去执行postHandle()方法，并直接return，并不执行视图渲染

十一、异常处理

11.1 xml配置文件配置

  • 在springMVC配置文件中进行配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <property name="exceptionMappings">
        <props>
        	<!--
        		properties的键表示处理器方法执行过程中出现的异常
        		properties的值表示若出现指定异常时，设置一个新的视图名称，跳转到指定页面
				error为指定跳转的视图名称，即出现ArithmeticException异常就会跳转到error页面
        	-->
            <prop key="java.lang.ArithmeticException">error</prop>
        </props>
    </property>
    <!--
    	exceptionAttribute属性设置一个属性名，将出现的异常信息在请求域（默认）中进行共享，在页面输出th:text="${ex}"的信息时，就会在页面打印出异常信息
    -->
    <property name="exceptionAttribute" value="ex"></property>
</bean>

11.2 注解配置异常

  • 异常控制器，写在controller层中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
//@ControllerAdvice将当前类标识为异常处理的组件
@ControllerAdvice
public class ExceptionController {

    //@ExceptionHandler用于设置所标识方法处理的异常
    @ExceptionHandler(ArithmeticException.class)
    //ex表示当前请求处理中出现的异常对象
    public String handleArithmeticException(Exception ex, Model model){
        // model中添加错误信息，方便前端显示
        model.addAttribute("ex", ex);
        return "error";
    }

}

十二、注解配置

12.1 创建初始化类，代替web.xml

  • 创建两个配置类
    • SpringConfig
    • WebConfig
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {

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

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

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

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

12.2 创建SpringConfig配置类，代替Spring配置文件

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

12.3 创建WebConfig配置类，代替SpringMVC的配置文件

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

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

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

    //配置拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        FirstInterceptor firstInterceptor = new FirstInterceptor();
        registry.addInterceptor(firstInterceptor).addPathPatterns("/**");
    }
    
    //配置视图控制
    
    /*@Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("index");
    }*/
    
    //配置异常映射
    /*@Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
        Properties prop = new Properties();
        prop.setProperty("java.lang.ArithmeticException", "error");
        //设置异常映射
        exceptionResolver.setExceptionMappings(prop);
        //设置共享异常信息的键
        exceptionResolver.setExceptionAttribute("ex");
        resolvers.add(exceptionResolver);
    }*/

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

    //生成模板引擎并为模板引擎注入模板解析器
    @Bean
    public SpringTemplateEngine templateEngine(ITemplateResolver templateResolver) {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(templateResolver);
        return templateEngine;
    }

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


}

十三、SpringMVC执行流程