Spring MVC

Stone大约 32 分钟

Spring MVC

Spring MVC 是 Spring 框架中的一个重要模块，它提供了构建 Web 应用程序的全功能 MVC（Model-View-Controller）框架。MVC 是一种将应用程序的逻辑、数据和表示层分离的设计模式，Spring MVC 则基于这种模式为开发者提供了一个清晰、简洁的 Web 开发途径。

以下是 Spring MVC 的主要特点和简介：

模型（Model）：
- 封装了应用程序的数据和处理业务逻辑的组件。
- 在 Spring MVC 中，模型通常由 POJO（Plain Old Java Object）或 JavaBean 构成，它们通过服务层与数据库进行交互。
视图（View）：
- 负责数据的展示，通常与用户界面相关。
- 在 Spring MVC 中，视图可以是 JSP、Thymeleaf、FreeMarker 等模板技术，也可以是 JSON、XML 等数据格式。
- Spring MVC 支持多种视图解析技术，可以轻松地集成现有的视图技术。
控制器（Controller）：
- 负责接收用户请求并调用相应的业务逻辑进行处理。
- 在 Spring MVC 中，控制器是一个普通的 Java 类，它使用 @Controller 注解进行标记，并使用 @RequestMapping 注解来映射请求 URL 到特定的处理方法。
请求和响应：
- Spring MVC 通过 DispatcherServlet 作为前端控制器来拦截所有的请求，并根据请求 URL 调用相应的控制器方法。
- 控制器方法处理完业务逻辑后，返回一个 ModelAndView 对象或视图名称和模型数据，然后由 DispatcherServlet 交给视图解析器进行视图渲染。
灵活的配置：
- Spring MVC 支持基于 Java 的配置和基于 XML 的配置，开发者可以根据需要选择最适合自己的配置方式。
- 通过 JavaConfig，开发者可以使用 Java 类来定义 Spring MVC 的配置，使配置更加灵活和可维护。
强大的功能：
- 提供了数据绑定、消息转换、异常处理、文件上传下载等丰富的功能。
- 支持国际化（i18n）和本地化（l10n）。
- 集成了 Spring 框架的其他模块，如 Spring Security、Spring Data JPA 等，可以方便地构建安全的、数据驱动的 Web 应用程序。
易于测试：
- 由于 Spring MVC 的控制器是普通的 Java 类，因此可以很容易地使用 JUnit 或 Mockito 等测试框架进行单元测试。
- Spring MVC 还提供了 MockMvc 类来模拟 HTTP 请求和响应，使测试更加便捷。

总之，Spring MVC 是一个功能强大、易于使用且易于扩展的 Web MVC 框架，它可以帮助开发者高效地构建高质量的 Web 应用程序。

Start

在 IDEA 中创建 Web 项目，在 pom.xml 文件中引入 Spring MVC 依赖：

<?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>com.itheima</groupId>
  <artifactId>springmvc_01_quickstart</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <dependencies>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <port>80</port>
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

其中：

provided 表示该包只在编译和测试的时候用，运行的时候无效。避免与 Tomcat中的 servlet-api 包发生冲突。

创建配置类：

@Configuration
@ComponentScan("com.itheima.controller")
public class SpringMvcConfig {
}

public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    //加载 Spring MVC 配置类
    protected WebApplicationContext createServletApplicationContext() {
        //初始化 WebApplicationContext 对象
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        //加载指定配置类
        ctx.register(SpringMvcConfig.class);
        return ctx;
    }

    //设置由 Spring MVC 控制器处理的请求映射路径
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    //加载 Spring 配置类
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }
}

创建 Controller 类：

@Controller
public class UserController {
    
    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("user save ...");
        return "{'info':'springmvc'}";
    }
}

注意：

Spring MVC 是基于 Spring 的，在 pom.xml 只导入了 spring-webmvc 的原因是它会自动依赖 Spring 相关坐标。
AbstractDispatcherServletInitializer 类是 Spring MVC 提供的快速初始化 Web3.0 容器的抽象类。
AbstractDispatcherServletInitializer 提供了三个方法：
- createServletApplicationContext 方法，创建 Servlet 容器时，加载 Spring MVC 对应的 Bean 并放入 WebApplicationContext 对象范围中，而 WebApplicationContext 的作用范围为 ServletContext 范围，即整个 Web 容器范围。
- getServletMappings 方法，设定 Spring MVC 对应的请求映射路径，即 Spring MVC 拦截哪些请求。
- createRootApplicationContext 方法，如果创建 Servlet 容器时需要加载非 Spring MVC 对应的Bean，使用当前方法进行，使用方式和 createServletApplicationContext 相同。
- createServletApplicationContext 用来加载 Spring MVC 环境。
- createRootApplicationContext 用来加载 Spring 环境。

启动服务器初始化过程：

服务器启动，执行 ServletContainersInitConfig 类，初始化 Web 容器，功能类似于以前的 web.xml。
执行 createServletApplicationContext 方法，创建了 WebApplicationContext 对象，该方法加载 Spring MVC 的配置类 SpringMvcConfig 来初始化 Spring MVC 的容器。
加载 SpringMvcConfig 配置类。
执行 @ComponentScan 加载对应的 Bean，扫描指定包及其子包下所有类上的注解，如 Controller 类上的 @Controller 注解。
加载 UserController，每个 @RequestMapping 的名称对应一个具体的方法，此时就建立了 /save 和 save 方法的对应关系。
执行 getServletMappings 方法，设定 Spring MVC 拦截请求的路径规则，/ 代表所拦截请求的路径规则，只有被拦截后才能交给 Spring MVC 来处理请求。

