SpringMVC学习笔记

SpringMVC简介
HelloWorld
@RequestMapping注解
SpringMVC获取请求参数
向域对象中存放共享数据
SpringMVC的视图
RESTful
HttpMessageConverter
拦截器
异常处理器
使用注解配置SpringMVC
SpringMVC执行流程
总结

javaSE -> JavaWeb -> SSM（SpringMVC、Spring、MyBatis） -> JavaEE -> SpringBoot、SpringCloud

涉及的spring模块：

spring-webmvc（包含了aop、bean、context、core、expression、spring-web）

SpringMVC简介

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视图，渲染数据后最终响应给浏览器

2、什么是SpringMVC

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

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

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

3、SpringMVC的特点

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

HelloWorld

1、开发环境
构建工具：maven3.5.4，服务器：tomcat8，Spring版本：5.3.1

2、创建maven工程
a>添加web模块
b>打包方式：war
c>引入依赖

 <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 的传递性，我们不必将所有需要的包全部配置依赖，而是配置最顶端的依赖，其他靠传递性导入。
thymeleaf-spring5的3.0.12.RELEASE版本导入后xml文件找不到与spring整合的类，使用3.0.15.RELEASE

3、配置web.xml
注册SpringMVC的前端控制器DispatcherServlet

a>默认配置方式

此配置作用下，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>

b>扩展配置方式

可通过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处理，从而找不到相应的页面。
/*则能够匹配所有请求，例如在使用过滤器时，若需要对所有请求进行过滤，就需要使用/*的写法

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

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

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

5、创建springMVC的配置文件

 <!-- 自动扫描包 -->
<context:component-scan base-package="com.atguigu.mvc.controller"/>
 
<!-- 配置Thymeleaf视图解析器 -->
<bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
    <property name="order" value="1"/>
    <property name="characterEncoding" value="UTF-8"/>
    <property name="templateEngine">
        <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
            <property name="templateResolver">
                <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
                    <!-- 视图前缀 -->
                    <property name="prefix" value="/WEB-INF/templates/"/>
                    <!-- 视图后缀 -->
                    <property name="suffix" value=".html"/>
                    <property name="templateMode" value="HTML5"/>
                    <property name="characterEncoding" value="UTF-8" />
                </bean>
            </property>
        </bean>
    </property>
</bean>
 
<!--
   处理静态资源，例如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>

6、测试HelloWorld

a>实现对首页的访问

在请求控制器中创建处理请求的方法，访问/时返回首页index.html

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

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

在主页index.html中设置超链接，点击这个超链接会调用控制器中对应的/hello路径方法

 <!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="@{/hello}">HelloWorld</a><br/>
</body>
</html>

在请求控制器中创建处理请求的方法：该控制器返回另外一个视图target

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

7、总结

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

@RequestMapping注解

@RequestMapping注解的功能

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

@RequestMapping注解的位置

可以放在类上，也可以放在方法上，放在类上的表示初始路径，放在方法上的表示具体路径，必须有放在方法上的@RequestMapping，该方法才能被映射

@RequestMapping注解的属性

value属性，设置请求映射的匹配路径，类似是String数组，可以写多个
method属性，设置匹配的方法（GET/POST...），可以写多个，不满足method属性的匹配会报405
- 派生注解：@GetMapping、@PostMapping、@PutMapping...
- 浏览器只支持get/post
- 若要发送put和delete请求，则需要通过spring提供的过滤器HiddenHttpMethodFilter
params属性，设置匹配的请求参数，不能匹配报400
- "param"，必须携带的请求参数param
- "!param"，必须不能携带的参数param，
- "param=value"，必须携带请求参数且param=value
- "param!=value"，必须携带请求参数且param!=value
headers属性，设置匹配的请求头参数，不能匹配报404
- 设置方法同上
SpringMVC支持ant风格的路径
- ?：表示任意的单个字符
- *：表示任意的0个或多个字符
- **：表示任意的一层或多层目录，注意：在使用**时，只能使用/**/xxx的方式
SpringMVC支持路径中的占位符
- 当请求路径中将某些数据通过路径的方式传输到服务器中，就可以在相应的@RequestMapping注解的value属性中通过占位符{xxx}表示传输的数据，在通过@PathVariable注解，将占位符所表示的数据赋值给控制器方法的形参
- 如@RequestMapping("/testRest/{id}/{username}")
- public String testRest(@PathVariable("id") String id, @PathVariable("username") String username)就可以拿到请求路径中的参数

SpringMVC获取请求参数

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

 @RequestMapping("/testParam")
