Spring事务及事务传播机制

r囧r小猫 2024-03-22 22:26 83阅读 0赞

## 一.事务回顾 ##

### 1.什么是事务 ###

事务定义 :将一组操作封装成⼀个执行单元（封装到一起），要么全部成功，要么全部失败。

### 2.为什么要使用事务 ###

还是用一个老生常谈的例子来说

> 张三给李四转账 :
> 
> 张三账户-100;
> 
> 李四账户+100;

如果在张三账户-100的时候发生异常,此时李四账户+100的操作还没有完成,张三账户的钱不就平白无故的消失了,而如果使用事务就可以解决这个问题，让这一组操作要么一起成功，要么一起失败。

### 3.MySQL 中的事务使用 ###

> \--开启事务 
> 
> start transaction; 
> 
> \--  业务执行
> 
> \--  提交事务 
> 
> commit; 
> 
> \--  回滚事务 
> 
> rollback;

## 二.Spring中的事务 ##

### 0.准备工作 ###

#### 1.先来创建数据库 ####

-- 创建数据库
            drop database if exists mycnblog;
            create database mycnblog default character set utf8mb4;
            -- 使⽤数据数据
            use mycnblog;
            -- 创建表[⽤户表]
            drop table if exists userinfo;
            create table userinfo(
            id int primary key auto_increment,
            username varchar(100) not null,
            password varchar(32) not null,
            photo varchar(500) default '',
            createtime datetime default now(),
            updatetime datetime default now(),
            `state` int default 1
            ) default charset 'utf8mb4';
    
            -- 添加⼀个⽤户信息
            insert into `mycnblog`.`userinfo` (`id`, `username`, `password`, `photo`,
            `createtime`, `updatetime`, `state`) values
            (1, 'admin', 'admin', '', '2021-12-06 17:10:48', '2021-12-06 17:10:48', 1)
            ;
            -- 添加⼀个用户日志表
            DROP TABLE IF EXISTS userlog;
            CREATE TABLE userlog(
            id INT PRIMARY KEY AUTO_INCREMENT,
            username VARCHAR(100) NOT NULL,
            createtime DATETIME DEFAULT NOW( ),
            updatetime DATETIME DEFAULT NOW()
            ) DEFAULT CHARSET 'utf8mb4';

#### 2.实体类 ####

@Data
    public class User {
        private Integer id;
        private String username;
        private String password;
        private String photo;
        private Date createtime;
        private Date updatetime;
    }

@Data
    public class UserLog {
        private Integer id;
        private String username;
        private Date cratetime;
        private Date updatetime;
    
        public UserLog() {
        }
    
        public UserLog(String username) {
            this.username = username;
        }
    }

#### 3.Mapper ####

@Mapper
    public interface UserMapper {
        @Select("select * from userinfo")
        List<User> selectAll();
         @Insert("insert into userinfo(username,password) values (#{username},#{password}))")
        Integer insert(User user);
    }

@Mapper
    public interface UserLogMapper {
        @Insert("insert into userlog(username) values (#{username})")
        Integer insert(UserLog userLog);
    }

#### 4.Service ####

@Service
    public class UserService {
        @Autowired
        UserMapper userMapper;
    
        public List<User> selectAll() {
            return userMapper.selectAll();
        }
    
        public Integer addUser(User user) {
            return userMapper.insert(user);
        }
    }

@Service
    public class UserLogService {
        @Autowired
        UserLogMapper userLogMapper;
    
        public Integer addUser(UserLog userLog) {
            return userLogMapper.insert(userLog);
        }
    }

Spring 中的事务操作分为两类：

1.  编程式事务（手动写代码操作事务）.

2.  声明式事务（利用注解自动开启和提交事务）.

**普通的添加操作**

@RestController
    @Slf4j
    @RequestMapping("/trans")
    public class TransactionalController {
        @Autowired
        UserService userService;
    
        @RequestMapping("/add")
        public Integer addUser() {
            User user = new User();
            user.setName("zxn123");
            user.setPwd("123456");
            return userService.addUser(user);
    
        }
    }

![4c86867e4cb641248096be775829e927.png][]

![352cd591867c4baaad9210f587fc6e64.png][] 可以看到是添加成功的

### 1.手动 ###

**加入事务之后进行rollback**

