07 Spring事务

Dear 丶 2023-09-28 18:21 23阅读 0赞

**目录**

一、Spring事务\_事务简介

二、Spring事务\_事务管理方案

三、Spring事务\_事务管理器

四、Spring事务\_事务控制的API

五、Spring事务\_事务的相关配置

六、Spring事务\_事务的传播行为

七、Spring事务\_事务的隔离级别

八、Spring事务\_注解配置声明式事务

第一种：半注解半配置文件方式

第二种：全注解方式（配置类方式）

九、知识点整理：

--------------------

> ## 一、Spring事务\_事务简介 ##
> 
> ![b54d1497b30b44a59830916943e68fb9.png][]
> 
> 事务：不可分割的原子操作，即一系列的操作要么同时成功，要么同时失败。
> 
> 开发过程中，事务管理一般在 service 层， service 层中可能会操作多次数据库，这些操作是不可分割的。**否则当程序报错时，可能会造** **成数据异常** 。 
> 
> 如：张三给李四转账时，需要两次操作数据库：张三存款减少、李四存款增加。如果这两次数据库操作间出现异常，则会造成数据错误。

**项目结构：**

![c14ab2ef59f448918ed31fbf61c6dfbe.png][]

**1.准备数据库**

CREATE DATABASE `spring` ;
    USE `spring`;
    DROP TABLE IF EXISTS `account`;
    CREATE TABLE `account` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `username` varchar(255) DEFAULT NULL,
      `balance` double DEFAULT NULL,
      PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT
    CHARSET=utf8;
    insert  into
    `account`(`id`,`username`,`balance`)
    values (1,'张三',1000),(2,'李四',1000);

![b06d1315fcae4435af80e27d9ab84298.png][]

**2.创建Maven项目，引入依赖**

<dependencies>
            
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.5.7</version>
            </dependency>
    
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.26</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.8.7</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.3.13</version>
            </dependency>
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>5.2.12.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>5.2.12.RELEASE</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>2.0.6</version>
            </dependency>
    
            
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.2.8</version>
            </dependency>
    
            
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>5.2.12.RELEASE</version>
            </dependency>
        </dependencies>

**3.创建配置文件applicationContext.xml**

**4.在domain层编写实体类Account代码**

// 账户
    public class Account {
        private int id; // 账号
        private String username; // 用户名
        private double balance; // 余额
        
        // 省略getter/setter/tostring/构造方法
    }

**5.在dao层编写AccountDao接口**

@Repository
    public interface AccountDao {
    //      根据id查找用户
        @Select("select * from account where id = #{id} ")
        Account findById(int id);
    
    //      修改用户
        @Update("update account set balance = #{balance} where id = #{id} ")
        void update(Account account);
    }

**6.在service层编写AccountService类**

@Service("accountService")
    public class AccountService {
        @Autowired
        private AccountDao accountDao;
    
        /**
         * 转账
         * @param id1     转出人id
         * @param id2     转入人id
         * @param price    金额
         */
        public void transfer(int id1,int id2,double price){
    //        转出人减少余额
            Account account1 = accountDao.findById(id1);
            account1.setBalance(account1.getBalance()-price);
            accountDao.update(account1);
    
            int i = 1/0;//设置异常，模拟程序出错
    
    //        转入人增加金额
            Account account2 = accountDao.findById(id2);
            account2.setBalance(account2.getBalance()+price);
            accountDao.update(account2);
        }
    }

**7.测试转账**

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = "classpath:applicationContext.xml")
    public class serviceTest {
        @Autowired
        private AccountService accountService;
    
        @Test
        public void testTransfer(){
            accountService.transfer(1,2,500);
        }
    }

> 8.测试结果：
> 
> ![a2b348e2c4cc406988270b37a7a07010.png][]
> 
> 程序执行了异常前面的代码，异常后面的代码没有执行，**此时没有事务管理，会造成张三的余额减少，而李四的余额并没有增加**。所以事务处理位于业务层，即一个service 方法是不能分割的。