public String testParam(HttpServletRequest request){
    String username = request.getParameter("username");
    String password = request.getParameter("password");
    System.out.println("username:"+username+",password:"+password);
    return "success";
}

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

 //<a th:href="@{/testParam(username='admin',password=123456)}">测试获取请求参数-->/testParam</a><br>
@RequestMapping("/testParam")
public String testParam(String username, String password){
    System.out.println("username:"+username+",password:"+password);
    return "success";
}

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

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

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

@RequestParam，将请求参数和控制器方法的形参创建映射关系，有三个属性：
- value：指定为形参赋值的请求参数的参数名
- required：设置是否必须传输此请求参数，默认值为true
  - 若设置为true时，则当前请求必须传输value所指定的请求参数，若没有传输该请求参数，且没有设置defaultValue属性，则页面报错400：Required String parameter 'xxx' is not present；若设置为false，则当前请求不是必须传输value所指定的请求参数，若没有传输，则注解所标识的形参的值为null
- defaultValue：不管required属性值为true或false，当value所指定的请求参数没有传输或传输的值为""时，则使用默认值为形参赋值，地址栏?a=这种a的值为空字符串
@RequestHeader
将请求头信息和控制器方法的形参创建映射关系，有三个属性：value、required、defaultValue，用法同@RequestParam
@CookieValue
将cookie数据和控制器方法的形参创建映射关系，有三个属性：value、required、defaultValue，用法同@RequestParam
通过POJO获取请求参数
可以在控制器方法的形参位置设置一个实体类类型的形参，此时若浏览器传输的请求参数的参数名和实体类中的属性名一致，那么请求参数就会为此属性赋值

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

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

 <!--配置springMVC的编码过滤器-->
<filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
        <param-name>forceResponseEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

注：SpringMVC中处理编码的过滤器一定要配置到其他过滤器之前，否则无效，如果控制台输出显示实心问号，不是过滤器设置编码没生效，是控制台输出内容的编码不对，需要增加tomcat启动的VM参数-Dfile.encoding=UTF-8

向域对象中存放共享数据

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

 @RequestMapping("/testServletAPI")
public String testServletAPI(HttpServletRequest request){
    request.setAttribute("testScope", "hello,servletAPI");
    return "success";
}

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

 @RequestMapping("/testModelAndView")
public ModelAndView testModelAndView(){
    /**
     * ModelAndView有Model和View的功能
     * Model主要用于向请求域共享数据
     * View主要用于设置视图，实现页面跳转
     */
    ModelAndView mav = new ModelAndView();
    //向请求域共享数据
    mav.addObject("testScope", "hello,ModelAndView");
    //设置视图，实现页面跳转
    mav.setViewName("success");
    return mav;
}

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

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

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

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

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

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

Model、ModelMap、Map的关系
Model、ModelMap、Map类型的参数其实本质上都是 BindingAwareModelMap 类型的，DispatcherServlet传递BindingAwareModelMap实参，上层不管使用哪个api都可以，本质上都满足

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

向session域共享数据

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

向application域共享数据

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

SpringMVC的视图

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

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

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

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

ThymeleafView

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

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

转发视图 InternalResourceView

SpringMVC中默认的转发视图是InternalResourceView

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

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

例如"forward:/"，"forward:/employee"

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

重定向视图 RedirectView

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

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

例如"redirect:/"，"redirect:/employee"

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

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

视图控制器view-controller

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

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

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

如果配置了<mvc:default-servlet-handler/>也必须加注解驱动标签，否则所有请求都使用DefaultServlet处理，而META-INF下的资源又无法被直接访问，所以如果不配控制器里面的映射将失效

RESTful

RESTful简介

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

a>资源

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

b>资源的表述

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

c>状态转移

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

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请求方式

HiddenHttpMethodFilter

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

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

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

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

b>当前请求必须传输请求参数_method

满足以上条件，HiddenHttpMethodFilter 过滤器就会将当前请求的请求方式转换为请求参数_method的值，因此请求参数_method的值才是最终的请求方式

在web.xml中注册HiddenHttpMethodFilter

 <filter>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

注：目前为止，SpringMVC中提供了两个过滤器：CharacterEncodingFilter和HiddenHttpMethodFilter
在web.xml中注册时，必须先注册CharacterEncodingFilter，再注册HiddenHttpMethodFilter

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

RESTful案例

使用静态资源处理需要添加标签：<mvc:default-servlet-handler/>，使用DefaultServlet处理静态资源（当DispatcherServlet匹配不到映射时使用DefaultServlet处理），如果开启了必须添加<mvc:annotation-driven/>，否则都使用DefaultServlet处理

发送delete请求：

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

