Mysql事务隔离与Spring

╰+哭是因爲堅強的太久メ 2021-12-20 02:25 180阅读 0赞

> Spring学习事务的时候看到很多只读事务 和事务隔离和事务传播和事务挂起，为了更好的理解学习了mysql这块的知识。

本文用的SQL命令

#------ 设置事务隔离登记-----
    
    #读已提交
    set session transaction isolation level read committed ;
    #读未提交
    set session transaction isolation level read uncommitted ;
    #可重复度 mysql默认级别
    set session transaction isolation level repeatable read  ;
    #串行化
    set session transaction isolation level serializable  ;
    
    #------ 开启事务-----
    
    #开启可读写事务
    start transaction;
    #开启只读事务
    start transaction read only;
    #开启读写事务 与start transaction;等价
    start transaction read write;
    
    
    # 提交事务
    commit；
    
    # 事务回滚
    rollback；
    
    #------事务挂起-----
    
    #记录事务保存点 mm为保存点自定义的id
    savepoint mm;
    #回滚事务到mm 保存点.直接运行rollback全部回滚
    ROLLBACK TO mm;
    #删除保存点
    RELEASE SAVEPOINT mm;
    
    # 获取事务隔离类 如 read committed等
    SHOW VARIABLES LIKE 'transaction_isolation';

### 事务 ###

事务个人定义:某一任务序列的集合。

举例：  
小明在银行取钱的一个序列

小明

插卡

输入密码

取款金额

ATM吐纸钞退卡

上面5个步骤合在一起我们就称为一个事务。

在Mysql我们可以理解多个Sql语句的合集。

如下Sql：

# 小明给小张转账
    update User set money=money-23 where username='小明';
    update User set money=money+23 where username='小张';

上述两个sql语句根据固定顺序构成了一事务。

我们之所以把一定任务序列构成事务，是因为我们希望任务序列要么全部执行成功，要么不执行。

举个例子：

# 小明给小张转账
    update User set money=money-23 where username='小明';
    #假设只执行上面的小明的 money=money-23 但是还没执行
    #小张的money=money+23语句，此时出现了异常不能执行（比如断电） money=money+23
    #那么我们希望 money=money-23 语句就行回滚，就像没发生过一样,小明
    #和小张金额一起没有任何变化
    update User set money=money+23 where username='小张';

未解决上面的问题可以采用mysql 为我们提供事务语句解决

# 开启事务
    start transaction ;
    # start transaction read only; 只读事务 后续讲解
    
    #事务开启后如果没有执行 commit 那么数据并不会真正写入数据库中，
    # 但sql语句会生产临时数据（临时数据后面在引用问题,当然不会扩展到mvvc内容，主要我太菜）。
    
    # 小明给小张转账
    update User set money=money-23 where username='小明';
    
    update User set money=money+23 where username='小张';
    
    #提交事务
    commit ;
    
    #根据需要回滚
    # rollback;

数据库只有一个，但是数据库操却并发着。比如12306有无数个请求（无数个事务）在修改数据库，那么这么多事务并发操作必然存在问题。

我们知道在事务中SQL语句在没有提交事务的时候，虽然不会最终写入数据库，但会产生临时数据，这些临时数据会被其他事务读取。

问题1： 脏读

> 事务读取到其他事务未提交的临时数据。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]

问题2： 不可重复读

> 事务两次读取同一记录的数据不一致。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]

问题3：幻读

> 事务A 修改/删除/更新 了一些在其他事务已经删除或者插入的数据

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]  
上图中某个事务没有id=2的数据（此时其他事务插入的），但是更新id=2为的数据居然成功。