> ## 二、Spring事务\_事务管理方案 ##
> 
> ![0b750e8806574dd2b3a7621726293e61.png][]
> 
> 在service层手动添加事务可以解决该问题：
> 
>     @Service("accountService")
>     public class AccountService {
>         @Autowired
>         private AccountDao accountDao;
>     
>         /**
>          * 转账
>          * @param id1     转出人id
>          * @param id2     转入人id
>          * @param price    金额
>          */
>         public void transfer(int id1,int id2,double price){
>          try{
>                 //        转出人减少余额
>             Account account1 = accountDao.findById(id1);
>             account1.setBalance(account1.getBalance()-price);
>             accountDao.update(account1);
>     
>             int i = 1/0;//设置异常，模拟程序出错
>     
>     //        转入人增加金额
>             Account account2 = accountDao.findById(id2);
>             account2.setBalance(account2.getBalance()+price);
>             accountDao.update(account2);
>                 sqlSession.commit();
>             }catch(Exception e){
>                 sqlSession.rollback();
>              }
>     
>         }
>     }
> 
> 但在 **Spring** **管理下不允许手动提交和回滚事务**。此时我们**需要使用Spring的事务管理方案**，在 Spring 框架中提供了两种事务管理方案：

> 1.  编程式事务：通过编写代码实现事务管理。 
> 
> **2.声明式事务：基于AOP技术实现事务管理。**

> **在Spring框架中，编程式事务管理很少使用，我们对声明式事务管理进行详细学习。** 
> 
> **Spring的声明式事务管理在底层采用了AOP** **技术**，其最大的优点在于无需通过编程的方式管理事务，**只需要在配置文件中进行相关的规则声明，就可以将事务规则应用到业务逻辑中**。 
> 
> **使用AOP技术为service方法添加如下通知：** 
> 
> ![258d8444efc543388203ca6542eb4efc.png][]

> ## 三、Spring事务\_事务管理器 ##
> 
> ![f89d3e4601bd462c8023187f2984ac11.png][]
> 
> **Spring依赖事务管理器进行事务管理，事务管理器即一个通知类**，我们为该通知类设置切点为service层方法即可完成事务自动管理。由于**不同技术操作数据库，进行事务操作的方法不同**。如：**JDBC****提交事务是 connection.commit() ，MyBatis提交事务是 sqlSession.commit() ，所以Spring提供了多个事务管理器。**
> 
> <table style="width:673px;"> 
>  <tbody> 
>   <tr> 
>    <td style="width:429px;"><strong>事务管理器名称</strong></td> 
>    <td style="width:242px;"><strong>作用</strong></td> 
>   </tr> 
>   <tr> 
>    <td style="width:429px;">org.springframework.jdbc.datasource.DataSourceTransactionManager</td> 
>    <td style="width:242px;">针对JDBC技术提供的事务管理器，适用于JDBC和MyBatis</td> 
>   </tr> 
>   <tr> 
>    <td style="width:429px;">org.springframework.orm.hibernate3.HibernateTransactionManger</td> 
>    <td style="width:242px;">针对于Hibernate框架提供的事务管理器。适用于Hibernate</td> 
>   </tr> 
>   <tr> 
>    <td style="width:429px;">org.springframework.orm.jpa.JpaTransactionManger</td> 
>    <td style="width:242px;">针对于JPA技术提供的事务管理器。适用于JPA</td> 
>   </tr> 
>   <tr> 
>    <td style="width:429px;">org.springframework.transaction.jta.JtaTransactionManger</td> 
>    <td style="width:242px;">跨越了多个事务管理源。适用在两个或者多个不同的数据源中实现事务控制。</td> 
>   </tr> 
>  </tbody> 
> </table>
> 
> 我们使理。 
> 
>  **1.引入依赖**
> 
>     
>     <dependency>
>         <groupId>org.springframework</groupId>
>         <artifactId>spring-tx</artifactId>
>         <version>5.3.13</version>
>     </dependency>
>     
>     <dependency>
>         <groupId>org.aspectj</groupId>
>         <artifactId>aspectjweaver</artifactId>
>         <version>1.8.7</version>
>     </dependency>
> 
> **2.在配置文件中引入约束**
> 
>     xmlns:aop="http://www.springframework.org/schema/aop"
>     xmlns:tx="http://www.springframework.org/schema/tx"
>     http://www.springframework.org/schema/aop
>     http://www.springframework.org/schema/aop/spring-aop.xsd
>     http://www.springframework.org/schema/tx
>     http://www.springframework.org/schema/tx/spring-tx.xsd
> 
> **3.进行事务配置**
> 
>     
>         <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
>             <property name="dataSource" ref="dataSource"></property>
>         </bean>
>     
>         
>         <tx:advice id="txAdvice">
>             <tx:attributes>
>                 
>                 <tx:method name="*" propagation="REQUIRED" isolation="DEFAULT"/>
>                 
>                 <tx:method name="find*" read-only="true" isolation="READ_UNCOMMITTED"></tx:method>
>             </tx:attributes>
>         </tx:advice>
>     
>         
>         <aop:config>
>             
>             <aop:pointcut id="pointcut" expression="execution(* com.itbaizhan.service.*.*(..))"/>
>             
>             <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"></aop:advisor>
>         </aop:config>
> 
> 配置好Spring事务之后，这是再执行上面的“张三李四转账”操作，**要么全部执行，要么全部不执行。**