@RestController
    @Slf4j
    @RequestMapping("/trans")
    public class TransactionalController {
        @Autowired
        private UserService userService;
        //数据库事务管理器
        @Autowired
        private DataSourceTransactionManager dataSourceTransactionManager;
        //事务属性
        @Autowired
        private TransactionDefinition transactionDefinition;
    
        @RequestMapping("/add")
        public Integer addUser(String username, String password) {
            TransactionStatus transaction = dataSourceTransactionManager.getTransaction(transactionDefinition);
            User user = new User();
            user.setName(username);
            user.setPwd(password);
            Integer insert = userService.addUser(user);
            log.info("影响了" + insert + "行");
            dataSourceTransactionManager.rollback(transaction);
            return insert;
    
        }
    }

仍然执行上面的操作.数据库没有发生改变,说明数据进行了回滚

![352cd591867c4baaad9210f587fc6e64.png][]

**加入事务之后进行rollback日志**

![d18003f3e945466e9dc33b28d50fee52.png][]  **加入事务之后进行commit日志**

![ea78c4c58c01494baa1d73afdab1c1ef.png][]

### 2.注解 ###

加入@Transactional注解

@RestController
    @Slf4j
    @RequestMapping("/trans2")
    public class TransactionalController2 {
        @Autowired
        private UserService userService;
        @Transactional
        @RequestMapping("/add")
        public Integer addUser(String username, String password) {
            User user = new User();
            user.setName(username);
            user.setPwd(password);
            Integer insert = userService.addUser(user);
            log.info("影响了" + insert + "行");
            return insert;
    
        }
    }

#### 1.没有异常,自动提交 ####

![15ca48afc31140af849850ae498b9c04.png][]

![f9eaecb20b134d37bbed4ae1c5b265cc.png][]

#### 2.有异常,自动rollback ####

![871bafa4166940eab61718615ee309f1.png][]

可以看到没有提交操作.

#### 3.@Transactional 作用范围 ####

@Transactional 可以用来修饰方法或类：

修饰方法时：需要注意只能应用到 public 方法上，否则不生效。推荐此种用法。

修饰类时：表明该注解对该类中所有的 public 方法都生效。

#### 4.@Transactional 参数说明 ####

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>参数</td> 
   <td>作用</td> 
  </tr> 
  <tr> 
   <td>value</td> 
   <td>当配置了多个事务管理器时，可以使用该属性指定选择哪个事务管理器.</td> 
  </tr> 
  <tr> 
   <td>transactionManager</td> 
   <td>当配置了多个事务管理器时，可以使用该属性指定选择哪个事务管理器.</td> 
  </tr> 
  <tr> 
   <td>propagation</td> 
   <td>事务的传播行为,默认值Propagation.REQUIRED</td> 
  </tr> 
  <tr> 
   <td>isolation</td> 
   <td>事务的隔离级别,默认值为lsolation.DEFAULT</td> 
  </tr> 
  <tr> 
   <td>timeout</td> 
   <td>事务的超时时间,默认值为-1.如果超过该时间限制但事务还没有完成,则自动回滚事务.</td> 
  </tr> 
  <tr> 
   <td>readOnly<br> &nbsp;</td> 
   <td>指定事务是否为只读事务,默认值为false;为了忽略那些不需要事务的方法,比如读取数据，可以设置read-only为 true.</td> 
  </tr> 
  <tr> 
   <td>rollbackFor</td> 
   <td>用于指定能够触发事务回滚的异常类型,可以指定多个异常类型.</td> 
  </tr> 
  <tr> 
   <td>rollbackForClassName</td> 
   <td>用于指定能够触发事务回滚的异常类型,可以指定多个异常类型.</td> 
  </tr> 
  <tr> 
   <td>noRollbackFor</td> 
   <td>抛出指定的异常类型,不回滚事务,也可以指定多个异常类型.</td> 
  </tr> 
  <tr> 
   <td>noRollbackForClassName<br> &nbsp;</td> 
   <td>抛出指定的异常类型,不回滚事务,也可以指定多个异常类型.</td> 
  </tr> 
 </tbody> 
</table>

演示noRollbackFor

@Transactional(noRollbackFor = ArithmeticException.class)
        @RequestMapping("/add")
        public Integer addUser(String username, String password) {
            User user = new User();
            user.setName(username);
            user.setPwd(password);
            Integer insert = userService.addUser(user);
            log.info("影响了" + insert + "行");
            int a = 10 / 0;
            return insert;
    
        }

此时可以看到是有ArithmeticException错误的,我们添加数据

![23abc8a9cd844dd8b50be4fa9bb25f9f.png][]

![ff0b2e74a83a4dcdb2f766f6c1c354fc.png][] 可以看到是添加成功了的

> @Transactional默认只在遇到运行时异常和Error时才会回滚，非运行时异常不回滚  
> 即Exception的子类中，除了RuntimeException及其子类