参考:  
维基百科 Isolation [https://en.wikipedia.org/wiki/Isolation\_(database\_systems)][https_en.wikipedia.org_wiki_Isolation_database_systems]

针对事务并发导致的几个问题，数据库innodb提供几个事务隔离策略让我们针对上诉的问题针对性解决。read committed、read uncommitted、 repeatable read、serializable。

### read uncommitted 读未提交 ###

此隔离模式会导致事务可以读取其他未提交的事务的临时数据。  
假设B事务修改了User表的小李的Age=20字段 但未提交事务，此时A事务将读取到小李的Age字段等于20。

模拟环境如下：  
A事务、 B事务。  
表结构：

-- auto-generated definition
    create table User
    (
        id       int auto_increment
            primary key,
        username varchar(255) null,
        birthday date         null,
        sex      varchar(255) null,
        address  varchar(255) null,
        money    int          null
    );

A事务执行任务如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]  
可见此隔离无法阻止脏读，同理可证明无法阻止幻读和不可重复度问题。

这在注意一个问题，`事务B`此时对User表id为1的数据进行了行锁。其他事物如果需要修改id为1的数据需要`事务B`提交事务才可。

### read committed 读已提交 ###

可以读取其他事务已提交的数据，对于其他未提交的事务的临时数据是无法查询。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 5]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 6]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 7]

此处可证明`read committed`能解决数据脏读问题。但对于`幻读`和`可重复读`无法解决。

### repeatable read 可重复读 ###

多次重复读取可保持一致性  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 8]  
在`事务A`修改`id=1`的数据时会自动同步B事务提交`id=1`新数据(假设`事务B`同时修改`id=2`和`id=1`的数据，此时也不会刷新`id=2`的新数据，只是刷新`id=1`)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 9]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 10]  
再次提一个小心点可重复读，修改一个数据时，此数据行若被其他事务修改，那么以其他事物已提交的数据为数据源做修改。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 11]

同理`事务B`插入新的数据行，`事务A`同样无法查询到。除非`事务A`使用`update`更新整个表。

但可重复读无法避免幻读现象  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 12]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 13]

事务A中查询不到`id=2`的数据，然后执行更新`id=2`操作居然成功了

### serializable 串行执行 ###

一个事务只能等候另一个事务执行完成了才可以使用。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 14]

此隔离等级可解决幻读 重复读 脏读问题，但效率过差

### 只读事务 ###

只读事务是指建立在四种隔离机制之上的。表示当前事务只能对表进行读取操作，其他删除/更新/插入会导致锁异常。

如执行以下下SQL语句

set session transaction isolation level read committed ;
    
    start transaction read only ;
    
    #不能执行
    #insert User(id,username) values (2,'小帅');
    
    #不能执行
    #update  User set username=concat(username,' 放学') ;
    
    
    
    #不能执行
    #delete from User;
    
    #因为设置了 read committed ; 查询其他事务已经提交的数据，和原来无差别
    select *
    from User;
    
    commit ;

`start transaction read only ;`开启可读事务，mysql会对其进行优化处理 。但事务内部查询可见性依然由事务隔离级别决定。

### 事务的保存点 ###

有时候我们希望在事务执行时可以控制部分区域回滚，可以让我们更细腻化的控制的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 15]  
其他命令这里直接给出结论读者可以自己进行验证。存在多个存储点时，执行`rollback` 将回滚全部，而`rollback to XX` 会回滚到指定点。`RELEASE SAVEPOINT xx;` 删除指定存储点位置 后面无法执行此`id`的`rollback to XX` 。

> Tip:Spring事务传播NESTED类型就是使用Savepoint

### 事务嵌套问题 ###

事务开启后无法变更隔离级别，包含事务保存点`savepoint`之后调用`set session transaction isolation level xxxx ;`也无法更改

执行以下sql文件

set session transaction isolation level read uncommitted;
    start transaction;
    
    SHOW VARIABLES LIKE 'transaction_isolation';#返回read uncommitted
    
    select *
    from User;
    
    #想修改为 读已提交
    set session transaction isolation level read committed ;
    
    SHOW VARIABLES LIKE 'transaction_isolation'; #虽然返回read committed 但是依然是read uncommitted;
    
    #结果还是read uncommitted;
    select *
    from User;
    
    #想修改为 读已提交
    #并且在一次开始 依然没用
    set session transaction isolation level read committed ;
    start transaction;
    
    #结果还是read uncommitted;
    select *
    from User;
    
    commit;