单次请求过程：

发送请求 http://localhost/save。
Web 容器发现该请求满足 Spring MVC 拦截规则，将请求交给 Spring MVC 处理。
解析请求路径 /save。
由 /save 匹配到对应的方法 save()。
执行 save()。
检测到有 @ResponseBody，直接将 save() 方法的返回值作为响应体返回给请求方。

Request

请求路径

在 IDEA 中创建 Web 项目，在 pom.xml 文件中引入 Spring MVC 依赖：

<?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>com.itheima</groupId>
  <artifactId>springmvc_03_request_mapping</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <dependencies>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <port>80</port>
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

创建对应的配置类：

public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {

    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }
}

@Configuration
@ComponentScan("com.itheima.controller")
public class SpringMvcConfig {
}

创建 BookController 和 UserController：

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

    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("user save ...");
        return "{'module':'user save'}";
    }
    
    @RequestMapping("/delete")
    @ResponseBody
    public String save(){
        System.out.println("user delete ...");
        return "{'module':'user delete'}";
    }
}

@Controller
@RequestMapping("/book")
public class BookController {

    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("book save ...");
        return "{'module':'book save'}";
    }
}

其中：

当类上和方法上都添加了 @RequestMapping 注解，前端发送请求的时候，要和两个注解的 value 值相加匹配才能访问到。
@RequestMapping 注解的 value 属性前面加不加 / 都可以。

参数传递

Spring MVC 可以对方法及方法入参标注相应的注解（@PathVariable、@RequestParam、@RequestHeader等），Spring MVC 框架会将 HTTP 请求的信息绑定到相应的方法入参中，并根据方法的返回值类型做出相应的后续处理。

常见的参数有:

普通参数：参数名称相同时直接传递，不同时使用 @RequestParam 指定
POJO 类型参数：直接传递
嵌套 POJO 类型参数：直接传递
数组类型参数：直接传递
集合类型参数：使用 @RequestParam 绑定

普通参数：URL 地址传参，地址参数名与形参变量名相同，定义形参即可接收参数。

http://localhost/commonParamDifferentName?name=张三&age=18

@RequestMapping("/commonParam")
@ResponseBody
public String commonParam(String name , int age){
    System.out.println("普通参数传递 name ==> "+name);
    System.out.println("普通参数传递 age ==> "+age);
    return "{'module':'common param'}";
}

普通参数：URL 地址传参，地址参数名与形参变量名不同，使用 @RequestParam 进行指定。

@RequestMapping("/commonParamDifferentName")
    @ResponseBody
    public String commonParamDifferentName(@RequestParam("name") String userName , int age){
        System.out.println("普通参数传递 userName ==> "+userName);
        System.out.println("普通参数传递 age ==> "+age);
        return "{'module':'common param different name'}";
    }

POJO 参数：请求参数名与形参对象属性名相同，定义 POJO 类型形参即可接收参数。

http://localhost/commonParamDifferentName?name=张三&age=18

//POJO参数：请求参数与形参对象中的属性对应即可完成参数传递
@RequestMapping("/pojoParam")
@ResponseBody
public String pojoParam(User user){
    System.out.println("pojo参数传递 user ==> "+user);
    return "{'module':'pojo param'}";
}

嵌套 POJO 参数：请求参数名与形参对象属性名相同，按照对象层次结构关系即可接收嵌套 POJO 属性参数。

http://localhost/commonParamDifferentName?name=张三&age=18&address.city=beijing&address.province=beijing

//POJO参数：请求参数与形参对象中的属性对应即可完成参数传递
@RequestMapping("/pojoParam")
@ResponseBody
public String pojoParam(User user){
    System.out.println("pojo参数传递 user ==> "+user);
    return "{'module':'pojo param'}";
}

数组参数：请求参数名与形参对象属性名相同且请求参数为多个，定义数组类型即可接收参数。

http://localhost/commonParamDifferentName?likes=game&likes=music

  //数组参数：同名请求参数可以直接映射到对应名称的形参数组对象中
    @RequestMapping("/arrayParam")
    @ResponseBody
    public String arrayParam(String[] likes){
        System.out.println("数组参数传递 likes ==> "+ Arrays.toString(likes));
        return "{'module':'array param'}";
    }

集合保存普通参数：请求参数名与形参集合对象名相同且请求参数为多个，@RequestParam 绑定参数关系。

http://localhost/commonParamDifferentName?likes=game&likes=music

//集合参数：同名请求参数可以使用@RequestParam注解映射到对应名称的集合对象中作为数据
@RequestMapping("/listParam")
@ResponseBody
public String listParam(@RequestParam List<String> likes){
    System.out.println("集合参数传递 likes ==> "+ likes);
    return "{'module':'list param'}";
}

JSON

对于 JSON 数据类型，常见的有三种：

JSON 普通数组（["value1","value2","value3",...]）
JSON 对象（{key1:value1,key2:value2,...}）
JSON 对象数组（[{key1:value1,...},{key2:value2,...}]）

前端如果发送的是 JSON 数据，需要先在 pom.xml 添加 jackson 依赖：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.0</version>
</dependency>

然后在 Spring MVC 的配置类中开启 Spring MVC 的注解支持，这里面就包含了将 JSON 转换成对象的功能：

@Configuration
@ComponentScan("com.itheima.controller")
//开启 JSON 数据类型自动转换
@EnableWebMvc
public class SpringMvcConfig {
}

