SpringMVC简介

1. 概述

2. 快速入门

2.1 导入spring-mvc坐标

pom.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
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>spring-webmvc-test02</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.10</version>
        </dependency>
    </dependencies>

</project>

2.2 配置前端控制器DispatcherServlet

web.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
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
	version="4.0">

	<!--配置DispatcherServlet-->
	<servlet>
		<servlet-name>DispatcherServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  
        <!--指定初始化参数（跟第三步配合，扫描对应配置文件）-->
        <init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:spring-mvc.xml</param-value>
		</init-param>
		<load-on-startup>2</load-on-startup>
  
	</servlet>
	<servlet-mapping>
		<servlet-name>DispatcherServlet</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>

</web-app>

2.3 编写Controller，配置映射路径，并交给SpringMVC容器管理

spring-mvc.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       ">

    <!--组件扫描-->
    <context:component-scan base-package="com.itheima.controller"/>

</beans>
1
2
3
4
5
6
7
@Controller
public class QuickController {
    @RequestMapping("/show")
    public void show() {
        System.out.println("show running....");
    }
}
1
2
3
4
5
6
7
8
9
10
11
服务器启动，读到2，直接创建对象，
创建DispatcherServlet对象，
读取contextConfigLocation初始化参数，
然后找到了配置文件，
组件扫描，扫到QuickController，
然后QuickController中的信息就被放到spring-mvc容器当中，
映射地址也被放进去。
请求的时候找到DispatcherServlet，然后它在进行分发，
根据容器当中已经存储好的信息，
找到访问的地址，
然后执行调用响应方法

3. Controller中访问容器中的Bean

上面配的是SpringMVC容器

现在再配一下Spring容器（使用之前用的监听器配置），将二者集成

applicationContext.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       ">

    <!--组件扫描-->
    <context:component-scan base-package="com.itheima.service"/>

</beans>

web.xml

1
2
3
4
5
6
7
<!--配置ContextLoaderListener-->
<context-param>
	<param-name>contextConfigLocation</param-name>		<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
1
2
3
4
5
6
7
8
9
10
11
12
@Controller
public class QuickController {

    //直接注入Service进行使用
    @Autowired
    private QuickService quickService;

    @RequestMapping("/show")
    public void show() {
        System.out.println("show running...." + quickService);
    }
}

4. SpringMVC关键组件浅析

image-20240412154400209

简单了解三个组件间的关系

image-20240412154914965

由于前后端分离，所以视图解析器不会讲太多

5. Spring加载组件的策略

SpringMVC在前端控制器DispatcherServlet加载时，会进行初始化操作

在进行初始化操作时，会加载一些SpringMVC的默认组件

这些默认组件配置在DispatcherServlet.properties文件中

默认情况下，前端控制器启动时会初始化很多组件，这些组件从

DispatcherServlet.properties文件中加载，存储到DispatcherServlet类的集合中。

问题：有没有把初始化好的组件存储到Spring容器或SpringMVC容器当中

答：都没有

可以自定义组件，并将组件存储到Spring容器或SpringMVC容器当中。根据源码可知，前端控制器会先判断Spring容器中是否有组件，如果有的话，就会加载Spring中的组件，而不会去加载默认组件

SpringMVC的请求处理

1. 请求映射路径的配置

image-20240412164749321

举一反三

参数：映射地址，method方式等等

不只可以配置到方法上，还可以配置到类上，表示路径的拼接

2. 请求数据的接收

2.1 接收普通请求数据

  • 当请求参数有特殊格式数据（如日期）时，可以使用Spring内置的类型解析器
1
2
3
4
5
6
//username=haohao&age=35&birthday=1986/01/01 
@GetMapping("/show")
public String show(String username,int age,Date birthday){
    System.out.println(username+"=="+age+"=="+birthday);
    return "/index.jsp";
}
1
2
3
4
5
@GetMapping("/show")
public String show(String username,int age,@DateTimeFormat(pattern = "yyyy-MM-dd") Date birthday){
    System.out.println(username+"=="+age+"=="+birthday);
    return "/index.jsp";
}
  • 当请求参数的名称与方法参数名不一致时，可以使用@RequestParam注解进行标注
1
2
3
4
5
6
//username=haohao&age=35
@GetMapping("/show")
public String show(@RequestParam(name = "username",required = true) String name, int age){
    System.out.println(name+"=="+age);
    return "/index.jsp";
}

2.2 接收实体JavaBean属性数据

  • 单个JavaBean数据：提交的参数名称只要与Java的属性名一致，就可以进行自动封装

2.3 接收数组或集合数据

  • 客户端传递多个同名参数时，可以使用数组接收
