SpringMVC详细介绍 zh-SSM整合（4）

我不是女神ヾ 2023-09-24 22:22 87阅读 0赞

**内容**

>  *  完成`SSM的整合开发`
>  *  能够理解并`实现统一结果封装与统一异常处理`
>  *  能够完成`前后台功能整合开发`
>  *  掌握`拦截器`的编写

# 1.SSM整合 #

前面我们已经把`Mybatis`、`Spring`和`SpringMVC`三个框架进行了学习，今天主要的内容就是把这三个框架整合在一起完成我们的业务功能开发，具体如何来整合，我们一步步来学习。

## 1) 流程分析 ##

(1) 创建工程

*  创建一个Maven的web工程
 *  pom.xml添加SSM需要的依赖jar包
 *  编写Web项目的入口配置类，实现`AbstractAnnotationConfigDispatcherServletInitializer`重写以下方法
    
     *  `getRootConfigClasses()` ：返回Spring的配置类->需要SpringConfig配置类
     *  `getServletConfigClasses()` ：返回SpringMVC的配置类->需要SpringMvcConfig配置类
     *  `getServletMappings()` : 设置SpringMVC请求拦截路径规则
     *  `getServletFilters()` ：设置过滤器，解决POST请求中文乱码问题

(2)SSM整合\[重点是各个配置的编写\]

*  SpringConfig
    
     *  标识该类为`配置类 @Configuration`
     *  `扫描Service`所在的包`@ComponentScan`
     *  在`Service层`要管理事务 `@EnableTransactionManagement`
     *  `读取外部的properties`配置文件 `@PropertySource`
     *  整合Mybatis需要引入Mybatis相关配置类 `@Import`
        
         *  第三方数据源配置类 `JdbcConfig`
            
             *  构建`DataSource数据源`，`DruidDataSouroce`,需要注入数据库连接四要素，`@Bean @Value`
             *  构建平台`事务管理器`，`DataSourceTransactionManager`,`@Bean`
         *  Mybatis配置类 `MybatisConfig`
            
             *  构建`SqlSessionFactoryBean`并设置`别名扫描与数据源`，`@Bean`
             *  构建`MapperScannerConfigurer`并设置`DAO层的包扫描`
 *  SpringMvcConfig
    
     *  标识该类为配置类 `@Configuration`
     *  扫描Controller所在的包`@ComponentScan`
     *  开启SpringMVC注解支持 `@EnableWebMvc`

(3)功能模块\[与具体的业务模块有关\]

*  创建数据库表
 *  根据数据库表创建对应的模型类
 *  通过`Dao层完成数据库表的增删改查(接口+自动代理)`
 *  编写`Service层[Service接口+实现类]`
    
     *  @Service
     *  @Transactional
     *  整合`Junit对业务层进行单元测试`
        
         *  `@RunWith`
         *  `@ContextConfiguration`
         *  `@Test`
 *  编写`Controller层`
    
     *  接收请求 `@RequestMapping @GetMapping @PostMapping @PutMapping @DeleteMapping`
     *  `接收数据 简单、POJO、嵌套POJO、集合、数组、JSON数据类型`
        
         *  `@RequestParam`
         *  `@PathVariable`
         *  `@RequestBody`
     *  `转发业务层`
        
         *  `@Autowired`
     *  `响应结果`
        
         *  `@ResponseBody`

## 2) 整合配置 ##

掌握上述的知识点后，接下来，我们就可以按照上述的步骤一步步的来完成SSM的整合。

### 步骤1：创建Maven的web项目 ###

可以使用Maven的骨架创建

![在这里插入图片描述][fdaa9ae38f754d3da3aa14b3e1232a9f.png]  
![在这里插入图片描述][c10c41a9b4be4164896b34189514c6fd.png]

### 步骤2:添加依赖 ###

pom.xml添加SSM所需要的依赖jar包

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

### 步骤3:创建项目包结构 ###

![在这里插入图片描述][08567b40df364796b4bdff67a86c89c3.png]

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

### 步骤4:创建SpringConfig配置类 ###

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

### 步骤5:创建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;
        }
    }

### 步骤6:创建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;
        }
    }

### 步骤7:创建jdbc.properties ###

在resources下提供jdbc.properties,设置数据库连接四要素

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

### 步骤8:创建SpringMVC配置类 ###

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

### 步骤9:创建Web项目入口配置类 ###

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

至此SSM整合的环境就已经搭建好了。在这个环境上，我们如何进行功能模块的开发呢?

## 3) 功能模块开发 ##

> 需求:对表tbl\_book进行新增、修改、删除、根据ID查询和查询所有

### 步骤1:创建数据库及表 ###

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+');

### 步骤2:编写模型类 ###

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

### 步骤3:编写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();
    }

### 步骤4:编写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中注入的会提示一个红线提示，为什么呢?
    
     *  `BookDao是一个接口`，没有实现类，接口是不能创建对象的，所以`最终注入的应该是代理对象`
     *  代理对象是由`Spring的IOC容器`来创建管理的
     *  `IOC容器`又是在`Web服务器启动`的时候才会创建
     *  `IDEA在检测依赖关系的时候，没有找到适合的类注入，所以会提示错误提示`
     *  但是程序运行的时候，`代理对象就会被创建，框架会使用DI进行注入，所以程序运行无影响。`
 *  如何解决上述问题?
    
     *  可以不用理会，因为运行是正常的
     *  设置错误提示级别

![在这里插入图片描述][4280931bb9fc4066abe2f09f32a457b1.png]

### 步骤5:编写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();
        }
    }

对于图书模块的增删改查就已经完成了编写，我们可以从后往前写也可以从前往后写，最终只需要能把功能实现即可。

接下来我们就先把业务层的代码使用`Spring整合Junit`的知识点进行单元测试:

## 4) 单元测试 ##

### 步骤1:新建测试类 ###

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

### 步骤2:注入Service类 ###

### 步骤3:编写测试方法 ###

我们先来对查询进行单元测试。

@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);
        }
    
    }

根据ID查询，测试的结果为:

![在这里插入图片描述][65a87f4753384d4981e1b89863a17432.png]

查询所有，测试的结果为:

![在这里插入图片描述][1660b3683e874c2696cdb0a9f362934b.png]