然后参数前添加 @RequestBody：

//使用 @RequestBody 注解将外部传递的 JSON 数组数据映射到形参的集合对象中作为数据
@RequestMapping("/listParamForJson")
@ResponseBody
public String listParamForJson(@RequestBody List<String> likes){
    System.out.println("list common(json)参数传递 list ==> "+likes);
    return "{'module':'list common for json param'}";
}

@RequestBody 与 @RequestParam 区别：

区别
- @RequestParam 用于接收 URL 地址传参及表单传参，格式为 application/x-www-form-urlencoded。
- @RequestBody 用于接收 JSON 数据，格式为 application/json。
应用
- 后期开发中，以发送 JSON 格式数据为主，@RequestBody 应用较多。
- 如果发送非 JSON 格式数据，选用 @RequestParam 接收请求参数。

日期类型

Spring MVC 默认可以处理的日期格式为 yyyy/MM/dd，如果是其他日期格式，则需要使用 @DateTimeFormat 注解指定日期参数的格式。

例如对于以下带不同格式的日期请求：

http://localhost/dataParam?date=2088/08/08&date1=2088-08-08

使用 @DateTimeFormat 指定日期参数的格式：

@RequestMapping("/dataParam")
@ResponseBody
public String dataParam(Date date,
                        @DateTimeFormat(pattern="yyyy-MM-dd") Date date1)
    System.out.println("参数传递 date ==> "+date);
	System.out.println("参数传递 date1(yyyy-MM-dd) ==> "+date1);
    return "{'module':'data param'}";
}

对于带时间格式的请求：

http://localhost/dataParam?date=2088/08/08&date1=2088-08-08&date2=2088/08/08 8:08:08

使用 @DateTimeFormat 指定日期时间参数的格式：

@RequestMapping("/dataParam")
@ResponseBody
public String dataParam(Date date,
                        @DateTimeFormat(pattern="yyyy-MM-dd") Date date1,
                        @DateTimeFormat(pattern="yyyy/MM/dd HH:mm:ss") Date date2)
    System.out.println("参数传递 date ==> "+date);
	System.out.println("参数传递 date1(yyyy-MM-dd) ==> "+date1);
	System.out.println("参数传递 date2(yyyy/MM/dd HH:mm:ss) ==> "+date2);
    return "{'module':'data param'}";
}

Response

对于响应，主要就包含两部分内容：

响应页面
响应数据
- 文本数据
- JSON 数据

因为异步调用是目前常用的主流方式，所以需要更关注的就是如何返回 JSON 数据。

在 IDEA 中创建 Web 项目，pom.xml 文件添加 Spring MVC 依赖：

<?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>com.itheima</groupId>
  <artifactId>springmvc_05_response</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <dependencies>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <port>80</port>
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

创建对应的配置类：

public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }

    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    //乱码处理
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};
    }
}

@Configuration
@ComponentScan("com.itheima.controller")
//开启 JSON 数据类型自动转换
@EnableWebMvc
public class SpringMvcConfig {
}

创建模型类 User：

public class User {
    private String name;
    private int age;
    //getter...setter...toString省略
}

webapp 目录下创建 page.jsp：

<html>
<body>
<h2>Hello Spring MVC!</h2>
</body>
</html>

创建 UserController：

@Controller
public class UserController {
}

返回页面：

@Controller
public class UserController {
    
    @RequestMapping("/toJumpPage")
    //注意
    //1.此处不能添加 @ResponseBody,如果加了该注解，会直接将 page.jsp 当字符串返回前端
    //2.方法需要指定返回类型为 String
    public String toJumpPage(){
        System.out.println("跳转页面");
        return "page.jsp";
    }
    
}

返回文本内容：

@Controller
public class UserController {
    
   	@RequestMapping("/toText")
	//注意此处该注解就不能省略，如果省略了,会把 response text 当前页面名称去查找，如果没有回报 404 错误
    @ResponseBody
    public String toText(){
        System.out.println("返回纯文本数据");
        return "response text";
    }
    
}

将 POJO 对象转换为 JSON 返回：

@Controller
public class UserController {
    
    @RequestMapping("/toJsonPOJO")
    @ResponseBody
    public User toJsonPOJO(){
        System.out.println("返回 JSON 对象数据");
        User user = new User();
        user.setName("itcast");
        user.setAge(15);
        return user;
    }
    
}

返回值为实体类对象，设置返回值类型为实体类类型，即可实现返回对应对象的 JSON 数据，需要依赖 @ResponseBody 注解和 @EnableWebMvc 注解。

将 POJO 对象集合转换为 JSON 返回：

@Controller
public class UserController {
    
    @RequestMapping("/toJsonList")
    @ResponseBody
    public List<User> toJsonList(){
        System.out.println("返回json集合数据");
        User user1 = new User();
        user1.setName("传智播客");
        user1.setAge(15);

        User user2 = new User();
        user2.setName("黑马程序员");
        user2.setAge(12);

        List<User> userList = new ArrayList<User>();
        userList.add(user1);
        userList.add(user2);

        return userList;
    }
    
}

对于 @ResponseBody：

该注解可以写在类上或者方法上
写在类上就是该类下的所有方法都有 @ReponseBody 功能
当方法上有 @ReponseBody 注解后
- 方法的返回值为字符串，会将其作为文本内容直接响应给前端
- 方法的返回值为对象，会将对象转换成 JSON 响应给前端