HttpMessageConverter

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

@RequestBody可以获取请求体，需要在控制器方法设置一个形参，使用@RequestBody进行标识，当前请求的请求体就会为当前注解所标识的形参赋值。
- 如果用String接收，那么发送的请求体是什么，接收到的就是什么
- 如果用JSONObject接收，需要导入jackson-databind依赖，消息转换器才能工作
- 如果没有标注@RequestBody，形参只能接收请求行上的请求参数
RequestEntity，请求实体，包括请求的所有信息（请求行、请求头、请求体），封装请求报文的一种类型，需要在控制器方法的形参中设置该类型的形参，当前请求的请求报文就会赋值给该形参，可以通过getHeaders()获取请求头信息，通过getBody()获取请求体信息
@ResponseBody，用于标识一个控制器方法，可以将该方法的返回值直接作为响应报文的响应体响应到浏览器
- 如果要返回对象转换为json给前端，需要导入jackson-databind依赖，消息转换器才能工作
SpringMVC处理json
- 导入jackson-databind依赖
- 开启注解驱动<mvc:annotation-driven/>，此时在HandlerAdaptor中会自动装配一个消息转换器：MappingJackson2HttpMessageConverter，可以将响应到浏览器的Java对象转换为Json格式的字符串
- 在处理器方法上使用@ResponseBody注解进行标识
- 将Java对象直接作为控制器方法的返回值返回，就会自动转换为Json格式的字符串
@RestController注解，是springMVC提供的一个复合注解，标识在控制器的类上，就相当于为类添加了@Controller注解，并且为其中的每个方法添加了@ResponseBody注解
ResponseEntity用于控制器方法的返回值类型，该控制器方法的返回值就是响应到浏览器的响应报文，包括响应的所有信息（响应头，响应码，响应体），这个需要自己new出来然后作为返回值。使用这个可以实现数据的下载，泛型参数中放入byte[]，将数据作为字节数据写出

文件的上传和下载：

下载：
- 需要在Controller方法的形参上添加HttpSession，获取realPath，读取文件为byte，放入ResponseEntity<byte[]>响应报文中
- 在响应头中需要添加响应报文格式headers.add("Content-Disposition", "attachment;filename=1.jpg")
- 添加响应码
上传：
- 文件上传要求form表单的请求方式必须为post，并且添加属性enctype="multipart/form-data"
- SpringMVC中将上传的文件封装到MultipartFile对象中，通过此对象可以获取文件相关信息，所以需要在Controller方法形参中添加接口参数MultipartFile，如果下载到当前目录，也需要HttpSession获取realPath，一般应该使用文件服务器
- 添加上传依赖

 <!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
</dependency>

 - 配置文件解析器到ioc容器

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

拦截器

SpringMVC中的拦截器用于拦截控制器方法的执行（或者是拦截被DispatcherServlet处理的请求），拦截器需要实现HandlerInterceptor接口，且必须在SpringMVC的配置文件中进行配置：

 <bean class="com.atguigu.interceptor.FirstInterceptor"></bean>
<ref bean="firstInterceptor"></ref>
<!-- 以上两种配置方式都是对DispatcherServlet所处理的所有的请求进行拦截 -->
<mvc:interceptor>
    <mvc:mapping path="/**"/>
    <mvc:exclude-mapping path="/testRequestEntity"/>
    <ref bean="firstInterceptor"></ref>
</mvc:interceptor>
<!--以上配置方式可以通过ref或bean标签设置拦截器，通过mvc:mapping设置需要拦截的请求，通过mvc:exclude-mapping设置需要排除的请求，即不需要拦截的请求
-->

拦截器的三个抽象方法：

preHandle：控制器方法执行之前执行preHandle()，其boolean类型的返回值表示是否拦截或放行，返回true为放行，即调用控制器方法；返回false表示拦截，即不调用控制器方法
postHandle：控制器方法执行之后执行postHandle()
afterComplation：处理完视图和模型数据，渲染视图完毕之后执行afterComplation()

多个拦截器的执行顺序：

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

异常处理器

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

SpringMVC提供了自定义的异常处理器SimpleMappingExceptionResolver，使用方式：

 <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <property name="exceptionMappings">
        <props>
        	<!--
        		properties的键表示处理器方法执行过程中出现的异常
        		properties的值表示若出现指定异常时，设置一个新的视图名称，跳转到指定页面
        	-->
            <prop key="java.lang.ArithmeticException">error</prop>
        </props>
    </property>
    <!--
    	exceptionAttribute属性设置一个属性名，将出现的异常信息在请求域中进行共享
    -->
    <property name="exceptionAttribute" value="ex"></property>