1
2
3
4
5
6
7
8
//hobbies=eat&hobbies=sleep
@GetMapping("/show")
public String show(String[] hobbies){
    for (String hobby : hobbies) {
        System.out.println(hobby);
    }
    return "/index.jsp";
}
  • 客户端传递多个同名参数时，也可以使用单列集合接收，但是需要使用@RequestParam告知框架传递的参数是要同名设置的，不是对象属性设置的
1
2
3
4
5
6
7
@GetMapping("/show")
public String show(@RequestParam List<String> hobbies){
    for (String hobby : hobbies) {
        System.out.println(hobby);
    }
    return "/index.jsp";
}

2.4 接收Json数据格式数据

  • Json数据都是以请求体的方式提交的，且不是原始的键值对格式的，所以我们要使用 @RequestBody注解整体接收该数据。
1
2
3
4
5
6
7
8
9
10
{
    "username":"haohao",
    "age":18,
    "hobbies":["eat","sleep"],
    "birthday":"1986-01-01",
    "address":{
        "city":"tj",
        "area":"binhai"
    }
}
1
2
3
4
5
@PostMapping("/show6")
public String show6(@RequestBody String body){
    System.out.println(body);
    return "/index.jsp";
}
  • 使用Json工具（jackson）将Json格式的字符串转化为JavaBean进行操作
1
2
3
4
5
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.0</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
@PostMapping("/show")
public String show(@RequestBody String body) throws IOException {
    System.out.println(body);
    //获得ObjectMapper
    ObjectMapper objectMapper = new ObjectMapper();
    //将json格式字符串转化成指定的User
    User user = objectMapper.readValue(body, User.class);
    System.out.println(user);
    return "/index.jsp";
}
  • 配置RequestMappingHandlerAdapter，指定消息转换器，就不用手动转换json格式字符串了
1
2
3
4
5
6
7
8
9
<bean 
class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <property name="messageConverters">
        <list>
            <bean 
class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        </list>
    </property>
</bean>
1
2
3
4
5
@PostMapping("/show")
public String show(@RequestBody User user){
    System.out.println(user);
    return "/index.jsp";
}
  • 接收Json数据格式数据，使用Map接收json格式字符串
1
2
3
4
5
@PostMapping("/show")
public String show(@RequestBody Map map){
    System.out.println(map);
    return "/index.jsp";
}

2.5 接收Restful风格数据

2.5.1 什么是Rest风格

Rest（Representational State Transfer）表象化状态转变（表述性状态转变），在2000年被提出，基于HTTP、URI 、xml、JSON等标准和协议，支持轻量级、跨平台、跨语言的架构设计。是Web服务的一种新网络应用程序的设计风格和开发方式。

2.5.2 常见规则

  1. 用URI表示某个模块资源，资源名称为名词；

  2. 用请求方式表示模块具体业务动作，例如：GET表示查询、POST表示插入、PUT表示更新、DELETE表示删除

    image-20240412194032414

  3. 用HTTP响应状态码表示结果，国内常用的响应包括三部分：状态码、状态信息、响应数据

2.5.3 接收数据

Restful请求数据一般会在URL地址上携带，可以使用注解 @PathVariable(占位符参数名称)

单个参数

1
2
3
4
5
@PostMapping("/user/{id}")
public String findUserById(@PathVariable("id") Integer id){
    System.out.println(id);
    return "/index.jsp";
}

多个参数

1
2
3
4
5
6
@PostMapping("/user/{username}/{age}")
public String findUserByUsernameAndAge(@PathVariable("username") String 
username,@PathVariable("age") Integer age){
    System.out.println(username+"=="+age);
    return "/index.jsp";
}

2.6 接收文件上传的数据

文件上传的表单需要一定的要求，如下：

  1. 表单的提交方式必须是POST
  2. 表单的enctype属性必须是multipart/form-data
  3. 文件上传项需要有name属性
1
2
3
<form action="" enctype="multipart/form-data">
    <input type="file" name="myFile">
</form>

服务器端，由于映射器适配器需要文件上传解析器，而该解析器默认未被注册，所以手动注册

1
2
3
4
5
6
7
8
<!--配置文件上传解析器，注意：id的名字是固定写法-->
<bean id="multipartResolver" 
class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="defaultEncoding" value="UTF-8"/><!--文件的编码格式 默认是ISO8859-1-->
    <property name="maxUploadSizePerFile" value="1048576"/><!--上传的每个文件限制的大小 单位字节-->
    <property name="maxUploadSize" value="3145728"/><!--上传文件的总大小-->
    <property name="maxInMemorySize" value="1048576"/><!--上传文件的缓存大小-->
</bean>

而CommonsMultipartResolver底层使用的Apache的是Common-fileuplad等工具API进行的文件上传

1
2
3
4
5
6
7
8
9
10
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.4</version>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.7</version>
</dependency>