此处又使用到了类型转换，内部还是通过 Converter 接口的实现类完成的，所以 Converter 除了实现日期格式转换外，还可以实现:

对象转 JSON 数据（POJO -> JSON）
集合转 JSON 数据（Collection -> JSON）

REST

按照 REST 风格访问资源时使用行为动作区分对资源进行了何种操作

http://localhost/users 查询全部用户信息 GET（查询）
http://localhost/users/1 查询指定用户信息 GET（查询）
http://localhost/users 添加用户信息 POST（新增/保存）
http://localhost/users 修改用户信息 PUT（修改/更新）
http://localhost/users/1 删除用户信息 DELETE（删除）

按照不同的请求方式代表不同的操作类型。

发送 GET 请求是用来做查询
发送 POST 请求是用来做新增
发送 PUT 请求是用来做修改
发送 DELETE 请求是用来做删除

简化 REST 开发：

将 @RequestMapping 提到类上面，用来定义所有方法共同的访问路径。
使用 @GetMapping，@PostMapping，@PutMapping 和 @DeleteMapping 代替 @RequestMapping。
将 @ResponseBody 提到类上面，让所有的方法都有 @ResponseBody 的功能。
使用 @RestController 注解替换 @Controller 与 @ResponseBody 注解，简化书写。

@RestController //@Controller + @ReponseBody
@RequestMapping("/books")
public class BookController {
    
	//@RequestMapping(method = RequestMethod.POST)
    @PostMapping
    public String save(@RequestBody Book book){
        System.out.println("book save..." + book);
        return "{'module':'book save'}";
    }

    //@RequestMapping(value = "/{id}",method = RequestMethod.DELETE)
    @DeleteMapping("/{id}")
    public String delete(@PathVariable Integer id){
        System.out.println("book delete..." + id);
        return "{'module':'book delete'}";
    }

    //@RequestMapping(method = RequestMethod.PUT)
    @PutMapping
    public String update(@RequestBody Book book){
        System.out.println("book update..." + book);
        return "{'module':'book update'}";
    }

    //@RequestMapping(value = "/{id}",method = RequestMethod.GET)
    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("book getById..." + id);
        return "{'module':'book getById'}";
    }

    //@RequestMapping(method = RequestMethod.GET)
    @GetMapping
    public String getAll(){
        System.out.println("book getAll...");
        return "{'module':'book getAll'}";
    }
    
}

三个注解 @RequestBody、@RequestParam、@PathVariable，区别和应用如下：

区别
- @RequestParam 用于接收 URL 地址传参或表单传参
- @RequestBody 用于接收 JSON 数据，一般不支持 @GetMapping
- @PathVariable 用于接收路径参数
应用
- 后期开发中，发送请求参数超过 1 个时，以 JSON 格式为主，@RequestBody 应用较多
- 如果发送非 JSON 格式数据，使用 @RequestParam 接收请求参数
- 采用 RESTful 进行开发，当参数数量较少时，例如 1 个，可以采用 @PathVariable 接收请求路径变量，通常用于传递 id 值

SSM

整合 Spring，Spring MVC 及 MyBatis。

整合配置

在 IDEA 中创建 Web 项目，在 pom.xml 文件中引入 Spring MVC 依赖：

<?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>com.itheima</groupId>
  <artifactId>springmvc_08_ssm</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

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

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.6</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>

    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.16</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <port>80</port>
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

创建项目包结构：

其中：

config 目录存放的是相关的配置类。
controller 编写的是 Controller 类。
dao 存放的是 Dao 接口，因为使用的是 Mapper 接口代理方式，所以没有实现类包。
service 存放的是 Service 接口，impl 存放的是 Service 实现类。
resources 存放的是配置文件，如 jdbc.properties。
webapp 目录可以存放静态资源。
test/java 存放的是测试类。

在 resources 目录下创建 jdbc.properties，设置数据库连接四要素：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm_db
jdbc.username=root
jdbc.password=root

在 config 目录下创建 JDBC 配置类 JdbcConfig：

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }

    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager ds = new DataSourceTransactionManager();
        ds.setDataSource(dataSource);
        return ds;
    }
}

在 config 目录下创建 MyBatis 配置类 MybatisConfig：

public class MyBatisConfig {
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        factoryBean.setTypeAliasesPackage("com.itheima.domain");
        return factoryBean;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}

在 config 目录下创建 Spring MVC 配置类 SpringMvcConfig：

@Configuration
@ComponentScan("com.itheima.controller")
@EnableWebMvc
public class SpringMvcConfig {
}

其中：

标识该类为配置类 @Configuration
扫描 Controller 所在的包 @ComponentScan
开启 Spring MVC 注解支持 @EnableWebMvc

在 config 目录下创建 Spring 配置类 SpringConfig：

@Configuration
@ComponentScan({"com.itheima.service"})
@PropertySource("jdbc.properties")
@Import({JdbcConfig.class,MyBatisConfig.class})
@EnableTransactionManagement
public class SpringConfig {
}

其中：

标识该类为配置类 @Configuration
扫描 Service 所在的包 @ComponentScan
在 Service 层要管理事务 @EnableTransactionManagement
读取外部的属性配置文件 @PropertySource
整合 MyBatis 需要引入相关配置类 @Import
- 第三方数据源配置类 JdbcConfig
  - 构建 DataSource 数据源 DruidDataSouroce，需要注入数据库连接四要素
  - 构建平台事务管理器 DataSourceTransactionManager