## 5) PostMan测试 ##

#### 新增 ####

`http://localhost/books`

{
        
    	"type":"类别测试数据",
        "name":"书名测试数据",
        "description":"描述测试数据"
    }

![在这里插入图片描述][f509351caa614e28b63ed50075e80920.png]

#### 修改 ####

`http://localhost/books`

{
        
        "id":13,
    	"type":"类别测试数据",
        "name":"书名测试数据",
        "description":"描述测试数据"
    }

![在这里插入图片描述][8c67039bd7fd47c89bc6e118edf6bcfe.png]

#### 删除 ####

`http://localhost/books/14`

![在这里插入图片描述][01c1ba3995bb49f9b167c59863cb670c.png]

#### 查询单个 ####

`http://localhost/books/1`

![在这里插入图片描述][ba6667fa371843c2ae7725c7c788a52e.png]

#### 查询所有 ####

`http://localhost/books`

![在这里插入图片描述][a324b924a87348eaa26861e62518e0f5.png]

# 2.统一结果封装 #

## 1) 表现层与前端数据传输协议定义 ##

SSM整合以及功能模块开发完成后，接下来，我们在上述案例的基础上分析下有哪些问题需要我们去解决下。首先第一个问题是:

*  在Controller层增删改`返回给前端的是boolean类型数据`  
    ![在这里插入图片描述][8340a1070121462590cd853bdbf08bcd.png]
 *  在Controller层查询单个`返回给前端的是对象`

![在这里插入图片描述][d957c00bbe0b4aebb9710ed88df22723.png]

*  在Controller层查询所有`返回给前端的是集合对象`

![在这里插入图片描述][08de9c1de3584868a13ef2272b61145f.png]

目前我们就已经有三种数据类型返回给前端，如果随着业务的增长，我们需要返回的数据类型会越来越多。对于前端开发人员在解析数据的时候就比较凌乱了，所以对于前端来说，如果后台能够返回一个统一的数据结果，前端在解析的时候就可以按照一种方式进行解析。开发就会变得更加简单。

所以我们就想能不能将返回结果的数据进行统一，具体如何来做，大体的思路为:

*  为了封装返回的结果数据:创建结果模型类，封装数据到data属性中
 *  为了封装返回的数据是何种操作及是否操作成功:封装操作结果到code属性中
 *  操作失败后为了封装返回的错误信息:封装特殊消息到message(msg)属性中

![在这里插入图片描述][02d827906c7c4495bac944eed33001fb.png]

根据分析，我们可以设置统一数据返回结果类

public class Result{
        
    	private Object data;
    	private Integer code;
    	private String msg;
    }

**注意:** `Result类名及类中的字段并不是固定的`，可以根据需要自行增减提供若干个构造方法，方便操作。

## 2) 表现层与前端数据传输协议实现 ##

前面我们已经分析了如何封装返回结果数据，具体在项目中该如何实现，我们通过个例子来操作一把

### (1) 环境准备 ###

*  创建一个Web的Maven项目
 *  pom.xml添加SSM整合所需jar包
 *  创建对应的配置类
 *  编写Controller、Service接口、Service实现类、Dao接口和模型类
 *  resources下提供jdbc.properties配置文件

因为这个项目环境的内容和SSM整合的内容是一致的，所以我们就不在把代码粘出来了，大家在练习的时候可以在前面整合的例子案例环境下，进行本节内容的开发。

最终创建好的项目结构如下:

![在这里插入图片描述][373aa154b14f45bc9b210ac5fec76030.png]

### (2) 结果封装 ###

对于结果封装，我们应该是在表现层进行处理，所以我们把结果类放在controller包下，当然你也可以放在domain包，这个都是可以的，具体如何实现结果封装，具体的步骤为:

#### 步骤1:创建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...省略
    }

#### 步骤2:定义返回码Code类 ####

\*\*注意:\*\*code类中的常量设计也不是固定的，可以根据需要自行增减，例如将查询再进行细分为GET\_OK,GET\_ALL\_OK,GET\_PAGE\_OK等。

#### 步骤3:修改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);
        }
    }

#### 步骤4:启动服务测试 ####

![在这里插入图片描述][eed9618151b84d6e86f51f6179ae256c.png]  
![在这里插入图片描述][ae708c1d592f431d9024672f7b09e7f7.png]

至此，我们的返回结果就已经能以一种统一的格式返回给前端。前端根据返回的结果，先从中获取`code`,根据code判断，如果成功则取`data`属性的值，如果失败，则取`msg`中的值做提示。

# 3.统一异常处理 #

## 1)问题描述 ##

在讲解这一部分知识点之前，我们先来演示个效果，修改BookController类的`getById`方法

@GetMapping("/{id}")
    public Result getById(@PathVariable Integer id) {
        
        //手动添加一个错误信息
        if(id==1){
        
            int i = 1/0;
        }
        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);
    }

重新启动运行项目，使用PostMan发送请求，当传入的id为1，则会出现如下效果：

![在这里插入图片描述][e409a74a53e8409e89ab5dc777c0ef99.png]

前端接收到这个信息后和之前我们约定的格式不一致，这个问题该如何解决?

在解决问题之前，我们先来看下异常的种类及出现异常的原因:

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

看完上面这些出现异常的位置，你会发现，在我们开发的任何一个位置都有可能出现异常，而且这些异常是不能避免的。所以我们就得将异常进行处理。

**思考**

`1. 各个层级均出现异常，异常处理代码书写在哪一层?`

所有的异常均抛出到表现层进行处理

`2. 异常的种类很多，表现层如何将所有的异常都处理到呢?`

异常分类

`3. 表现层处理异常，每个方法中单独书写，代码书写量巨大且意义不强，如何解决?`

AOP

对于上面这些问题及解决方案，SpringMVC已经为我们提供了一套解决方案:

*  异常处理器:
    
     *  集中的、统一的处理项目中出现的异常。

![在这里插入图片描述][00d85892e2da48998d2f23204a04dc5e.png]

## 2) 异常处理器的使用 ##

### 1 环境准备 ###

内容参考前面的项目或者直接使用前面的项目进行本节内容的学习。

最终创建好的项目结构如下:

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9k9A2qhi-1678216274004)(assets/1630657972564.png)\]