效果图

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 16]

### Spring事务传播 ###

<table> 
 <thead> 
  <tr> 
   <th>事务类型</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>PROPAGATION_REQUIRED</td> 
   <td>如果当前存在事务，那么使用当前事务，自身事务配置将 不生效，如果不存在使用自身配置信息创新事务</td> 
  </tr> 
  <tr> 
   <td>PROPAGATION_SUPPORTS</td> 
   <td>如果当前存在事务，那么使用当前事务，如果没有那么以非事务运行</td> 
  </tr> 
  <tr> 
   <td>PROPAGATION_MANDATORY</td> 
   <td>支持（使用）当前事务，如果不存在事务抛出异常</td> 
  </tr> 
  <tr> 
   <td>PROPAGATION_REQUIRES_NEW</td> 
   <td>如果当前存在事务，则挂起当前事务，然后开启自身配置事务</td> 
  </tr> 
  <tr> 
   <td>PROPAGATION_NOT_SUPPORTED</td> 
   <td>以非事务的方式运行，如果有事务存在，则挂起当前事务</td> 
  </tr> 
  <tr> 
   <td>PROPAGATION_NEVER</td> 
   <td>已非事务的方式运行，如果有事务存在，则抛出异常</td> 
  </tr> 
  <tr> 
   <td>PROPAGATION_NESTED</td> 
   <td>如果当前事务存在，则嵌套事务执行 使用savePoint（保存点）技术</td> 
  </tr> 
 </tbody> 
</table>

介绍几个关键API：

DataSourceUtils.getConnection(dataSources)

获取当前线程的数据源的Connection对象

# PROPAGATION\_REQUIRED和PROPAGATION\_REQUIRES\_NEW #

//TestTx.java
    
    @Component
    public class TestTx {
        
    
        @Autowired
        JdbcTemplate jdbcTemplate;
    
        @Autowired
        DataSource dataSource;
    
        /**
         * 事务隔离级别为 读取已提交事务的数据
         * 传播级别：PROPAGATION_REQUIRED 如果当前事务存在事务那么自身事务配置不生效，直接加入到现有事务中
         * 如果没有事务那么使用自身的事务隔离级别创建事务
         */
        @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
        public void query() {
        
    
            List<User> query = jdbcTemplate.query("select * from User", new BeanPropertyRowMapper(User.class));
    
            System.out.println("TestTx ::" + query);
    
            print("TestTx.query", dataSource);
        }
        public void print(String prefix, DataSource dataSources) {
        
    
            try {
        
                System.out.println("\n\n" + prefix + " : \n" +
                        "getTransactionIsolation : " + DataSourceUtils.getConnection(dataSources).getTransactionIsolation() +
                        "\nconn : " + DataSourceUtils.getConnection(dataSources) + "\n\n");
            } catch (SQLException e) {
        
                e.printStackTrace();
            }
    	}
    }

//TestTx2.java
    @Component
    public class TestTx2 {
        
    
        @Autowired
        JdbcTemplate jdbcTemplate;
    
        @Autowired
        DataSource dataSource;
    
    
        /**
         * 事务隔离级别：读取已经提交事务的数据
         * 传播：如果存在事务那么挂起，开启自己的新事务
         */
        @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRES_NEW)
        public void query() {
        
    
            List<User> query = jdbcTemplate.query("select * from User", new BeanPropertyRowMapper(User.class));
    
            System.out.println("TestTx2::" + query);
    
            print("TestTx2.query", dataSource);
        }
          public void print(String prefix, DataSource dataSources) {
        
    
            try {
        
                System.out.println("\n\n" + prefix + " : \n" +
                        "getTransactionIsolation : " + DataSourceUtils.getConnection(dataSources).getTransactionIsolation() +
                        "\nconn : " + DataSourceUtils.getConnection(dataSources) + "\n\n");
            } catch (SQLException e) {
        
                e.printStackTrace();
            }
    
        }

