SpringMVC 吐血总结「5W字」长文-优快云博客

本文链接：https://blog.youkuaiyun.com/baihuaeryue/article/details/131492544

文章详细介绍了SpringMVC框架中的请求处理机制，包括控制器的注解使用如`@RequestMapping`，模型数据的绑定，视图解析，以及数据格式化如JSON和文件上传。此外，还讨论了SpringMVC的验证机制、自定义拦截器的实现以及异常处理策略，包括局部和全局异常处理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

SpringMVC-基本介绍

SpringMVC 从易用性，效率上比曾经流行的 Struts2 更好
SpringMVC 是 WEB 层框架【老韩解读: SpringMVC 接管了Web 层组件, 比如控制器, 视图, 视图解析, 返回给用户的数据格式, 同时支持 MVC 的开发模式/开发架构】

Web 层组件

MVC 开发模式

SpringMVC 通过注解，让 POJO 成为控制器，不需要继承类或者实现接口
. SpringMVC 采用低耦合的组件设计方式，具有更好扩展和灵活性.
. 支持 REST 格式的 URL 请求
SpringMVC 是基于 Spring 的, 也就是 SpringMVC 是在 Spring 基础上的。SpringMVC的核心包 spring-webmvc-xx.jar 和 spring-web-xx.jar

梳理 Spring SpringMVC SpringBoot 的关系

Spring MVC 只是 Spring 处理 WEB 层请求的一个模块/组件, Spring MVC 的基石是Servlet【Java WEB]】
Spring Boot 是为了简化开发者的使用, 推出的封神框架(约定优于配置，简化了Spring的配置流程), SpringBoot 包含很多组件/框架，Spring就是最核心的内容之一，也包含SpringMVC
他们的关系大概是: Spring Boot > Spring > Spring MVC

快速入门

SpringMVC 登录流程分析

目录结构

后面 applicationContext-mvc.xml 放到和 web.xml 一直的路径下, 在 web.xml 就不需要指定对应的属性

UserServlet.java

@Controller  
public class UserServlet {  

    /**  
    * 老韩解读  
    * 1. login() 方法用于响应用户的登录请求  
    * 2. @RequestMapping(value = "/login") 类似于原生的Servlet 配置的url-pattern  
    * 3. 当用户在浏览器输入 http://localhost:8888/web工程目录/login, 就会访问到该方法  
    * @return 表示结果返回给视图解析器, 视图解析器会根据配置 ,来决定找到那个页面  
    *  
    * <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
    * <property name="prefix" value="/WEB-INF/pages"/>  
    * <property name="suffix" value=".jsp" />  
    * </bean>  
    *  
    * 最终会去找  
    * /WEB-INF/pages/login_ok.jsp  
    */  
    @RequestMapping(value = "/login")  
    public String login() {  
        System.out.println("login ok ~");  
        return "login_ok";  
    }  

}

applicationContext-mvc.xml

<?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"  
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">  

    <!-- 配置扫描的包-->  
    <context:component-scan base-package="com.hspedu.web" />  

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
    <!-- 这个目录第一个/表示的是 web 目录-->  
    <property name="prefix" value="/WEB-INF/pages/"/>  
    <property name="suffix" value=".jsp" />  
    </bean>  
</beans>

login_ok.jsp

<%--
  Created by IntelliJ IDEA.
  User: leikooo
  Date: 2023/6/6
  Time: 6:31
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录成功</title>
</head>
<body>
<h1>恭喜 登录成功!</h1>
</body>
</html>

login.jsp

<%--
  Created by IntelliJ IDEA.
  User: leikooo
  Date: 2023/6/6
  Time: 6:18
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录</title>
</head>
<body>

<%--这样写表示地是 http://ip:port/web工程路径/login--%>
<form action="login">
    u: <input type="text" name="username"> <br>
    p: <input type="password" name="password"> <br>
    <input type="submit" value="登录">
</form>

</body>
</html>

web.xml

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

<!--    配置前端控制器/中央控制器/分发控制器
        1. 用户的请求都会经过他的处理

-->
    <servlet>
        <servlet-name>springDispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--        配置属性 contextConfigLocation 指定去操作的Spring配置文件-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext-mvc.xml</param-value>
        </init-param>
<!--        在web项目启动时, 就需要自动加载DispatcherServlet-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springDispatcherServlet</servlet-name>
<!--
        1. 这里的配置的url-pattern / 表示用户所有的请求都会经过DispatcherServlet
        2. 这样配置也支持 rest 风格的url请求
-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

当然最后还需要配置Tomcat才能看到效果

细节

重点学习如何搭建一个 springmvc 项目，初步理解 springmvc 工作流程
这里的 UserServlet 需要注解成@Controller ，我们称为一个Handler 处理器

UserServlet 指定 url 时，还可以省略 value 属性

 @RequestMapping("/login")  
 public String login() {  
     System.out.println("login ok ~");  
     return "login_ok";  
 }

关于 SpringMVC 的 DispatcherServlet 的配置文件，如果不在web.xml 指定applicationContext-mvc.xml, 默认在/WEB-INF/springDispatcherServlet-servlet.xml 找这个配置文件【简单看下 DispatcherServlet 的源码】。(推荐使用, 我们做下修改，并完成测试)

/**
- Suffix for WebApplicationContext namespaces. If a servlet of this class is
- given the name “test” in a context, the namespace used by the servlet will
- resolve to “test-servlet”.
  */
  public static final String DEFAULT_NAMESPACE_SUFFIX = “-servlet”;

SpingMVC 执行流程

一图胜千言

@RequestMapping

基本使用 : @RequestMapping 注解可以指定控制器/处理器的某个方法的请求的url, 基本用法前面我们讲过了, RequestMapping : 请求映射

    @RequestMapping("/login")  
    public String login() {  
        System.out.println("login ok ~");  
        return "login_ok";  
    }

@RequestMapping 可以修饰方法和类

说明: @RequestMapping 注解可以修饰方法，还可以修饰类当同时修饰类和方法时，请求的 url 就是组合 /类请求值/方法请求值 .

UserHandler.java

@RequestMapping("/user")  
@Controller // 就是一个处理器/控制器  
public class UserHandler {  

    /**  
    * 老韩解读  
    * 1. method=RequestMethod.POST: 表示请求 buy 目标方法必须是post  
    * 2. RequestMethod 四个选项 POST, GET, PUT, DELETE  
    * 3. SpringMVC 控制器默认支持 GET 和 POST 两种方式  
    * 4. buy() 方法请求的url http://localhost:8080/工程路径/user/buy  
    */  
    @RequestMapping(value = "/buy", method = RequestMethod.POST)  
    public String buy() {  
    System.out.println("购买商品");  
    return "success";  
    }  

}

request.jsp

注意这里的 form 的 action=“user/buy”

<%--
  Created by IntelliJ IDEA.
  User: leikooo
  Date: 2023/6/6
  Time: 14:43
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>购买商品</h1>
<%--不需要加 / --%>
<form action="user/buy" method="post">
    购买人:<input type="text" name="username"><br>
    够买量:<input type="text" name="nums"><br>
    <input type="submit" value="购买">
</form>
</body>
</html>

@RequestMapping 可以指定请求方式