### 2 使用步骤 ###

#### 步骤1:创建异常处理器类 ####

//@RestControllerAdvice用于标识当前类为REST风格对应的异常处理器
    @RestControllerAdvice
    public class ProjectExceptionAdvice {
        
        //除了自定义的异常处理器，保留对Exception类型的异常处理，用于处理非预期的异常
        @ExceptionHandler(Exception.class)
        public void doException(Exception ex){
        
          	System.out.println("嘿嘿,异常你哪里跑！")
        }
    }

确保SpringMvcConfig能够扫描到异常处理器类

#### 步骤2:让程序抛出异常 ####

修改`BookController`的getById方法，添加`int i = 1/0`.

@GetMapping("/{id}")
    public Result getById(@PathVariable Integer id) {
        
      	int i = 1/0;
        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);
    }

#### 步骤3:运行程序，测试 ####

![在这里插入图片描述][d205eb107d7a4724bbda3149996c6da5.png]

说明异常已经被拦截并执行了`doException`方法。

#### 异常处理器类返回结果给前端 ####

//@RestControllerAdvice用于标识当前类为REST风格对应的异常处理器
    @RestControllerAdvice
    public class ProjectExceptionAdvice {
        
        //除了自定义的异常处理器，保留对Exception类型的异常处理，用于处理非预期的异常
        @ExceptionHandler(Exception.class)
        public Result doException(Exception ex){
        
          	System.out.println("嘿嘿,异常你哪里跑！")
            return new Result(666,null,"嘿嘿,异常你哪里跑！");
        }
    }

启动运行程序，测试

![在这里插入图片描述][adc5ffe45cc74ff4b9dceb5557c317e6.png]

至此，就算后台执行的过程中抛出异常，最终也能按照我们和前端约定好的格式返回给前端。

#### 知识点1：@RestControllerAdvice ####

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@RestControllerAdvice</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>类注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>Rest风格开发的控制器增强类定义上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>为Rest风格开发的控制器类做增强</td> 
  </tr> 
 </tbody> 
</table>

**说明:**  
此注解自带@ResponseBody注解与@Component注解，具备对应的功能

![在这里插入图片描述][92740357ccee40feaddddb76cfbfb849.png]

#### 知识点2：@ExceptionHandler ####

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@ExceptionHandler</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>方法注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>专用于异常处理的控制器方法上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置指定异常的处理方案，功能等同于控制器方法，<br>出现异常后终止原始控制器执行,并转入当前方法执行</td> 
  </tr> 
 </tbody> 
</table>

\*\*说明：\*\*此类方法可以根据处理的异常不同，制作多个方法分别处理对应的异常

## 3) 项目异常处理方案 ##

### 1 异常分类 ###

异常处理器我们已经能够使用了，那么在咱们的项目中该如何来处理异常呢?

因为异常的种类有很多，如果每一个异常都对应一个`@ExceptionHandler`，那得写多少个方法来处理各自的异常，所以我们在处理异常之前，需要对异常进行一个分类:

*  业务异常（BusinessException）
    
     *  规范的用户行为产生的异常
        
         *  用户在页面输入内容的时候未按照指定格式进行数据填写，如在年龄框输入的是字符串

![在这里插入图片描述][9e96dd8614224ec99e495911cf078abc.png]

*  不规范的用户行为操作产生的异常
    
     *  如用户故意传递错误数据
    
    ![在这里插入图片描述][02ae784e051043828cfcd804001e8e00.png]
 *  系统异常（SystemException）
    
     *  项目运行过程中可预计但无法避免的异常
        
         *  比如数据库或服务器宕机
 *  其他异常（Exception）
    
     *  编程人员未预期到的异常，如:用到的文件不存在

![在这里插入图片描述][39cab701780c41b489b0b104c1a52692.png]

将异常分类以后，针对不同类型的异常，要提供具体的解决方案:

### 2 异常解决方案 ###

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

### 3 异常解决方案的具体实现 ###

> 思路:
> 
> 1.先通过自定义异常，完成`BusinessException`和`SystemException`的定义
> 
> 2.将其他异常包装成自定义异常类型
> 
> 3.在异常处理器类中对不同的异常进行处理

#### 步骤1:自定义异常类 ####

//自定义异常处理器，用于封装异常信息，对异常进行分类
    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`属性的原因是`为了更好的区分异常是来自哪个业务的`

#### 步骤2:将其他异常包成自定义异常 ####

假如在BookServiceImpl的getById方法抛异常了，该如何来包装呢?

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自定义异常即可

上面为了使`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;
    }

#### 步骤3:处理器类中处理自定义异常 ####

//@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,"系统繁忙，请稍后再试！");
        }
    }

#### 步骤4:运行程序 ####

根据ID查询，

如果传入的参数为1，会报`BusinessException`

![在这里插入图片描述][faf4ab29429c49e8b8f61d12f1fd9b1d.png]

如果传入的是其他参数，会报`SystemException`

![在这里插入图片描述][6a4b58f85ebb4bfab7ba3e47cecbe8e3.png]

对于异常我们就已经处理完成了，不管后台哪一层抛出异常，都会以我们与前端约定好的方式进行返回，前端只需要把信息获取到，根据返回的正确与否来展示不同的内容即可。

**小结**

以后项目中的异常处理方式为:

![在这里插入图片描述][d1fe3f585e3441219e45f47ac258e2f5.png]

# 4.前后台协议联调 #

## 1) 环境准备 ##

内容参考前面的项目或者直接使用前面的项目进行本节内容的学习。

最终创建好的项目结构如下:

![在这里插入图片描述][3c49cfd787b94089a96c5e71452be982.png]

1.  将`资料\SSM功能页面`下面的静态资源拷贝到webapp下。

![在这里插入图片描述][bd0b2ccc176342d2afdecbc1d34aa933.png]

1.  因为添加了静态资源，SpringMVC会拦截，所有需要在SpringConfig的配置类中将静态资源进行放行。