![36e31bf1982a4834a3399c99faf3bfe1.png][] 因此我们可以自行设置,即可对所有的异常进行回滚

> @Transactional(rollbackFor = Exception.class)

#### 5.注解的注意事项 ####

**@Transactional 在异常被捕获的情况下，不会进行事务自动回滚**

@RequestMapping("/add2")
        @Transactional
        public Integer add2(String username, String password) {
            User user = new User();
            user.setName(username);
            user.setPwd(password);
            // 插⼊数据库
            int result = userService.addUser(user);
            try {
                // 执⾏了异常代码(0不能做除数)
                int i = 10 / 0;
            } catch (Exception e) {
                log.info(e.getMessage());
            }
            return result;
        }

![cd8e74bba79c4e35b2685379695d1df3.png][]

![7bbb1270024447cd872fcc54c482d5ea.png][]

![e0692ae732e64aeeb738b23dc86d1e47.png][] 此时可以看到仍然是添加成功的了

## 三.事务的隔离级别 ##

### 1.事务的特性 ###

1.  **原子性（Atomicity）** 原子性是指**事务是一个不可分割的工作单位**，事务中的操作要么都发生，要么都不发生。
2.  **一致性（Consistency）** 事务必须使数据库从**一个一致性状态变换到另外一个一致性状态**。
3.  **隔离性（Isolation）** 事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。(具体见事务的隔离级别)
4.  **持久性（Durability）** 持久性是指一个**事务一旦被提交**，它对数据库中数据的**改变就是永久**性的，接下来的其他操作和数据库故障不应该对其有任何影响。

### 2.事务的隔离级别 ###

![ee39876f07a3454da773661987ac7591.png][]

*  **脏读**: 对于两个事务 T1, T2, T1 读取了已经被 T2 更新但还**没有被提交**的字段。之后, 若 T2 回滚, T1读取的内容就是临时且无效的。
 *  **不可重复读**: 对于两个事务T1, T2, T1 读取了一个字段, 然后 T2 **更新**了该字段。之后, T1再次读取同一个字段, 值就不同了。
 *  **幻读**: 对于两个事务T1, T2, T1 从一个表中读取了一个字段, 然后 T2 在该表中**插入**了一些新的行。之后, 如果 T1 再次读取同一个表, 就会多出几行。

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>事务隔离级别</td> 
   <td>脏读</td> 
   <td>不可重复读</td> 
   <td>幻读</td> 
  </tr> 
  <tr> 
   <td>读未提交(READ UNCOMMITTED)</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td>读已提交(READ COMMITTED)</td> 
   <td>x</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td>可重复读（REPEATABLE READ)</td> 
   <td>x</td> 
   <td>x</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td>串行化(SERIALIZABLE)</td> 
   <td>x</td> 
   <td>x</td> 
   <td>x</td> 
  </tr> 
 </tbody> 
</table>

![730b80a7aeb047a29a271beafe443b6c.png][]

### 3.Spring事务的隔离级别 ###

而 Spring 中事务隔离级别包含以下 5 种：

1.  Isolation.DEFAULT：以连接的数据库的事务隔离级别为主。 
2.  Isolation.READ\_UNCOMMITTED：读未提交，可以读取到未提交的事务，存在脏读。 
3.  Isolation.READ\_COMMITTED：读已提交，只能读取到已经提交的事务，解决了脏读，存在不可重复读。 
4.  Isolation.REPEATABLE\_READ：可重复读，解决了不可重复读，但存在幻读（MySQL默认级别）。 
5.  Isolation.SERIALIZABLE：串行化，可以解决所有并发问题，但性能太低。

Spring 中事务隔离级别只需要设置 @Transactional 里的 isolation 属性即可，具体实现代码如下：

> @Transactional(isolation = Isolation.READ\_COMMITTED)

## 四.Spring 事务传播机制  ##

### 1.事务传播机制是什么 ###

Spring 事务传播机制定义了多个包含了事务的方法，相互调用时，事务是如何在这些方法间进行传递的。

事务隔离级别是保证多个并发事务执行的可控性的（稳定性的），而事务传播机制是保证一个事务在多个调用方法间的可控性的（稳定性的）。

事务传播机制解决的是一个事务在多个节点（方法）中传递的问题

![0041ff14d2b14f989689f77bf8d8bec4.png][]

### 2.事务的传播机制 ###

Spring 事务传播机制包含以下 7 种：