- MyBatis 配置类 MybatisConfig
  - 构建 SqlSessionFactoryBean 并设置别名扫描与数据源
  - 构建 MapperScannerConfigurer 并设置 Dao 层的包扫描

在 config 目录下创建 Web 项目入口配置类 ServletConfig：

public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    //加载 Spring 配置类
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }
    //加载 Spring MVC 配置类
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }
    //设置 Spring MVC 请求地址拦截规则
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
    //设置 POST 请求中文乱码过滤器
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("utf-8");
        return new Filter[]{filter};
    }
}

其中：

getRootConfigClasses()：返回 Spring 的配置类，需要 SpringConfig
getServletConfigClasses()：返回 Spring MVC 的配置类，需要 SpringMvcConfig 配置类
getServletMappings()：设置 Spring MVC 请求拦截路径规则
getServletFilters()：设置过滤器，解决 POST 请求中文乱码问题

功能模块

创建数据库及表：

create database ssm_db character set utf8;
use ssm_db;
create table tbl_book(
  id int primary key auto_increment,
  type varchar(20),
  name varchar(50),
  description varchar(255)
);
insert  into `tbl_book`(`id`,`type`,`name`,`description`) values (1,'计算机理论','Spring实战 第五版','Spring入门经典教程，深入理解Spring原理技术内幕'),(2,'计算机理论','Spring 5核心原理与30个类手写实践','十年沉淀之作，手写Spring精华思想'),(3,'计算机理论','Spring 5设计模式','深入Spring源码刨析Spring源码中蕴含的10大设计模式'),(4,'计算机理论','Spring MVC+Mybatis开发从入门到项目实战','全方位解析面向Web应用的轻量级框架，带你成为Spring MVC开发高手'),(5,'计算机理论','轻量级Java Web企业应用实战','源码级刨析Spring框架，适合已掌握Java基础的读者'),(6,'计算机理论','Java核心技术 卷Ⅰ 基础知识(原书第11版)','Core Java第11版，Jolt大奖获奖作品，针对Java SE9、10、11全面更新'),(7,'计算机理论','深入理解Java虚拟机','5个纬度全面刨析JVM,大厂面试知识点全覆盖'),(8,'计算机理论','Java编程思想(第4版)','Java学习必读经典，殿堂级著作！赢得了全球程序员的广泛赞誉'),(9,'计算机理论','零基础学Java(全彩版)','零基础自学编程的入门图书，由浅入深，详解Java语言的编程思想和核心技术'),(10,'市场营销','直播就这么做:主播高效沟通实战指南','李子柒、李佳奇、薇娅成长为网红的秘密都在书中'),(11,'市场营销','直播销讲实战一本通','和秋叶一起学系列网络营销书籍'),(12,'市场营销','直播带货:淘宝、天猫直播从新手到高手','一本教你如何玩转直播的书，10堂课轻松实现带货月入3W+');

创建模型类：

public class Book {
    private Integer id;
    private String type;
    private String name;
    private String description;
    //getter...setter...toString省略
}

创建 Dao 接口：

public interface BookDao {

//    @Insert("insert into tbl_book values(null,#{type},#{name},#{description})")
    @Insert("insert into tbl_book (type,name,description) values(#{type},#{name},#{description})")
    public void save(Book book);

    @Update("update tbl_book set type = #{type}, name = #{name}, description = #{description} where id = #{id}")
    public void update(Book book);

    @Delete("delete from tbl_book where id = #{id}")
    public void delete(Integer id);

    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);

    @Select("select * from tbl_book")
    public List<Book> getAll();
}

创建 Service 接口和实现类：

@Transactional
public interface BookService {
    /**
     * 保存
     * @param book
     * @return
     */
    public boolean save(Book book);

    /**
     * 修改
     * @param book
     * @return
     */
    public boolean update(Book book);

    /**
     * 按id删除
     * @param id
     * @return
     */
    public boolean delete(Integer id);

    /**
     * 按id查询
     * @param id
     * @return
     */
    public Book getById(Integer id);

    /**
     * 查询全部
     * @return
     */
    public List<Book> getAll();
}

@Service
public class BookServiceImpl implements BookService {
    @Autowired
    private BookDao bookDao;

    public boolean save(Book book) {
        bookDao.save(book);
        return true;
    }

    public boolean update(Book book) {
        bookDao.update(book);
        return true;
    }

    public boolean delete(Integer id) {
        bookDao.delete(id);
        return true;
    }

    public Book getById(Integer id) {
        return bookDao.getById(id);
    }

    public List<Book> getAll() {
        return bookDao.getAll();
    }
}

注意：bookDao 在 Service 中注入会出现红线提示，是因为要注入的代理对象需要在 Web 服务器启动的时候，由 Spring 的 IoC 容器来创建管理。此时没有启动，IDEA 在检测依赖关系的时候，没有找到适合的类注入，所以会提示错误，但是程序运行的时候，代理对象就会被创建，框架会使用 DI 进行注入，所以程序运行无影响。故可以可以不用理会该错误提示或者设置更改提示级别让 IDEA 不提示该错误。

创建 Contorller 类：

@RestController
@RequestMapping("/books")
public class BookController {

    @Autowired
    private BookService bookService;

    @PostMapping
    public boolean save(@RequestBody Book book) {
        return bookService.save(book);
    }

    @PutMapping
    public boolean update(@RequestBody Book book) {
        return bookService.update(book);
    }

    @DeleteMapping("/{id}")
    public boolean delete(@PathVariable Integer id) {
        return bookService.delete(id);
    }