*  新建SpringMvcSupport
    
        @Configuration
        public class SpringMvcSupport extends WebMvcConfigurationSupport {
              
            @Override
            protected void addResourceHandlers(ResourceHandlerRegistry registry) {
              
                registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
                registry.addResourceHandler("/css/**").addResourceLocations("/css/");
                registry.addResourceHandler("/js/**").addResourceLocations("/js/");
                registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
            }
        }
 *  在SpringMvcConfig中扫描SpringMvcSupport
    
        @Configuration
        @ComponentScan({
              "com.itheima.controller","com.itheima.config"})
        @EnableWebMvc
        public class SpringMvcConfig {
              
        }

接下来我们就需要将所有的列表查询、新增、修改、删除等功能一个个来实现下。

## 2) 列表功能 ##

![在这里插入图片描述][f92c77a98a974bf69e481c6665016ed3.png]

> 需求:页面加载完后发送异步请求到后台获取列表数据进行展示。
> 
> 1.找到页面的钩子函数，`created()`
> 
> 2.`created()`方法中调用了`this.getAll()`方法
> 
> 3.在getAll()方法中使用axios发送异步请求从后台获取数据
> 
> 4.访问的路径为`http://localhost/books`
> 
> 5.返回数据

返回数据res.data的内容如下:

{
        
        "data": [
            {
        
                "id": 1,
                "type": "计算机理论",
                "name": "Spring实战 第五版",
                "description": "Spring入门经典教程，深入理解Spring原理技术内幕"
            },
            {
        
                "id": 2,
                "type": "计算机理论",
                "name": "Spring 5核心原理与30个类手写实践",
                "description": "十年沉淀之作，手写Spring精华思想"
            },...
        ],
        "code": 20041,
        "msg": ""
    }

发送方式:

getAll() {
        
        //发送ajax请求
        axios.get("/books").then((res)=>{
        
            this.dataList = res.data.data;
        });
    }

![在这里插入图片描述][4b119ba1c95d41988f0cab5bb9065fa7.png]

## 3) 添加功能 ##

![在这里插入图片描述][8f78026c61344a01a94bf328a21a6b5c.png]

> 需求:完成图片的新增功能模块
> 
> 1.找到页面上的`新建`按钮，按钮上绑定了`@click="handleCreate()"`方法
> 
> 2.在method中找到`handleCreate`方法，方法中打开新增面板
> 
> 3.新增面板中找到`确定`按钮,按钮上绑定了`@click="handleAdd()"`方法
> 
> 4.在method中找到`handleAdd`方法
> 
> 5.在方法中发送请求和数据，响应成功后将新增面板关闭并重新查询数据

`handleCreate`打开新增面板

handleCreate() {
        
        this.dialogFormVisible = true;
    },

`handleAdd`方法发送异步请求并携带数据

handleAdd () {
        
        //发送ajax请求
        //this.formData是表单中的数据，最后是一个json数据
        axios.post("/books",this.formData).then((res)=>{
        
            this.dialogFormVisible = false;
            this.getAll();
        });
    }

## 4) 添加功能状态处理 ##

基础的新增功能已经完成，但是还有一些问题需要解决下:

> 需求:新增成功是关闭面板，重新查询数据，那么新增失败以后该如何处理?
> 
> 1.在handlerAdd方法中根据后台返回的数据来进行不同的处理
> 
> 2.如果后台返回的是成功，则提示成功信息，并关闭面板
> 
> 3.如果后台返回的是失败，则提示错误信息

(1)修改前端页面

handleAdd () {
        
        //发送ajax请求
        axios.post("/books",this.formData).then((res)=>{
        
            //如果操作成功，关闭弹层，显示数据
            if(res.data.code == 20011){
        
                this.dialogFormVisible = false;
                this.$message.success("添加成功");
            }else if(res.data.code == 20010){
        
                this.$message.error("添加失败");
            }else{
        
                this.$message.error(res.data.msg);
            }
        }).finally(()=>{
        
            this.getAll();
        });
    }

(2)后台返回操作结果，将Dao层的增删改方法返回值从`void`改成`int`

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 int save(Book book);
    
        @Update("update tbl_book set type = #{type}, name = #{name}, description = #{description} where id = #{id}")
        public int update(Book book);
    
        @Delete("delete from tbl_book where id = #{id}")
        public int 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();
    }

(3)在BookServiceImpl中，增删改方法根据DAO的返回值来决定返回true/false

@Service
    public class BookServiceImpl implements BookService {
        
        @Autowired
        private BookDao bookDao;
    
        public boolean save(Book book) {
        
            return bookDao.save(book) > 0;
        }
    
        public boolean update(Book book) {
        
            return bookDao.update(book) > 0;
        }
    
        public boolean delete(Integer id) {
        
            return bookDao.delete(id) > 0;
        }
    
        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);
        }
    
        public List<Book> getAll() {
        
            return bookDao.getAll();
        }
    }

(4)测试错误情况，将图书类别长度设置超出范围即可

![在这里插入图片描述][024b2998befc456b9eda6c16c961cfc1.png]

处理完新增后，会发现新增还存在一个问题，

新增成功后，再次点击`新增`按钮会发现之前的数据还存在，这个时候就需要在新增的时候将表单内容清空。

resetForm(){
        
    	this.formData = {
        };
    }
    handleCreate() {
        
        this.dialogFormVisible = true;
        this.resetForm();
    }

## 5) 修改功能 ##

![在这里插入图片描述][5347115f731244fb9d4074caaacfbe86.png]

> 需求:完成图书信息的修改功能
> 
> 1.找到页面中的`编辑`按钮，该按钮绑定了`@click="handleUpdate(scope.row)"`
> 
> 2.在method的`handleUpdate`方法中发送异步请求根据ID查询图书信息
> 
> 3.根据后台返回的结果，判断是否查询成功
> 
> 如果查询成功打开修改面板回显数据，如果失败提示错误信息
> 
> 4.修改完成后找到修改面板的`确定`按钮，该按钮绑定了`@click="handleEdit()"`
> 
> 5.在method的`handleEdit`方法中发送异步请求提交修改数据
> 
> 6.根据后台返回的结果，判断是否修改成功
> 
> 如果成功提示错误信息，关闭修改面板，重新查询数据，如果失败提示错误信息

scope.row代表的是当前行的行数据，也就是说,scope.row就是选中行对应的json数据，如下:

{
        
        "id": 1,
        "type": "计算机理论",
        "name": "Spring实战 第五版",
        "description": "Spring入门经典教程，深入理解Spring原理技术内幕"
    }