**测试一**

//TestBean.java
    @Component
    public class TestBean {
        
    
        @Autowired
        TestTx testTx;
        @Autowired
        TestTx2 testTx2;
    
    
        /**
         * 开启事务 可以读取一些未提交的事务数据
         */
        @Transactional(isolation = Isolation.READ_UNCOMMITTED)
        public void testOne() {
        
            try {
        
            	//#22行
                testTx.query();
                //#24行
                testTx.query();
                //#26行
                testTx2.query();
    
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }

testOne方法输出：

TestTx ::[User{id=688022, userName='新插入未提交', birthday=null, sex='null', address='null'}, User{id=688024, userName='张三', birthday=null, sex='null', address='null'}, User{id=688025, userName='张三', birthday=null, sex='null', address='null'}]
    
    
    TestTx.query : 
    getTransactionIsolation : 1
    conn : com.mchange.v2.c3p0.impl.NewProxyConnection@7d32c62e [wrapping: com.mysql.cj.jdbc.ConnectionImpl@59ffa66d]
    
    
    TestTx ::[User{id=688022, userName='新插入未提交', birthday=null, sex='null', address='null'}, User{id=688024, userName='张三', birthday=null, sex='null', address='null'}, User{id=688025, userName='张三', birthday=null, sex='null', address='null'}]
    
    
    TestTx.query : 
    getTransactionIsolation : 1
    conn : com.mchange.v2.c3p0.impl.NewProxyConnection@7d32c62e [wrapping: com.mysql.cj.jdbc.ConnectionImpl@59ffa66d]
    
    
    TestTx2::[User{id=688024, userName='张三', birthday=null, sex='null', address='null'}, User{id=688025, userName='张三', birthday=null, sex='null', address='null'}]
    
    
    TestTx2.query : 
    getTransactionIsolation : 2
    conn : com.mchange.v2.c3p0.impl.NewProxyConnection@73f75fec [wrapping: com.mysql.cj.jdbc.ConnectionImpl@4d021f9e]

输出分析：  
`{id=688022, userName='新插入未提交', birthday=null, sex='null', address='null'}`为其他事务未提交的脏数据

结论一：  
`TestBean.java`的 `22行`和`24行`的`testTx.query();`打印出相同的查询结果，且能读取到脏数据。证明自己的事务`TestTx`的`query`方法配置`Isolation.READ_COMMITTED`没有生效，而是采用`TestBean`类`testOne`方法的`READ_UNCOMMITTED` 。

结论二：  
`TestBean.java`的 `22行`和`24行`的`testTx.query();`打印出相同`Connection`对象。加入其他事务的时候会使用同一`Connection`对象。

结论三：  
`TestBean.java`的26行`testTx2.query();`没有打印出`{id=688022, userName='新插入未提交', birthday=null, sex='null', address='null'}`证明自身的`Isolation.READ_COMMITTED`生效。

结论四：  
`TestBean.java`的26行`testTx2.query();`打印的`Connection`对象与 `22行`和`24行`的`testTx.query();`不相同。证明不同一个事务`Connection`对象不同.

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

**测试二**

@Component
    public class TestBean {
        
    
        @Autowired
        TestTx testTx;
        @Autowired
        TestTx2 testTx2;
    
        /**
         * 开启事务 可以读取一些未提交的事务数据
         */
        @Transactional(isolation = Isolation.READ_UNCOMMITTED)
        public void testOne() {
        
            try {
        
                testTx.query();
                testTx.query();
                testTx2.query();
    
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    
    
        /**
         * 与测试一不同的是 自身没有开启事务
         */
        public void testTwo() {
        
            try {
        
                testTx.query();
                testTx.query();
                testTx2.query();
    
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    
    }

testTwo输出：

TestTx ::[User{id=688024, userName='张三', birthday=null, sex='null', address='null'}, User{id=688025, userName='张三', birthday=null, sex='null', address='null'}]
    
    
    TestTx.query : 
    getTransactionIsolation : 2
    conn : com.mchange.v2.c3p0.impl.NewProxyConnection@7d32c62e [wrapping: com.mysql.cj.jdbc.ConnectionImpl@59ffa66d]
    
    
    TestTx ::[User{id=688024, userName='张三', birthday=null, sex='null', address='null'}, User{id=688025, userName='张三', birthday=null, sex='null', address='null'}]
    
    
    TestTx.query : 
    getTransactionIsolation : 2
    conn : com.mchange.v2.c3p0.impl.NewProxyConnection@7577863f [wrapping: com.mysql.cj.jdbc.ConnectionImpl@73f75fec]
    
    
    TestTx2::[User{id=688024, userName='张三', birthday=null, sex='null', address='null'}, User{id=688025, userName='张三', birthday=null, sex='null', address='null'}]
    
    
    TestTx2.query : 
    getTransactionIsolation : 2
    conn : com.mchange.v2.c3p0.impl.NewProxyConnection@2a4e842f [wrapping: com.mysql.cj.jdbc.ConnectionImpl@73f75fec]

结论一：  
三者使用不同`Connection`对象，且使用自己的隔离级别创建事务。

**测试三**

关于`PROPAGATION_REQUIRES_NEW`会把原事务挂起，`PROPAGATION_REQUIRED`会加入现有事务的测试说明。

@Component
    public class TestTx {
        
    
        @Autowired
        JdbcTemplate jdbcTemplate;
    
        @Autowired
        DataSource dataSource;
    
        /**
         * 添加用户
         * 传播级别：PROPAGATION_REQUIRED 如果当前事务存在事务那么自身事务配置不生效(readonly=true也会失效 一样可以插入，
         * isolation跟随当前事务 自身也失效，此处可以参考 之前查询测试)，直接加入到现有事务中.
         * 如果没有事务那么使用自身的事务隔离级别创建事务
         *
         * @param user
         */
        @Transactional(isolation = Isolation.READ_UNCOMMITTED, propagation = Propagation.REQUIRED, readOnly = true)
        public void addUser(User user) {
        
    
            jdbcTemplate.update("insert into User( username)  values (?) ", user.getUserName());
    
            print("TestTx.addUser", dataSource);
    
        }
    
        @Transactional(isolation = Isolation.READ_UNCOMMITTED, propagation = Propagation.REQUIRED)
        public void addUserWithExeption(User user) {
        
            jdbcTemplate.update("insert into User(username)  values (?) ", user.getUserName());
            print("TestTx.addUserWithExeption", dataSource);
     		int i = 1 / 0;
        }
    
        /**
         * 事务隔离级别为 读取已提交事务的数据
         * 传播级别：PROPAGATION_REQUIRED 如果当前事务存在事务那么自身事务配置不生效，直接加入到现有事务中
         * 如果没有事务那么使用自身的事务隔离级别创建事务
         */
        @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
        public void query() {
        
    
            List<User> query = jdbcTemplate.query("select * from User", new BeanPropertyRowMapper(User.class));
    
            System.out.println("TestTx ::" + query);
    
            print("TestTx.query", dataSource);
        }
    
        public void print(String prefix, DataSource dataSources) {
        
    
            try {
        
                System.out.println("\n\n" + prefix + " : \n" +
                        "getTransactionIsolation : " + DataSourceUtils.getConnection(dataSources).getTransactionIsolation() +
                        "\nconn : " + DataSourceUtils.getConnection(dataSources) + "\n\n");
            } catch (SQLException e) {
        
                e.printStackTrace();
            }
    
        }
    
    }

测试类

这里直接说结论 李四 王五都没有插入。两种使用同一个Connection

捕获回滚异常问题，请看下图

//TestBean.java
    @Component
    public class TestBean {
        
    
        @Autowired
        TestTx testTx;
    
    
         /**
         * 与测试一不同的是 自身没有开启事务
         */
        @Transactional(isolation = Isolation.READ_UNCOMMITTED)
        public void testThree() throws Exception {
        
    
    
            testTx.addUser(new User("李四"));
    
            try {
        
                testTx.addUserWithExeption(new User("张珊"));
            } catch (Exception e) {
        
            	//addUserWithExeption因为传播机制是REQUIRED
            	//所以和当前方法为同一事物，当addUserWithExeption发生
            	//异常时会标记以前当前事物为回滚，并需要获取addUserWithExeption返回的异常
            	//自己捕获后，testThree的AOP after advice代码（在testThree方法最后切入的代码）无法捕获到异常，而标记了回滚，此时会在        System.out.println("====再次插入小明后=====");
            	//之后抛出异常Transaction rolled back because it has been marked as rollback-only
    
                System.out.println("异常:::"+e.getMessage());
            }
    
            System.out.println("=====再次插入小明前====");
            testTx.addUser(new User("小明"));
            System.out.println("====再次插入小明后=====");
    		
        }

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration({
        "classpath:bean.xml"})
    @ComponentScan({
        "com.fmy"})
    public class Demo {
        
    
    
        @Autowired
        TestTx testTx;
        @Autowired
        TestBean testBean;
    
    
    
        @Test
        public void main() {
        
    
            try {
        
                testBean.testThree();
            } catch (Exception e) {
        
                System.out.println("最外层调用testThree 捕获到异常::"+e.getMessage());
            }
    
    
        }
    }

以上运行结果 （）

TestTx.addUserWithExeption : 
    getTransactionIsolation : 1
    conn : com.mchange.v2.c3p0.impl.NewProxyConnection@4bc88ff5 [wrapping: com.mysql.cj.jdbc.ConnectionImpl@424d86ce]
    
    
    异常:::/ by zero
    =====再次插入小明前====
    ====再次插入小明后=====
    最外层调用testThree 捕获到异常::Transaction rolled back because it has been marked as rollback-only

虽然小明 李四和张珊都没插入 但是不建议这么捕获异常

如果addUserWithExeption传播机制改为REQUIRES\_NEW即可避免，但事务不同请开发者自行注意。

PROPAGATION\_REQUIRED 测试用例

@Component
    public class TestTx2 {
        
    
        @Autowired
        JdbcTemplate jdbcTemplate;
    
        @Autowired
        DataSource dataSource;
    
        @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRES_NEW)
        public void addUser(User user) {
        
            jdbcTemplate.update("insert into User( username)  values (?) ", user.getUserName());
    
            print("TestTx2.addUser", dataSource);
        }

/**
         * 与测试一不同的是 自身没有开启事务
         */
        @Transactional(isolation = Isolation.READ_UNCOMMITTED)
        public void testFour() throws Exception {
        
    
            testTx.addUser(new User("李四"));
            //注意testTx2的addUser处于不同事务中
            testTx2.addUser(new User("张三"));
            int i = 1 / 0;
        }

**结果:**  
张三插入  
李四失败

testTx和testTx2使用不同connection 且不再同一个事务。当执行1/0发生异常，只发生在testTx事务中，testTx2事务不受影响。

## PROPAGATION\_NESTED ##

事务嵌套，此处采用采用SavePoint技术。

//TestTx2.java
    @Component
    public class TestTx2 {
        
    
        @Autowired
        JdbcTemplate jdbcTemplate;
    
        @Autowired
        DataSource dataSource;
    
        @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.NESTED)
        public void addUser(User user) {
        
            jdbcTemplate.update("insert into User( username)  values (?) ", user.getUserName());
            int i = 1 / 0;
            print("TestTx2.addUser", dataSource);
        }
    
    
        /**
         * 事务隔离级别：读取已经提交事务的数据，但是当前当前事务isolation跟随已存在事务隔离机制
         * 传播： 如果当前存在事务，则在嵌套事务内执行 使用 数据库savepoit技术，。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。
         */
        @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.NESTED)
        public void query() {
        
    
            List<User> query = jdbcTemplate.query("select * from User", new BeanPropertyRowMapper(User.class));
    
            System.out.println("TestTx2::" + query);
    
            print("TestTx2.query", dataSource);
        }

@Component
    public class TestBean {
        
    
        @Autowired
        TestTx testTx;
    
    
        @Autowired
        TestTx2 testTx2;
    
    
        /**
         * 与测试一不同的是 自身没有开启事务
         */
        @Transactional(isolation = Isolation.READ_UNCOMMITTED)
        public void testFive() throws Exception {
        
    
          testTx.query();
          testTx2.query();
    
        }
    
    
    }

结果：  
testTx和testTx2在同一个事务，并且使用同一个connection，查询数据相同。读取的数据全部是READ\_UNCOMMITTED级别的，虽然testTx2设置READ\_COMMITTED了，但是记住同一个事务开启后不可以更换隔离级别。

继续测试最后一个

@Component
    public class TestBean {
        
    
        @Autowired
        TestTx testTx;
    
    
        @Autowired
        TestTx2 testTx2;
    
    
        /**
         * 与测试一不同的是 自身没有开启事务
         */
        @Transactional(isolation = Isolation.READ_UNCOMMITTED)
        public void testSix() throws Exception {
        
    
          testTx.addUser(new User("张三"));
    
    
            try {
        
                testTx2.addUser(new User("李四"));
            } catch (Exception e) {
        
                e.printStackTrace();
            }
    
        }
    
    
    }

结果：

结果插入张三，  
李四插入失败。  
虽然 testTx2和testTx在同一个事务，但是testTx2使用savepoint技术，只会回滚此方法的数据.(记得捕获testTx2的异常，不然testTx会一起回滚，事务异常会把异常向上抛出，NESTED和REQUIRES\_NEW可以捕获，其他隔离级别请勿捕获)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: /images/20211220/1cfa6ba392a34c47ba58c7d70ee26717.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]: /images/20211220/db690d917daf4506a6d0b0a0a332bf77.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]: /images/20211220/f2bb9d3a3e064d26b29d6869a40609d8.png
[https_en.wikipedia.org_wiki_Isolation_database_systems]: https://en.wikipedia.org/wiki/Isolation_%28database_systems%29
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]: /images/20211220/71b804dcecf44655a53f1d194528bf40.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]: /images/20211220/04b9e6fbb9dc47b59179728abc035abf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 5]: /images/20211220/bb415120b18147749020fca0981ea0e3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 6]: /images/20211220/6ce0aa4ae9c0482d9a8ec92d18d8aabb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 7]: /images/20211220/3fb17e6457ea40109dca2c2b8a47c618.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 8]: /images/20211220/ff3a98da42a84982ab0eef681e7c87b4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 9]: /images/20211220/9b3415cbcafd4a2eba447e01e736d68c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 10]: /images/20211220/516a3a861f894c23b0cffa01e2484302.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 11]: /images/20211220/d35c857aef514b64a84ff810fd9092f7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 12]: /images/20211220/9d41228915f94122819153d338316658.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 13]: /images/20211220/10aba1c9d5c54c13a2a552bc0c500ac6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 14]: /images/20211220/2a9f188cd6e84a578809f726f942e02e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 15]: /images/20211220/a1a1e80b68174dc19e5fcfa56e46099a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9mYW5taW5neWkuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 16]: /images/20211220/ca9f224e02f149b5b3bb43b633d556ad.png