使用MultipartFile类型接收上传文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@PostMapping("/fileUpload")
public String fileUpload(@RequestBody MultipartFile myFile) throws IOException {
    System.out.println(myFile);
    //获得上传的文件的流对象
    InputStream inputStream = myFile.getInputStream();
    //使用commons-io存储到C:\haohao\abc.txt位置
    FileOutputStream outputStream = new 
FileOutputStream("C:\\Users\\haohao\\"+myFile.getOriginalFilename());
    IOUtils.copy(inputStream,outputStream);
    //关闭资源
    inputStream.close();
    outputStream.close();
    return "/index.jsp";
}

如果进行多文件上传的话，则使用MultipartFile数组即可

2.7 接收Http请求头数据

  1. 接收指定名称的请求头
1
2
3
4
5
@GetMapping("/headers")
public String headers(@RequestHeader("Accept-Encoding") String acceptEncoding){
    System.out.println("Accept-Encoding:"+acceptEncoding);
    return "/index.jsp";
}
  1. 接收所有的请求头信息
1
2
3
4
5
6
7
@GetMapping("/headersMap")
public String headersMap(@RequestHeader Map<String,String> map){
    map.forEach((k,v)->{
        System.out.println(k+":"+v);
    });
    return "/index.jsp";
}

2.8 获得客户端携带的Cookie数据

1
2
3
4
5
@GetMapping("/cookies")
public String cookies(@CookieValue(value = "JSESSIONID",defaultValue = "") String jsessionid){
    System.out.println(jsessionid);
    return "/index.jsp";
}

2.9 获得转发Request域中数据

在进行资源之间转发时，有时需要将一些参数存储到request域中携带给下一个资源

1
2
3
4
5
6
7
8
9
10
11
@GetMapping("/request1")
public String request1(HttpServletRequest request){
    //存储数据
    request.setAttribute("username","haohao");
    return "forward:/request2";
}
@GetMapping("/request2")
public String request2(@RequestAttribute("username") String username){
    System.out.println(username);
    return "/index.jsp";
}

2.10 请求参数乱码的解决方案

Spring已经提供好的CharacterEncodingFilter来进行编码过滤

1
2
3
4
5
6
7
8
9
10
11
12
13
<!--配置全局的编码过滤器-->
<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>

3. Javaweb常用对象获取

SpringMVC注入传统的web对象

获得Javaweb常见原生对象，有时在我们的Controller方法中需要用到Javaweb的原生对象，例如：Request、 Response等，我们只需要将需要的对象以形参的形式写在方法上，SpringMVC框架在调用Controller方法时，会自 动传递实参：

1
2
3
4
5
6
7
@GetMapping("/javawebObject")
public String javawebObject(HttpServletRequest request, HttpServletResponse response, HttpSession session){
    System.out.println(request);
    System.out.println(response);
    System.out.println(session);
    return "/index.jsp";
}

4. 请求静态资源

4.1 静态资源请求失效的原因

当DispatcherServlet的映射路径配置为 / 的时候，那么就覆盖的Tomcat容器默认的缺省 Servlet，在Tomcat的config目录下有一个web.xml 是对所有的web项目的全局配置，其中有如下配置：

1
2
3
4
5
6
7
8
9
<servlet>
    <servlet-name>default</servlet-name>
    <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>
    <servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

url-pattern配置为 / 的Servlet我们称其为缺省的Servlet，作用是当其他Servlet都匹配不成功时，就找缺省的Servlet ，静态资源由于没有匹配成功的Servlet，所以会找缺省的DefaultServlet，该DefaultServlet具备二次去匹配静态资源的功能。但是我们配置DispatcherServlet后就将其覆盖掉了，而DispatcherServlet会将请求的静态资源的名称当 成Controller的映射路径去匹配，即静态资源访问不成功了！

4.2 静态资源请求的三种解决方案

  1. 第一种方案，可以再次激活Tomcat的DefaultServlet，Servlet的url-pattern的匹配优先级是：<span style="color:blue">精确匹配 > 目录匹配 > 扩展名匹配 > 缺省匹配，所以可以指定某个目录下或某个扩展名的资源使用DefaultServlet进行解析：
1
2
3
4
5
6
7
8
9
<!--再次激活-->
<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>/img/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.html</url-pattern>
</servlet-mapping>
  1. 第二种方案，在spring-mvc.xml中去配置静态资源映射，匹配映射路径的请求到指定的位置去匹配资源
1
2
3
4
5
<!-- mapping是映射资源路径，location是对应资源所在的位置 -->
<mvc:resources mapping="/img/*" location="/img/"/>
<mvc:resources mapping="/css/*" location="/css/"/>
<mvc:resources mapping="/css/*" location="/js/"/>
<mvc:resources mapping="/html/*" location="/html/"/>
  1. 第三种方案，在spring-mvc.xml中去配置< mvc:default-servlet-handler >，该方式是向Spring容器当中注册了一个 DefaultServletHttpRequestHandler 处理器，静态资源的访问都由该处理器去处理，这也是开发中使用最多的