</bean>

基于注解实现：本质是也是一个Controller，只是在正常Controller出现异常的时候调用ControllerAdvice中的对应异常方法，该方法与Controller方法使用相同，形参Exception可以获取到当前异常，是DispatcherServlet传递的

 //@ControllerAdvice将当前类标识为异常处理的组件
@ControllerAdvice
public class ExceptionController {
 
    //@ExceptionHandler用于设置所标识方法处理的异常
    @ExceptionHandler(ArithmeticException.class) //可以写多个异常
    //ex表示当前请求处理中出现的异常对象
    public String handleArithmeticException(Exception ex, Model model){
        model.addAttribute("ex", ex); //放入请求作用域中供前端使用
        return "error";//要返回的视图
    }
}

使用注解配置SpringMVC

使用配置类和注解代替web.xml和SpringMVC配置文件的功能

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

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

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

 /**
 * web工程的初始化类 用来代替web.xml
 *      - 会自动查找javax.servlet.ServletContainerInitializer的实现
 *      - Spring提供了这个接口的实现，名为SpringServletContainerInitializer
 *      - 这个类会查找WebApplicationInitializer接口的实现类
 *      - 该接口的实现类为: AbstractAnnotationConfigDispatcherServletInitializer
 *      - 需要我们继承
 */
public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {
 
    /**
     * 获取Spring的配置类
     */
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }
 
    /**
     * 获取SpringMVC的配置类 springMVC.xml
     */
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{WebConfig.class};
    }
 
    /**
     * 指定DispatcherServlet的映射规则     url-pattern
     */
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
 
    /**
     * 注册过滤器
     */
    @Override
    protected Filter[] getServletFilters() {
        //编码过滤器
        CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter();
        encodingFilter.setEncoding("UTF-8");
        encodingFilter.setForceResponseEncoding(true);
 
        //隐藏方法过滤器 用于转换post请求 _method的其他方法
        HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
        return new Filter[]{encodingFilter, hiddenHttpMethodFilter};
    }
}

创建SpringConfig配置类，代替spring的配置文件

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

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

 /**
 * 使用注解代替web.xml在SpringMVC中的配置SpringMVC.xml
 *      1 - 扫描组件
 *      2 - 视图解析器
 *      3 - view-controller
 *      4 - default-servlet-handler
 *      5 - mvc-annotation
 *      6 - 文件上传解析器
 *      7 - 异常处理
 *      8 - 拦截器
 *
 */
@Configuration
//1 - 扫描组件
@ComponentScan("org.example.controller") //filter包 servlet包 exception.handler包必须被扫描到它他们的注解才能生效
//5 - mvc-annotation
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
 
    /**
     * 实现WebMvcConfigurer 通过实现接口中的方法 来配置原来SpringMVC.xml中的配置
     */
    /**
     * 4 - default-servlet-handler
     */
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable(); //开启默认的Servlet
    }
 
 
    /**
     * 8 - 拦截器
     *      - 原来是注入的拦截器 然后再配置到<mvc:interceptors>里面
     *      这里直接new了 所以拦截器不用@Component放入ioc
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyFirstInterceptor())
                .addPathPatterns("/**").excludePathPatterns("/");
        registry.addInterceptor(new MySecondInterceptor())
                .addPathPatterns("/**").excludePathPatterns("/");
    }
 
    /**
     * 3 - view-controller
     */
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/testView")
                .setViewName("view");
        registry.addViewController("/testFileDownload")
                .setViewName("index");
    }
 
    /**
     * 6 - 文件上传解析器
     */
    @Bean
    public MultipartResolver multipartResolver() {
        return new CommonsMultipartResolver();
    }
 
    /**
     * 7 - 异常处理
     *      - 这里配置SpringMVC.xml中的简单异常处理器
     *      - 也可以定义自己的ControllerAdvice 写@ExceptionHandler
     *      - 这里也可以使用@Bean 注入SimpleMappingExceptionResolver 因为在SpringMVC.xml中其实也是一个Bean
     */
    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {
        SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
        Properties props = new Properties();
        props.setProperty("java.lang.ArithmeticException", "error");
        exceptionResolver.setExceptionAttribute("ex");
        exceptionResolver.setExceptionMappings(props);
        resolvers.add(exceptionResolver);
    }
 
    /**
     * 2 - 视图解析器
     */
    //配置生成模板解析器
    @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;
    }
}

配置完成后就不需要web.xml了，在使用idea配置module为web时，路径不要写到web.xml，写到webapp即可，然后刷新maven，会自动创建facts和artifacts

SpringMVC执行流程

SpringMVC常用组件：

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