## 四、Spring事务\_事务控制的API ##

![d7a558feb1f44cee8b67337e3f29c1a5.png][]

**Spring进行事务控制的功能是由三个接口提供的**，**这三个接口是Spring实现的，在开发中我们很少使用到，只需要了解他们的作用即可：**

> **PlatformTransactionManager** **接口** 
> 
> PlatformTransactionManager 是 Spring 提供的事务管理器接口，**所有事务管理器都实现了该接口**。
> 
> 该接口中提供了三个事务操作方法： 
> 
> **TransactionStatus getTransaction（TransactionDefinition definition** **）：**获取事务状态信息。 
> 
> **void commit（TransactionStatus status** **）：**事务提交 
> 
> **void rollback（TransactionStatus status** **）：**事务回滚

> **TransactionDefinition** **接口** 
> 
> **TransactionDefinition是事务的定义信息对象，** 它有如下方法： 
> 
> **String getName()** **：**获取事务对象名称。 
> 
> **int getIsolationLevel()** **：**获取事务的隔离级别。 
> 
> **int getPropagationBehavior()** **：**获取事务的传播行为。 
> 
> **int getTimeout()** **：**获取事务的超时时间。 
> 
> **boolean isReadOnly()** **：**获取事务是否只读。

> **TransactionStatus** **接口** 
> 
> **TransactionStatus** **是事务的状态接口，它描述了某一时间点上事务的状态信息。**它有如下方法： 
> 
> void flush() : 刷新事务 
> 
> boolean hasSavepoint() : 获取是否存在保存点 
> 
> boolean isCompleted():  获取事务是否完成 
> 
> boolean isNewTransaction():  获取是否是新事务 
> 
> boolean isRollbackOnly():  获取是否回滚 
> 
> void setRollbackOnly() : 设置事务回滚

## 五、Spring事务\_事务的相关配置 ##

在  <tx:advice>  中可以进行事务的相关配置：

<tx:advice id="txAdvice">
            <tx:attributes>
                
                <tx:method name="*" propagation="REQUIRED" isolation="DEFAULT"/>
                
                <tx:method name="find*" read-only="true" isolation="READ_UNCOMMITTED"></tx:method>
            </tx:attributes>
        </tx:advice>

> <tx:method>  中的属性： 
> 
> name ：指定配置的方法。  \*  表示所有方法，  find\*  表示所有以 find 开头的方法。 
> 
> read-only ：是否是只读事务，只读事务不存在数据的修改，数据库将会为只读事务提供一些 
> 
> 优化手段，会对性能有一定提升，建议在查询中开启只读事务。 
> 
> timeout ：指定超时时间，在限定的时间内不能完成所有操作就会抛异常。默认永不超时(一般不配置)
> 
> rollback-for：指定某个异常事务回滚，其他异常不回滚。默认所有异常回滚。（一般不配置)
> 
> no-rollback-for ：指定某个异常不回滚，其他异常回滚。默认所有异常回滚。（一般不配置）
> 
> propagation ：事务的传播行为 
> 
> isolation ：事务的隔离级别

## 六、Spring事务\_事务的传播行为 ##

![84251694bd734db2b5c3b0b113b7bf05.png][]

**事务传播行为是指多个含有事务的方法相互调用时，事务如何在这些方法间传播。**

如果在 service 层的方法中调用了其他的 service 方法，假设每次执行service方法都要开启事务，此时就无法保证外层方法和内层方法处于同一个事务当中。

// method1的所有方法在同一个事务中
    public void method1(){
        // 此时会开启一个新事务，这就无法保证method1()
    中所有的代码是在同一个事务中
        method2();
        System.out.println("method1");
    }
    public void method2(){
        System.out.println("method2");
    }

