【SpringMVC】统一异常处理前后台协议联调拦截器

一时失言乱红尘 2024-04-20 08:00 73阅读 0赞

### 1，统一异常处理 ###

#### 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，则会出现如下效果：

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

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

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

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

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

**思考**

1.  各个层级均出现异常，异常处理代码书写在哪一层?
    
    所有的异常均抛出到表现层进行处理
2.  异常的种类很多，表现层如何将所有的异常都处理到呢?
    
    异常分类
3.  表现层处理异常，每个方法中单独书写，代码书写量巨大且意义不强，如何解决?
    
    AOP

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

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

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

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

##### 1. 环境准备 #####

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

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

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

![在这里插入图片描述][dd41cb657cc04fbea1f3c295bfdcd853.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:运行程序，测试 ######

![在这里插入图片描述][351b4f64049447c6ba49622f37a18014.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,"嘿嘿,异常你哪里跑！");
        }
    }

启动运行程序，测试

![在这里插入图片描述][341d64b43e7946769182de7a84ac3eb4.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注解，具备对应的功能

![在这里插入图片描述][4f24723a4b714814aec827263f53657d.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）
    
     *  规范的用户行为产生的异常
        
         *  用户在页面输入内容的时候未按照指定格式进行数据填写，如在年龄框输入的是字符串

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

*  不规范的用户行为操作产生的异常
    
     *  如用户故意传递错误数据

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

*  系统异常（SystemException）
    
     *  项目运行过程中可预计但无法避免的异常
        
         *  比如数据库或服务器宕机
 *  其他异常（Exception）
    
     *  编程人员未预期到的异常，如:用到的文件不存在

![在这里插入图片描述][67ea741d3f6548c28ef7e79699fab200.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`

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

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

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

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

**小结**

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

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

### 2，前后台协议联调 ###

#### 1. 环境准备 ####

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

最终创建好的项目结构如下:  
![在这里插入图片描述][f1ac13f9733940f7a04d02bbd0477eee.png]

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

链接：https://pan.baidu.com/s/1Nu1jT–H00csTU48c7TyVg?pwd=0kfh  
提取码：0kfh

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. 列表功能 ####

![在这里插入图片描述][2a0fb1cdabfa4bd297b62729f0e1f28f.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;
        });
    }

#### 3. 添加功能 ####

![在这里插入图片描述][189720efc32f43cfa43092bedfe3d11f.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)测试错误情况，将图书类别长度设置超出范围即可

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

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

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

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

#### 5. 修改功能 ####

![在这里插入图片描述][bf31af67d6f343b599c60f51175660a7.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 删除功能 ####

![在这里插入图片描述][0497e509dc454d1d89ada5bb089bb477.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>

### 3，拦截器 ###

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

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

#### 1. 拦截器概念 ####

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

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

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

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

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

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

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

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

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

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

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

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

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

看完以后，大家会发现

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

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

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

![在这里插入图片描述][908e728d955b4b8bba689a769eee12ef.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'}";
            }
        }

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

![在这里插入图片描述][bc9cdde2f4ec48cc80c0256474a6f4c3.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`

![在这里插入图片描述][50b97831158a4a3ea7edabd462be6ce9.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`类了。

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

![在这里插入图片描述][d4ee552767eb411589d58edfa711b379.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. 配置多个拦截器 #####

###### 步骤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:运行程序，观察顺序

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

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

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

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

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

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

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

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

笔记来自：[黑马程序员SSM框架教程][SSM]

### 4，图书推荐 ###

> 本书专门为想要入行从事产品经理相关工作的零基础就业人员而编写，涵盖了在产品准备阶段、产品开发阶段、产品测试阶段和产品上线后产品经理所需要具备的各项基本技能。  
> 全书共分为9章，第1章大致认识产品经理的职能范围；第2章讲解了产品经理的工作职责；第3章讲解了需求的相关知识；第4章介绍了流程的相关知识；第5章展示了结构图；第6章详细阐述了界面原型的相关知识；第7章介绍了UML图；第8章介绍了PRD文档的相关知识；第9章介绍了软件测试的相关知识。  
> 本书适合零基础想要入门产品经理、产品规划师、需求分析师的人员阅读，也适合用户体验、市场运营等相关部门的朋友，特别是互联网、软件行业、AI开发行业的人员阅读，还适合大专院校互联网和产品开发相关专业的老师和学生阅读。

![在这里插入图片描述][3c9202545d1f4bb6b38934aa5c956845.jpeg]

> ?本次送 5本书 ，从评论区抽5位小伙伴?  
> 活动时间：截止到 2023-06-23 20:00:00  
> 抽奖方式：利用程序进行抽奖。  
> 参与方式：关注博主、点赞、收藏，**进行优质评论**

> ? 获奖名单?  
> [釉色清风][Link 1]  
> [在努力的前端小白][Link 2]  
> [冰.封万里][.]  
> [韩楚风][Link 3]  
> [万物皆可der][der]  
> 名单公布时间： 2023-06-23 20:00:00

[0c340ea5888747399942140913527420.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/37ab62f8689c4aada2e7bf3b5bd33fe9.png
[971128034b234c67a31641b83217ffa4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/bfbc6e805cc148c79ab92c1d70c8fcbd.png
[dd41cb657cc04fbea1f3c295bfdcd853.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/80ffeec0be4f4d0f99d8f3980807aacd.png
[351b4f64049447c6ba49622f37a18014.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/bda6526348a745a5b4fbaa9dce05e51a.png
[341d64b43e7946769182de7a84ac3eb4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/f4340ffd9ffd426bb6cf6a713c242b6c.png
[4f24723a4b714814aec827263f53657d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/2e67989d24e2405aa5e33e5f7648402e.png
[61500233fdb1490583cbec266fc8c3a6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/49b924db52c24f3294f84762aafc15e2.png
[cb81405282b94d2d960e65de25b529b6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/29e5d4cb6af3451f9358b6cd88fcc9ed.png
[67ea741d3f6548c28ef7e79699fab200.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/7588250cfc8548869499cf3d6c990545.png
[235767f79fdf49289c747d0000938af1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/682a35454f224e79a25cc3320dcb0674.png
[864777d317d9478e90b737c41eea71c2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/7828000b04cf4faab96019bfb17b92d4.png
[616ce820c7364ceba5b36131bd8f7ca8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/d5a06727dc0248b1a2391590c2d3b5b5.png
[f1ac13f9733940f7a04d02bbd0477eee.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/bf3ea3c01cd8417fa709ffe61dbe3d06.png
[2a0fb1cdabfa4bd297b62729f0e1f28f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/cdf9204ebe2b4dcf9b8da1d673c5f6c0.png
[189720efc32f43cfa43092bedfe3d11f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/b2e33691f99046b2a87aad1d5dca36fb.png
[29956f5521954692867e90f62633f2c5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/ab2a87581611435eaba6c7147d3403a5.png
[bf31af67d6f343b599c60f51175660a7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/76a6ccffda734f3da34191fa133f8c62.png
[0497e509dc454d1d89ada5bb089bb477.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/05567ea89a7b4ee2a614337e24c54833.png
[9596e5052e3c49f59585c15abb3101c2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/dadaa8c70dc84717bcf8d16b4f959999.png
[908e728d955b4b8bba689a769eee12ef.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/54a9dc191ec14cdf8c4dca027221c61d.png
[bc9cdde2f4ec48cc80c0256474a6f4c3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/ccddb77e63de42a8839eac2bc4df6016.png
[50b97831158a4a3ea7edabd462be6ce9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/1912d70709dc45a9bf8ea55c9e10724a.png
[d4ee552767eb411589d58edfa711b379.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/1363a3e9ce7c4d689de6e0469e5c5f00.png
[8f254db4b342448dbb9b505b05b0cd6f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/fa41e994a8514a91af9c00dc43165e93.png
[03375a4c7f6649b3ab322eee7a4583a7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/8a2ca29618724dbb8bc0d7b4f17bab81.png
[SSM]: https://www.bilibili.com/video/BV1Fi4y1S7ix?p=45&vd_source=2f12ef5e5cee49948f2fd4895020c2d4
[3c9202545d1f4bb6b38934aa5c956845.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/10f492c494054d1cb0642e137c9a960e.jpeg
[Link 1]: https://blog.csdn.net/2302_76305195
[Link 2]: https://blog.csdn.net/m0_57731044
[.]: https://blog.csdn.net/weixin_46412417
[Link 3]: https://blog.csdn.net/senllang
[der]: https://blog.csdn.net/weixin_54174102?type=blog