1
<mvc:default-servlet-handler/>

5. 注解驱动 <mvc:annotation-driven>标签

5.1 引入问题

刚开始是只能配置动态资源，静态资源由于前端控制器导致无法访问。

上面提供了三个解决方案，后两个方案又会引发另一个问题，由于标签底层向Spring容器中注册了SimpleUrlHarderMapping，覆盖掉了SpringMVC默认加载的三个组件 具体看SpringMVC简介5.Spring加载组件的策略，从而导致RequsetMappingHandlerMapping不加载，@RequsetMapping失效，动态资源又无法访问了。

（根据翻源码，发现只要加载这个标签，parse方法中就会向Spring容器中注册一个SimpleUrlHarderMapping，查看继承关系发现它实现了HandlerMapping，默认的三个组件就不加载了）

5.2 解决方法

5.2.1 手动加载

自己在加载静态资源的基础上手动加载RequsetMappingHandlerMapping，RequestMappingHandlerAdapter以及向其中注入Json消息转换器，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<!-- 显示配置RequestMappingHandlerMapping -->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>

<!-- 显示配置RequestMappingHandlerAdapter -->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <property name="messageConverters">
        <list>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        </list>
    </property>
</bean>

<!--配置DefaultServletHttpRequestHandler-->
<mvc:default-servlet-handler/>

5.2.2 使用 <mvc:annotation-driven>标签

<mvc:annotation-driven >浓缩了上面的两段配置，内部会帮忙注册那两个东西。

不过它的作用远不止于此（例如日期转换器），目前会用这两个就行

1
2
3
4
<!--mvc注解驱动-->
<mvc:annotation-driven/>
<!--配置DefaultServletHttpRequestHandler-->
<mvc:default-servlet-handler/>

PS： 标签在不同的版本中，帮我们注册的组件不同，Spring 3.0.X 版本注册是 DefaultAnnotationHandlerMapping 和 AnnotationMethodHandlerAdapter，由于框架的发展，从Spring 3.1.X 开始注册组件变为 RequestMappingHandlerMapping和RequestMappingHandlerAdapter

SpringMVC的响应处理

响应数据主要分为两大部分：

  • 传统同步方式：

    准备好模型数据，在跳转到执行页面进行展示，此方式使用越来越少了，基于历史原因，一些旧 项目还在使用；

  • 前后端分离异步方式：

    前端使用Ajax技术+Restful风格与服务端进行Json格式为主的数据交互，目前市场上几乎 都是此种方式了。

1. 传统同步业务数据响应

传统同步业务在数据响应时，SpringMVC又涉及如下四种形式：

1.1 请求资源转发

image-20240412215405736

1.2 请求资源重定向

image-20240412215415284

1.3 响应模型数据

响应模型数据本质也是转发，在转发时可以准备模型数据

1
2
3
4
5
6
7
8
9
10
11
@GetMapping("/forward5")
public ModelAndView forward5(ModelAndView modelAndView){
    //准备JavaBean模型数据
    User user = new User();
    user.setUsername("haohao");
    //设置模型
    modelAndView.addObject("user",user);
    //设置视图
    modelAndView.setViewName("/index.jsp");
    return modelAndView;
}

1.4 直接回写数据给客户端

直接通过方法的返回值返回给客户端的字符串，但是SpringMVC默认的方法返回值是视图，可以 <span style="color:blue">通过 @ResponseBody 注解显示的告知此处的返回值不要进行视图处理，是要以响应体的方式处理的

1
2
3
4
5
@GetMapping("/response2")
@ResponseBody
public String response2() throws IOException {
    return "Hello haohao!";
}

2. 前后端分离异步业务数据响应

2.0 二者区别

其实此处的回写数据，跟上面回写数据给客户端的语法方式一样，只不过有如下一些区别：

  • 同步方式回写数据，是将数据响应给浏览器进行页面展示的，而异步方式回写数据一般是回写给Ajax引擎的，即 谁访问服务器端，服务器端就将数据响应给谁
  • 同步方式回写的数据，一般就是一些无特定格式的字符串，而异步方式回写的数据大多是Json格式字符串

2.1 回写普通数据

使用@ResponseBody标注方法，直接返回字符串即可

1
2
3
4
5
@GetMapping("/response3")
@ResponseBody
public String response3(HttpServletResponse response) {
    return "{\"username\":\"haohao\",\"age\":18}";
}

2.2 回写Json格式的字符串

2.2.1 无@ResponseBody

即将直接拼接Json格式的字符串或使用工具将JavaBean转换成Json格式的字符串回写