**事务的传播特性就是解决这个问题的，Spring帮助我们将外层方法和内层方法放入同一事务中。**

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td><strong>传播行为</strong></td> 
   <td><strong>介绍</strong></td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">REQUIRED</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">默认。支持当前事务，如果当前没有事务，就新建一个事务这是最常见的选择。 </span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">SUPPORTS </span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">支持当前事务，如果当前没有事务，就以非事务方式执行。</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">MANDATORY </span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">支持当前事务，如果当前没有事务，就抛出异常。 </span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">REQUIRES_NEW </span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">新建事务，如果当前存在事务，把当前事务挂起。 </span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">NOT_SUPPORTED </span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">NEVER</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">以非事务方式执行，如果当前存在事务，则抛出异常。</span> 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">NESTED</span> 
    </div> </td> 
   <td> 
    <div> 
     <span style="color:#333333;">必须在事务状态下执行，如果没有事务则新建事务，如果当前有事务则创建一个嵌套事务</span> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

## 七、Spring事务\_事务的隔离级别 ##

![979714e9d4104469ac53c7e5a77e8525.png][]

事务隔离级别反映事务提交并发访问时的处理态度，**隔离级别越高，数据出问题的可能性越低，但效率也会越低。**

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>隔离级别</td> 
   <td>脏读</td> 
   <td>不可重复读</td> 
   <td>幻读</td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">READ_UNCOMMITED</span> 
     <span style="color:#333333;">（读取未提交内容） </span> 
    </div> </td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">READ_COMMITED</span> 
     <span style="color:#333333;">（读取提交内容）</span> 
    </div> </td> 
   <td>×</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">REPEATABLE_READ</span> 
     <span style="color:#333333;">（重复读） </span> 
    </div> </td> 
   <td>×</td> 
   <td>×</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td> 
    <div> 
     <span style="color:#333333;">SERIALIZABLE</span> 
     <span style="color:#333333;">（可串行化） </span> 
    </div> </td> 
   <td>×</td> 
   <td>×</td> 
   <td>×</td> 
  </tr> 
 </tbody> 
</table>

> √表示有，×表示没有

> **如果设置为DEFAULT会使用数据库的默认隔离级别。**
> 
> SqlServer , Oracle 默认的事务隔离级别是 READ\_COMMITED 
> 
> Mysql 的默认隔离级别是 REPEATABLE\_READ

## 八、Spring事务\_注解配置声明式事务 ##

**Spring支持使用注解配置声明式事务。用法如下：**

> ### 第一种：半注解半配置文件方式 ###
> 
> **1.在配置文件applicationContext.xml中注册事务注解驱动**
> 
>     
>         <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
>     
>         
>         <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
>             <property name="dataSource" ref="dataSource"></property>
>         </bean>
> 
> **2.在需要事务支持的方法或类上加@Transactional注解**
> 
>     @Service("accountService")
>     //@Transactional:作用于类上时，该类的所有public方法都将具有该类型的事务属性
>     @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT)
>     public class AccountService {
>         @Autowired
>         private AccountDao accountDao;
>     
>         /**
>          * 转账
>          * @param id1     转出人id
>          * @param id2     转入人id
>          * @param price    金额
>          */
>         public void transfer(int id1,int id2,double price){
>     //        转出人减少余额
>             Account account1 = accountDao.findById(id1);
>             account1.setBalance(account1.getBalance()-price);
>             accountDao.update(account1);
>     
>             int i = 1/0;//设置异常，使得操作中断，造成事务问题
>     
>     //        转入人增加金额
>             Account account2 = accountDao.findById(id2);
>             account2.setBalance(account2.getBalance()+price);
>             accountDao.update(account2);
>         }
>     
>         //作用于方法上时，该方法将都具有该类型的事务属性
>         @Transactional(isolation = Isolation.READ_UNCOMMITTED)
>         public Account findById(int id){
>             return accountDao.findById(id);
>         }
>     }
> 
> **测试方法：**
> 
>     @RunWith(SpringJUnit4ClassRunner.class)
>     //加载配置文件
>     @ContextConfiguration(locations = "classpath:applicationContext.xml")
>     public class serviceTest {
>         @Autowired
>         private AccountService accountService;
>     
>         @Test
>         public void testTransfer(){
>             accountService.transfer(1,2,500);
>         }
>     }