修改`handleUpdate`方法

//弹出编辑窗口
    handleUpdate(row) {
        
        // console.log(row);   //row.id 查询条件
        //查询数据，根据id查询
        axios.get("/books/"+row.id).then((res)=>{
        
            if(res.data.code == 20041){
        
                //展示弹层，加载数据
                this.formData = res.data.data;
                this.dialogFormVisible4Edit = true;
            }else{
        
                this.$message.error(res.data.msg);
            }
        });
    }

修改`handleEdit`方法

handleEdit() {
        
        //发送ajax请求
        axios.put("/books",this.formData).then((res)=>{
        
            //如果操作成功，关闭弹层，显示数据
            if(res.data.code == 20031){
        
                this.dialogFormVisible4Edit = false;
                this.$message.success("修改成功");
            }else if(res.data.code == 20030){
        
                this.$message.error("修改失败");
            }else{
        
                this.$message.error(res.data.msg);
            }
        }).finally(()=>{
        
            this.getAll();
        });
    }

至此修改功能就已经完成。

## 6) 删除功能 ##

![在这里插入图片描述][2d169aa1b2704ddcb883df2ab11578e6.png]

> 需求:完成页面的删除功能。
> 
> 1.找到页面的删除按钮，按钮上绑定了`@click="handleDelete(scope.row)"`
> 
> 2.method的`handleDelete`方法弹出提示框
> 
> 3.用户点击取消,提示操作已经被取消。
> 
> 4.用户点击确定，发送异步请求并携带需要删除数据的主键ID
> 
> 5.根据后台返回结果做不同的操作
> 
> 如果返回成功，提示成功信息，并重新查询数据
> 
> 如果返回失败，提示错误信息，并重新查询数据

修改`handleDelete`方法

handleDelete(row) {
        
        //1.弹出提示框
        this.$confirm("此操作永久删除当前数据，是否继续？","提示",{
        
            type:'info'
        }).then(()=>{
        
            //2.做删除业务
            axios.delete("/books/"+row.id).then((res)=>{
        
                if(res.data.code == 20021){
        
                    this.$message.success("删除成功");
                }else{
        
                    this.$message.error("删除失败");
                }
            }).finally(()=>{
        
                this.getAll();
            });
        }).catch(()=>{
        
            //3.取消删除
            this.$message.info("取消删除操作");
        });
    }

接下来，下面是一个完整页面