1
2
3
4
5
6
7
8
9
10
@GetMapping("/response4")
public String response4() throws JsonProcessingException {
    //创建JavaBean
    User user = new User();
    user.setUsername("haohao");
    user.setAge(18);
    //使用Jackson转换成json格式的字符串
    String json = new ObjectMapper().writeValueAsString(user);
    return json;
}

2.2.2 有@ResponseBody

在讲解SringMVC接收请求数据时，客户端提交的Json格式的字符串，也是使用Jackson进行的手动转换成JavaBean ，可以当我们使用了@RequestBody时，直接用JavaBean就接收了Json格式的数据，原理其实就是SpringMVC底层 帮我们做了转换，此处@ResponseBody也可以将JavaBean自动给我们转换成Json格式字符串回响应

1
2
3
4
5
6
7
8
9
10
@GetMapping("/response5")
@ResponseBody
public User response5() throws JsonProcessingException {
    //创建JavaBean
    User user = new User();
    user.setUsername("haohao");
    user.setAge(18);
    //直接返回User对象
    return user;
}

2.2.3 <span style="color:blue">@ResponseBody注解使用优化

在进行前后端分离开发时，Controller的每个方法都是直接回写数据的，所以每个 方法上都得写@ResponseBody，可以将@ResponseBody写到Controller上，那么该Controller中的所有方法都具备 了返回响应体数据的功能了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Controller
@ResponseBody
public class UserController{
    @GetMapping("/response7")
    public ResultInfo response7() {
        //省略其他代码
        return info;
    }
    @GetMapping("/response5")
    public User response5() throws JsonProcessingException {
        //省略其他代码
        return user;
    }
    // ... 省略其他方法 ...
}

进一步优化，可以使用@RestController替代@Controller和@ResponseBody，@RestController内部具备的这两个注解的功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@RestController
public class UserController{
    @GetMapping("/response7")
    public ResultInfo response7() {
        //省略其他代码
        return info;
    }
    @GetMapping("/response5")
    public User response5() throws JsonProcessingException {
        //省略其他代码
        return user;
    }
    // ... 省略其他方法 ...
}

SpringMVC的拦截器

1. 拦截器Interceptor简介

1.1 Filter与Interceptor

SpringMVC的拦截器Interceptor规范，主要是对Controller资源访问时进行拦截操作的技术，当然拦截后可以进行权 限控制，功能增强等都是可以的。拦截器有点类似 Javaweb开发中的Filter，拦截器与Filter的区别如下图：

image-20240412221153720

由上图，对Filter 和 Interceptor 做个对比：

Filter技术 Interceptor技术
技术范畴 Javaweb原生技术 SpringMVC框架技术
拦截/过滤资源 可以对所有请求都过滤，包括任何Servlet、Jsp、 其他资源等 只对进入了SpringMVC管辖范围的才拦截，主要拦截 Controller请求
执行时机 早于任何Servlet执行 晚于DispatcherServlet执行

1.2 HandlerInterceptor接口

实现了HandlerInterceptor接口，且被Spring管理的Bean都是拦截器，接口定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
public interface HandlerInterceptor {
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object 
handler) throws Exception {
        return true;
    }
    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object 
handler, @Nullable ModelAndView modelAndView) throws Exception {
    }
    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, 
Object handler, @Nullable Exception ex) throws Exception {
    }
}

HandlerInterceptor接口方法的作用及其参数、返回值详解如下：

作用 参数 返回值
preHandle 对拦截到的请求进行预处理，返回true放 行执行处理器方法，false不放行 Handler是拦截到的Controller方法处理器 一旦返回false，代表终止向后 执行，所有后置方法都不执行，最终方法只执行对应preHandle 返回了true的
postHandle 在处理器的方法执行后，对拦截到的请求 进行后处理，可以在方法中对模型数据和 视图进行修改 Handler是拦截到的Controller方法处理器；modelAndView是返 回的模型视图对象 无
afterCompletion 视图渲染完成后(整个流程结束之后)，进行 最后的处理，如果请求流程中有异常，可 以处理异常对象 Handler是拦截到的Controller方法处理器；ex是异常对象 无

2. 拦截器快速入门

编写MyInterceptor01实现HandlerInterceptor接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class MyInterceptor01 implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object 
handler) throws Exception {
        System.out.println("Controller方法执行之前...");
        return true;//放行
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, 
ModelAndView modelAndView) throws Exception {
        System.out.println("Controller方法执行之后...");
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object 
handler, Exception ex) throws Exception {
        System.out.println("渲染视图结束，整个流程完毕...");
    }
}

配置Interceptor