1.  Propagation.REQUIRED：默认的事务传播级别，它表示如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
2.  Propagation.SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的 方式继续运行。
3.  Propagation.MANDATORY：（mandatory：强制性）如果当前存在事务，则加入该事务；如果当 前没有事务，则抛出异常。
4.  Propagation.REQUIRES\_NEW：表示创建一个新的事务，如果当前存在事务，则把当前事务挂起。也就是说不管外部方法是否开启事务，Propagation.REQUIRES\_NEW 修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。
5.  Propagation.NOT\_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
6.  Propagation.NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。
7.  Propagation.NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于 PROPAGATION\_REQUIRED

以上事务传播机制,可分为三类

![5ccb34e7b1414e0b948794609d00632a.png][]

![99e453f4bf5a4a9bb6c06d3076601877.png][]

### 3.Spring 事务传播机制使用和各种场景演示 ###

#### 1.支持当前事务（REQUIRED） ####

没有错误的模拟

@Transactional(propagation = Propagation.REQUIRED)
        public Integer addUser(User user) {
            return userMapper.insert(user);
        }

@Transactional(propagation = Propagation.REQUIRED)
        public Integer addUserLog(UserLog userLog) {
            return userLogMapper.insert(userLog);
        }

@RestController
    @Slf4j
    @RequestMapping("/trans3")
    public class TransactionalController3 {
        @Autowired
        private UserService userService;
        @Autowired
        private UserLogService userLogService;
        @Transactional
        @RequestMapping("/addUser")
        public boolean addUser(String username, String password) {
            User user = new User();
            user.setName(username);
            user.setPwd(password);
            //插入用户表
            userService.addUser(user);
            UserLog userLog = new UserLog(username);
            //插入日志表
            userLogService.addUserLog(userLog);
            return true;
    
        }
    }

![56d948b181594f60806d52fb56687a36.png][]

![bba9c2243b1246648352cc02769d6688.png][] ![c9c2120e4ea8424396e0a839b3db3a56.png][] ![6b07438431834980a0d0eca114453195.png][]

错误发生时的模拟

@Transactional(propagation = Propagation.REQUIRED)
        public Integer addUserLog(UserLog userLog) {
            int i = 10 / 0;
            return userLogMapper.insert(userLog);
        }

![542f32faa506456a9978e5a7314fa213.png][]

![06bac557a27840239b25f6be61059cd4.png][]

![d8ac43b1f04e497eb4fd6b6f8d527b6d.png][] 可以看到数据并没有发生改变

#### 2.不支持当前事务（REQUIRES\_NEW） ####

修改隔离级别

@Transactional(propagation = Propagation.REQUIRES_NEW)
        public Integer addUser(User user) {
            return userMapper.insert(user);
        }

@Transactional(propagation = Propagation.REQUIRES_NEW)
        public Integer addUserLog(UserLog userLog) {
            int i = 10 / 0;
            return userLogMapper.insert(userLog);
        }

![5d5d50295f5546fa940988c0b740f9b7.png][]

![6e56317f53a64453b6e65e54fcfeb681.png][]

![a635773789d4489f961b8ad20b1f9206.png][] 可以看到userinfo表示添加成功的了

#### 3.不支持当前事务，NEVER 抛异常  ####

@Transactional(propagation = Propagation.NEVER)
        public Integer addUser(User user) {
            return userMapper.insert(user);
        }

@Transactional(propagation = Propagation.NEVER)
        public Integer addUserLog(UserLog userLog) {
            int i = 10 / 0;
            return userLogMapper.insert(userLog);
        }

执行,会出现以下报错日志

![f5692b1c7e614bb3b819ee19a532c052.png][]

#### 4.NESTED 嵌套事务 ####

@Transactional(propagation = Propagation.NESTED)
        public Integer addUser(User user) {
            return userMapper.insert(user);
        }

@Transactional(propagation = Propagation.NESTED)
        public Integer addUserLog(UserLog userLog) {
            int i = 10 / 0;
            return userLogMapper.insert(userLog);
        }

![540077dd5d644cada4b468a2c70991fc.png][]

![7ba53c992da6436582988bb267b00953.png][]

![04f7fcf4db7742ce80b49d48f59b7f25.png][] 捕获异常

@Transactional(propagation = Propagation.NESTED)
        public Integer addUserLog(UserLog userLog) {
            userLogMapper.insert(userLog);
            try {
                int i = 10 / 0;
            } catch (Exception e) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
            return 1;
        }

![45da394e1ea94e62a35318d390f09ec0.png][]![ab3b975b436f4060ae3d00175c80be6e.png][]

![7171e539034c4f9d8569afbe26c0fe20.png][] 可以看到userinfo表示添加成功,而userlog表示添加失败的了.

这个只是回滚了部分事务,如果是required的话,会回滚所有的事务.