<!DOCTYPE html>
    
    <html>
    
        <head>
    
            
    
            <meta charset="utf-8">
    
            <meta http-equiv="X-UA-Compatible" content="IE=edge">
    
            <title>SpringMVC案例</title>
    
            <meta content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no" name="viewport">
    
            
    
            <link rel="stylesheet" href="../plugins/elementui/index.css">
    
            <link rel="stylesheet" href="../plugins/font-awesome/css/font-awesome.min.css">
    
            <link rel="stylesheet" href="../css/style.css">
    
        </head>
    
        <body class="hold-transition">
    
            <div id="app">
    
                <div class="content-header">
    
                    <h1>图书管理</h1>
    
                </div>
    
                <div class="app-container">
    
                    <div class="box">
    
                        <div class="filter-container">
    
                            <el-input placeholder="图书名称" v-model="pagination.queryString" style="width: 200px;" class="filter-item"></el-input>
    
                            <el-button @click="getAll()" class="dalfBut">查询</el-button>
    
                            <el-button type="primary" class="butT" @click="handleCreate()">新建</el-button>
    
                        </div>
    
                        <el-table size="small" current-row-key="id" :data="dataList" stripe highlight-current-row>
    
                            <el-table-column type="index" align="center" label="序号"></el-table-column>
    
                            <el-table-column prop="type" label="图书类别" align="center"></el-table-column>
    
                            <el-table-column prop="name" label="图书名称" align="center"></el-table-column>
    
                            <el-table-column prop="description" label="描述" align="center"></el-table-column>
    
                            <el-table-column label="操作" align="center">
    
                                <template slot-scope="scope">
    
                                    <el-button type="primary" size="mini" @click="handleUpdate(scope.row)">编辑</el-button>
    
                                    <el-button type="danger" size="mini" @click="handleDelete(scope.row)">删除</el-button>
    
                                </template>
    
                            </el-table-column>
    
                        </el-table>
    
                        
    
                        <div class="add-form">
    
                            <el-dialog title="新增图书" :visible.sync="dialogFormVisible">
    
                                <el-form ref="dataAddForm" :model="formData" :rules="rules" label-position="right" label-width="100px">
    
                                    <el-row>
    
                                        <el-col :span="12">
    
                                            <el-form-item label="图书类别" prop="type">
    
                                                <el-input v-model="formData.type"/>
    
                                            </el-form-item>
    
                                        </el-col>
    
                                        <el-col :span="12">
    
                                            <el-form-item label="图书名称" prop="name">
    
                                                <el-input v-model="formData.name"/>
    
                                            </el-form-item>
    
                                        </el-col>
    
                                    </el-row>
    
    
                                    <el-row>
    
                                        <el-col :span="24">
    
                                            <el-form-item label="描述">
    
                                                <el-input v-model="formData.description" type="textarea"></el-input>
    
                                            </el-form-item>
    
                                        </el-col>
    
                                    </el-row>
    
                                </el-form>
    
                                <div slot="footer" class="dialog-footer">
    
                                    <el-button @click="dialogFormVisible = false">取消</el-button>
    
                                    <el-button type="primary" @click="handleAdd()">确定</el-button>
    
                                </div>
    
                            </el-dialog>
    
                        </div>
    
                        
    
                        <div class="add-form">
    
                            <el-dialog title="编辑检查项" :visible.sync="dialogFormVisible4Edit">
    
                                <el-form ref="dataEditForm" :model="formData" :rules="rules" label-position="right" label-width="100px">
    
                                    <el-row>
    
                                        <el-col :span="12">
    
                                            <el-form-item label="图书类别" prop="type">
    
                                                <el-input v-model="formData.type"/>
    
                                            </el-form-item>
    
                                        </el-col>
    
                                        <el-col :span="12">
    
                                            <el-form-item label="图书名称" prop="name">
    
                                                <el-input v-model="formData.name"/>
    
                                            </el-form-item>
    
                                        </el-col>
    
                                    </el-row>
    
                                    <el-row>
    
                                        <el-col :span="24">
    
                                            <el-form-item label="描述">
    
                                                <el-input v-model="formData.description" type="textarea"></el-input>
    
                                            </el-form-item>
    
                                        </el-col>
    
                                    </el-row>
    
                                </el-form>
    
                                <div slot="footer" class="dialog-footer">
    
                                    <el-button @click="dialogFormVisible4Edit = false">取消</el-button>
    
                                    <el-button type="primary" @click="handleEdit()">确定</el-button>
    
                                </div>
    
                            </el-dialog>
    
                        </div>
    
                    </div>
    
                </div>
    
            </div>
    
        </body>
    
        
    
        <script src="../js/vue.js"></script>
    
        <script src="../plugins/elementui/index.js"></script>
    
        <script type="text/javascript" src="../js/jquery.min.js"></script>
    
        <script src="../js/axios-0.18.0.js"></script>
    
        <script>
            var vue = new Vue({
          
    
                el: '#app',
                data:{
          
                    pagination: {
          },
    				dataList: [],//当前页要展示的列表数据
                    formData: {
          },//表单数据
                    dialogFormVisible: false,//控制表单是否可见
                    dialogFormVisible4Edit:false,//编辑表单是否可见
                    rules: {
          //校验规则
                        type: [{
           required: true, message: '图书类别为必填项', trigger: 'blur' }],
                        name: [{
           required: true, message: '图书名称为必填项', trigger: 'blur' }]
                    }
                },
    
                //钩子函数，VUE对象初始化完成后自动执行
                created() {
          
                    this.getAll();
                },
    
                methods: {
          
                    //列表
                    getAll() {
          
                        //发送ajax请求
                        axios.get("/books").then((res)=>{
          
                            this.dataList = res.data.data;
                        });
                    },
    
                    //弹出添加窗口
                    handleCreate() {
          
                        this.dialogFormVisible = true;
                        this.resetForm();
                    },
    
                    //重置表单
                    resetForm() {
          
                        this.formData = {
          };
                    },
    
                    //添加
                    handleAdd () {
          
                        //发送ajax请求
                        axios.post("/books",this.formData).then((res)=>{
          
                            console.log(res.data);
                            //如果操作成功，关闭弹层，显示数据
                            if(res.data.code == 20011){
          
                                this.dialogFormVisible = false;
                                this.$message.success("添加成功");
                            }else if(res.data.code == 20010){
          
                                this.$message.error("添加失败");
                            }else{
          
                                this.$message.error(res.data.msg);
                            }
                        }).finally(()=>{
          
                            this.getAll();
                        });
                    },
    
                    //弹出编辑窗口
                    handleUpdate(row) {
          
                        // console.log(row);   //row.id 查询条件
                        //查询数据，根据id查询
                        axios.get("/books/"+row.id).then((res)=>{
          
                            // console.log(res.data.data);
                            if(res.data.code == 20041){
          
                                //展示弹层，加载数据
                                this.formData = res.data.data;
                                this.dialogFormVisible4Edit = true;
                            }else{
          
                                this.$message.error(res.data.msg);
                            }
                        });
                    },
    
                    //编辑
                    handleEdit() {
          
                        //发送ajax请求
                        axios.put("/books",this.formData).then((res)=>{
          
                            //如果操作成功，关闭弹层，显示数据
                            if(res.data.code == 20031){
          
                                this.dialogFormVisible4Edit = false;
                                this.$message.success("修改成功");
                            }else if(res.data.code == 20030){
          
                                this.$message.error("修改失败");
                            }else{
          
                                this.$message.error(res.data.msg);
                            }
                        }).finally(()=>{
          
                            this.getAll();
                        });
                    },
    
                    // 删除
                    handleDelete(row) {
          
                        //1.弹出提示框
                        this.$confirm("此操作永久删除当前数据，是否继续？","提示",{
          
                            type:'info'
                        }).then(()=>{
          
                            //2.做删除业务
                            axios.delete("/books/"+row.id).then((res)=>{
          
                                if(res.data.code == 20021){
          
                                    this.$message.success("删除成功");
                                }else{
          
                                    this.$message.error("删除失败");
                                }
                            }).finally(()=>{
          
                                this.getAll();
                            });
                        }).catch(()=>{
          
                            //3.取消删除
                            this.$message.info("取消删除操作");
                        });
                    }
                }
            })
    
        </script>
    
    </html>

# 5.拦截器 #

对于拦截器这节的知识，我们需要学习如下内容:

*  拦截器概念
 *  入门案例
 *  拦截器参数
 *  拦截器工作流程分析

## 1) 拦截器概念 ##

讲解拦截器的概念之前，我们先看一张图:

![在这里插入图片描述][891d328d12884f80bb724f03a4ef710c.png]

(1)`浏览器`发送一个请求会先到`Tomcat的web服务器`

(2)Tomcat服务器`接收到请求以后`，会去判断请求的是`静态资源还是动态资源`

(3)如果是`静态资源`，会直接到`Tomcat的项目部署目录下去直接访问`

(4)如果是`动态资源`，就需要`交给项目的后台代码进行处理`

(5)在找到具体的方法之前，我们可以去`配置过滤器(可以配置多个)`，按照顺序进行执行

(6)然后进入到到`中央处理器(SpringMVC中的内容)`，S`pringMVC会根据配置的规则进行拦截`

(7)`如果满足规则，则进行处理`，`找到其对应的controller类中的方法进行执行,完成后返回结果`

(8)如果`不满足规则`，则不进行处理

(9)这个时候，如果我们需要在每个Controller方法执行的前后添加业务，具体该如何来实现?

这个就是拦截器要做的事。

*  `拦截器（Interceptor）`是一种`动态拦截方法调用的机制`，在SpringMVC中`动态拦截控制器方法的执行`
 *  作用:
    
     *  在`指定的方法调用前后执行预先设定的代码`
     *  `阻止原始方法的执行`
     *  总结：拦截器就是用来做增强

看完以后，大家会发现

*  拦截器和过滤器在作用和执行顺序上也很相似

所以这个时候，就有一个问题需要思考==:拦截器和过滤器之间的区别是什么?==