    @GetMapping("/{id}")
    public Book getById(@PathVariable Integer id) {
        return bookService.getById(id);
    }

    @GetMapping
    public List<Book> getAll() {
        return bookService.getAll();
    }
}

单元测试

创建测试类，并注入 Service 类进行测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class BookServiceTest {

    @Autowired
    private BookService bookService;

    @Test
    public void testGetById(){
        Book book = bookService.getById(1);
        System.out.println(book);
    }

    @Test
    public void testGetAll(){
        List<Book> all = bookService.getAll();
        System.out.println(all);
    }

}

封装结果

将程序返回的结果以一种统一的格式返回给前端。

在 controller 包或者 domain 包下创建结果 Result 类：

public class Result {
    //描述统一格式中的数据
    private Object data;
    //描述统一格式中的编码，用于区分操作，可以简化配置  0或 1 表示成功失败
    private Integer code;
    //描述统一格式中的消息，可选属性
    private String msg;

    public Result() {
    }
	//构造方法是方便对象的创建
    public Result(Integer code,Object data) {
        this.data = data;
        this.code = code;
    }
	//构造方法是方便对象的创建
    public Result(Integer code, Object data, String msg) {
        this.data = data;
        this.code = code;
        this.msg = msg;
    }
	//setter...getter...省略
}

在 controller 包或者 domain 包下创建返回码 Code 类：

//状态码
public class Code {
    public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;

    public static final Integer SAVE_ERR = 20010;
    public static final Integer DELETE_ERR = 20020;
    public static final Integer UPDATE_ERR = 20030;
    public static final Integer GET_ERR = 20040;
}

修改 Controller 类的返回值：

//统一每一个控制器方法返回值
@RestController
@RequestMapping("/books")
public class BookController {

    @Autowired
    private BookService bookService;

    @PostMapping
    public Result save(@RequestBody Book book) {
        boolean flag = bookService.save(book);
        return new Result(flag ? Code.SAVE_OK:Code.SAVE_ERR,flag);
    }

    @PutMapping
    public Result update(@RequestBody Book book) {
        boolean flag = bookService.update(book);
        return new Result(flag ? Code.UPDATE_OK:Code.UPDATE_ERR,flag);
    }

    @DeleteMapping("/{id}")
    public Result delete(@PathVariable Integer id) {
        boolean flag = bookService.delete(id);
        return new Result(flag ? Code.DELETE_OK:Code.DELETE_ERR,flag);
    }

    @GetMapping("/{id}")
    public Result getById(@PathVariable Integer id) {
        Book book = bookService.getById(id);
        Integer code = book != null ? Code.GET_OK : Code.GET_ERR;
        String msg = book != null ? "" : "数据查询失败，请重试！";
        return new Result(code,book,msg);
    }

    @GetMapping
    public Result getAll() {
        List<Book> bookList = bookService.getAll();
        Integer code = bookList != null ? Code.GET_OK : Code.GET_ERR;
        String msg = bookList != null ? "" : "数据查询失败，请重试！";
        return new Result(code,bookList,msg);
    }
}

至此，返回结果就以一种统一的格式返回给前端。前端根据返回的结果，先从中获取 code，根据 code 判断，如果成功则取 data 中的值，如果失败，则取 msg 中的值进行提示。

处理异常

在 Spring MVC 中，统一异常处理是一个非常重要的功能，它允许开发者集中处理应用程序中发生的异常，而不是在每个控制器中单独处理。这有助于保持代码的整洁和可维护性。

异常的种类及出现异常的原因:

框架内部抛出的异常：因使用不合规导致
数据层抛出的异常：因外部服务器故障导致（例如：服务器访问超时）
业务层抛出的异常：因业务逻辑书写错误导致（例如：遍历业务书写操作，导致索引异常等）
表现层抛出的异常：因数据收集、校验等规则导致（例如：不匹配的数据类型间导致异常）
工具类抛出的异常：因工具类书写不严谨不够健壮导致（例如：必要释放的连接长期未释放等）

在处理异常之前，需要对异常进行一个分类:

业务异常（BusinessException）
- 规范的用户行为产生的异常
  - 用户在页面输入内容的时候未按照指定格式进行数据填写，例如在年龄框输入的是字符串
- 不规范的用户行为操作产生的异常
  - 例如用户故意传递错误数据
系统异常（SystemException）
- 项目运行过程中可预计但无法避免的异常
  - 例如数据库或服务器宕机
其他异常（Exception）
- 编程人员未预期到的异常，例如用到的文件不存在

针对以上各类异常，解决方案如下：

业务异常（BusinessException）
- 发送对应消息传递给用户，提醒规范操作
  - 常见的就是提示用户名已存在或密码格式不正确等
系统异常（SystemException）
- 发送固定消息传递给用户，安抚用户
  - 系统繁忙，请稍后再试
  - 系统正在维护升级，请稍后再试
  - 系统出问题，请联系系统管理员等
- 发送特定消息给运维人员，提醒维护
  - 可以发送短信、邮箱或者是公司内部通信软件
- 记录日志
  - 发消息和记录日志对用户来说是不可见的，属于后台程序
其他异常（Exception）
- 发送固定消息传递给用户，安抚用户
- 发送特定消息给编程人员，提醒维护（纳入预期范围内）
  - 一般是程序没有考虑全面，比如未做非空校验等
- 记录日志

具体实现：

在 exception 包下创建自定义异常类：