嵌套事务(NESTED)和加入事务(REQUIRED )的区别:

*  整个事务如果全部执行成功，二者的结果是一样的。
 *  如果事务执行到一半失败了，那么加入事务整个事务会全部回滚;而嵌套事务会局部回滚，不会影响上一个方法中执行的结果。

[4c86867e4cb641248096be775829e927.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/d75c723da3b24bf1aa1e7daf5d057bed.png
[352cd591867c4baaad9210f587fc6e64.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/dfc2769286bb4e4894adb8fd05b91e29.png
[d18003f3e945466e9dc33b28d50fee52.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/379df1959ef5455a9183c84a14b3b874.png
[ea78c4c58c01494baa1d73afdab1c1ef.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/e1c90debb6d44d13b447fb56dde564d2.png
[15ca48afc31140af849850ae498b9c04.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/ca1ebb9f1f1f47549dab765d3f2909ca.png
[f9eaecb20b134d37bbed4ae1c5b265cc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/2f08b5d0d457452fb7b499d52f99d480.png
[871bafa4166940eab61718615ee309f1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/0c07a7547b504084a514a071782e1875.png
[23abc8a9cd844dd8b50be4fa9bb25f9f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/41039286e18e4c3fbf7c7536af51b976.png
[ff0b2e74a83a4dcdb2f766f6c1c354fc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/9266d5554a644225a98225715b4e0695.png
[36e31bf1982a4834a3399c99faf3bfe1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/72272567f5be4e9a932431eb3cee9dd9.png
[cd8e74bba79c4e35b2685379695d1df3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/819228538bd841b1adfa03ddff5730a5.png
[7bbb1270024447cd872fcc54c482d5ea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/edb45366fe6b4969a014a4cf80db04a9.png
[e0692ae732e64aeeb738b23dc86d1e47.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/9ee4d01a206243e786ef2f0de61f80af.png
[ee39876f07a3454da773661987ac7591.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/eee10ac07feb4475b5a0a5d39eff5eb8.png
[730b80a7aeb047a29a271beafe443b6c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/dfbbed9efa214286bf671e8d74479cba.png
[0041ff14d2b14f989689f77bf8d8bec4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/dafa226ff2aa405f906156b01bbbd8b8.png
[5ccb34e7b1414e0b948794609d00632a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/b116a102911a4be28ebc81b0bd905291.png
[99e453f4bf5a4a9bb6c06d3076601877.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/702ab4c10d2f404b82caa09c1e63ddec.png
[56d948b181594f60806d52fb56687a36.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/b94351048432499f924f236b33bbebe4.png
[bba9c2243b1246648352cc02769d6688.png]: https://img-blog.csdnimg.cn/bba9c2243b1246648352cc02769d6688.png
[c9c2120e4ea8424396e0a839b3db3a56.png]: https://img-blog.csdnimg.cn/c9c2120e4ea8424396e0a839b3db3a56.png
[6b07438431834980a0d0eca114453195.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/4ebace053ba64a22b30a73a627f7fb7e.png
[542f32faa506456a9978e5a7314fa213.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/bf733c3f8c714588a18f2a565d2b7eba.png
[06bac557a27840239b25f6be61059cd4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/5d1ee42c19404691bafaafa6dae598d2.png
[d8ac43b1f04e497eb4fd6b6f8d527b6d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/f04d76acc8df491dbfafa9442e105765.png
[5d5d50295f5546fa940988c0b740f9b7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/78a2e684393f472fb0c6820687ff3e06.png
[6e56317f53a64453b6e65e54fcfeb681.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/8510e35c2bad430686c7bbaa20652220.png
[a635773789d4489f961b8ad20b1f9206.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/3135f4ec78e24fbcafcb6143f017b3a7.png
[f5692b1c7e614bb3b819ee19a532c052.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/5241c419b6744d9aa6902e90d972985b.png
[540077dd5d644cada4b468a2c70991fc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/6a6d244eb89242b6935ddc74fd9588f7.png
[7ba53c992da6436582988bb267b00953.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/db8f5a75909e444bbc51d278bf9ff909.png
[04f7fcf4db7742ce80b49d48f59b7f25.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/864a7629e2a548b6b7161c41d3db2a30.png
[45da394e1ea94e62a35318d390f09ec0.png]: https://img-blog.csdnimg.cn/45da394e1ea94e62a35318d390f09ec0.png
[ab3b975b436f4060ae3d00175c80be6e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/642b8a76d8594c21994a7d95ed181025.png
[7171e539034c4f9d8569afbe26c0fe20.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/dc91d11eae7244f5be9f2cc2d9eb031a.png