*  `归属不同`：`Filter属于Servlet技术`，`Interceptor属于SpringMVC技术`  
    \-`拦截内容不同`：`Filter对所有访问进行增强`，`Interceptor仅针对SpringMVC的访问进行增强`

![在这里插入图片描述][ef49617b0c6647aab160b5f63d701890.png]

## 2 ) 拦截器入门案例 ##

### 1 环境准备 ###

*  创建一个Web的Maven项目
 *  pom.xml添加SSM整合所需jar包
    
        <?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{
              
           
        }
 *  创建模型类Book
    
        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'}";
            }
        }

最终创建好的项目结构如下:

![在这里插入图片描述][7b4ac1fd46944157ac79ba72d80737a8.png]

### 2 拦截器开发 ###

#### 步骤1:创建拦截器类 ####

让类实现`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...");
        }
    }

**注意:**  
`拦截器类要被SpringMVC容器扫描到`。

#### 步骤2:配置拦截器类 ####

@Configuration
    public class SpringMvcSupport extends WebMvcConfigurationSupport {
        
        @Autowired
        private ProjectInterceptor projectInterceptor;
    
        @Override
        protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        
            registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
        }
    
        @Override
        protected void addInterceptors(InterceptorRegistry registry) {
        
            //配置拦截器
            registry.addInterceptor(projectInterceptor).addPathPatterns("/books" );
        }
    }

#### 步骤3:SpringMVC添加SpringMvcSupport包扫描 ####

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

#### 步骤4:运行程序测试 ####

使用PostMan发送`http://localhost/books`

![在这里插入图片描述][d10e05d6577b46979e9764083c8d46f9.png]

如果发送`http://localhost/books/100`会发现拦截器没有被执行，原因是拦截器的`addPathPatterns`方法配置的拦截路径是`/books`,我们现在发送的是`/books/100`，所以没有匹配上，因此没有拦截，拦截器就不会执行。

#### 步骤5:修改拦截器拦截规则 ####

这个时候，如果再次访问`http://localhost/books/100`，拦截器就会被执行。

最后说一件事，就是拦截器中的`preHandler`方法，如果返回true,则代表放行，会执行原始Controller类中要请求的方法，如果返回false，则代表拦截，后面的就不会再执行了。

#### 步骤6:简化SpringMvcSupport的编写 ####

