文章目录
- 一、SpringMVC简介
- 1、什么是MVC
- 2、什么是SpringMVC
- 3、SpringMVC的特点
- 二、HelloWorld
- 三、@RequestMapping注解
- 1. 介绍
- 2. value属性
- 3. method属性
- 4. params属性
- 5. headers属性
- 6. SpringMVC支持ant风格的路径
- 7. SpringMVC中支持路径的占位符
- 四、SpringMVC获取请求参数
- 1. 通过ServletAPI获取
- 2. 通过同名形参自动获取请求参数
- 3. @RequestParam
- 4. @RequestHeader
- 5. @CookieValue
- 6. 通过POJO获取请求参数
- 7. 解决获取请求参数的乱码问题
- 五、域对象共享数据
- 1. 使用ServletAPI向request域对象共享数据
- 2. 使用ModelAndView向request域对象共享数据
- 3. 使用Model向request域对象共享数据
- 4. 使用Map向request域对象共享数据
- 5. 使用ModelMap向request域对象共享数据
- 6. Model、ModelMap、Map的关系
- 7. 向Session域共享数据
- 8. 向Application域共享数据
- 六、SpringMVC的视图
- 1. ThymeleafView
- 2. 转发视图InternalResourceView
- 3. 重定向视图RedirectView
- 4. 视图控制器view-controller
- 5. jsp页面使用的视图解析器
- 七、RESTful
- 1. RESTful
- 2. HiddenHttpMethodFilter
- 八、HttpMessageConverter
- 1、@RequestBody
- 2、RequestEntity
- 3、@ResponseBody
- 4、SpringMVC处理json
- 5、SpringMVC处理ajax
- 6、@RestController注解
- 7、ResponseEntity
- 九、文件上传和下载
- 1. 文件下载
- 2. 文件上传
- 十、拦截器
- 1. 拦截器的配置
- 2. 拦截器的三个抽象方法
- 3. 多个拦截器的执行顺序
- 十一、异常处理器
- 1. 基于配置的异常处理器
- 2. 基于注解的异常处理器
- 十二、注解配置SpringMVC
- 1. 创建初始化类，代替web.xml
- 2. 创建SpringConfig配置类，代替Spring的配置文件
- 3. 创建WebConfig配置类，代替SpringMVC的配置文件
- 十三、SpringMVC执行流程
- 1. SpringMVC的常用组件
- 2. DispatcherServlet初始化过程
- 3. DispatcherServlet调用组件处理请求
- 4. SpringMVC的执行流程
一、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）创建maven工程：
（2）pom.xml文件设置打包方式为war包，并且引入所需依赖
<groupId>org.oymn</groupId>
<artifactId>SpringMVC-demo1</artifactId>
<version>1.0-SNAPSHOT</version>
<!--设置打包方式：war-->
<packaging>war</packaging>
<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>（3）在main目录下创建webapp目录，在webapp目录下添加web.xml配置文件
创建webapp目录：
添加web.xml文件：
手动修改目录：
结果：
（4）配置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>扩展配置方式（一般使用这种）：
<!-- 配置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>（5）创建SpringMVC配置文件：
<!-- 自动扫描包 -->
<context:component-scan base-package="com.oymn"/>
<!-- 配置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>（6）创建请求控制器
虽然前端控制器对浏览器发送的请求进行了统一的处理，但是不同的请求需要有不同的处理过程，因此需要创建请求控制器，请求控制器中每一个处理请求的方法称为控制器方法。
请求控制器需要通过@Controller注解将其标识为控制层组件，交给Spring的IOC容器管理，这样SpringMVC才能识别控制器的存在。
@Controller //请求控制器
public class HelloController {
@RequestMapping("/") //将路径“/”和index.html页面联系起来
public String index(){
//返回视图名称
return "index";
}
@RequestMapping("/target") //将路径“/target”和target.html页面联系起来
public String toTarget() {
return "target";
}
}（7）在WEB-INF目录下创建templates目录，然后在其下面创建页面index.html和target.html
index.html：
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>首页</title>
</head>
<body>
<h1>你好</h1>
<!--用th修饰href属性，然后就可以使用@{} 来自动填充绝对路径了-->
<a th:href="@{/target}">跳转到target页面</a>
</body>
</html>target.html 跳转页面：
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
HelloWorld
</body>
</html>（8）总结：
浏览器发送请求，如果请求地址符合前端控制器的url-pattern，该请求就会被前端控制器DispatcherServlet处理。前端控制器会读取SpringMVC的配置文件，通过扫描组件找到控制器，将请求地址和控制器中@RequestMapping注解的value值进行匹配，如果匹配成功，则该控制器方法就是处理请求的方法。处理请求的方法需要返回一个字符串类型的视图名称，这个视图名称会被视图解析器解析，加上前缀和后缀组成完整的路径，通过Thymeleaf对视图进行渲染，最终**转发（而不是重定向）**到所对应的页面。
三、@RequestMapping注解
1. 介绍
- 将请求和处理请求的控制器方法关联起来，建立映射关系。
- @RequestMapping注解的位置：
- 修饰一个类：表示所映射的请求路径的初始信息。
- 修饰一个方法：表示所映射的请求路径的具体信息。
@Controller
@RequestMapping("/test")
public class RequestMappingController {
//此时请求映射所映射的请求的请求路径为：/test/testRequestMapping
@RequestMapping("/testRequestMapping")
public String testRequestMapping(){
return "success";
}
}- idea快捷键 alt+7 查看RequestMapping的所有属性
2. value属性
value属性通过请求地址来匹配请求映射。
@RequestMapping的value属性是一个字符串数组，可以同时匹配多个请求地址所对应的请求。
<a th:href="@{/testRequestMapping}">测试@RequestMapping的value属性-->/testRequestMapping</a><br>
<a th:href="@{/test}">测试@RequestMapping的value属性-->/test</a><br>@RequestMapping(
value = {"/testRequestMapping", "/test"}
)
public String testRequestMapping(){
return "success";
}上例中，不管是 /test请求 还是 /testRequestMapping请求，都能够跳转到success.html页面。
3. method属性
- 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 testRequestMapping(){
return "success";
}注：
对于处理特定请求的控制器方法，SpringMVC提供了@RequestMapping的派生注解：
处理get请求的注解：@GetMapping
处理post请求的注解：@PostMapping
处理put请求的注解：@PutMapping
处理delete请求的注解：@DeleteMapping
常用的请求方式有get，post，put，delete
但是目前的浏览器只支持get和post两种请求方式，如果在form表单提交设置了其他的请求方式（put或delete），则按照默认的请求方式get进行处理。
若要发送put或delete请求，则需要通过Spring提供的过滤器HiddenHttpMethodFilter，在RESTful部分会讲到。
4. params属性
- params属性通过请求参数来匹配请求映射。
- params属性是一个字符串类型的数组，可以通过四种表达式设置请求参数和请求映射的匹配关系
- ”param“：要求所匹配的请求必须携带param请求参数
- ”!param“：要求所匹配的请求必须不携带param请求参数
- ”param=value“：要求所匹配的请求必须携带param请求参数，并且值为value
- ”param!=value“：要求所匹配的请求必须携带param请求参数，但是值不能为value
<a th:href="@{/test(username='admin',password=123456)">测试@RequestMapping的params属性-->/test</a><br>@RequestMapping(
value = {"/testRequestMapping", "/test"}
,method = {RequestMethod.GET, RequestMethod.POST}
,params = {"username","password!=123456"}
)
public String testRequestMapping(){
return "success";
}注：若当前请求满足@RequestMapping的value属性和method属性，但是不满足params属性，此时页面会报错400：Parameter conditions “username, password!=123456” not met for actual request parameters: username={admin}, password={123456}
5. headers属性
- headers属性通过请求的请求头信息匹配请求映射。
- headers属性是一个字符串类型的数组，可以通过四种表达式来设置请求头信息和请求映射的匹配关系。
- “header”：要求请求映射所匹配的请求必须携带header请求头信息
- “!header”：要求请求映射所匹配的请求必须不能携带header请求头信息
- “header=value”：要求请求映射所匹配的请求必须携带header请求头信息且header=value
- “header!=value”：要求请求映射所匹配的请求必须携带header请求头信息且header!=value
- 若当前请求满足@RequestMapping的value属性和method属性，但是不满足headers属性，此时页面显示404错误，即资源未找到。
@RequestMapping(
value="/test1",
headers={"Host=localhost:8081"} //若使用默认端口8080访问，则会报错404
)
public String test1(){
return "success";
}6. SpringMVC支持ant风格的路径
（1）？：表示任意的单个字符
@RequestMapping("/a?a") //请求路径中?的位置可以替代成任意单个字符(但不能省略),例如"/aba","/aga","/a:a"等都是可以的
public String test2(){
return "success";
}（2）*：表示任意的0个或多个字符
@RequestMapping("/a*a") //请求路径中*的位置可以替代成0个或多个字符,例如"/aba","/aa","/aaaaa"等都是可以的
public String test2(){
return "success";
}（3）**：表示任意的一层或多层目录
@RequestMapping("/**/a") //请求路径中**位置可以替代成0层或多层目录，例如"/a/a","/b/b/b/a","/a"等都是可以的
public String test2(){
return "success";
}7. SpringMVC中支持路径的占位符
原始方式：/deleteUser?id=1
rest方式：/deleteUser/1
SpringMVC路径中的占位符常用于RESTful风格中，通过请求路径的方式将参数传输到服务器中，就可以在相应的控制器方法的@RequestMapping注解的value属性中通过占位符{xxx}表示传输的参数，再通过**@PathVariable注解**，将占位符表示的参数赋值给控制器方法的形参。
<a th:href="@{/test/1/admin}">测试路径中的占位符</a><br/>@RequestMapping("/test/{id}/{username}")
public String test(@PathVariable("id") Integer id, @PathVariable("username") String username){
System.out.println("id="+id+",username="+username);
return "success";
}1. 通过ServletAPI获取
将HttpServletRequest作为控制器方法的形参，此时HttpServletRequest类型的参数表示封装了当前请求的请求报文的对象。
<a th:href="@{/test01(username='oymn',password='000000')}">测试通过HttpServletRequest获取请求参数</a><br/>@RequestMapping("/test01")
public String test1(HttpServletRequest request){ //传入HttpServletRequest对象
String username = request.getParameter("username");
String password = request.getParameter("password");
System.out.println("username="+username+",password="+password);
return "success";
}2. 通过同名形参自动获取请求参数
在控制器方法的形参位置，设置和请求参数同名的形参，当浏览器发送请求，匹配到请求映射时，DispatcherServlet会自动请求参数赋值给相对应的形参。
<a th:href="@{/test02(username='oymn',password='000000')}">测试同名形参获取请求参数</a><br/>@RequestMapping("/test02")
public String test2(String username, String password){ //设置同名形参，自动赋值
System.out.println("username="+username+",password="+password);
return "success";
}当请求中有多个同名的请求参数，例如表单中的复选框，此时可以设置字符串数组或者字符串类型的形参来接受该请求参数。
如果使用的是字符串数组，则数组包含了每一个请求参数。
如果使用的是字符串类型，则为请求参数用逗号拼接的字符串。
3. @RequestParam
通过上面的学习我们知道通过同名形参可以自动获取请求参数，但是当形参和请求参数不一致时，或者想要显式指定形参和请求参数的映射关系时，就可以使用@RequestParam注解。
@RequestParam一共有三个属性：
- value：指定为形参赋值的请求参数名。
- required：设置是否必须传输该请求参数，默认为true。
- defaultValue：不管required为true或false，当value指定的请求参数没有传输或者传输的值为空字符串时，则使用默认值defaultValue为形参赋值。
注：如果设置required为true，但是请求中没有包含该请求参数，并且没有设置defaultValue属性，则会报400错误：Required String parameter ‘xxx’ is not present；若设置为false，则该请求参数不是必须项，若没有传输，则注解所标识的形参值为null。
@RequestMapping("/test04")
//value的值为name,对应html文件中请求参数的名字;required设置为false表示该参数不是必须项;defaultValue设置默认值为oymn
public String test4(@RequestParam(value="name",required=false,defaultValue="oymn")String username){
System.out.println(username);
return "success";
}<a th:href="@{/test04(name='oymn')}">测试RequestParam注解</a><br/>4. @RequestHeader
@RequestHeader是将请求头信息和控制器方法的形参创建映射关系
@RequestHeader注解一共有三个属性：value、required、defaultValue，用法同@RequestParam
5. @CookieValue
@CookieValue是将cookie数据和控制器方法的形参创建映射关系
@CookieValue注解一共有三个属性：value、required、defaultValue，用法同@RequestParam
@RequestMapping("/test05")
public String test5(@CookieValue("JSESSIONID") String JSESSIONID){ //获取session的cookie
System.out.println(JSESSIONID);
return "success";
}6. 通过POJO获取请求参数
在控制器方法的形参设置为一个实体类对象，此时若浏览器发送的请求的参数名和该实体类对象的属性名一一对应，那么将会自动为该实体类的属性进行赋值。
<form th:action="@{/testpojo}" 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">
</form>@RequestMapping("/testpojo")
public String testPojo(User user){
System.out.println(user.toString());
return "success";
}上面的例子中，如果表单采用post方式提交，则在控制器方法testPojo()中输出user对象时性别将会乱码（因为是中文），需要解决乱码问题；而如果使用get方式提交，则不会产生乱码问题（如果也会，则应该是tomcat的问题）。
7. 解决获取请求参数的乱码问题
解决乱码问题，需要在过滤器阶段进行处理，因为发送一个请求会经过监听器，过滤器，然后再Servlet，如果像javaweb那样通过request.setCharacterEncoding()方法来设置是不行的，因为这个方法需要在获取请求参数之前就得执行，而SrpingMVC中在我们通过ServletAPI获取request请求对象之前，内部就已经自动获取了请求参数了，所以再进行设置编码是没有用的，所以需要将该任务提前到过滤器阶段。
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>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>CharacterEncodingFilter 部分源码：
public class CharacterEncodingFilter extends OncePerRequestFilter {
@Nullable
private String encoding; //这里就是设置编码的属性
private boolean forceRequestEncoding; //强制设置请求编码，默认为false
private boolean forceResponseEncoding; //强制设置响应编码，默认为false
//无参构造函数
public CharacterEncodingFilter() {
this.forceRequestEncoding = false;
this.forceResponseEncoding = false;
}
//这个就是过滤器的执行方法dofilter
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
String encoding = this.getEncoding(); //如果没有设置默认为null
if (encoding != null) { //如果设置了encoding
//request.getCharacterEncoding()==null这个条件表明了只要之前没有设置过编码,请求编码就可以设置成功了
if (this.isForceRequestEncoding() || request.getCharacterEncoding() == null) {
request.setCharacterEncoding(encoding);
}
//想要设置响应编码，还需要将forceResponseEncoding设置为true
if (this.isForceResponseEncoding()) {
response.setCharacterEncoding(encoding);
}
}
filterChain.doFilter(request, response);
}
}通过上面的源码分析，如果想要设置响应编码的话，除了需要设置encoding，还需要设置forceResponseEncoding为true，因此，比较完整的编码过滤器如下：
<!--配置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的编码过滤器需要再其他过滤器之前配置，否则无效。
1. 使用ServletAPI向request域对象共享数据
@RequestMapping("/testscope")
public String testScope(HttpServletRequest request){
request.setAttribute("hello","testScopeByServletAPI"); //调用setAttribute方法
return "success";
}<p th:text="${hello}"></p>2. 使用ModelAndView向request域对象共享数据
ModelAndView 有 Model 和 View 的功能：
- Model：用于向请求域中共享数据
- View：用于设置视图，实现页面跳转
@RequestMapping("/testscope2")
public ModelAndView testScope2(){
//创建ModelAndView对象
ModelAndView mav = new ModelAndView();
//向请求域中共享数据
mav.addObject("hello","hello,testScopeByModelAndView");
//设置视图，实现页面跳转
mav.setViewName("success");
return mav;
}3. 使用Model向request域对象共享数据
@RequestMapping("/testscope3")
public String testScope3(Model model){
model.addAttribute("hello","testScopeByModel");
return "success";
}4. 使用Map向request域对象共享数据
@RequestMapping("/testscope4")
public String testScope4(Map<String, Object> map){
map.put("hello", "testScopeByMap");
return "success";
}5. 使用ModelMap向request域对象共享数据
@RequestMapping("/testscope5")
public String testScope5(ModelMap modelMap){
modelMap.addAttribute("hello","testScopeByModelMap");
return "success";
}6. Model、ModelMap、Map的关系
System.out.println(model.getClass().getName());
System.out.println(modelMap.getClass().getName());
System.out.println(map.getClass().getName());
在控制器方法中输出这三个参数的实现类的全类名，输出结果均为：org.springframework.validation.support.BindingAwareModelMap，说明Model、ModelMap、Map类型的参数实质上是BindingAwareModelMap对象。
//ModelMap是ExtendedModelMap的父类,ExtendedModelMap是BindingAwareModelMap的父类
//相当于ModelMap是BindingAwareModelMap的父类
public class ExtendedModelMap extends ModelMap implements Model {}
public class BindingAwareModelMap extends ExtendedModelMap {}
//LinkedHashMap是ModelMap的父类，而LinkedHashMap实现了Map,相当于ModelMap实现了Map
//而BindingAwareModelMap是ModelMap的子类,相当于BindingAwareModelMap实现了Map
public class ModelMap extends LinkedHashMap<String, Object> {}
public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V> {}
//ExtendedModelMap实现了Model，相当于BindingAwareModelMap实现了Model
public interface Model {}
public class ExtendedModelMap extends ModelMap implements Model {}关系图如下：
7. 向Session域共享数据
@RequestMapping("/testscope6")
public String testScope6(HttpSession session){
session.setAttribute("hello","testSession");
return "success";
}<p th:text="${session.hello}"></p>8. 向Application域共享数据
@RequestMapping("/testscope7")
public String testScope7(HttpSession session){
ServletContext application = session.getServletContext(); //先获取ServletContext对象
application.setAttribute("hello","testApplication");
return "success";
}<p th:text="${application.hello}"></p>SpringMVC中的视图是View接口，视图的作用是渲染数据，将模型Model中的数据展示给用户。
SpringMVC中的视图有很多种，默认有转发视图和重定向视图。
当工程中引入jstl的依赖时，转发视图会自动转换为jstlView。
当使用的视图技术为Thymeleaf，即在SpringMVC的配置文件中配置了Thymeleaf的视图解析器，由此视图解析器解析之后得到的就是ThymeleafView。
1. ThymeleafView
当控制器方法中设置的视图名称没有任何前缀时，此时的视图名称会被SpringMVC配置文件中的视图解析器解析，视图名称拼接视图前缀和视图后缀所得到的最终路径，会通过转发的方式实现跳转。
@RequestMapping("/testThymeleaf")
public String testThymeleaf(){
return "success";
}跟踪一下源码：
在控制器方法中打断点，然后在debug的方法栈中找到doDispatch方法，此时doDispatch方法执行到这一行：
接着将程序执行到processDispatchReuslt，进入方法：
在processDispatchResult方法中执行到render方法并进入：
render方法中执行完resolveViewName方法后，可以看到此时view是一个ThymeleafView对象。
2. 转发视图InternalResourceView
SpringMVC中默认的转发视图是InternalResourceView。
SpringMVC中创建转发视图的情况：当控制器方法中所设置的视图名称以"forward:"为前缀时，会先创建InternalResourceView视图，此时视图名称不会被SpringMVC所配置的视图解析器解析，而是会将前缀"forward:"去掉，剩余部分作为最终路径通过转发的方式实现跳转。
@RequestMapping("/testInternalResourceView")
public String testInternalResourceView(){
return "forward:/testThymeleaf";
}
3. 重定向视图RedirectView
SpringMVC默认的重定向视图是RedirectView。
SpringMVC中创建重定向视图的情况：当控制器方法中所设置的视图名称以"redirect:"为前缀时，会先创建RedirectView视图，此时视图名称并不会被SpringMVC所配置的视图解析器解析，而是会将前缀"redirect:"去掉，剩余部分作为最终路径通过重定向的方式实现跳转。
@RequestMapping("/testRedirectView")
public String testRedirectView(){
return "redirect:/testThymeleaf";
}
注：重定向视图在解析时，会先将redirect:前缀去掉，然后会判断剩余部分是否以/开头，若是则会自动拼接上下文路径
4. 视图控制器view-controller
当控制器方法，仅仅用来实现页面跳转，即只需要设置视图名称时，可以使用view-controller标签替代控制器方法。
<!--
path：设置处理的请求地址
view-name：设置请求地址所对应的视图名称
-->
<mvc:view-controller path="/testView" view-name="success"></mvc:view-controller>
<!--开启mvc注解驱动-->
<mvc:annotation-driven />5. jsp页面使用的视图解析器
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/templates/"></property> <!--视图前缀-->
<property name="suffix" value=".jsp"></property> <!--视图后缀-->
</bean>1. RESTful
- REST：Representational State Transfer，表现层资源状态转移。
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请求方式 |
2. HiddenHttpMethodFilter
由于浏览器只支持发送get和post方式的请求，那么该如何发送put和delete请求呢？
SpringMVC 提供了 HiddenHttpMethodFilter 帮助我们将 POST 请求转换为 DELETE 或 PUT 请求
HiddenHttpMethodFilter 处理put和delete请求的条件：
- 当前请求的请求方式必须为 post
- 当前请求必须传输请求参数 _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><form th:action="@{/user}" method="post"> <!--条件1：设置请求方式为post-->
<input type="hidden" name="_method" value="put"> <!--条件2：通过隐藏域传输请求参数_method-->
<input type="submit" >
</form>注：
目前为止，SpringMVC中提供了两个过滤器：CharacterEncodingFilter 和 HiddenHttpMethodFilter
在web.xml中注册时，必须先注册CharacterEncodingFilter，再注册HiddenHttpMethodFilter
（在web.xml文件中CharacterEncodingFilter 写在 HiddenHttpMethodFilter 的前面）
原因：
在 CharacterEncodingFilter 中通过 request.setCharacterEncoding(encoding) 方法设置字符集的
request.setCharacterEncoding(encoding) 方法要求前面不能有任何获取请求参数的操作
而 HiddenHttpMethodFilter 恰恰有一个获取请求方式的操作：
String paramValue = request.getParameter(this.methodParam);
跟踪一下源码：
过滤器最重要的就是执行过滤的方法了，首先先从这里入手：doFilter（doFilterInternal）
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
HttpServletRequest requestToUse = request;
//这个判断需要满足两个条件：request是一个post请求;
//而request.getAttribute("javax.servlet.error.exception")为null 可以认为是恒成立的,这里不太清楚
if ("POST".equals(request.getMethod()) && request.getAttribute("javax.servlet.error.exception") == null) {
//这里的methodParam是一个字符串，值为"_method"
String paramValue = request.getParameter(this.methodParam);
//如果_method的值有长度，也就是不为空
if (StringUtils.hasLength(paramValue)) {
//将_method的值转换为大写
String method = paramValue.toUpperCase(Locale.ENGLISH);
//ALLOWED_METHODS是一个List集合,包含"PUT","DELETE","PATCH"
if (ALLOWED_METHODS.contains(method)) {
//HttpMethodRequestWrapper是HiddenHttpMethodFilter的一个内部类
//这里就是根据_method的值也就是真正的请求方式重新创建了一个请求对象
requestToUse = new HiddenHttpMethodFilter.HttpMethodRequestWrapper(request, method);
}
}
}
//从这里也可以看出，过滤器在放行时用的是根据_method的值新创建的请求对象
filterChain.doFilter((ServletRequest)requestToUse, response);
}HttpMessageConverter，报文信息转换器，将请求报文转换为java对象，或者将java对象转换为响应报文。
HttpMessageConverter提供了两个注解和两个类型：@RequestBody，@ResponseBody，RequestEntity，ResponseEntity。
1、@RequestBody
@RequestBody可以获取请求体，需要在控制器方法设置一个形参，使用@RequestBody进行标识，当前请求的请求体就会为当前注解所标识的形参赋值
<form th:action="@{/testRequestBody}" method="post">
用户名：<input type="text" name="username"><br>
密码：<input type="password" name="password"><br>
<input type="submit">
</form>@RequestMapping("/testRequestBody")
public String testRequestBody(@RequestBody String requestBody){
System.out.println("requestBody:"+requestBody);
return "success";
}输出结果：
requestBody:username=admin&password=123456
2、RequestEntity
RequestEntity封装请求报文的一种类型，需要在控制器方法的形参中设置该类型的形参，当前请求的请求报文就会赋值给该形参，可以通过getHeaders()获取请求头信息，通过getBody()获取请求体信息
@RequestMapping("/testRequestEntity")
public String testRequestEntity(RequestEntity<String> requestEntity){
System.out.println("requestHeader:"+requestEntity.getHeaders());
System.out.println("requestBody:"+requestEntity.getBody());
return "success";
}输出结果：
requestHeader:[host:“localhost:8080”, connection:“keep-alive”, content-length:“27”, cache-control:“max-age=0”, sec-ch-ua:“” Not A;Brand";v=“99”, “Chromium”;v=“90”, “Google Chrome”;v=“90"”, sec-ch-ua-mobile:“?0”, 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/90.0.4430.93 Safari/537.36”]
requestBody:username=admin&password=123
3、@ResponseBody
@ResponseBody用于标识一个控制器方法，可以将该方法的返回值直接作为响应报文的响应体响应到浏览器
@RequestMapping("/testResponseBody")
@ResponseBody
public String testResponseBody(){
return "success";
}结果：浏览器页面显示success
4、SpringMVC处理json
@ResponseBody处理json的步骤：
a>导入jackson的依赖
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.12.1</version>
</dependency>b>在SpringMVC的核心配置文件中开启mvc的注解驱动，此时在HandlerAdaptor中会自动装配一个消息转换器：MappingJackson2HttpMessageConverter，可以将响应到浏览器的Java对象转换为Json格式的字符串
<mvc:annotation-driven />c>在处理器方法上使用@ResponseBody注解进行标识
d>将Java对象直接作为控制器方法的返回值返回，就会自动转换为Json格式的字符串
@RequestMapping("/testResponseUser")
@ResponseBody
public User testResponseUser(){
return new User(1001,"admin","123456",23,"男");
}浏览器的页面中展示的结果：
{“id”:1001,“username”:“admin”,“password”:“123456”,“age”:23,“sex”:“男”}
5、SpringMVC处理ajax
a>请求超链接：
<div id="app">
<a th:href="@{/testAjax}" @click="testAjax">testAjax</a><br>
</div>b>通过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">
var vue = new Vue({
el:"#app",
methods:{
testAjax:function (event) {
axios({
method:"post",
url:event.target.href,
params:{
username:"admin",
password:"123456"
}
}).then(function (response) {
alert(response.data);
});
event.preventDefault();
}
}
});
</script>c>控制器方法：
@RequestMapping("/testAjax")
@ResponseBody
public String testAjax(String username, String password){
System.out.println("username:"+username+",password:"+password);
return "hello,ajax";
}6、@RestController注解
@RestController注解是springMVC提供的一个复合注解，标识在控制器的类上，就相当于为类添加了@Controller注解，并且为其中的每个方法添加了@ResponseBody注解
7、ResponseEntity
ResponseEntity用于控制器方法的返回值类型，该控制器方法的返回值就是响应到浏览器的响应报文
九、文件上传和下载1. 文件下载
- 使用ResponseEntity实现文件下载。
在webapp目录下新建目录 static，然后再新建img目录，在img目录下存放1.jpg
@RequestMapping("/fileDownload")
public ResponseEntity<byte[]> fileDownload(HttpSession session) throws IOException {
//获取ServletContext对象
ServletContext servletContext = session.getServletContext();
//获取服务器中文件的真实路径
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<byte[]>(bytes, headers, statusCode);
//关闭输入流
is.close();
return responseEntity;
}<a th:href="@{/fileDownload}">文件下载 1.jpg</a>2. 文件上传
文件上传要求form表单的请求方式为post，并且添加属性enctype=“multipart/form-data”
SpringMVC将上传的文件封装到 MultipartFile 对象中，通过此对象可以获取文件信息。
步骤：
添加文件上传的依赖：
<!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload --> <dependency> <groupId>commons-fileupload</groupId> <artifactId>commons-fileupload</artifactId> <version>1.3.1</version> </dependency>在SpringMVC中配置文件解析器，才能将文件转化为MultipartFile对象
<!--必须通过文件解析器的解析才能将文件转换为MultipartFile对象--> <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>控制器方法：
@RequestMapping("/fileUpload") //注意：这里MultipartFile的对象名photo需要和html中表单设置的名字一致,才能实现将文件转化为MultipartFile对象 public String fileUpload(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("/img"); File file = new File(photoPath); if(!file.exists()){ file.mkdir(); } String finalPath = photoPath + File.separator + fileName; //实现上传功能 photo.transferTo(new File(finalPath)); return "success"; }html页面：设置为post请求，enctype为 “multipart/form-data”，同时注意 <input> 标签中name属性和控制器方法形参的MultipartFile对象名要一致。
<form th:action="@{/fileUpload}" enctype="multipart/form-data" method="post"> <input type="file" name="photo"> <input type="submit"> </form>
1. 拦截器的配置
- SpringMVC的拦截器用于拦截控制器方法的执行。
步骤：
实现HandlerInterceptor接口，重写preHandle()，postHandle()，afterCompletion() 这三个方法。
public class TestInterceptor implements HandlerInterceptor { public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { System.out.println("preHandle"); return true; } public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { System.out.println("postHandle"); } public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { System.out.println("afterCompletion"); } }在SpringMVC的配置文件中进行配置
有三种写法：
第一种：
<mvc:interceptors> <bean class="com.oymn.interceptor.TestInterceptor"></bean> <!--设置拦截器--> </mvc:interceptors>第二种：
<mvc:interceptors> <ref bean="testInterceptor"></ref> <!--设置拦截器--> </mvc:interceptors>第三种：
<mvc:interceptors> <mvc:interceptor> <mvc:mapping path="/**"/> <!--/**表示拦截所有请求--> <mvc:exclude-mapping path="/"/> <!--表示不拦截/请求--> <ref bean="testInterceptor"></ref> <!--设置拦截器--> </mvc:interceptor> </mvc:interceptors>第一种和第二种都是对DispatcherServlet处理的所有请求进行拦截。
第三种通过ref或bean标签设置拦截器，通过mvc:mapping设置需要拦截的请求，通过mvc:exclude-mapping设置需要排除的请求，即不需要拦截的请求。
2. 拦截器的三个抽象方法
SpringMVC中的拦截器有三个抽象方法：
- preHandle：控制器方法执行之前执行preHandle()，其boolean类型的返回值表示是否拦截或者放行，返回true表示放行，即调用控制器方法；返回false表示拦截，即不调用控制器方法。
- postHandle：控制器方法执行之后执行postHandle()。
- afterCompletion：处理完视图和模型数据，渲染视图完毕后执行afterCompletion()。
源码：
进入 processDispatchResult 方法：
3. 多个拦截器的执行顺序
（1）若每个拦截器的prehandle()都返回 true：
此时多个拦截器的执行顺序和在SpringMVC的配置文件的配置顺序有关。
preHandle()会按照配置的顺序执行，而postHandle()和afterComplation()会按照配置的反序执行。
（2）若某个拦截器的prehandle()返回了 false：
preHandle()返回false的拦截器和它之前的拦截器的preHandle()都会执行，postHandle()都不执行，返回false的拦截器之前的拦截器的afterComplation()会执行，并且是反序执行。
源码分析：
进入applyPreHandle()方法：
boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
//正向遍历,同时interceptorIndex记录着最后一个返回true的拦截器的下标
for(int i = 0; i < this.interceptorList.size(); this.interceptorIndex = i++) {
//获取拦截器
HandlerInterceptor interceptor = (HandlerInterceptor)this.interceptorList.get(i);
//执行preHandle方法,然后判断是否返回false
if (!interceptor.preHandle(request, response, this.handler)) {
//当preHandle方法返回false时,会执行afterComplation()方法
this.triggerAfterCompletion(request, response, (Exception)null);
return false;
}
}
return true;
}进入applyPostHandle()方法：
void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv) throws Exception {
//反序遍历
for(int i = this.interceptorList.size() - 1; i >= 0; --i) {
HandlerInterceptor interceptor = (HandlerInterceptor)this.interceptorList.get(i);
//执行postHandle方法
interceptor.postHandle(request, response, this.handler, mv);
}
}进入triggerAfterCompletion方法：
void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex) {
//反序遍历，并且是只遍历interceptorIndex，也就是只遍历返回false的拦截器之前的拦截器
for(int i = this.interceptorIndex; i >= 0; --i) {
HandlerInterceptor interceptor = (HandlerInterceptor)this.interceptorList.get(i);
try {
//执行afterCompletion方法
interceptor.afterCompletion(request, response, this.handler, ex);
} catch (Throwable var7) {
logger.error("HandlerInterceptor.afterCompletion threw exception", var7);
}
}
}从这里可以看出，当applyPreHandle方法返回false时，也就是拦截器链表中有preHandle返回false的拦截器时，后面的applyPostHandle方法并不会执行。
1. 基于配置的异常处理器
SpringMVC提供了一个处理控制器方法执行过程中出现的异常的接口：HandlerExceptionResolver
HandlerExceptionResolver的实现类：DefaultHandlerExceptionResolver 和 SimpleMappingExceptionResolver
其中SimpleMappingExceptionResolver是SpringMVC提供的自定义的异常处理器。
<!--注册异常处理器-->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
<property name="exceptionMappings">
<props>
<!--key表示控制器方法执行过程中可能出现的异常:ArigthmeticException算术异常-->
<!--值error是指出现异常后跳转到指定页面error.html，该视图同样被thymeleaf解析,补充前后缀-->
<prop key="java.lang.ArithmeticException">error</prop>
</props>
</property>
<!--为exceptionAttribute设置一个值,作为异常信息的属性名,将出现的异常信息在请求域中进行共享-->
<property name="exceptionAttribute" value="exception"></property>
</bean>控制器方法：
@RequestMapping("/testException")
public String testException(){
int i = 1/0; //出现异常
return "success";
}error.html页面：
出现了错误<br/>
错误信息是：<p th:text="${exception}"></p> <!-这里的exception就是配置文件中exceptionAttribute的value值--->效果：
2. 基于注解的异常处理器
@ControllerAdvice //@ControllerAdvice将当前类表示为处理异常的组件
public class ExceptionController {
//@ExceptionHandler设置所处理的异常
@ExceptionHandler(value = {ArithmeticException.class,NullPointerException.class})
public String testException1(Exception ex, Model model){ //通过形参Exception类型对象接收异常信息
model.addAttribute("ex",ex);
return "error";
}
}error.html页面：
出现了错误<br/>
错误信息是：<p th:text="${ex}"></p> <!--这里的exception就是配置文件中exceptionAttribute的value值-->- 使用配置类和注解代替web.xml和SpringMVC配置文件的功能
1. 创建初始化类，代替web.xml
在Spring3.0及以后的环境中，容器会在类路径中查找实现了javax.servlet.ServletContainerInitializer接口的类，如果找到就用它来配置Servlet容器，也就是Tomcat服务器。
而Spring提供了这个接口的实现，叫做SpringServletContainerInitializer，这个类反过来又会查找实现WebApplicationInitializer的类并将配置的任务交给它们来完成。
而Spring3.2引入了WebApplicationInitializer的实现类，叫做AbstractAnnotationConfigDispatcherServletInitializer，当我们的类继承了这个实现类并将其部署到Servlet3.0容器的时候，容器会自动找到它，并用它来配置Servlet上下文。
public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer {
//指定Spring的配置类
protected Class<?>[] getRootConfigClasses() {
return new Class[]{SpringConfig.class};
}
//指定SpringMVC的配置类
protected Class<?>[] getServletConfigClasses() {
return new Class[]{WebConfig.class};
}
//指定DispatcherServlet的映射规则，即url-pattern
protected String[] getServletMappings() {
return new String[]{"/"};
}
//添加过滤器
@Override
protected Filter[] getServletFilters() {
//编码过滤器
CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter();
encodingFilter.setEncoding("UTF-8");
encodingFilter.setForceResponseEncoding(true);
//处理put、delete请求的过滤器
HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
return new Filter[]{encodingFilter,hiddenHttpMethodFilter};
}
}2. 创建SpringConfig配置类，代替Spring的配置文件
@Configuration
public class SpringConfig {
//ssm整合之后，spring的配置信息写在此类中
}3. 创建WebConfig配置类，代替SpringMVC的配置文件
// 1.组件扫描 2.视图解析器 3.mvc注解驱动 4.视图控制view-controller
// 5.文件上传解析器 6.defaultServletHandler 7.拦截器 8.异常处理器
@Configuration //标识配置类
@ComponentScan("com.oymn") //1.开启组件扫描
@EnableWebMvc //3.开启mvc注解驱动
public class WebConfig implements WebMvcConfigurer { //实现WebMvcConfigurer接口
//8.异常处理器
@Bean
public SimpleMappingExceptionResolver exceptionResolver(){
//创建SimpleMappingExceptionResolver
SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
Properties prop = new Properties();
//key表示可能出现的算数异常，value表示出现异常后跳转的error.html页面
prop.setProperty("java.lang.ArithmeticException","error");
//设置异常映射
exceptionResolver.setExceptionMappings(prop);
//设置共享信息的键
exceptionResolver.setExceptionAttribute("ex");
return exceptionResolver;
}
//7.配置拦截器
public void addInterceptors(InterceptorRegistry registry) {
//自定义的拦截器类FirstInterceptor
FirstInterceptor firstInterceptor = new FirstInterceptor();
//设置拦截规则：addPathPatterns的/**表示拦截所有请求，excludePathPatterns的/表示/请求不拦截
registry.addInterceptor(firstInterceptor).addPathPatterns("/**").excludePathPatterns("/");
}
//6.默认Servlet处理静态资源
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
configurer.enable();
}
//5.配置文件上传解析器
@Bean
public CommonsMultipartResolver multipartResolver(){
return new CommonsMultipartResolver();
}
//4.视图控制view-controller
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/").setViewName("index");
}
//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;
}
}上面的异常处理器，除了可以通过@Bean标签返回SimpleMappingExceptionResolver对象，也可以重写
WebMvcConfigurer接口提供configureHandlerExceptionResolvers方法，重写的内容基本和上面一致。
//8.异常处理器
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);
}1. SpringMVC的常用组件
- DispatcherServlet：前端控制器，不需要工程师开发，由框架提供
作用：统一处理请求和响应，整个流程控制的中心，由它调用其它组件处理用户的请求
- HandlerMapping：处理器映射器，不需要工程师开发，由框架提供
作用：根据请求的url、method等信息查找Handler，即控制器方法
- Handler：处理器，需要工程师开发
作用：在DispatcherServlet的控制下Handler对具体的用户请求进行处理
- HandlerAdapter：处理器适配器，不需要工程师开发，由框架提供
作用：通过HandlerAdapter对处理器（控制器方法）进行执行
- ViewResolver：视图解析器，不需要工程师开发，由框架提供
作用：进行视图解析，得到相应的视图，例如：ThymeleafView、InternalResourceView、RedirectView
- View：视图
作用：将模型数据通过页面展示给用户
2. DispatcherServlet初始化过程
DispatcherServlet本质上就是个Servlet
以上是DispatcherServlet初始化调用过程简略图：
接下来对一些源码进行分析：
- 初始化WebApplicationContext：
protected WebApplicationContext initWebApplicationContext() {
WebApplicationContext rootContext = WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());
WebApplicationContext wac = null;
//webApplicationContext为null，if语句不会执行
if (this.webApplicationContext != null) {
wac = this.webApplicationContext;
if (wac instanceof ConfigurableWebApplicationContext) {
ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext)wac;
if (!cwac.isActive()) {
if (cwac.getParent() == null) {
cwac.setParent(rootContext);
}
this.configureAndRefreshWebApplicationContext(cwac);
}
}
}
if (wac == null) {
wac = this.findWebApplicationContext();
}
if (wac == null) {
//创建WebApplicationContext
wac = this.createWebApplicationContext(rootContext);
}
if (!this.refreshEventReceived) {
synchronized(this.onRefreshMonitor) {
//刷新WebApplicationContext
this.onRefresh(wac);
}
}
if (this.publishContext) {
String attrName = this.getServletContextAttributeName();
//将IOC容器在应用域中共享
this.getServletContext().setAttribute(attrName, wac);
}
return wac;
}- 创建WebApplicationContex
protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
Class<?> contextClass = this.getContextClass();
if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
throw new ApplicationContextException("Fatal initialization error in servlet with name '" + this.getServletName() + "': custom WebApplicationContext class [" + contextClass.getName() + "] is not of type ConfigurableWebApplicationContext");
} else {
//通过反射创建IOC容器对象
ConfigurableWebApplicationContext wac = (ConfigurableWebApplicationContext)BeanUtils.instantiateClass(contextClass);
//设置环境
wac.setEnvironment(this.getEnvironment());
//设置父容器(也就是Spring)
wac.setParent(parent);
String configLocation = this.getContextConfigLocation();
if (configLocation != null) {
wac.setConfigLocation(configLocation);
}
this.configureAndRefreshWebApplicationContext(wac);
return wac;
}
}DispatcherServlet初始化策略
FrameworkServlet创建WebApplicationContext后，刷新容器，调用onFresh(wac)，此方法在DispatcherServlet进行了重写，调用了initStategies(context)方法，初始化策略，即初始化DispatcherServlet的各个组件。
protected void initStrategies(ApplicationContext context) { this.initMultipartResolver(context); this.initLocaleResolver(context); this.initThemeResolver(context); this.initHandlerMappings(context); this.initHandlerAdapters(context); this.initHandlerExceptionResolvers(context); this.initRequestToViewNameTranslator(context); this.initViewResolvers(context); this.initFlashMapManager(context); }
3. DispatcherServlet调用组件处理请求
HttpServlet中**service(HttpServletRequest request, HttpServletResponse response)**方法：
通过请求方式调用对应的doXXX方法
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
String method = req.getMethod();
long lastModified;
if (method.equals("GET")) {
lastModified = this.getLastModified(req);
if (lastModified == -1L) {
this.doGet(req, resp);
} else {
long ifModifiedSince = req.getDateHeader("If-Modified-Since");
if (ifModifiedSince < lastModified) {
this.maybeSetLastModified(resp, lastModified);
this.doGet(req, resp);
} else {
resp.setStatus(304);
}
}
} else if (method.equals("HEAD")) {
lastModified = this.getLastModified(req);
this.maybeSetLastModified(resp, lastModified);
this.doHead(req, resp);
} else if (method.equals("POST")) {
this.doPost(req, resp);
} else if (method.equals("PUT")) {
this.doPut(req, resp);
} else if (method.equals("DELETE")) {
this.doDelete(req, resp);
} else if (method.equals("OPTIONS")) {
this.doOptions(req, resp);
} else if (method.equals("TRACE")) {
this.doTrace(req, resp);
} else {
String errMsg = lStrings.getString("http.method_not_implemented");
Object[] errArgs = new Object[]{method};
errMsg = MessageFormat.format(errMsg, errArgs);
resp.sendError(501, errMsg);
}
}FrameworkServlet重写了HttpServlet中的service（HttpServletRequest request, HttpServletResponse response）方法和doXXX（）方法，而这些方法都调用了processRequest(request，response)。
//重写HttpServlet的service方法
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
if (httpMethod != HttpMethod.PATCH && httpMethod != null) {
//调用父类的service方法,但从上面的源码可以知道,实质上是调用了对应的doxxx方法
//而FrameworkServlet又重写了doXXX方法,如下,可以知道doXXX方法中又调用了processRequest方法,所以和下面else一样
super.service(request, response);
} else {
//调用processRequest方法
this.processRequest(request, response);
}
}
//重写HttpServlet的doGet方法
protected final void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.processRequest(request, response);
}
//重写HttpServlet的doPost方法
protected final void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.processRequest(request, response);
}
//重写HttpServlet的doPut方法
protected final void doPut(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.processRequest(request, response);
}
//重写HttpServlet的doDelete方法
protected final void doDelete(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.processRequest(request, response);
}processRequest（request，response）方法如下：
protected final void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
long startTime = System.currentTimeMillis();
Throwable failureCause = null;
LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
LocaleContext localeContext = this.buildLocaleContext(request);
RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
ServletRequestAttributes requestAttributes = this.buildRequestAttributes(request, response, previousAttributes);
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new FrameworkServlet.RequestBindingInterceptor());
this.initContextHolders(request, localeContext, requestAttributes);
try {
//执行服务,doService是一个抽象方法,在DispatcherServlet中进行了重写
this.doService(request, response);
} catch (IOException | ServletException var16) {
failureCause = var16;
throw var16;
} catch (Throwable var17) {
failureCause = var17;
throw new NestedServletException("Request processing failed", var17);
} finally {
this.resetContextHolders(request, previousLocaleContext, previousAttributes);
if (requestAttributes != null) {
requestAttributes.requestCompleted();
}
this.logResult(request, response, (Throwable)failureCause, asyncManager);
this.publishRequestHandledEvent(request, response, startTime, (Throwable)failureCause);
}
}DispatcherServlet中的doService方法：
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
this.logRequest(request);
Map<String, Object> attributesSnapshot = null;
if (WebUtils.isIncludeRequest(request)) {
attributesSnapshot = new HashMap();
Enumeration attrNames = request.getAttributeNames();
label120:
while(true) {
String attrName;
do {
if (!attrNames.hasMoreElements()) {
break label120;
}
attrName = (String)attrNames.nextElement();
} while(!this.cleanupAfterInclude && !attrName.startsWith("org.springframework.web.servlet"));
attributesSnapshot.put(attrName, request.getAttribute(attrName));
}
}
request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.getWebApplicationContext());
request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
request.setAttribute(THEME_SOURCE_ATTRIBUTE, this.getThemeSource());
if (this.flashMapManager != null) {
FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
if (inputFlashMap != null) {
request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
}
request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
}
RequestPath requestPath = null;
if (this.parseRequestPath && !ServletRequestPathUtils.hasParsedRequestPath(request)) {
requestPath = ServletRequestPathUtils.parseAndCache(request);
}
try {
//处理请求和响应
this.doDispatch(request, response);
} finally {
if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted() && attributesSnapshot != null) {
this.restoreAttributesAfterInclude(request, attributesSnapshot);
}
if (requestPath != null) {
ServletRequestPathUtils.clearParsedRequestPath(request);
}
}
}doDispatch方法：
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request;
HandlerExecutionChain mappedHandler = null;
boolean multipartRequestParsed = false;
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
try {
try {
ModelAndView mv = null;
Object dispatchException = null;
try {
processedRequest = this.checkMultipart(request);
multipartRequestParsed = processedRequest != request;
//执行链,包含handler,interceptorList,interceporIndex
//handler：浏览器发送的请求所匹配的控制器方法
//interceptorList：处理控制器方法的所有拦截器集合
//interceporIndex：拦截器索引,preHanler方法返回false的最后一个拦截器的下标，控制afterCompletion方法的执行
mappedHandler = this.getHandler(processedRequest);
if (mappedHandler == null) {
this.noHandlerFound(processedRequest, response);
return;
}
//处理器适配器，用于调用请求所对应的控制器方法
HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
String method = request.getMethod();
boolean isGet = "GET".equals(method);
if (isGet || "HEAD".equals(method)) {
long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
if ((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet){
return;
}
}
//调用拦截器的preHandle方法
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
//由处理器适配器调用具体的控制器方法，最终获得ModelAndView对象
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
this.applyDefaultViewName(processedRequest, mv);
//调用拦截器的postHandle方法
mappedHandler.applyPostHandle(processedRequest, response, mv);
}
catch (Exception var20) {
dispatchException = var20;
}
catch (Throwable var21) {
dispatchException = new NestedServletException("Handler dispatch failed", var21);
}
//后续处理：处理模型数据和渲染视图
processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
}
catch (Exception var22) {
this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
}
catch (Throwable var23) {
this.triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", var23));
}
} finally {
if (asyncManager.isConcurrentHandlingStarted()) {
if (mappedHandler != null) {
mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
}
} else if (multipartRequestParsed) {
this.cleanupMultipart(processedRequest);
}
}
}processDispatchResult方法：
private void processDispatchResult(HttpServletRequest request, HttpServletResponse response, @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv, @Nullable Exception exception) throws Exception {
boolean errorView = false;
if (exception != null) {
if (exception instanceof ModelAndViewDefiningException) {
this.logger.debug("ModelAndViewDefiningException encountered", exception);
mv = ((ModelAndViewDefiningException)exception).getModelAndView();
} else {
Object handler = mappedHandler != null ? mappedHandler.getHandler() : null;
mv = this.processHandlerException(request, response, handler, exception);
errorView = mv != null;
}
}
if (mv != null && !mv.wasCleared()) {
//处理模型数据和渲染视图
this.render(mv, request, response);
if (errorView) {
WebUtils.clearErrorRequestAttributes(request);
}
} else if (this.logger.isTraceEnabled()) {
this.logger.trace("No view rendering, null ModelAndView returned.");
}
if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
if (mappedHandler != null) {
//调用拦截器的afterCompletion方法
mappedHandler.triggerAfterCompletion(request, response, (Exception)null);
}
}
}4. SpringMVC的执行流程
用户向服务器发送请求，请求被SpringMVC 前端控制器 DispatcherServlet捕获。
DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI），判断请求URI对应的映射：
a) 不存在
i. 再判断是否配置了mvc:default-servlet-handler
ii. 如果没配置，则控制台报映射查找不到，客户端展示404错误
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SaH6iGR1-1672844074895)(D:\File\学习资料\SpringMVC\笔记\img\img006.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-63YAc6XD-1672844074896)(D:\File\学习资料\SpringMVC\笔记\img\img007.png)]
iii. 如果有配置，则访问目标资源（一般为静态资源，如：JS,CSS,HTML），找不到客户端也会展示404错误
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P9ZPpkcL-1672844074897)(D:\File\学习资料\SpringMVC\笔记\img\img008.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8jFa567Q-1672844074898)(D:\File\学习资料\SpringMVC\笔记\img\img009.png)]
b) 存在则执行下面的流程
根据该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(…)方法【逆向】。
将渲染结果返回给客户端。