> ### 第二种：全注解方式（配置类方式） ###
> 
> **配置类代替xml中的注解事务支持：在配置类上方写 @EnableTranscationManagement**
> 
>     @Configuration//表名配置类
>     @ComponentScan("com.itbaizhan")//扫描注解
>     @EnableTransactionManagement//开启注解事务
>     public class SpringConfig {
>     //    创建druid连接池数据源对象
>         @Bean
>         public DataSource getDataSource(){
>             DruidDataSource druidDataSource = new DruidDataSource();
>             druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
>             druidDataSource.setUrl("jdbc:mysql:///spring");
>             druidDataSource.setUsername("root");
>             druidDataSource.setPassword("123456");
>             return druidDataSource;
>         }
>     
>         @Bean
>         public SqlSessionFactoryBean getSqlSession(DataSource dataSource){
>             SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
>             sqlSessionFactoryBean.setDataSource(dataSource);
>             return sqlSessionFactoryBean;
>         }
>     
>         @Bean
>         public MapperScannerConfigurer getMapperScanner(){
>             MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
>             mapperScannerConfigurer.setBasePackage("com.itbaizhan.dao");
>             return mapperScannerConfigurer;
>         }
>     
>         @Bean
>         public DataSourceTransactionManager getTransactionManager(DataSource dataSource){
>             DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
>             dataSourceTransactionManager.setDataSource(dataSource);
>             return dataSourceTransactionManager;
>         }
>     }
> 
> **测试方法：**
> 
>     @RunWith(SpringJUnit4ClassRunner.class)
>     @ContextConfiguration(classes = SpringConfig.class)//加载配置类
>     public class serviceTest2 {
>         @Autowired
>         private AccountService accountService;
>     
>         @Test
>         public void testTransfer(){
>             accountService.transfer(1,2,500);
>         }
>     }

> ## 九、知识点整理： ##
> 
> 1.事务指“**不可分割的原子操作，要么全部执行，要么全部不执行**”。
> 
> 2.Spring声明式事务在底层**采用了AOP技术**
> 
> 3.**DataSourceTransactionManager** 可以管理MyBatis的事务
> 
> 4.在Spring中，**所有的事务管理器都实现了"****PlatformTransactionManager 接口**
> 
> 5.**<tx:method>** **中**read\-only **属性配置只读事务，isolation属性配置隔离级别**
> 
> 6.**.****在****Spring中，事务的默认传播级别为**REQUIRED 
> 
> 7.**事务的隔离级别越高，**数据出问题的可能性越低，效率也会越低。 
> 
> 8.**在****Spring****中，配置声明式事务用到的注解为@Transactional**

[b54d1497b30b44a59830916943e68fb9.png]: https://img-blog.csdnimg.cn/b54d1497b30b44a59830916943e68fb9.png
[c14ab2ef59f448918ed31fbf61c6dfbe.png]: https://img-blog.csdnimg.cn/c14ab2ef59f448918ed31fbf61c6dfbe.png
[b06d1315fcae4435af80e27d9ab84298.png]: https://img-blog.csdnimg.cn/b06d1315fcae4435af80e27d9ab84298.png
[a2b348e2c4cc406988270b37a7a07010.png]: https://img-blog.csdnimg.cn/a2b348e2c4cc406988270b37a7a07010.png
[0b750e8806574dd2b3a7621726293e61.png]: https://img-blog.csdnimg.cn/0b750e8806574dd2b3a7621726293e61.png
[258d8444efc543388203ca6542eb4efc.png]: https://img-blog.csdnimg.cn/258d8444efc543388203ca6542eb4efc.png
[f89d3e4601bd462c8023187f2984ac11.png]: https://img-blog.csdnimg.cn/f89d3e4601bd462c8023187f2984ac11.png
[d7a558feb1f44cee8b67337e3f29c1a5.png]: https://img-blog.csdnimg.cn/d7a558feb1f44cee8b67337e3f29c1a5.png
[84251694bd734db2b5c3b0b113b7bf05.png]: https://img-blog.csdnimg.cn/84251694bd734db2b5c3b0b113b7bf05.png
[979714e9d4104469ac53c7e5a77e8525.png]: https://img-blog.csdnimg.cn/979714e9d4104469ac53c7e5a77e8525.png