@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/*");
        }
    }

此后咱们就不用再写`SpringMvcSupport`类了。

最后我们来看下拦截器的执行流程:

![在这里插入图片描述][9679db1000984ff399b8de9a581f7a6b.png]

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

如果方法`返回true`，`则放行继续执行后面的handle[controller的方法]和后面的方法`

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

## 3) 拦截器参数 ##

### 1 前置处理方法 ###

原始方法之前运行`preHandle`

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

*  `request`:`请求对象`
 *  `response`:`响应对象`
 *  `handler`:`被调用的处理器对象`，本质上是一个方法对象，`对反射中的Method对象进行了再包装`

使用request对象可以获取请求数据中的内容，如获取请求头的`Content-Type`

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        
        String contentType = request.getHeader("Content-Type");
        System.out.println("preHandle..."+contentType);
        return true;
    }

`使用handler参数，可以获取方法的相关信息`

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        
        HandlerMethod hm = (HandlerMethod)handler;
        String methodName = hm.getMethod().getName();//可以获取方法的名称
        System.out.println("preHandle..."+methodName);
        return true;
    }

### 2 后置处理方法 ###

原始方法运行后运行，`如果原始方法被拦截，则不执行`

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

前三个参数和上面的是一致的。

`modelAndView:`如果处理器执行完成具有返回结果，可以读取到对应数据与页面信息，并进行调整

因为咱们现在都是返回json数据，所以该参数的使用率不高。

### 3 完成处理方法 ###

拦截器最后执行的方法，无论原始方法是否执行

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

前三个参数与上面的是一致的。

`ex:`如果处理器执行过程中出现异常对象，可以`针对异常情况进行单独处理`

因为我们现在已经有`全局异常处理器类`，所以`参数的使用率也不高。`

这三个方法中，最常用的是preHandle,在这个方法中可以`通过返回值来决定是否要进行放行`，我们可以把`业务逻辑放在该方法中，如果满足业务则返回true放行，不满足则返回false拦截。`

## 4) 拦截器链配置 ##

目前，我们在项目中只添加了一个拦截器，如果有多个，该如何配置?配置多个后，执行顺序是什么?

### 配置多个拦截器 ###

#### 步骤1:创建拦截器类 ####

实现接口，并重写接口中的方法

@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");
        }
    }

#### 步骤2:配置拦截器类 ####

@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/*");
        }
    }

步骤3:运行程序，观察顺序

![在这里插入图片描述][b2080332ba614949a1b928797a1ce781.png]

拦截器执行的顺序是和配置顺序有关。就和前面所提到的运维人员进入机房的案例，先进后出。

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

![在这里插入图片描述][ea73eb0d8d28469ab22f52b4b6219c41.png]

`preHandle`：`与配置顺序相同，必定运行`

`postHandle`:`与配置顺序相反，可能不运行`

`afterCompletion`:`与配置顺序相反，可能不运行。`

这个顺序不太好记，最终只需要把握住一个原则即可:以最终的运行结果为准

[fdaa9ae38f754d3da3aa14b3e1232a9f.png]: https://img-blog.csdnimg.cn/fdaa9ae38f754d3da3aa14b3e1232a9f.png
[c10c41a9b4be4164896b34189514c6fd.png]: https://img-blog.csdnimg.cn/c10c41a9b4be4164896b34189514c6fd.png
[08567b40df364796b4bdff67a86c89c3.png]: https://img-blog.csdnimg.cn/08567b40df364796b4bdff67a86c89c3.png
[4280931bb9fc4066abe2f09f32a457b1.png]: https://img-blog.csdnimg.cn/4280931bb9fc4066abe2f09f32a457b1.png
[65a87f4753384d4981e1b89863a17432.png]: https://img-blog.csdnimg.cn/65a87f4753384d4981e1b89863a17432.png
[1660b3683e874c2696cdb0a9f362934b.png]: https://img-blog.csdnimg.cn/1660b3683e874c2696cdb0a9f362934b.png
[f509351caa614e28b63ed50075e80920.png]: https://img-blog.csdnimg.cn/f509351caa614e28b63ed50075e80920.png
[8c67039bd7fd47c89bc6e118edf6bcfe.png]: https://img-blog.csdnimg.cn/8c67039bd7fd47c89bc6e118edf6bcfe.png
[01c1ba3995bb49f9b167c59863cb670c.png]: https://img-blog.csdnimg.cn/01c1ba3995bb49f9b167c59863cb670c.png
[ba6667fa371843c2ae7725c7c788a52e.png]: https://img-blog.csdnimg.cn/ba6667fa371843c2ae7725c7c788a52e.png
[a324b924a87348eaa26861e62518e0f5.png]: https://img-blog.csdnimg.cn/a324b924a87348eaa26861e62518e0f5.png
[8340a1070121462590cd853bdbf08bcd.png]: https://img-blog.csdnimg.cn/8340a1070121462590cd853bdbf08bcd.png
[d957c00bbe0b4aebb9710ed88df22723.png]: https://img-blog.csdnimg.cn/d957c00bbe0b4aebb9710ed88df22723.png
[08de9c1de3584868a13ef2272b61145f.png]: https://img-blog.csdnimg.cn/08de9c1de3584868a13ef2272b61145f.png
[02d827906c7c4495bac944eed33001fb.png]: https://img-blog.csdnimg.cn/02d827906c7c4495bac944eed33001fb.png
[373aa154b14f45bc9b210ac5fec76030.png]: https://img-blog.csdnimg.cn/373aa154b14f45bc9b210ac5fec76030.png
[eed9618151b84d6e86f51f6179ae256c.png]: https://img-blog.csdnimg.cn/eed9618151b84d6e86f51f6179ae256c.png
[ae708c1d592f431d9024672f7b09e7f7.png]: https://img-blog.csdnimg.cn/ae708c1d592f431d9024672f7b09e7f7.png
[e409a74a53e8409e89ab5dc777c0ef99.png]: https://img-blog.csdnimg.cn/e409a74a53e8409e89ab5dc777c0ef99.png
[00d85892e2da48998d2f23204a04dc5e.png]: https://img-blog.csdnimg.cn/00d85892e2da48998d2f23204a04dc5e.png
[d205eb107d7a4724bbda3149996c6da5.png]: https://img-blog.csdnimg.cn/d205eb107d7a4724bbda3149996c6da5.png
[adc5ffe45cc74ff4b9dceb5557c317e6.png]: https://img-blog.csdnimg.cn/adc5ffe45cc74ff4b9dceb5557c317e6.png
[92740357ccee40feaddddb76cfbfb849.png]: https://img-blog.csdnimg.cn/92740357ccee40feaddddb76cfbfb849.png
[9e96dd8614224ec99e495911cf078abc.png]: https://img-blog.csdnimg.cn/9e96dd8614224ec99e495911cf078abc.png
[02ae784e051043828cfcd804001e8e00.png]: https://img-blog.csdnimg.cn/02ae784e051043828cfcd804001e8e00.png
[39cab701780c41b489b0b104c1a52692.png]: https://img-blog.csdnimg.cn/39cab701780c41b489b0b104c1a52692.png
[faf4ab29429c49e8b8f61d12f1fd9b1d.png]: https://img-blog.csdnimg.cn/faf4ab29429c49e8b8f61d12f1fd9b1d.png
[6a4b58f85ebb4bfab7ba3e47cecbe8e3.png]: https://img-blog.csdnimg.cn/6a4b58f85ebb4bfab7ba3e47cecbe8e3.png
[d1fe3f585e3441219e45f47ac258e2f5.png]: https://img-blog.csdnimg.cn/d1fe3f585e3441219e45f47ac258e2f5.png
[3c49cfd787b94089a96c5e71452be982.png]: https://img-blog.csdnimg.cn/3c49cfd787b94089a96c5e71452be982.png
[bd0b2ccc176342d2afdecbc1d34aa933.png]: https://img-blog.csdnimg.cn/bd0b2ccc176342d2afdecbc1d34aa933.png
[f92c77a98a974bf69e481c6665016ed3.png]: https://img-blog.csdnimg.cn/f92c77a98a974bf69e481c6665016ed3.png
[4b119ba1c95d41988f0cab5bb9065fa7.png]: https://img-blog.csdnimg.cn/4b119ba1c95d41988f0cab5bb9065fa7.png
[8f78026c61344a01a94bf328a21a6b5c.png]: https://img-blog.csdnimg.cn/8f78026c61344a01a94bf328a21a6b5c.png
[024b2998befc456b9eda6c16c961cfc1.png]: https://img-blog.csdnimg.cn/024b2998befc456b9eda6c16c961cfc1.png
[5347115f731244fb9d4074caaacfbe86.png]: https://img-blog.csdnimg.cn/5347115f731244fb9d4074caaacfbe86.png
[2d169aa1b2704ddcb883df2ab11578e6.png]: https://img-blog.csdnimg.cn/2d169aa1b2704ddcb883df2ab11578e6.png
[891d328d12884f80bb724f03a4ef710c.png]: https://img-blog.csdnimg.cn/891d328d12884f80bb724f03a4ef710c.png
[ef49617b0c6647aab160b5f63d701890.png]: https://img-blog.csdnimg.cn/ef49617b0c6647aab160b5f63d701890.png
[7b4ac1fd46944157ac79ba72d80737a8.png]: https://img-blog.csdnimg.cn/7b4ac1fd46944157ac79ba72d80737a8.png
[d10e05d6577b46979e9764083c8d46f9.png]: https://img-blog.csdnimg.cn/d10e05d6577b46979e9764083c8d46f9.png
[9679db1000984ff399b8de9a581f7a6b.png]: https://img-blog.csdnimg.cn/9679db1000984ff399b8de9a581f7a6b.png
[b2080332ba614949a1b928797a1ce781.png]: https://img-blog.csdnimg.cn/b2080332ba614949a1b928797a1ce781.png
[ea73eb0d8d28469ab22f52b4b6219c41.png]: https://img-blog.csdnimg.cn/ea73eb0d8d28469ab22f52b4b6219c41.png