//自定义异常处理器，用于封装系统异常信息
public class SystemException extends RuntimeException{
    private Integer code;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public SystemException(Integer code, String message) {
        super(message);
        this.code = code;
    }

    public SystemException(Integer code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
    }

}

//自定义异常处理器，用于封装业务异常信息
public class BusinessException extends RuntimeException{
    private Integer code;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public BusinessException(Integer code, String message) {
        super(message);
        this.code = code;
    }

    public BusinessException(Integer code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
    }

}

说明：

让自定义异常类继承 RuntimeException 的好处是在抛出这两个异常的时候，就不用 try...catch... 或 throws 了。
自定义异常类中添加 code 属性的原因是为了更好的区分异常是来自哪个业务。

在 Code 类中新增需要的属性：

//状态码
public class Code {
    public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;

    public static final Integer SAVE_ERR = 20010;
    public static final Integer DELETE_ERR = 20020;
    public static final Integer UPDATE_ERR = 20030;
    public static final Integer GET_ERR = 20040;
    public static final Integer SYSTEM_ERR = 50001;
    public static final Integer SYSTEM_TIMEOUT_ERR = 50002;
    public static final Integer SYSTEM_UNKNOW_ERR = 59999;

    public static final Integer BUSINESS_ERR = 60002;
}

将其他异常包装成自定义异常：

public Book getById(Integer id) {
    //模拟业务异常，包装成自定义异常
    if(id == 1){
        throw new BusinessException(Code.BUSINESS_ERR,"请不要使用你的技术挑战我的耐性!");
    }
    //模拟系统异常，将可能出现的异常进行包装，转换成自定义异常
    try{
        int i = 1/0;
    }catch (Exception e){
        throw new SystemException(Code.SYSTEM_TIMEOUT_ERR,"服务器访问超时，请重试!",e);
    }
    return bookDao.getById(id);
}

具体的包装方式有：

方式一：使用 try...catch... 在 catch 中重新 throw 自定义异常即可。
方式二：直接 throw 自定义异常即可。

在 controller 包下创建异常处理器类拦截并处理自定义异常：

//@RestControllerAdvice 用于标识当前类为 REST 风格对应的异常处理器
@RestControllerAdvice
public class ProjectExceptionAdvice {
    //@ExceptionHandler 用于设置当前处理器类对应的异常类型
    @ExceptionHandler(SystemException.class)
    public Result doSystemException(SystemException ex){
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员,ex 对象发送给开发人员
        return new Result(ex.getCode(),null,ex.getMessage());
    }

    @ExceptionHandler(BusinessException.class)
    public Result doBusinessException(BusinessException ex){
        return new Result(ex.getCode(),null,ex.getMessage());
    }

    //除了自定义的异常处理器，保留对 Exception 类型的异常处理，用于处理非预期的异常
    @ExceptionHandler(Exception.class)
    public Result doOtherException(Exception ex){
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员,ex 对象发送给开发人员
        return new Result(Code.SYSTEM_UNKNOW_ERR,null,"系统繁忙，请稍后再试！");
    }
}

此时不管后台哪一层抛出异常，都会以与前端约定好的方式进行返回，前端只需要把信息获取到，根据返回的正确与否来展示不同的内容即可。

Interceptor

Spring MVC 拦截器（Interceptor）是 Spring MVC 框架中用于在请求处理流程中的某个点上拦截请求并执行某些操作的机制。它类似于 Servlet 规范中的过滤器（Filter），但拦截器是 Spring MVC 特有的，并且提供了更细粒度的控制，因为它可以访问到 Spring MVC 的许多核心对象，如 Handler、ModelAndView 等。

拦截器的主要用途包括：

日志记录：记录请求信息，如请求的 URL、请求参数、用户信息等。
性能监控：记录请求处理时间，用于性能分析。
身份验证和授权：检查用户是否已登录，是否有权访问请求的资源。
预处理和后处理：在请求处理前进行一些操作（如设置某些属性），或在请求处理后进行一些操作（如清理资源）。

拦截器和过滤器之间的区别如下：

归属不同：Filter 属于 Servlet 技术，Interceptor 属于 Spring MVC 技术
拦截内容不同：Filter 对所有访问进行增强，Interceptor 仅针对 Spring MVC 的访问进行增强。

入门案例

在 IDEA 中创建 Web 项目，在 pom.xml 文件中引入 Spring MVC 依赖：

<?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>com.itheima</groupId>
  <artifactId>springmvc_12_interceptor</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <dependencies>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <port>80</port>
          <path>/</path>
        </configuration>
      </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>8</source>
                <target>8</target>
            </configuration>
        </plugin>
    </plugins>
  </build>
</project>

创建对应的配置类：

public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }

    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    //乱码处理
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};
    }
}

@Configuration
@ComponentScan({"com.itheima.controller"})
@EnableWebMvc
public class SpringMvcConfig{
   
}

创建模型类：

public class Book {
    private String name;
    private double price;

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "书名='" + name + '\'' +
                ", 价格=" + price +
                '}';
    }
}

创建 Controller：

@RestController
@RequestMapping("/books")
public class BookController {

    @PostMapping
    public String save(@RequestBody Book book){
        System.out.println("book save..." + book);
        return "{'module':'book save'}";
    }

    @DeleteMapping("/{id}")
    public String delete(@PathVariable Integer id){
        System.out.println("book delete..." + id);
        return "{'module':'book delete'}";
    }