1
2
3
4
5
6
7
8
<!--配置拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--配置对哪些资源进行拦截操作-->
        <mvc:mapping path="/*"/>
        <bean class="com.itheima.interceptor.MyInterceptor01"></bean>
    </mvc:interceptor>
</mvc:interceptors>

3. 拦截器执行顺序

拦截器三个方法的执行顺序

当每个拦截器都是放行状态时，三个方法的执行顺序如下：

image-20240412222228151

当Interceptor1和Interceptor2处于放行，Interceptor3处于不放行时，三个方法的执行顺序如下：

image-20240412222254982

拦截器执行顺序取决于 interceptor 的配置顺序

1
2
3
4
5
6
7
8
9
10
<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/target"/>
        <bean class="com.itheima.interceptor.MyInterceptor02"></bean>
    </mvc:interceptor>
    <mvc:interceptor>
        <mvc:mapping path="/*"/>
        <bean class="com.itheima.interceptor.MyInterceptor01"></bean>
    </mvc:interceptor>
</mvc:interceptors>

4. 拦截器执行原理

image-20240414162842917

HandlerMappering找到对应的可以被执行的Interceptor和Controller，将Interceptor和Controller封装为一个HandlerExcutionChain对象（一个Handler执行资源和多个Interceptor 被封装在一个集合当中），然后在把对象交给HandlerAdapter适配器进行处理

翻源码：

  • 入口：前端控制器，doDispatch方法，HandlerExcutionChain h = getHandler()
  • HandlerExecutionChain的applyPreHandle方法，开始执行拦截器方法

算了，实际复现的时候自己去看吧，现在也看不太深

SpringMVC的全注解开发

1. spring-mvc.xml中组件转化为注解形式

跟之前全注解开发思路一致， xml配置文件使用核心配置类替代，xml中的标签使用对应的注解替代

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<!--1. 自定义Bean，组件扫描web层 -->
<context:component-scan base-package="com.itheima.controller"/>

<!--2. 非自定义Bean，例如-->
<!--配置文件上传解析器-->
<bean id="multipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartResolver"/>