说明: @RequestMapping 还可以指定请求的方式(post/get/put/delete…), 请求的方式需要和指定的一样，否则报错
SpringMVC 控制器默认支持GET和POST两种方式, 也就是你不指定method , 可以接收GET 和 POST 请求
当明确指定了 method , 则需要按指定方式请求, 否则会报错,比如 405`

@RequestMapping 可指定 params 和 headers 支持简单表达式

param1: 表示请求必须包含名为 param1 的请求参数
!param1: 表示请求不能包含名为 param1 的请求参数
param1 != value1: 表示请求包中param1值不能为value1, 可以没有param1参数
{“param1=value1”, “param2”}: 请求必须包含名为 param1 和param2 的两个请求参数，且 param1 参数的值必须为 value1

案例 :

/**  
* 1. params = "bookId" 表示请求目标参数的时候必须要给一个boolId 但是值没有限定  
* 2. search (String bookId) : 表示请求方法时, 携带的 bookId=100, 就会将请求携带的bookId 的 100 赋值给函数形参bookId  
*/  
@RequestMapping(value = "/find", params = "bookId", method = RequestMethod.GET)  
public String search(String bookId) {  
    System.out.println("查询书籍 bookId= " + bookId);  
    return "success";  
}

request.jsp

<hr><h1>演示 params 的使用</h1>  
<a href="user/find?bookId=100">查询书籍</a>

如果下面是参数传的是 bookIdXX 那么会报错, 传入的参数需要是 bookId



params = “bookId=100” 表示方法请求时携带的 bookId 必须是 100

@RequestMapping(value = "/find", params = "bookId=100", method = RequestMethod.GET)  
public String search(String bookId) {  
    System.out.println("查询书籍 bookId= " + bookId);  
    return "success";  
}

如果不是, 那么报错



@RequestMapping(value = "/find", params = "bookId!=100", method = RequestMethod.GET

如果bookId传入的是100, 那么直接报错!

@RequestMapping(value = "/search", params = {"bookId=100", "bookName!=张三知法犯法"})

这里有一个很坑的点 不传入bookName 也不会报错!!!

没有参数 bookName 也行，有 bookName 没有值也行，bookName 不能为 “张三知法犯法”

@RequestMapping 支持 Ant 风格资源地址

1. ?：匹配文件名中的一个字符
2. *：匹配文件名中的任意字符 
3. **:匹配多层路径 
4. Ant 风格的 url 地址举例
/user/*/createUser: 匹配 /user/aaa/createUser、/user/bbb/createUser 等URL 
/user/**/createUser: 匹配 /user/createUser、/user/aaa/bbb/createUser 等URL 
/user/createUser??: 匹配 /user/createUseraa、/user/createUserbb 等URL

/** * * 要求可以配置 /user/message/aa, /user/message/aa/bb/cc */ 
@RequestMapping ("/user/mesage/**")
public String im() { 
    System.out.println("发送消息"); 
    return "success"; 
}

@RequestMapping 可配合 @PathVariable 映射 URL 绑定的占位符

@RequestMapping 还可以配合 @PathVariable 映射 URL 绑定的占位符。
这样就不需要在 url 地址上带参数名了，更加的简洁明了

/**
- 我们希望目标方法获取到 username 和 userid, value=“/xx/{username}
  */
  @RequestMapping(”/reg/{username}/{userid}")
  public String register(@PathVariable(“username”) String name, @PathVariable(“userid”) String id) {
  System.out.println(“接收到参数–” + "username= " + name + “–” + "usreid= " + id);
  return “success”;
  }

细节

@RequestMapping(“/reg/{username}/{userid}”) 这里的username和userid可以自定义
register(@PathVariable(“username”) String name, @PathVariable(“userid”) String id) 这里的@PathVariable注解的value属性必须和上面的@RequestMapping的value值得 { } 中的内容一致

注意事项和使用细节

映射的 URL, 不能重复

@RequestMapping(value = “/hi”)
public String hi() {
System.out.println(“hi”);
return “success”;
}

@RequestMapping(value = “/hi”)
public String hi2() {
System.out.println(“hi”);
return “success”;
}

重复会报错

各种请求的简写形式

@RequestMapping(value = “/buy”,method = RequestMethod.POST) 等价@PostMapping(value = “/buy”)

简写方式一览: @GetMapping @PostMapping @PutMapping @DeleteMapping

如果我们确定表单或者超链接会提交某个字段数据比如(email), 要求提交的参数名和目标方法的参数名保持一致

@GetMapping(value = “/hello3”)
public String hello3(String email) {
System.out.println("hello3 " + email);
return “success”;
}

输入 localhost:9998/user/hello3?email=tom@sohu.com, 一定要注入提交参数名和后台方法的形参名保持一致, 否则后端接收不到参数

Rest-优雅的 url 请求风格

REST：即 Representational State Transfer。(资源)表现层状态转化。是目前流行的请求方式。它结构清晰, 很多网站采用
HTTP 协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。它们分别对应四种基本操作：GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE用来删除资源。
说明：传统的 url 是通过参数来说明 crud 的类型，rest 是通过get/post/put/delete来说明 crud 的类型

REST 的核心过滤器

当前的浏览器只支持 post/get 请求，因此为了得到 put/delete 的请求方式需要使用Spring提供的 HiddenHttpMethodFilter 过滤器进行转换.
HiddenHttpMethodFilter：浏览器 form 表单只支持 GET 与POST 请求，而DELETE、PUT等 method 并不支持，Spring 添加了一个过滤器，可以将这些请求转换为标准的http方法，使得支持 GET、POST、PUT 与 DELETE 请求
HiddenHttpMethodFilter 能对 post 请求方式进行转换，因此我们需要特别的注意这一点
这个过滤器需要在 web.xml 中配置

Rest 风格的 url-完成增删改查

rest.jsp 文件

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script type="text/javascript" src="scrip/jquery-3.6.0.min.js"></script>
    <script type="text/javascript">
        $(function () {
            $("#deleteBook").click(function () {
                alert("ok");
                var href = this.href;
                $("#hiddenForm").attr("action", href);
                $(":hidden").val("DELETE");
                $("#hiddenForm").submit();//这里就是提交删除请求了
                return false; //这里必须返回 false,否则会提交两次
            });
        })
    </script>
</head>
<body>
<h3>Rest 风格的 crud 操作案例</h3>
<br>
<hr>
<h3>rest 风格的 url 查询书籍[get]</h3>
<a href="user/book/100">点击查询书籍</a>
<br>
<hr>
<h3>rest 风格的 url 添加书籍[post]</h3>
<form action="user/book" method="post">
    name:<input name="bookName" type="text"> <br>
    <input type="submit" value="添加书籍">
</form>
<br>
<hr>
<h3>rest 风格的 url, 删除一本书</h3>
<!--
    1. 这里我们需要将删除方式（get）转成 delete 的方式，需要使用过滤器和jquery来完成
    2. name="_method" 名字需要写成 _method 因为后台的 HiddenHttpMethodFilter 就是按这个名字来获取 hidden 域的值，从而进行请求转换的.
 -->
<a href="user/book/100" id="deleteBook">删除指定 id 的书</a>
<form action="" method="POST" id="hiddenForm">
    <input type="hidden" name="_method"/>
</form>
<br>
<hr>
<h3>rest 风格的 url 修改书籍[put]~</h3>
<form action="user/book/100" method="post">
    <input type="hidden" name="_method" value="PUT">
    <input type="submit" value="修改书籍~">
</form>
</body>
</html>

Spring配置文件

<?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:mvc="http://www.springframework.org/schema/mvc"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">  

    <!-- 配置扫描的包-->  
    <context:component-scan base-package="com.hspedu.web" />  

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
    <!-- 这个目录第一个/表示的是 web 目录-->  
    <property name="prefix" value="/WEB-INF/pages/"/>  
    <property name="suffix" value=".jsp" />  
    </bean>  

    <!-- 加入两个常规配置-->  
    <!-- 能支持 SpringMVC 高级功能，比如 JSR303 校验，映射动态请求-->  
    <mvc:annotation-driven> </mvc:annotation-driven>  
    <!-- 将 SpringMVC 不能处理的请求交给 Tomcat, 比如请求 css,js 等-->  
    <mvc:default-servlet-handler />  
</beans>

web.xml

<?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">
    <!--
        配置 hiddenHttpMethodFilter
        1. 可以将以 post 方式提交的 delete 和 put 请求进行转换
        2. 配置url-pattern 是 /* 表示所有请求都经过 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>


<!--    配置前端控制器/中央控制器/分发控制器
        1. 用户的请求都会经过他的处理

-->
    <servlet>
        <servlet-name>springDispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--        配置属性 contextConfigLocation 指定去操作的Spring配置文件-->
<!--        <init-param>-->
<!--            <param-name>contextConfigLocation</param-name>-->
<!--            <param-value>classpath:springDispatcherServlet-servlet.xml</param-value>-->
<!--        </init-param>-->
<!--        在web项目启动时, 就需要自动加载DispatcherServlet-->
<!--        <load-on-startup>1</load-on-startup>-->
    </servlet>
    <servlet-mapping>
        <servlet-name>springDispatcherServlet</servlet-name>
<!--
        1. 这里的配置的url-pattern / 表示用户所有的请求都会经过DispatcherServlet
        2. 这样配置也支持 rest 风格的url请求
-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

BeanHandler.java 文件

@Controller  
@RequestMapping("/user")  
public class BeanHandler {  

    @RequestMapping(value = "/book/{id}", method = RequestMethod.GET)  
        public String getBook(@PathVariable("id") String id) {  
        System.out.println("查询的数据id = " + id);  
        return "success";  
    }  

    @PostMapping("/book")  
    public String addBook(String bookName) {  
        System.out.println("添加的book的名字是 : " + bookName);  
        return "success";  
    }  

    @RequestMapping(value = "/book/{id}", method = RequestMethod.DELETE)  
    public String deleteBook(@PathVariable("id") String id) {  
        System.out.println("要删除的book的id = " + id);  
        // return "success"; // JSPs only permit GET POST or HEAD  
        // 使用重定向方式返回  
        // 这里要注意会被解析为 /工程路径/user/success  
        return "redirect:/user/success";  
    }  

    /**  
    * 如果请求的是 /user/success , 转发到success.jsp  
    * successGeneral 对应的url是 http://localhost:8080/工程路径/user/success  
    * @return  
    */  
    @RequestMapping(value = "/success")  
        public String successGeneral() {  
        return "success";  
    }  

    @PutMapping("/book/{id}")  
    public String updateBook(@PathVariable("id") String id) {  
        System.out.println("需要update的 id = " + id);  
        return "redirect:/user/success";  
    }  
}

SpringMVC 映射请求数据

获取参数值

开发中，如何获取到 http://xxx/url?参数名=参数值&参数名=参数值
这个使用的非常广泛，我们看一个案例

如果提交的参数名和后台不一致, 那么可以使用 @RequestParam注解

@RequestParam(value = “name”, required = false)
value=“name” 表示提交的参数名

required = false 表示参数可以没有, 默认是true, 表示必须要有

@Controller
@RequestMapping(“/vote”)
public class VoteHandler {

 /**  
 * 1. 获取超链接的数据 https://ip:port/工程路径/vote/vote01?user=xxx 后台接收不到信息  
 * 2. @RequestParam(value = "name", required = false)  
 * 3. @RequestParam 表示提交的参数 value="name" 表示提交的参数  
 * 4. required = false 表示参数可以没有, 默认是true, 表示必须要有  
 * 5. 当我们使用这个参数之后, 请求的参数名和方法的形参就可以不一致  
 * @param username  
 * @return  
 */  
 @RequestMapping(value = "/vote01")  
 public String test01(@RequestParam(value = "name", required = false) String username) {  
     System.out.println("得到的username = " + username);  
     return "success";  
 }

}

获取 http 请求消息头

使用较少

@RequestHeader 使用这个注解, value需要填写 请求头的信息

    // 表示绑定请求头中Accept-Encoding 对应的值到方法的参数 ae 上
    @RequestMapping("/vote02")
    public String test02(@RequestHeader(value = "Accept-Encoding") String ae, @RequestHeader("Host") String host) {
        System.out.println("ae = " + ae + "; host = " + host);
        return "success";
    }

获取 JavaBean 形式的数据

开发中，如何获取到 JavaBen 的数据，就是以前的 entity/pojo 对象数据

方法的形参用对应的类型就会 自动封装
如果自动完成封装, 要求提交的数据, 参数名和对象的字段名保持一致
如果属性是对象, 这里就任然是通过字段名.字段比如Master中的 Pet 属性, 提交的参数名是 pet.id pet.name 【支持级联属性】
如果提交的参数和字段不匹配, 那么对象的属性值就是null

/**
- 1. 方法的形参用对应的类型就会自动封装
- 1. 如果自动完成封装, 要求提交的数据, 参数名和对象的字段名保持一致
- 1. 如果属性是对象, 这里就任然是通过字段名.字段
- 比如Master中的 Pet 属性, 提交的参数名是 pet.id pet.name
- 1. 如果提交的参数和字段不匹配, 那么对象的属性值就是null
    */
    @RequestMapping(“/vote03”)
    public String test03(Master master) {
    System.out.println("master = " + master);
    return “success”;
    }

前端页面

<form action="vote/vote03" method="post">  
    主人号:<input type="text" name="id"><br>  
    主人名:<input type="text" name="name"><br>  
    宠物号:<input type="text" name="pet.id"><br>  
    宠物名:<input type="text" name="pet.name"><br>  
    <input type="submit" value="添加主人和宠物">  
</form>

获取 Servlet API

开发中, 我们可能需要使用到原生的 servlet api ，看看如何获取
使用 servlet api , 需要引入 tomcat/lib 下的 servlet-api.jar

前端文件

<h1>获取 servlet api </h1>  
<form action="vote/vote04" method="post">  
    用户名:<input type="text" name="username"><br>  
    密 码:<input type="password" name="password"><br>  
    <input type="submit" value="添加用户">  
</form>

后端

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

注意事项

除了 HttpServletRequest, HttpServletResponse 还可以其它对象也可以这样的形式获取
HttpSession、java.security.Principal,InputStream,OutputStream,Reader,Writer
其中一些对象也可以通过 HttpServletRequest / HttpServletResponse 对象获取，比如Session 对象 ,既可以通过参数传入，也以通过 request.getSession() 获取，效果一样【对象是同一个】，推荐使用参数形式传入，更加简单明了

验证是否是同一个对象

    @RequestMapping("/vote04")
    public String test04(HttpServletRequest request, HttpServletResponse response, HttpSession hs) {
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        System.out.println("password = " + password + " username = " + username);

        HttpSession session = request.getSession();
        System.out.println(session == hs); // true

        return "success";
    }

模型数据

提交的数据 -> 封装到成 Java 对象 -> SpringMVC 会自动将其放入到 request 域中

但是也有自己修改一些

方式 1: 通过 HttpServletRequest 放入 request 域

    /**
     * 1. 演示将提交的数据 -> 封装到成 Java 对象 -> SpringMVC 会自动将其放入到 request 域中
     * 2. 这样我们就可以在跳转的页面取出数据, 属性名是 类型首字母小写
     */
    @RequestMapping("/vote05")
    public String test05(Master master100, HttpServletRequest request, HttpServletResponse response) {
        /*
         1. SpringMVC会自动把获取的model模型, 放入到 request 域中, 名字就是master
         2. 也可以手动实现
         */
        // 手动放入属性
        request.setAttribute("address", "beijing");
        // 由于是传入的是地址值, 所以这里修改之后 request域中的数据也会修改
        // 如果我们希望修改master属性
        master100.setName("nono");
        // 分析一下SpringMVC中默认存放的的对象到 request 域中
        // 属性名是 类型首字母小写
        return "vote_ok";
    }

vote_ok.jsp 显示数据

<%@ page contentType="text/html;charset=UTF-8" language="java" %>  
<html>  
<head>  
    <title>获取的数据显示页面</title>  
</head>  
<body>  
<h1>获取的数据显页面</h1>  
<hr>  
取出数据 <br>   
    主人名字: ${requestScope.master.name} <br>  
    主人id : ${requestScope.master.id} <br>  
    宠物的号: ${requestScope.master.pet.id} <br>  
    宠物名 : ${requestScope.master.pet.name}  
</body>  
</html>

model_vote.jsp 提交数据

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

<h1>添加主人信息</h1>
<!-- 老韩解读
1. 这里的字段名称和对象的属性名保持一致,级联添加属性也是一样保持名字对应关系
2. 如果只是添加主人信息，则去掉宠物号和宠物名输入框即可 ,pet 为null-->
<form action="vote/vote05" method="post">
  主人号:<input type="text" name="id"><br>
  主人名:<input type="text" name="name"><br>
  宠物号:<input type="text" name="pet.id"><br>
  宠物名:<input type="text" name="pet.name"><br>
  <input type="submit" value="添加主人和宠物">
</form>

</body>
</html>

方式 2: 通过请求的方式 3: 通过返回 ModelAndView 对象实现 request 域数据方法参数 Map 放入 request 域

    @RequestMapping("/vote06")
    public String test06(Map<String, Object> map, Master master) {
        // 老师需求 通过Map对象, 添加属性到 request 中
        // 原理分析: SpringMVC 会遍历 map 中的 k-v 放到 request 中
        map.put("address", "shanghai~");
//         如果我们把 master 设置为 null  -->  结果前端拿不到数据
        map.put("master", null);
        return "vote_ok";
    }

方式 3: 通过返回 ModelAndView 对象实现 request 域数据

    @RequestMapping("/vote07")
    public ModelAndView test07(Master master) {
        ModelAndView modelAndView = new ModelAndView();
        // 将属性放入到 ModelAndView
        modelAndView.addObject("address", "shanghai~");
        // 这样会到导致 master 变成 null 
        //  modelAndView.addObject("master", null);
        // 也可以从数据库得到数据 -> 对象 -> 放入到视图 [Service-DAO-DB]
        // 这里指的调转视图的名称
        modelAndView.setViewName("vote_ok");
        // 返回结果
        return modelAndView;
    }

注意事项

从本质看，请求响应的方法 return “xx”, 是返回了一个字符串，其实本质是返回了一个ModelAndView 对象，只是默认被封装起来的.
ModelAndView 即可以包含 model 数据，也可以包含视图信息
ModelAndView 对象的 addObject 方法可以添加 key-val 数据，默认在request 域中
ModelAndView 对象 setView 方法可以指定视图名称
如果你返回一个自定义的 ModelAndView 对象，其中包含了自定义的视图对象，Spring MVC 会直接使用该对象进行视图渲染，而不会再触发视图解析器

模型数据处理-数据放入 session

开发中, 控制器/处理器中获取的数据如何放入 session 域，然后在前端(VUE/JSP/…)取出显示

/**  
* 将 model(master 对象) 放入到 session 域中  
*/  
@RequestMapping("/vote08")  
public String test09(Map<String, Object> map, Master master, HttpSession session) {  
    // master 对象默放置到 request 域  
    // 我们将 master 对象放入倒 session 域  
    session.setAttribute("master", master);  
    session.setAttribute("address", "guangzhou");  
    return "vote_ok";  
}

前端文件

<hr>  
取出 session 域的数据 <br>  
address : ${sessionScope.address} <br>  
主人名字= ${sessionScope.master.name}  
主人信息= ${sessionScope.master}

@ModelAttribute 实现 prepare 方法

开发中，有时需要使用某个前置方法(比如 prepareXxx(), 方法名由程序员定)给目标方法准备一个模型对象【类似AOP前置通知】

@ModelAttribute 注解可以实现这样的需求
在某个方法上，增加了@ModelAttribute 注解后
那么在调用该 Handler 的任何一个方法时，都会先调用这个方法

/**
- 老韩解读
- 1. 当在某个方法上，增加了@ModelAttribute 注解
- 1. 那么在调用该 Handler 的任何一个方法时，都会先调用这个方法
- 1. 类似于我们 Spring 讲解的 AOP 机制
- 1. prepareModel 前置方法, 会切入到其他方法前执行
    */
    @ModelAttribute
    public void prepareModel() {
    System.out.println(“prepareModel() ------完成前置通知----”);
    }

实际使用

在修改前，在前置方法中从数据库查出这个用户
在修改方法(目标方法)中，可以使用前置方法从数据库查询的用户
如果表单中对用户的某个属性修改了，则以新的数据为准，如果没有修改，则以数据库的信息为准，比如，用户的某个属性不能修改，就保持原来的值

视图和视图解析器

. 在 springMVC 中的目标方法最终返回都是一个视图（有各种视图）
返回的视图都会由一个视图解析器来处理成为具体的视图对象（视图解析器有很多种）

自定义视图

在默认情况下，我们都是返回默认的视图, 然后这个返回的视图交由 SpringMVC 的InternalResourceViewResolver 视图处理器来处理的

 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
     <!--  这个目录第一个/表示的是 web 目录-->
     <property name="prefix" value="/WEB-INF/pages/"/>
     <property name="suffix" value=".jsp" />
 </bean>

在实际开发中，我们有时需要自定义视图,这样可以满足更多更复杂的需求.

MyView.jsp 这个就是自定义视图 , 需要继承 AbstractView

/**  
* ClassName: MyView  
* Package: com.hspedu.web.viewresolver  
*  
* @Author: leikooo  
* @Creat: 2023/6/10 - 7:31  
* @Description:  
* 1. MyView 继承了 AbstractView 就可以当做视图使用了  
* 2. @Component("hspView") 该视图注入到容器中, 名字/id 是 hspView  
*/  
@Component("hspView")  
public class MyView extends AbstractView {  

    @Override  
    protected void renderMergedOutputModel(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {  
        // 完成视图渲染  
        // 并且决定调转的页面「请求转发」 /WEB-INF/pages/my_view.jsp  
        System.out.println("进入到自己的视图~~");  
        // 请求转发  
        // /WEB-INF/pages/my_view.jsp 最终会被解析为 /工程路径/WEB-INF/pages/my_view.jsp  
        request.getRequestDispatcher("/WEB-INF/pages/my_view.jsp").forward(request, response);  
    }  
}

Spring配置文件

<?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:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--    配置扫描的包-->
    <context:component-scan base-package="com.hspedu.web"/>

<!--    这个是默认视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--  这个目录第一个/表示的是 web 目录-->
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

<!--    自定义视图解析器
        1. 配置自定义的视图解析器 BeanNameViewResolver
        2. BeanNameViewResolver 可以去解析我们自定义的视图
        3. order 属性表示视图解析器执行的顺序, 值越小优先级越高
        4. 属性 order 默认优先级是 Integer.MAX_VALUE
-->
    <bean class="org.springframework.web.servlet.view.BeanNameViewResolver">
        <property name="order" value="99" />
    </bean>


    <!-- 加入两个常规配置-->
    <!-- 能支持 SpringMVC 高级功能，比如 JSR303 校验，映射动态请求-->
    <mvc:annotation-driven> </mvc:annotation-driven>
    <!-- 将 SpringMVC 不能处理的请求交给 Tomcat, 比如请求 css,js 等-->
    <mvc:default-servlet-handler/>

</beans>

Handler

/**  
* ClassName: GoodsHandler  
* Package: com.hspedu.web.viewresolver  
*  
* @Author: leikooo  
* @Creat: 2023/6/10 - 7:30  
* @Description:  
*/  
@Controller  // 注入到容器之中
@RequestMapping("/goods")  
public class GoodsHandler {  

    @RequestMapping("/buy")  
    public String buy() {  
        System.out.println("----buy----");  
        // 待会填写自定义是视图的名称  
        return "hspView";  
    }  

}

自定义视图工作流程小结

自定义视图-小结

自定义视图: 创建一个 View 的 bean, 该 bean 需要继承自AbstractView, 并实现renderMergedOutputModel 方法.
并把自定义 View 加入到 IOC 容器中
自定义视图的视图处理器，使用 BeanNameViewResolver，这个视图处理器也需要配置到 ioc 容器
BeanNameViewResolver 的调用优先级需要设置一下，设置order 比Integer.MAX_VAL小的值. 以确保其在 InternalResourceViewResolver 之前被调用

自定义视图-工作流程

SpringMVC 调用目标方法, 返回自定义 View 在 IOC 容器中的 id
SpringMVC 调用 BeanNameViewResolver 解析视图: 从 IOC 容器中获取返回id值对应的 bean, 即自定义的 View 的对象
SpringMVC 调用自定义视图的 renderMergedOutputModel 方法渲染视图
老韩说明: 如果在 SpringMVC 调用目标方法, 返回自定义View 在IOC 容器中的id, 不存在，则仍然按照 默认的视图处理器机制处理

目标方法直接指定转发或重定向

默认返回的方式是请求转发，然后用视图处理器进行处理，比如在目标方法中这样写

@RequestMapping(“/buy”)
public String buy() {
System.out.println(“----buy----”);
return “hspView”;
}
也可以在目标方法直接指定重定向或转发的 url 地址
如果指定重定向，不能定向到 /WEB-INF 目录中

请求转发

forward:/WEB-INF/pages/vote_ok.jsp 会被解析为 /工程路径/WEB-INF/pages/vote_ok.jsp

@RequestMapping("/order")  
public String order() {  
    System.out.println("请求转发 ~ ");  
    // forward:/WEB-INF/pages/vote_ok.jsp 会被解析为 /工程路径/WEB-INF/pages/vote_ok.jsp  
    return "forward:/WEB-INF/pages/vote_ok.jsp";  
}

重定向

@RequestMapping("/order")  
public String order() {  
    System.out.println("重定向 ~ ");  
    // 不能重定向到 /WEB-INF/ 目录下  
    // return "redirect:/WEB-INF/pages/vote_ok.jsp";  
    return "redirect:/login.jsp";  
}

数据格式化

基本数据类型和字符串自动转换

说明: 在我们提交数据(比如表单时)SpringMVC 怎样对提交的数据进行转换和处理的

基本数据类型可以和字符串之间自动完成转换

比如: Spring MVC 上下文中内建了很多转换器，可完成大多数 Java 类型的转换工作。【相互转换，这里只列出部分】

字符串转换为整数：

@RequestMapping(“/example”)
public String exampleMethod(@RequestParam(“num”) int number) {
// 使用转换后的整数
return “success”;
}
字符串转换为日期：

@RequestMapping(“/example”)
public String exampleMethod(@RequestParam(“date”) @DateTimeFormat(pattern = “yyyy-MM-dd”) Date date) {
// 使用转换后的日期
return “success”;
}
字符串转换为枚举类型： 大小写需要一致

public enum Status {
ACTIVE, INACTIVE
}

@RequestMapping(“/example”)
public String exampleMethod(@RequestParam(“status”) Status status) {
// 使用转换后的枚举类型
return “success”;
}
字符串数组转换为列表

@RequestMapping(“/example”)
public String exampleMethod(@RequestParam(“ids”) List ids) {
// 使用转换后的列表
return “success”;
}

特殊数据类型和字符串间的转换

特殊数据类型和字符串之间的转换使用注解(比如日期，规定格式的小数比如货币形式等)
对于日期和货币可以使用 @DateTimeFormat 和 @NumberFormat 注解. 把这两个注解标记在字段上即可.

目录结构 ├─src │ └─com │ └─hspedu │ └─web │ ├─datavalid │ └─web ├─scrip └─WEB-INF ├─lib └─pages └─datavalid

Monster.java 在 datavalid 目录下面

package com.hspedu.web.datavalid;

import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.format.annotation.NumberFormat;

import java.util.Date;


/**
 * @author leikooo
 * @create 2023-06-22 19:32
 * @Package com.hspedu.web.datavalid
 * @Description
 */
public class Monster {
    private Integer id;
    private String email;
    private Integer age;
    private String name;

    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date birthday;

    @NumberFormat(pattern = "###,###.##")
    private Float salary;

    public Monster() {
    }

    public Integer getId() {
        return id;
    }

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

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public Float getSalary() {
        return salary;
    }

    public void setSalary(Float salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Monster{" +
                "id=" + id +
                ", email='" + email + '\'' +
                ", age=" + age +
                ", name='" + name + '\'' +
                ", birthday=" + birthday +
                ", salary=" + salary +
                '}';
    }
}

monster_addUI.jsp 在 page 下面的 datavalid 下面

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h3>添加妖怪~~</h3>
<!-- 这里的表单，我们使用 springMVC 的标签来完成
特别说明几点:
1. SpringMVC 表单标签在显示之前必须在 request 中有一个bean, 该bean的属性和表单标签的字段要对应!
request 中的 key 为: form 标签的 modelAttribute 属性值，比如这里的monsters
2. SpringMVC 的 form:form 标签的 action 属性值中的/ 不代表WEB应用的根目录.
3. 这里使用 SpringMVC 的标签主要目的是 数据回显
-->
<form:form action="saveMonster" method="POST" modelAttribute="monsters">妖怪名字:
    <form:input path="name"/> <br><br>
    妖怪年龄~: <form:input path="age"/> <br><br>
    电子邮件: <form:input path="email"/> <br><br>
    妖怪生日: <form:input path="birthday"/> 要求以"9999-11-11"的形式<br><br>
    妖怪工资: <form:input path="salary"/> 要求以"123,890.12"的形式<br><br>
    <input type="submit" value="添加妖怪"/>
</form:form>
</body>
</html>

success.jsp 和上面的在同一目录下

<%@ page contentType="text/html;charset=UTF-8" language="java" %>  
<html>  
<head>  
<title>添加成功</title>  
</head>  
<body>  
<h1>恭喜你添加成功！</h1>  
</body>  
</html>

data_valid.jsp 在 web 目录下面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>  
<html>  
<head>  
<title>SpringMVC[数据格式/验证等]</title>  
</head>  
<body>  
<h1>SpringMVC[数据格式/验证等]</h1>  
<hr>  
<a href="<%=request.getContextPath()%>/addMonsterUI">添加妖怪</a>  
</body>  
</html>

MonsterHandler.java

package com.hspedu.web.datavalid;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.Map;

/**
 * @author leikooo
 * @create 2023-06-22 19:53
 * @Package com.hspedu.web.datavalid
 * @Description
 */
@Controller
@Scope("prototype") // 多例, 每次请求 MonsterHandle 就会生成新的实例
public class MonsterHandle {

    @RequestMapping("/addMonsterUI")
    public String addMonsterUi(Map<String, Object> map) {
        /**老韩解读:
         1. 这里的表单，我们使用 springMVC 的标签来完成2. SpringMVC 表单标签在显示之前必须在 request 中有一个bean, 该bean的属性和表单标签的字段要对应!
         request 中的 key 为: form 标签的 modelAttribute 属性值，比如这里的monsters
         3. SpringMVC 的 form:form 标签的 action 属性值中的/ 不代表WEB应用的根目录.
         4. <form:form action="monster" method="POST" modelAttribute="monster">
         这 里 需 要 给 request 增 加 一 个 monster ，因为jsp 页面的 modelAttribute="monster" 需要
         这时是 springMVC 的内部的检测机制 即使是一个空的也需要，否则报错
         */
        map.put("monsters", new Monster());
        // 这里我在 SpringMVC 配置文件配置了 suffix 和 prefix 才能找到 pages 目录下面的目标文件
        return "datavalid/monster_addUI";
    }

    /**
     * 1. SpringMVC 可以将提交的数据，按照参数名称和属性名匹配
     * 2. 直接封装到对象之中 --> 模型数据方面的知识
     * 编写方法，处理添加妖怪
     */
    @RequestMapping("/saveMonster")
    public String save(Monster monster) {
        System.out.println("monster = " + monster);
        return "datavalid/success";
    }

}

验证以及国际化

对输入的数据(比如表单数据)，进行必要的验证，并给出相应的提示信息。
对于验证表单数据，SpringMVC 提供了很多实用的注解, 这些注解由 JSR 303 验证框架提供.

JSR 303

JSR 303 是 Java 为 Bean 数据合法性校验提供的标准框架，它已经包含在 JavaEE 中
JSR 303 通过在 Bean 属性上标注类似于 @NotNull、@Max 等标准的注解指定校验规则，并通过标准的验证接口对 Bean 进行验证

Hibernate Validator 扩展注解

Hibernate Validator 和 Hibernate 没有关系，只是 JSR 303 实现的一个扩展.
Hibernate Validator 是 JSR 303 的一个参考实现，除支持所有标准的校验注解外，它还支持以下的扩展注解:
支持的注解

细节说明和注意事项

在需要验证的 Javabean/POJO 的字段上加上相应的验证注解.
目标方法上,在 JavaBean/POJO 类型的参数前, 添加 @Valid 注解. 告知 SpringMVC 该 bean 是需要验证的，要注意！
在 @Valid 注解之后, 添加一个 Errors 或 BindingResult 类型的参数, 可以获取到验证的错误信息
需要使用 <form:errors path=“email”></form:errors> 标签来显示错误消息, 这个标签，需要写在标签内生效.
错误消息的国际化文件 i18n.properties , 中文需要是 Unicode 编码

    √ 格式: 验证规则.表单 modelAttribute 值.属性名=消息信息
    √ NotEmpty.monster.name=\u540D\u5B57\u4E0D\u80FD\u4E3A\u7A7A 
    √ typeMismatch.monster.age=\u7C7B\u578B\u4E0D\u5339\u914D

注解@NotNull 和 @NotEmpty 的区别说明

@NotEmpty Asserts that the annotated string, collection, mapor array is not {@code null} or empty.
@NotNull The annotated element must not be {@codenull}. Accepts any type.

SpingMVC 验证时，会根据不同的验证错误, 返回对应的信息

具体案例

这里老韩的视频代码没有 @ModelAttribute(“monsters”) ，但是我自己实际测试发现没有的话会报错。

    /**
     * 1. SpringMVC 可以将提交的数据，按照参数名称和属性名匹配
     * 2. 直接封装到对象之中 --> 模型数据方面的知识
     * 3. @Valid Monster monster 表示要对 monster 接受的信息进行校验
     * 4. Errors errors 如果校验异常，错误信息就会被填充到这里
     * 5. Map<String, Object> map 如果校验异常，会保存错误信息和 monster 对象
     * 6. 校验发生的时机，是 SpringMVC 底层反射调用 http 请求的数据，然后根据注解进行验证，如果出现了错误那么就把错误信息填充到 errors 和 map 中
     * 编写方法，处理添加妖怪
     */
    @RequestMapping("/saveMonsters")
    public String save(@ModelAttribute("monsters") @Valid Monster monsters, Errors errors, Map<String, Object> map) {
        map.put("monsters", monsters);
        System.out.println("monster = " + monsters);
        System.out.println("====map====");
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue());
        }

        System.out.println("===errors====");
        if (errors.hasErrors()) {//判断是否有错误
            List<ObjectError> allErrors = errors.getAllErrors();
            for (ObjectError error : allErrors) {
                System.out.println("error=" + error);
            }
            return "datavalid/monster_addUI";
        }
        return "datavalid/success";
    }

配置国际化文件

<!-- 配置国际化错误信息的资源处理 bean -->、
<bean id="messageSource" class=  
"org.springframework.context.support.ResourceBundleMessageSource">  
    <!-- 配置国际化文件名字  
    如果你这样配的话，表示 messageSource 回到 src/i18nXXX.properties 去读取错误信息  
    -->  
    <property name="basename" value="i18n"> </property>  
</bean>

i18n.properties 需要放在 src 下面

NotEmpty.monsters.name=\u7528\u6237\u540d\u4e0d\u80fd\u4e3a\u7a7a  
typeMismatch.monsters.age=\u5e74\u9f84\u8981\u6c42\u5728\u0031\u002d\u0031\u0035\u0030\u4e4b\u95f4  
typeMismatch.monsters.birthday=\u751f\u65e5\u683c\u5f0f\u4e0d\u6b63\u786e  
typeMismatch.monsters.salary=\u85aa\u6c34\u683c\u5f0f\u4e0d\u6b63\u786e  
Range.monsters.age=\u8fd9\u4e2a\u4ee3\u66ff\u4e86 Range \u7684\u539f\u59cb\u7684\u62a5\u9519\u4fe1\u606f

monster_addUI.jsp 文件

<form:errors path=“XXX”/> 用于回显错误信息

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>  
<%@ page contentType="text/html;charset=UTF-8" language="java" %>  
<html>  
<head>  
<title>Title</title>  
</head>  
<body>  
<h3>添加妖怪~~</h3>  
<!-- 这里的表单，我们使用 springMVC 的标签来完成  
特别说明几点:  
1. SpringMVC 表单标签在显示之前必须在 request 中有一个bean, 该bean的属性和表单标签的字段要对应!  
request 中的 key 为: form 标签的 modelAttribute 属性值，比如这里的monsters  
2. SpringMVC 的 form:form 标签的 action 属性值中的/ 不代表WEB应用的根目录.  
3. 这里使用 SpringMVC 的标签主要目的是 数据回显  
-->  
<form:form action="saveMonsters" method="POST" modelAttribute="monsters">妖怪名字:  
妖怪名字: <form:input path="name"/> <form:errors path="name"/> <br><br>  
妖怪年龄~: <form:input path="age"/> <form:errors path="age"/> <br><br>  
电子邮件: <form:input path="email"/> <form:errors path="email"/> <br><br>  
妖怪生日: <form:input path="birthday"/> <form:errors path="birthday"/> 要求以"9999-11-11"的形式<br><br>  
妖怪薪水: <form:input path="salary"/> <form:errors path="salary"/> 要求以"123,890.12"的形式<br><br>  
<input type="submit" value="添加妖怪"/>  
</form:form>  
</body>  
</html>

注解的组合使用

使用@NotNull + @Range 组合使用解决

数据类型转换校验核心类-DataBinder

DataBinder 中的主要方法 validate（）

    public void validate(Object... validationHints) {
        Object target = getTarget();
        Assert.state(target != null, "No target to validate");
        BindingResult bindingResult = getBindingResult();
        // Call each validator with the same binding result
        for (Validator validator : getValidators()) {
            if (!ObjectUtils.isEmpty(validationHints) && validator instanceof SmartValidator) {
                ((SmartValidator) validator).validate(target, bindingResult, validationHints);
            }
            else if (validator != null) {
                validator.validate(target, bindingResult);
            }
        }
    }

Monster.java 类

public class Monster {
    private Integer id;
    @Email
    @NotNull(message = "email 不能为空")
    private String email;
    /**
     * 表示接受的范围是 0 到 100 之间
     */
    @NotNull(message = "age 不能为空") // 为空时提示的信息
    @Range(min = 1,max = 100)
    private Integer age;
    /**
     * @NotEmpty
     * Asserts that the annotated string, collection, map or array is not null or empty
     */
    @NotEmpty
    private String name;

    @NotNull
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date birthday;

    @NotNull
    @NumberFormat(pattern = "###,###.##")
    private Float salary;
}

追源码



首先出现错误的是数据转化这个个步骤

![[Pasted image 20230624120613.png]]

然后才是数据校验这个过程出现的错误

取消某个属性的绑定

在默认情况下，表单提交的数据都会和 pojo 类型的 javabean 属性绑定，如果程序员在开发中，希望取消某个属性的绑定，也就是说，不希望接收到某个表单对应的属性的值，则可以通过 @InitBinder 注解取消绑定.

使用

编写一个方法, 使用@InitBinder 标识的该方法，可以对 WebDataBinder 对象进行初始化。WebDataBinder 是 DataBinder 的子类，用于完成由表单字段到JavaBean 属性的绑定
@InitBinder 方法不能有返回值，它必须声明为 void。

@InitBinder 方法的参数通常是是 WebDataBinder

 //取消绑定 monster的name表单提交的值给monster.name属性
 @InitBinder
 public void initBinder(WebDataBinder webDataBinder) {
     /**
      * 老师解读
      * 1. 方法上需要标注 @InitBinder  springmvc底层会初始化 WebDataBinder
      * 2. 调用 webDataBinder.setDisallowedFields("name") 表示取消指定属性的绑定
      *    即：当表单提交字段为 name时， 就不在把接收到的name值，填充到model数据monster的name属性
      * 3. 机制：springmvc 在底层通过反射调用目标方法时, 接收到http请求的参数和值,使用反射+注解技术
      *    取消对指定属性的填充
      * 4. setDisallowedFields支持可变参数，可以填写多个字段
      * 5. 如果我们取消某个属性绑定,验证就没有意义了,应当把验证的注解去掉, name属性会使用默认值null
      *  //@NotEmpty
      *  private String name;
      *
      */
     webDataBinder.setDisallowedFields("name");
 }

细节

setDisallowedFields() 是可变形参，可以指定多个字段
当将一个字段/属性，设置为 disallowed,就不在接收表单提交的值，那么这个字段/属性的值，就是该对象默认的值 (具体看程序员定义时指定)
一般来说，如果不接收表单字段提交数据，则该对象字段的验证也就没有意义

中文乱码的解决

当表单提交数据为中文时，会出现乱码

使用自定义过滤器

使用 Filter 进行处理，需要注意实现的是 javax 下面的 Filter

import javax.servlet.*;  
import java.io.IOException;  

/**  
* @author leikooo  
* @create 2023-06-24 16:50  
* @Package com.hspedu.web.Filter  
* @Description Filter 这个是 javax 下面的 servlet  
*/  
public class MyCharacterFilter implements Filter {  
    @Override  
    public void init(FilterConfig filterConfig) throws ServletException {  

    }  

    @Override  
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {  
        // 加入对编码的处理  
        servletRequest.setCharacterEncoding("utf-8");  
        // 放行  
        filterChain.doFilter(servletRequest,servletResponse);  
    }  

    @Override  
    public void destroy() {  

    }  
}

web.xml 的配置

建议写在最前面

<!-- filter 写在最前面-->  
<filter>  
    <filter-name>myCharacterFilter</filter-name>  
    <filter-class>com.hspedu.web.Filter.MyCharacterFilter</filter-class>  
</filter>  

<filter-mapping>  
    <filter-name>myCharacterFilter</filter-name>  
    <url-pattern>/*</url-pattern>  
</filter-mapping>

Spring 提供的过滤器处理中文

需要使用配置 web.xml , 优点是更灵活

<filter>  
    <filter-name>CharacterEncodingFilter</filter-name>  
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param>  
    <param-name>encoding</param-name>  
    <param-value>UTF-8</param-value>  
</init-param>  
</filter>  
<filter-mapping>  
    <filter-name>CharacterEncodingFilter</filter-name>  
    <url-pattern>/*</url-pattern>  
</filter-mapping>

处理 Json 和 HttpMessageConverter

处理 JSON-@ResponseBody

项目开发中，我们往往需要服务器返回的数据格式是按照 JSON 来返回的数据

需要引入对应的 jar 包

目录格式

└─entity
    ∟ Dog.java
JsonHandler.java


package com.hspedu.web.json.entity;  

/**  
* @author leikooo  
* @create 2023-06-24 17:16  
* @Package com.hspedu.web.json.entity  
* @Description  
*/  
public class Dog {  
    private String name;  
    private String address;  

    public Dog() {  
    }  

    public Dog(String name, String address) {  
        this.name = name;  
        this.address = address;  
    }  

    public String getName() {  
        return name;  
    }  

    public void setName(String name) {  
        this.name = name;  
    }  

    public String getAddress() {  
        return address;  
    }  

    public void setAddress(String address) {  
        this.address = address;  
    }  

    @Override  
    public String toString() {  
    return "Dog{" +  
    "name='" + name + '\'' +  
    ", address='" + address + '\'' +  
    '}';  
    }  
}

JsonHandler.java

@Controller
public class JsonHandler {

    /**
     * 1. @ResponseBody 表示返回的数据是 json 格式
     * 2. SpringMVC 底层根据 @ResponseBody 注解，返回指定的格式，根据 Http 请求进行处理
     * 3. 原生的 SpringMVC 使用了转换器
     */
    @RequestMapping("/json/dog")
    @ResponseBody
    public Dog getJson() {
        // 返回对象
        Dog dog = new Dog();
        dog.setAddress("东北");
        dog.setName("小黄");
        return dog;
    }

}

json.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Json</title>
    <%--    引入 ajax--%>
    <script src="scrip/jquery-3.6.0.min.js"></script>
    <script type="text/javascript">
        $(function () {
            // 给 事件 绑定 click
            $("#getJson").click(function () {
                let url = this.href;
                // console.log(url);
                $.getJSON(
                    url,
                    {"time": new Date},
                    (success) => {
                        console.log("success = " , success);
                        console.log("name = " + success.name);
                        console.log("address = " + success.address);
                    }
                )
                // 返回 false 阻止默认 url 提交
                return false;
            })
        })

    </script>
</head>
<body>
<h1>请求一个 json 数据</h1>
<%--
1. 这里一般点击之后要发送一个 AJAX 请求
2. 需要使用到 AJAX 之前的知识
--%>
<a href="<%=request.getContextPath()%>/json/dog" id="getJson"> 点击获取 JSON 数据 </a>
</body>
</html>

测试结果

处理 JSON-@RequestBody

前面老韩给大家讲解的是通过表单, 或者 url 请求携带参数名=参数值把数据提交给目标方法

给大家举例客户端发送 json 字符串数据，
使用 SpringMVC 的 @RequestBody 将客户端提交的 json 数据，封装成JavaBean对象
再把这个 javabean 以 json 对象形式返回

细节

@ResponseBody 返回的可以是集合
@ResponseBody 可以直接写在类上面，对所有的方法都标识了注解
@ResponseBody + @Controller 可以简化为 @RestController

HttpMessageConverter<\T>流程分析

SpringMVC 处理 JSON-底层实现是依靠 HttpMessageConverter <\T> 来进行转换的

流程



处理 JSON-底层实现(HttpMessageConverter<\T>)

使用 HttpMessageConverter<\T> 将请求信息转化并绑定到处理方法的入参中, 或将响应结果转为对应类型的响应信息，Spring 提供了两种途径

使用 @RequestBody / @ResponseBody 对目标方法进行标注
使用 HttpEntity<\T> / ResponseEntity<\T> 作为目标方法的入参或返回值

当控制器处理方法使用到 @RequestBody/@ResponseBody或HttpEntity<\T>/ResponseEntity<\T> 时, Spring 首先根据请求头或响应头的Accept 属性选择匹配的 HttpMessageConverter, 进而根据参数类型或泛型类型的过滤得到匹配的HttpMessageConverter, 若找不到可用的 HttpMessageConverter 将报错

DEBUG 流程



SpringMVC 文件下载

在 SpringMVC 中，通过返回 ResponseEntity< T >的类型，可以实现文件下载的功能

public ResponseEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers, HttpStatus status)

HttpHeaders 是 MultiValueMap 的一个具体实现，它是Spring框架提供的用于表示HTTP头部的类。因此，你可以直接将 HttpHeaders 对象传递给 ResponseEntity 构造器的第二个参数，因为 HttpHeaders 是MultiValueMap<String, String> 类型的

@RequestMapping("/download")  
public ResponseEntity<byte[]> downloadFile(HttpSession session) throws IOException {  
    // 1. 获取下载文件的 inputStreamInputStream inputStream = session.getServletContext().getResourceAsStream("/img/2.jpg");  
    // 2. 开辟一个存放 byte[] 可以至此二进制数据  
    byte[] bytes = new byte[inputStream.available()];  
    // 3. 将下载的文件数据读取到 byte[]inputStream.read(bytes);  
    // 使用这个构造器:  
    // public ResponseEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers, HttpStatus status)  
    HttpStatus httpStatus = HttpStatus.OK;  
    // 5. 创建 headers
    HttpHeaders httpHeaders = new HttpHeaders();  
    httpHeaders.add("Content-Disposition", "attachment;filename=2.jpg");  
    return new ResponseEntity<>(bytes, httpHeaders, httpStatus);  
}

SpringMVC 文件上传

基本介绍

Spring MVC 为文件上传提供了直接的支持，这种支持是通过即插即用的MultipartResolver 实现的。 Spring 用 Jakarta Commons FileUpload 技术实现了一个 MultipartResolver 实现类是CommonsMultipartResovler
Spring MVC 上下文中默认没有装配 MultipartResovler，因此默认情况下不能处理文件的上传工作，如果想使用 Spring 的文件上传功能，需现在上下文中配置 MultipartResolver

这个 id=“multipartResolver” 需要注意，不要瞎写，会报 400 错误

<!-- 配置文件上传需要的 bean--><!-- 需要开启，否则不支持文件上传-->  
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver" />

对应的方法

@Controller  
public class FileUpload {  
    /**  
    * @param file 代表接受到的文件  
    * @param request request 请求  
    * @param introduce 代表介绍  
    */  
    @RequestMapping("/fileUpload")  
    public String fileUpload(@RequestParam("file") MultipartFile file, HttpServletRequest request, String introduce) throws IOException {  

        // 接收到提交的文件名字  
        String filename = file.getOriginalFilename();  
        System.out.println("你上传的文件是 = " + filename);  
        System.out.println("introduce = " + introduce);  
        // 得到要把传的文件保存到哪一个路径 保存到的是 「out」工作目录  
        String fileFullPath = request.getServletContext().getRealPath("/img/" + filename);  
        // 创建文件  
        File saveFile = new File(fileFullPath);  

        file.transferTo(saveFile);  
        return "success";  
    }  

}

fileUpload.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title> 文件上传和下载 </title>
</head>
<body>
<h1> 文件上传 </h1>
// 需要指定 enctype="multipart/form-data" 类型
<form action="<%=request.getContextPath()%>/fileUpload" method="post" enctype="multipart/form-data">
    文件的介绍: <input type="text" name="introduce"> <br>
    选择文件: <input type="file" name="file"> <br>
    <input type="submit" value="文件上传">
</form>
</body>
</html>

使用 POSTMAN 测试提交数据

底层机制

底层是实现还是用的是 JavaWeb 文件上传机制

![[文件上传和下载#^9225fe]]

CommonsMultipartFile # transferTo（）方法

this.fileItem.write(dest) 是一个关键的语句，可以自己 debug 查看更详细的信息

SpringMVC 拦截器

什么是拦截器

SpringMVC 也可以使用拦截器对请求进行拦截处理，用户可以自定义拦截器来实现特定的功能.
自定义的拦截器必须实现 HandlerInterceptor 接口

自定义拦截器的三个方法

preHandle()：这个方法在业务处理器处理请求之前被调用，在该方法中对用户请求request 进行处理。
postHandle()：这个方法在目标方法处理完请求后执行
afterCompletion()：这个方法在完全处理完请求后被调用，可以在该方法中进行一些资源清理的操作

如果 preHandle 方法返回 false, 则不再执行目标方法, 可以在此指定返回页面
postHandle 在目标方法被执行后执行. 可以在方法中访问到目标方法返回的ModelAndView 对象
若 preHandle 返回 true, 则 afterCompletion 方法在渲染视图之后被执行.
若 preHandle 返回 false, 则 afterCompletion 方法不会被调用
在配置拦截器时，可以指定该拦截器对哪些请求生效，哪些请求不生效

自定义拦截器应用实例

快速入门

@Component
public class MyInterceptor01 implements HandlerInterceptor {

    /**
     * 1. 该方法在目标方法执行前，被执行
     * 2. 如果 preHandle() 返回 false，不在执行目标方法
     * 3. 该方法可以获取到 request，response，handler
     * 4. 可以根据业务进行拦截，指定跳转到哪一个页面
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor01 的  preHandle() 方法执行了--");
        return true;
    }


    /**
     * 1. 在目标方法执行后，会执行 postHandle()
     * 2. 该方法可以获取到 目标方法，返回 ModelAndView
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor01 的  postHandle() 方法执行了--");

    }

    /**
     * 视图渲染后被执行，可以做一资源清理工作
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor01 的  afterCompletion() 方法执行了~~");
    }
}

需要的 SpringMVC 配置文件

<beans>
    <mvc:interceptors>  
        <!--  
        1. 配置自定义拦截器  
        2. 使用 ref 引用 myInterceptor013. 使用这种方式，会拦截所有的目标方法  
        -->  
        <ref bean="myInterceptor01" />  
    </mvc:interceptors>
</beans>

前端请求界面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>  
<html>  
<head>  
<title>测试自定义拦截器</title>  
</head>  
<body>  
<h1>测试自定义拦截器</h1>  
<a href="<%=request.getContextPath()%>/hi">测试自定义拦截器</a><br><br>  
<a href="<%=request.getContextPath()%>/hello">登录</a>  
</body>  
</html>

正常结果 MyInterceptor01 的 preHandle() 方法执行了-- FurnHandler 的 hi() 被执行~~ MyInterceptor01 的 postHandle() 方法执行了-- MyInterceptor01 的 afterCompletion() 方法执行了~~

注意事项和细节

默认配置是都所有的目标方法都进行拦截, 也可以指定拦截目标方法, 比如只是拦截hi

mvc:interceptors
mvc:interceptor
<mvc:mapping path=“/hi”/>

</mvc:interceptor>
</mvc:interceptors>
mvc:mapping 支持通配符, 同时指定不对哪些目标方法进行拦截

mvc:interceptors
mvc:interceptor
<mvc:mapping path=“/h*”/>

<mvc:exclude-mapping path=“/hello”/>

</mvc:interceptor>
</mvc:interceptors>
拦截器需要配置才生效，不配置是不生效的.
如果 preHandler() 方法返回了 false, 就不会执行目标方法(前提是你的目标方法被拦截了), 程序员可以在这里根据业务需要指定跳转页面.

Debug 执行流程

执行目标方法

DispatcherServlet 是分发处理器，其中的 render（）方法

多个拦截器

前提是多个拦截器都拦截目标方法

执行流程示意图

快速入门

配置文件

按照配置的先后顺序执行拦截器

<mvc:interceptors>
    <mvc:interceptor>  
        <mvc:mapping path="/hi"/>  
        <ref bean="myInterceptor01"/>  
    </mvc:interceptor>  

    <mvc:interceptor>  
        <mvc:mapping path="/h*"/>  
        <ref bean="myInterceptor02"/>  
    </mvc:interceptor>
</mvc:interceptors>

MyInterceptor02 自定义拦截器，需要注意是实现 HandlerInterceptor 接口

@Component
public class MyInterceptor02 implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor02#preHandle()");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor02#postHandle()");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor02#afterCompletion()");
    }
}

MyInterceptor01

@Component
public class MyInterceptor01 implements HandlerInterceptor {

    /**
     * 1. 该方法在目标方法执行前，被执行
     * 2. 如果 preHandle() 返回 false，不在执行目标方法
     * 3. 该方法可以获取到 request，response，handler
     * 4. 可以根据业务进行拦截，指定跳转到哪一个页面
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor01 的  preHandle() 方法执行了--");
        return true;
    }


    /**
     * 1. 在目标方法执行后，会执行 postHandle()
     * 2. 该方法可以获取到 目标方法，返回 ModelAndView
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor01 的  postHandle() 方法执行了--");

    }

    /**
     * 视图渲染后被执行，可以做一资源清理工作
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor01 的  afterCompletion() 方法执行了~~");
    }
}

效果

也可以进行请求转发

public class MyInterceptor01 implements HandlerInterceptor {  

    /**  
    * 1. 该方法在目标方法执行前，被执行  
    * 2. 如果 preHandle() 返回 false，不在执行目标方法  
    * 3. 该方法可以获取到 request，response，handler  
    * 4. 可以根据业务进行拦截，指定跳转到哪一个页面  
    *  
    * @param request  
    * @param response  
    * @param handler  
    * @throws Exception  
    */  
    @Override  
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {  
        System.out.println("MyInterceptor01 的 preHandle() 方法执行了--");  
        String keywords = request.getParameter("keywords");  
        if ("病毒".equals(keywords)) {  
        request.getRequestDispatcher("/WEB-INF/pages/warning.jsp").forward(request, response);  
        return false;  
        }  

        System.out.println("keywords = " + keywords);  

        return true;  
    }  


    /**  
    * 1. 在目标方法执行后，会执行 postHandle()  
    * 2. 该方法可以获取到 目标方法，返回 ModelAndView  
    *  
    * @param request  
    * @param response  
    * @param handler  
    * @param modelAndView  
    * @throws Exception  
    */  
    @Override  
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {  
        System.out.println("MyInterceptor01 的 postHandle() 方法执行了--");  

    }  

    /**  
    * 视图渲染后被执行，可以做些资源清理工作  
    *  
    * @param request  
    * @param response  
    * @param handler  
    * @param ex  
    * @throws Exception  
    */  
    @Override  
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {  
        System.out.println("MyInterceptor01 的 afterCompletion() 方法执行了~~");  
    }  
}

如果是提交中含有「病毒」那么就会直接跳转到指定页面

细节

如果第 1 个拦截器的 preHandle() 返回 false , 后面都不在执行
如果第 2 个拦截器的 preHandle() 返回 false , 就直接执行第1 个拦截器的afterCompletion()方法, 如果拦截器更多，规则类似
说明: 前面说的规则，都是目标方法被拦截的前提

异常处理

异常处理-基本介绍

SpringMVC 通过 HandlerExceptionResolver 处理程序的异常，包括 Handler 映射、数据绑定以及目标方法执行时发生的异常。
主要处理 Handler 中用 @ExceptionHandler 注解定义的方法。
ExceptionHandlerMethodResolver 内部若找不到 @ExceptionHandler 注解的话，会找@ControllerAdvice 类的 @ExceptionHandler 注解方法, 这样就相当于一个全局异常处理器

局部异常

默认机制非常的不友好，如果不处理默认 Tomcat 进行处理

MyExceptionHandler.java

@Controller  
public class MyExceptionHandler {  

    /**  
    * 1. 这个方法是处理局部异常  
    * 2. 这里处理的是 ArithmeticException.class, NullPointerException.class 这两个异常  
    * 3. Exception ex 生成的异常对象，可以通过 ex 获取相关的信息，可以加入自己的逻辑  
    */  
    @ExceptionHandler({ArithmeticException.class, NullPointerException.class})  
    public String localException(HttpServletRequest request, Exception ex) {  
        System.out.println("异常对象 = " + ex);  
        request.setAttribute("erro", ex);  
        return "exception_mine";  

    }  

    /**  
    * 如果我们不进行异常处理，那么 Tomcat 就会默认处理  
    */  
    @RequestMapping("/testException01")  
    public String test01(Integer num) {  
        int i = 1 / num;  
        return "success";  
    }  
}

exception_mine.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>  
<html>  
<head>  
<title>异常信息提醒</title>  
</head>  
<body>  

<h1> 朋友，程序发生了异常 </h1>  
异常信息是 ${requestScope.erro}  
</body>  
</html>

效果图

debug 源码

全局异常

@ControllerAdvice 如果在类上面标识，就是一个全局异常处理类

@ControllerAdvice  
public class MyGlobalException {  

    /**  
    * 1. 全局异常就是不管是哪一个 handler 抛出的异常，都可以捕获 @ExceptionHandler({异常类型})  
    * 2. 全局异常优先级低  
    */  
    @ExceptionHandler({NumberFormatException.class, ClassCastException.class})  
    public String globalException(Exception ex, HttpServletRequest request) {  
        System.out.println("ex = " + ex);  
        request.setAttribute("erro", ex);  
        return "exception_mine";  
    }  

}

测试方法

@RequestMapping("/testGlobalException")  
public String global() {  
    // 局部异常没有这个异常，去找全局异常  
    int num = Integer.parseInt("hello");  
    return "success";  
}

debug

拿到定义的 MyGlobalException 类

拿到 MyGlobalException 中定义的方法，以后反射调用

自定义异常

自定义异常也可以被全局异常进行接管

@ResponseStatus(reason="年龄需要在 1 - 120 之间", value = HttpStatus.BAD_REQUEST)  
public class AgeException extends RuntimeException {  

}

测试方法

@RequestMapping("/testException02")  
public String test02() {  
    throw new AgeException();  
}

效果

全局异常接管自定义异常

全局异常类

// 这个信息是在默认页面显示的内容 （Tomcat）使用
@ResponseStatus(reason = "年龄需要在 1 - 120 之间", value = HttpStatus.BAD_REQUEST)  
public class AgeException extends RuntimeException {  

    public AgeException() {  

    }  

    public AgeException(String message) {  
        super(message);  
    }  
}

测试方法

@RequestMapping("/testException02")  
public String test02() {  
    throw new AgeException("年龄需要在 1 - 120 之间~~~");  
}

全局异常类

@ControllerAdvice  
public class MyGlobalException {  

    /**  
    * 1. 全局异常就是不管是哪一个 handler 抛出的异常，都可以捕获 @ExceptionHandler({异常类型})  
    * 2. 全局异常优先级低  
    */  
    @ExceptionHandler({NumberFormatException.class, ClassCastException.class, AgeException.class})  
        public String globalException(Exception ex, HttpServletRequest request) {  
        System.out.println("ex = " + ex);  
        request.setAttribute("erro", ex);  
        return "exception_mine";  
    }  

}

结果

debug

debug 流程和全局异常的流程几乎一致

统一异常处理

SimpleMappingExceptionResolver

如果希望对所有异常进行统一处理，可以使用 SimpleMappingExceptionResolver
它将异常类名映射为视图名，即发生异常时使用对应的视图报告异常
需要在 ioc 容器中配置

配置文件

<!-- 配置统一异常处理-->  
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">  
    <property name="exceptionMappings">  
        <props>  
            arrEx， 这个是视图名称
            <prop key="java.lang.ArrayIndexOutOfBoundsException">arrEx</prop>  
        </props>  
    </property>  
</bean>

测试方法

@RequestMapping("/testException03")  
public String test03() {  
    int[] arr = new int[10];  
    System.out.println("arr[90] = " + arr[90]);  
    return "success";  
}

对未知异常进行统一处理

异常种类很多，不可能全都自己写，所以就需要对异常进行统一处理

配置文件

<!-- 配置统一异常处理-->  
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">  
    <property name="exceptionMappings">  
        <props>  
            <prop key="java.lang.Exception">allEx</prop>  
        </props>  
    </property>  
</bean>