    @PutMapping
    public String update(@RequestBody Book book){
        System.out.println("book update..."+book);
        return "{'module':'book update'}";
    }

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("book getById..."+id);
        return "{'module':'book getById'}";
    }

    @GetMapping
    public String getAll(){
        System.out.println("book getAll...");
        return "{'module':'book getAll'}";
    }
}

在 controller 包下创建拦截器类，以便被 Spring MVC 容器扫描到。让类实现 HandlerInterceptor 接口，重写接口中的三个方法：

@Component
//定义拦截器类，实现 HandlerInterceptor 接口
//注意当前类必须受 Spring 容器控制
public class ProjectInterceptor implements HandlerInterceptor {
    @Override
    //原始方法调用前执行的内容
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle...");
        return true;
    }

    @Override
    //原始方法调用后执行的内容
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle...");
    }

    @Override
    //原始方法调用完成后执行的内容
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion...");
    }
}

HandlerInterceptor 接口定义了三个方法：

preHandle(HttpServletRequest request, HttpServletResponse response, Object handler): 在请求处理之前调用。如果返回 false，则请求不会继续传递给下一个拦截器或处理器，而是直接返回。
postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView): 在请求处理之后，但在视图渲染之前调用。此时可以修改 ModelAndView 对象。
afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex): 在整个请求处理完成后调用，即在视图渲染之后调用。通常用于清理资源。

关于拦截器的参数说明：

HttpServletRequest request: 这是当前 HTTP 请求的封装对象，包含了请求的所有信息，如请求头、请求参数等。
HttpServletResponse response: 这是 HTTP 响应的封装对象，用于设置响应状态码、响应头、发送响应体等。
Object handler: 这是处理请求的处理器对象，通常是HandlerMethod（对应 @RequestMapping 注解的方法）或 Controller 的实例。可以通过类型转换或反射来获取更具体的信息。
ModelAndView modelAndView: 这是一个可选参数，只在 postHandle 方法中存在。它包含了视图名称和模型数据，用于视图渲染。如果目标处理器没有返回 ModelAndView 对象（如返回了 String 类型的视图名称或 @ResponseBody 注解的响应体），则此参数为 Null。
Exception ex: 这是一个可选参数，只在 afterCompletion 方法中存在。如果请求处理过程中抛出了异常，这个参数将包含该异常对象；否则为 Null。

在 config 包下创建拦截器配置类：

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    @Autowired
    private ProjectInterceptor projectInterceptor;

    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        //配置拦截器
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books" );
    }
}

Spring MVC 增加对 SpringMvcSupport 的扫描：

@Configuration
@ComponentScan({"com.itheima.controller","com.itheima.config"})
@EnableWebMvc
public class SpringMvcConfig{
   
}

也可以直接在 Spring MVC 配置文件中实现 WebMvcConfigurer，配置拦截器：

@Configuration
@ComponentScan({"com.itheima.controller"})
@EnableWebMvc
//实现 WebMvcConfigurer 接口可以简化开发，但具有一定的侵入性
public class SpringMvcConfig implements WebMvcConfigurer {
    @Autowired
    private ProjectInterceptor projectInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //配置多拦截器
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");
    }
}

拦截器执行流程：

当有拦截器后，请求会先进入 preHandle 方法，

如果方法返回 true，则放行继续执行后面的 handle（Controller）的方法和后面的方法。

如果返回 false，则直接跳过后面方法的执行。

拦截器链

在Spring MVC中，拦截器可以配置成一个链（Chain），这个链中的拦截器会按照定义的顺序依次执行。当请求到达时，会按照配置的拦截器顺序执行 preHandle 方法，如果所有拦截器的 preHandle 方法都返回 true，则继续执行控制器（Controller）的方法；如果任何一个拦截器的 preHandle 方法返回 false，则整个请求结束，不会执行后续的拦截器和控制器方法。

在请求处理完成后，会按照拦截器链的逆序执行 postHandle 方法。最后，在所有请求处理都完成后，会按照拦截器链的逆序执行 afterCompletion 方法。

增加拦截器类：

@Component
public class ProjectInterceptor2 implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle...222");
        return false;
    }

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

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

配置拦截器：

@Configuration
@ComponentScan({"com.itheima.controller"})
@EnableWebMvc
//实现 WebMvcConfigurer 接口可以简化开发，但具有一定的侵入性
public class SpringMvcConfig implements WebMvcConfigurer {
    @Autowired
    private ProjectInterceptor projectInterceptor;
    @Autowired
    private ProjectInterceptor2 projectInterceptor2;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //配置多拦截器
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");
        registry.addInterceptor(projectInterceptor2).addPathPatterns("/books","/books/*");
    }
}

拦截器执行的顺序是和配置顺序有关，先进后出。

当配置多个拦截器时，形成拦截器链
拦截器链的运行顺序参照拦截器添加顺序为准
当拦截器中出现对原始处理器的拦截，后面的拦截器均终止运行
当拦截器运行中断，仅运行配置在前面的拦截器的 afterCompletion 操作

Spring MVC

# Spring MVC

# Start

# Request

# 请求路径

# 参数传递

# JSON

# 日期类型

# Response

# REST

# SSM

# 整合配置

# 功能模块

# 单元测试

# 封装结果

# 处理异常

# Interceptor

# 入门案例

# 拦截器链

Spring MVC

Start

Request

请求路径

参数传递

JSON

日期类型

Response

REST

SSM

整合配置

功能模块

单元测试

封装结果

处理异常

Interceptor

入门案例

拦截器链