<!--3. 非Bean的配置-->
<!--注解驱动-->
<mvc:annotation-driven/>
<!--配置拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/*"/>
        <bean class="com.itheima.interceptor.MyInterceptor01"></bean>
    </mvc:interceptor>
</mvc:interceptors>
<!--配置DefaultServletHttpRequestHandler-->
<mvc:default-servlet-handler/>

组件扫描，可以通过@ComponentScan注解完成；

文件上传解析器multipartResolver可以通过非自定义Bean的注解配置方式，即@Bean注解完成

1与2的配置方式之前Spring都学过

@EnableWebMvc实现 <mvc:default-servlet-handler/>和 <mvc:interceptors>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Configuration
@ComponentScan("com.itheima.controller")
@EnableWebMvc
public class SpringMVCConfig {
    @Bean
    public CommonsMultipartResolver multipartResolver(){
        CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
        multipartResolver.setDefaultEncoding("UTF-8");
        multipartResolver.setMaxUploadSize(3145728);
        multipartResolver.setMaxUploadSizePerFile(1048576);
        multipartResolver.setMaxInMemorySize(1048576);
        return multipartResolver;
    }
}

@EnableWebMvc原理

<mvc:default-servlet-handler/>和 <mvc:interceptors>怎么办呢？SpringMVC 提供了一个注解叫做 @EnableWebMvc，我们看一下源码，内部通过@Import 导入了DelegatingWebMvcConfiguration类

1
2
3
4
5
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({DelegatingWebMvcConfiguration.class})
public @interface EnableWebMvc {}
1
2
3
4
5
6
7
8
9
10
11
12
@Configuration(proxyBeanMethods = false)
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
    private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
    //从容器中注入WebMvcConfigurer类型的Bean
    @Autowired(required = false)
    public void setConfigurers(List<WebMvcConfigurer> configurers) {
        if (!CollectionUtils.isEmpty(configurers)) {
            this.configurers.addWebMvcConfigurers(configurers);
        }
    }
    //省略其他代码
}

WebMvcConfigurer类型的Bean会被注入进来，然后被自动调用，所以可以实现WebMvcConfigurer接口，完成一些 解析器、默认Servlet等的指定，WebMvcConfigurer接口定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public interface WebMvcConfigurer {
    //配置默认Servet处理器
    default void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) { }
    //添加拦截器
    default void addInterceptors(InterceptorRegistry registry) {}
    //添加资源处理器
    default void addResourceHandlers(ResourceHandlerRegistry registry) {}
    //添加视图控制器
    default void addViewControllers(ViewControllerRegistry registry) {}
    //配置视图解析器
    default void configureViewResolvers(ViewResolverRegistry registry) {}
    //添加参数解析器
    default void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {}
    //... 省略其他代码 ...
}

创建MyWebMvcConfigurer实现WebMvcConfigurer接口，实现addInterceptors 和 configureDefaultServletHandling方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Component
public class MyWebMvcConfigurer implements WebMvcConfigurer {
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        //开启DefaultServlet，可以处理静态资源了
        configurer.enable();
    }
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //创建拦截器对象，进行注册
        //Interceptor的执行顺序也取决于添加顺序
        registry.addInterceptor(new MyInterceptor01()).addPathPatterns("/*");
    }
}

2. DispatcherServlet加载核心配置类

DispatcherServlet在进行SpringMVC配置文件加载时，使用的是以下方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!--配置springMVC前端控制器-->
<servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--指定springMVC配置文件位置-->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <!--服务器启动就创建-->
    <load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

现在是使用SpringMVCConfig核心配置类提替代的spring-mvc.xml，怎么加载呢？参照Spring的 ContextLoaderListener加载核心配置类的做法，定义了一个AnnotationConfigWebApplicationContext，通过 代码注册核心配置类

1
2
3
4
5
6
7
public class MyAnnotationConfigWebApplicationContext extends
AnnotationConfigWebApplicationContext {
    public MyAnnotationConfigWebApplicationContext(){
        //注册核心配置类
        super.register(SpringMVCConfig.class);
    }
}
1
2
3
4
5
<!--指定springMVC的applicationContext全限定名 -->
<init-param>
    <param-name>contextClass</param-name>
    <param-value>com.itheima.config.MyAnnotationConfigWebApplicationContext</param-value>
</init-param>

3. <span style="color:red">消除web.xml

<span style="color:red">了解消除web.xml还是很重要的

目前，几乎消除了配置文件，但是web工程的入口还是使用的web.xml进行配置的，如下

<span style="color:blue">两个入口，Spring的监听器ContextLoaderListener和SpringMVC的前端控制器DispatcherServlet

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<!--配置Spring的ContextLoaderListener-->
<context-param>
	<param-name>contextConfigLocation</param-name>		<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<!--配置SpringMVC前端控制器-->
<servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--指定springMVC的applicationContext全限定名 -->
    <init-param>
        <param-name>contextClass</param-name>
        <param-value>com.itheima.config.MyAnnotationConfigWebApplicationContext</param-value>
    </init-param>
    <!--服务器启动就创建-->
    <load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

如何消除？

  • Servlet3.0环境中，web容器提供了javax.servlet.<span style="color:blue">ServletContainerInitializer接口，实现了该接口后，在对 应的类加载路径的META-INF/services 目录创建一个名为javax.servlet.ServletContainerInitializer的文件， 文件内容指定具体的ServletContainerInitializer实现类，那么，当web容器启动时就会运行这个初始化器做 一些组件内的初始化工作；
  • 基于这个特性，Spring就定义了一个SpringServletContainerInitializer实现了ServletContainerInitializer接口；
  • 而SpringServletContainerInitializer会查找实现了WebApplicationInitializer的类，Spring又提供了一个 WebApplicationInitializer的基础实现类AbstractAnnotationConfigDispatcherServletInitializer，当我们编写类继承AbstractAnnotationConfigDispatcherServletInitializer时，容器就会自动发现我们自己的类， 在该类中我们就可以配置Spring和SpringMVC的入口了。

按照下面的配置就可以完全省略web.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class MyAnnotationConfigDispatcherServletInitializer extends
AbstractAnnotationConfigDispatcherServletInitializer {
    //返回的带有@Configuration注解的类用来配置ContextLoaderListener
    protected Class<?>[] getRootConfigClasses() {
        System.out.println("加载核心配置类创建ContextLoaderListener");
        return new Class[]{ApplicationContextConfig.class};
    }
    //返回的带有@Configuration注解的类用来配置DispatcherServlet
    protected Class<?>[] getServletConfigClasses() {
        System.out.println("加载核心配置类创建DispatcherServlet");
        return new Class[]{SpringMVCConfig.class};
    }
    //将一个或多个路径映射到DispatcherServlet上
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

SpringMVC的组件原理剖析

1. 前端控制器初始化

2. 前端控制器执行主流程

SpringMVC的异常处理机制

1. SpringMVC异常的处理流程

异常分为编译时异常和运行时异常，编译时异常我们 try-cache 进行捕获，捕获后自行处理，而运行时异常是不 可预期的，就需要规范编码来避免，在SpringMVC 中，不管是编译异常还是运行时异常，都可以最终由 SpringMVC提供的异常处理器进行统一处理，这样就避免了随时随地捕获处理的繁琐性。

SpringMVC 处理异常的思路是，一路向上抛，都抛给前端控制器 DispatcherServlet ，DispatcherServlet 在调 用异常处理器ExceptionResolver进行处理，如下图：

image-20240414184715491

2. SpringMVC异常的处理方式

SpringMVC 提供了以下三种处理异常的方式：

2.1 简单异常处理器

使用SpringMVC 内置的异常处理器处理 SimpleMappingExceptionResolver；

使用SimpleMappingExceptionResolver处理一些简单异常，配置开启SimpleMappingExceptionResolver， 并指定异常捕获后的处理动作，当发生了异常后，会被 SimpleMappingExceptionResolver 处理，跳转到我们 配置的错误页面error.html给用户进行友好展示

1
2
3
4
5
<!--配置简单异常处理器-->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <!-- 异常捕获后动作：展示视图 -->
    <property name="defaultErrorView" value="/error.html"/>
</bean>

可以在配置SimpleMappingExceptionResolver时，指定一些参数，例如：异常的类型

1
2
3
4
5
6
7
8
9
10
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <property name="defaultErrorView" value="/error.html"/>
    <property name="exceptionMappings">
        <props>
 <!-- 配置异常类型对应的展示视图 -->
            <prop key="java.lang.RuntimeException">/error.html</prop>
            <prop key="java.io.FileNotFoundException">/io.html</prop>
        </props>
    </property>
</bean>

注解方式配置简单映射异常处理器

1
2
3
4
5
6
7
8
9
10
11
12
13
@Bean
public SimpleMappingExceptionResolver simpleMappingExceptionResolver(){
    //创建SimpleMappingExceptionResolver
    SimpleMappingExceptionResolver resolver = new SimpleMappingExceptionResolver();
    //设置默认错误展示视图
    resolver.setDefaultErrorView("/error.html");
    //定义Properties设置特殊异常对应的映射视图
    Properties properties = new Properties();
    properties.setProperty("java.lang.RuntimeException","/error.html");
    properties.setProperty("java.io.FileNotFoundException","/io.html");
    resolver.setExceptionMappings(properties);
    return resolver;
}

2.2 自定义异常处理器

实现HandlerExceptionResolver接口自定义异常处理器，可以完成异常逻辑的处理。

1
2
3
4
5
6
7
8
9
10
public class MyHandlerExceptionResolver implements HandlerExceptionResolver {
    @Override
    //参数Object是当前目标方法处理器对象HandlerMethod
    public ModelAndView resolveException(HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse, Object o, Exception e) {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("/error.html");
        return modelAndView;
    }
}

交给Spring管理异常处理器

1
<bean class="com.itheima.exception.MyHandlerExceptionResolver"></bean>

返回Json格式字符串信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Component
public class MyHandlerExceptionResolver implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse, Object o, Exception e) {
        //编写要返回的json格式的字符串
        String jsonStr = "{\"code\":0,\"message\":\"error\",\"data\":\"\"}";
        try {
            httpServletResponse.getWriter().write(jsonStr);
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        return null;
    }
}

2.3 注解方式

使用注解 @ControllerAdvice + @ExceptionHandler 配置异常。

@ControllerAdvice 注解本质是一个 @Component，也会被扫描到，与此同时，具备AOP功能，默认情况下对所有的Controller都进行拦截操作， 拦截后干什么呢？就需要在结合@ExceptionHandler、@InitBinder、@ModelAttribute 注解一起使用了，此处我们讲解的是异常，所以是@ControllerAdvice + @ExceptionHandler的组合形式。

编写全局异常处理器类，使用@ControllerAdvice标注，且@ExceptionHandler指定异常类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(RuntimeException.class)
    public ModelAndView runtimeHandleException(RuntimeException e){
        System.out.println("全局异常处理器执行...."+e);
        ModelAndView modelAndView = new ModelAndView("/error.html");
        return modelAndView;
    }
    @ExceptionHandler(IOException.class)
    @ResponseBody
    public ResultInfo ioHandleException(IOException e){
        //模拟一个ResultInfo
        ResultInfo resultInfo = new ResultInfo(0,"IOException",null);
        return resultInfo;
    }
}

如果全局异常处理器响应的数据都是Json格式的字符串的话，可以使用@RestControllerAdvice替代 @ControllerAdvice 和 @ResponseBody

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(RuntimeException.class)
    public ResultInfo runtimeHandleException(RuntimeException e){
        //模拟一个ResultInfo
        ResultInfo resultInfo = new ResultInfo(0,"RuntimeException",null);
        return resultInfo;
    }
    @ExceptionHandler(IOException.class)
    public ResultInfo ioHandleException(IOException e){
        //模拟一个ResultInfo
        ResultInfo resultInfo = new ResultInfo(0,"IOException",null);
        return resultInfo;
    }
}

3. 异常处理机制原理剖析

4. SpringMVC常用的异常解析器

SpringMVC 相关的处理器异常解析器继承体系如下：

image-20240414190234383

image-20240414190247281