DispatcherServlet初始化过程：

DispatcherServlet本质上是一个 Servlet，所以天然的遵循 Servlet 的生命周期。所以宏观上是 Servlet 生命周期来进行调度。
分析DispatcherServlet的继承关系，初始化过程如下：
- Servlet的init(ServletConfig)方法
- 实现类GenericServlet实现的接口中的这个init方法调用了自己的空实现init()方法
- 子类HttpServletBean的重载方法init()调用了initServletBean()
- 子类FrameworkServlet重载了initServletBean()方法，调用了initWebApplicationContext()
- 在这个方法中，创建了IOC容器，并设置Spring的容器为父容器，创建容器后调用了onRefresh(wac)方法
- 在子类中重写了onRefresh()方法，并调用了initStrategies(context)方法，初始化DispatcherServlet的各个组件

DispatcherServlet调用组件处理请求：

FrameworkServlet重写HttpService中的service()和doXxx()方法，这些方法中调用了processRequest(request, response)方法
DispatcherServlet中重写了doService()方法，调用了doDispatch()方法，其中铜鼓控制器方法创建相应的处理器适配器（用于调用对应的控制器方法），调用拦截器，调用具体控制器方法，获取ModelAndView对象，后续调用processDispatcherResult()处理模型数据和渲染视图，并执行拦截器的afterCompletion()方法

SpringMVC的执行流程：

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

总结

SpringMVC的概念
使用：
- 视图解析器的配置
- 默认Servlet的配置<mvc:default-servlet-handler/>，必须再加<mvc:annotation-driven>SpringMVC才生效，否则都是默认Servlet处理
- 使用@RequestMapping注解，value属性、method属性、params属性、headers属性，支持ant风格?/*/**
  - @PathVariable注解提出占位符变量
  - 获取请求参数直接使用形参，DispatcherServlet会自动根据名称赋值，也可以使用注解@RequstParam指定与形参的映射，也可以直接使用POJO获取（字段名相同）
  - @RequestHeader注解获取Header信息
  - @CookieValue注解获取cookie信息
  - 请求参数乱码需要配置编码过滤器CharacterEncodingFilter
- 域对象共享数据
  - request作用域：Map类型的kv本质上都是BindingAwareModelMap 类型
    - 使用形参HttpServletRequest
    - 返回值为ModelAndView
    - 使用形参Model
    - 使用形参Map<String, Object>
    - 使用形参ModelMap
  - session作用域：形参HttpSession
  - application作用域：形参HttpSession，获取Servlet上下文，往上下文中放数据
- SpringMVC的视图：
  - 被视图解析器解析后返回（如thymeleaf）
  - 转发
  - 重定向
  - 视图控制器，仅仅实现页面跳转
- Restful，使用过滤器HiddenHttpMethodFilter实现获取到隐藏的其他请求类型
- 消息转换器HttpMessageConverter
  - 使用@RequestBody获取请求体
  - 使用形参RequestEntity获取请求信息，可以获取到所以请求信息
  - 使用@ResponseBody将返回值直接作为响应报文响应给客户端，需要引入依赖jackson-databind，配置了<mvc:annotation-driven/>会自动在HandlerAdaptor中配置一个MappingJackson2HttpMessageConverter，将Java对象转换为JSON格式的字符串
  - @RestController
  - ResponseEntity，作为返回类型，直接控制整个响应报文的内容，如响应码、响应数据，可以实现文件的下载
  - 文件上传需要引入依赖commons-fileupload，并将CommonsMultipartResolver注入到ioc容器，使用形参MultipartFile接收封装后的上传文件（如果要保存到当前系统，需要使用形参HttpSession获取到realPath）
- 拦截器，三个抽象方法，拦截器拦截的是Controller方法
- 异常处理器，也是一种Controller，只是在正常的Controller方法执行出现异常时，调用对应的异常处理器的异常处理方法，可以对每个方法设置接收的异常类型（@ControllerAdvice，@ExceptionHandler）。也可以使用SpringMVC自定义的SimpleMappingExceptionResolver进行配置
- 使用注解配置SpringMVC，继承AbstractAnnotationConfigDispatcherServletInitializer，配置各组件
SpringMVC执行流程

posted on 2022-07-09 20:59 Bingmous 阅读(33) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· SpringBoot学习笔记

· JavaWeb学习笔记

· SpringMVC（一）--入门

· springMVC 笔记

· springMVC笔记

阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 单线程的Redis速度为什么快？

bingmous

导航

统计

公告

搜索

常用链接

最新随笔

我的标签

积分与排名

随笔分类 (106)

阅读排行榜