Spring事务和MySQL事务详解面试

左手的ㄟ右手 2022-12-05 15:13 109阅读 0赞

### 文章目录 ###

*   *  数据库事务
     *   *  事务是什么
         *  事务的四大特性
     *  MySQL事务隔离级别
     *   *  查看MySQL当前事务隔离级别
         *  MySQL默认操作模式为自动提交模式
     *  JDBC处理事务
     *  Spring事务
     *   *  Spring的事务传播
         *   *  PROPAGATION\_REQUIRED
             *  PROPAGATION\_SUPPORTS
             *  PROPAGATION\_MANDATORY
             *  PROPAGATION\_REQUIRES\_NEW
             *  PROPAGATION\_NOT\_SUPPORTED
             *  PROPAGATION\_NEVER
             *  PROPAGATION\_NESTED
         *  Spring事务的隔离级别
         *  Spring事务基本配置样例

## 数据库事务 ##

### 事务是什么 ###

是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作；这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行；事务是一组不可再分割的操作集合。

### 事务的四大特性 ###

1.  原子性  
    事务是数据库的逻辑工作单位，事务中包含的各操作要么都做，要么都不做
2.  一致性  
    事务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态。
3.  隔离性  
    一个事务的执行不能被其它事务干扰。即一个事务内部的操作及使用的数据对其它并发事务是隔离的，并发执行的各个事务之间不能互相干扰。
4.  持续性  
    也称永久性，指一个事务一旦提交，它对数据库中的数据的改变就是永久性的。接下来的其它操作或故障不应该对其执行结果有任何影响。

## MySQL事务隔离级别 ##

<table> 
 <thead> 
  <tr> 
   <th>隔离级别</th> 
   <th>隔离级别的值</th> 
   <th>导致的问题</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Read-Uncommitted</td> 
   <td>0</td> 
   <td>导致脏读</td> 
  </tr> 
  <tr> 
   <td>Read-Committed</td> 
   <td>1</td> 
   <td>避免脏读，允许不可重复读和幻读</td> 
  </tr> 
  <tr> 
   <td>Repeatable-Read</td> 
   <td>2</td> 
   <td>MySQL默认的隔离级别。避免脏读，不可重复读，允许幻读</td> 
  </tr> 
  <tr> 
   <td>Serializable</td> 
   <td>3</td> 
   <td>串行化读，事务只能一个一个执行，避免了 脏读、不可重复读、幻读。执行效率慢，使用时慎重</td> 
  </tr> 
 </tbody> 
</table>

**1. 脏读**

一个事务对数据进行了增删改查，但是未提交事务。另一个事物可以读取到未提交的数据，如果第一个事务进行了回滚，那么第二个事务就读到了脏数据。

例子：

领导给张三发工资，10000元已打到张三账户，但该事务还未提交，正好这时候张三去查询工资，发现10000元已到账。这时领导发现张三工资算多了5000元，于是回滚了事务，修改了金额后将事务提交。最后张三实际到账的只有5000元。

**2. 不可重复度**

一次事务发生了两次读操作，两个读操作之间发生了另一个事务对数据修改操作，这时候第一次和第二次读到的数据不一致。

*不可重复度关注点在数据更新和删除，通过**行级锁**可以实现可重复读的隔离级别。*

例子：

张三需要转正1000元，系统读到卡余额有2000元，此时张三老婆正好需要转正2000元，并且在张三提交事务前把2000元转走了，当张三提交转账是系统提示余额不足。

**3. 幻读**

幻读，指的是当某个事务在读取某个范围内的记录时，另外一个事务又在该范围内插入了新的记录，当之前的事务再次读取该范围的记录时，会产生幻行。

相对于不可重复读，幻读更关注其它事务的新增数据。通过行级锁可以避免不可重复读，但无法解决幻读的问题，想要解决幻读，只能通过Serializable隔离级别来实现。

例子：

张三老婆准备打印张三这个月的信用卡消费记录，经查询发现消费了两次共1000元，而这时张三刚按摩完准备结账，消费了1000元，这时银行记录新增了一条1000元的消费记录。当张三老婆将消费记录打印出来时，发现总额变为了2000元，这让张三老婆很诧异。

**4. 串行化读**

Serializable是最高的隔离级别，性能很低，一般很少用。在这级别下，事务是串行顺序执行的，不仅避免了脏读、不可重复读，还避免了幻读。

### 查看MySQL当前事务隔离级别 ###

MySQL InnoDB默认的事务隔离级别为`REPEATABLE-READ`

mysql> select @@tx_isolation;
    +-----------------+
    | @@tx_isolation  |
    +-----------------+
    | REPEATABLE-READ |
    +-----------------+

### MySQL默认操作模式为自动提交模式 ###

除非显示的开启一个事务，否则每个查询都被当成一个单独的事务自动执行。可以通脱设置autocommit的值改变默认的提交模式。

1.  查看当前提交模式

mysql> show variables like 'autocommit';
    +---------------+-------+
    | Variable_name | Value |
    +---------------+-------+
    | autocommit    | ON    |
    +---------------+-------+

1.  关闭自动提交。0代表关闭，1代表开启。

mysql> set autocommit = 0;
    Query OK, 0 rows affected (0.00 sec)
    
    mysql> show variables like 'autocommit';
    +---------------+-------+
    | Variable_name | Value |
    +---------------+-------+
    | autocommit    | OFF   |
    +---------------+-------+

## JDBC处理事务 ##

Connection connection = null;
    PreparedStatement pstmt = null;
    ResultSet resultSet = null;
    
    try { 
        Class.forName("com.mysql.jdbc.Driver");
        connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/dbname?characterEncoding=utf-8","username", "password");
    
        connection.setAutoCommit(false);
        
        // others ......
        
        connection.commit();
    } catch (Exception e) { 
        connection.rollback();
    } finally { 
        connection.setAutoCommit(true);
        // close connection
    }

## Spring事务 ##

Spring事务本质是对数据库事务的支持，如果数据库不支持事务（例如MySQL的MyISAM引擎不支持事务），则Spring事务也不会生效。

### Spring的事务传播 ###

事务传播行为是指一个事务方法A被另一个事务方法B调用时，这个事务A应该如何处理。事务A应该在事务B中运行还是另起一个事务，这个有事务A的传播行为决定。

事务传播属性定义`TransactionDefinition`

int PROPAGATION_REQUIRED = 0;
    int PROPAGATION_SUPPORTS = 1;
    int PROPAGATION_MANDATORY = 2;
    int PROPAGATION_REQUIRES_NEW = 3;
    int PROPAGATION_NOT_SUPPORTED = 4;
    int PROPAGATION_NEVER = 5;
    int PROPAGATION_NESTED = 6;

<table> 
 <thead> 
  <tr> 
   <th>常量名称</th> 
   <th>常量解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>PROPAGATION_REQUIRED</td> 
   <td>支持当前事务，如果当前没有事务，就新建一个事务。这是Spring 默认的事务的传播。</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>新建事务，如果当前存在事务，把当前事务挂起。新建的事务将和被挂起的事务没有任何关系，是两个独立的事务，外层事务失败回滚之后， 不能回滚内层事务执行的结果，内层事务失败抛出异常，外层事务捕获， 也可以不处理回滚操作。 使用JtaTransactionManager作为事务管理器</td> 
  </tr> 
  <tr> 
   <td>PROPAGATION_NOT_SUPPORTED</td> 
   <td>以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。使用JtaTransactionManager作为事务管理器</td> 
  </tr> 
  <tr> 
   <td>PROPAGATION_NEVER</td> 
   <td>以非事务方式执行，如果当前存在事务，则抛出异常。</td> 
  </tr> 
  <tr> 
   <td>PROPAGATION_NESTED</td> 
   <td>如果一个活动的事务存在，则运行在一个嵌套的事务中。如果没有活动事务，则按REQUIRED属性执行。它使用了一个单独的事务，这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager事务管理器起效。</td> 
  </tr> 
 </tbody> 
</table>

#### PROPAGATION\_REQUIRED ####

如果存在一个事务，则支持当前事务，如果没有事务则开启事务。  
![image][]

如下例子，单独调用methodB时，当前上下文没有事务，所以会开启一个新的事务。

调用methodA方法时，因为当前上下文不存在事务，所以会开启一个新的事务。当执行到methodB时，methodB发现当前上下文有事务，因此就加入到当前事务A中来。

@Transactional(propagation = Propagation.REQUIRED)
    public void methodA() { 
        methodB();
        // do something
    }
     
    @Transactional(propagation = Propagation.REQUIRED)
    public void methodB() { 
        // do something
    }

#### PROPAGATION\_SUPPORTS ####

如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行.  
![image][image 1]

单独的调用methodB时，methodB方法是非事务的执行的。当调用methdA时,methodB则加入了methodA的事务中,事务地执行。

@Transactional(propagation = Propagation.REQUIRED)
    public void methodA() { 
        methodB();
        // do something
    }
     
    // 事务属性为SUPPORTS
    @Transactional(propagation = Propagation.SUPPORTS)
    public void methodB() { 
        // do something
    }

#### PROPAGATION\_MANDATORY ####

如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。  
![image][image 2]

当单独调用methodB时，因为当前没有一个活动的事务，则会抛出异常`throw new IllegalTransactionStateException(“Transaction propagation ‘mandatory’ but no existing transaction found”)`

当调用methodA时，methodB则加入到methodA的事务中，以事务方式执行。

@Transactional(propagation = Propagation.REQUIRED)
    public void methodA() { 
        methodB();
        // do something
    }
    
    @Transactional(propagation = Propagation.MANDATORY)
    public void methodB() { 
        // do something
    }

#### PROPAGATION\_REQUIRES\_NEW ####

使用PROPAGATION\_REQUIRES\_NEW,需要使用 JtaTransactionManager作为事务管理器。  
它会开启一个新的事务。如果一个事务已经存在，则先将这个存在的事务挂起。  
![image][image 3]

从下面代码可以看出，事务B与事务A是两个独立的事务，互不相干。事务B是否成功并不依赖于 事务A。如果methodA方法在调用methodB方法后的doSomeThingB方法失败了，而methodB方法所做的结果依然被提交。而除了 methodB之外的其它代码导致的结果却被回滚了

@Transactional(propagation = Propagation.REQUIRED)
    public void methodA() { 
        doSomeThingA();
        methodB();
        doSomeThingB();
        // do something else
    }
     
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void methodB() { 
        // do something
    }

当调用methodA()，相当于

public static void main(){ 
        TransactionManager tm = null;
        try{ 
            //获得一个JTA事务管理器
            tm = getTransactionManager();
            tm.begin();//开启一个新的事务
            Transaction ts1 = tm.getTransaction();
            doSomeThing();
            tm.suspend();//挂起当前事务
            try{ 
                tm.begin();//重新开启第二个事务
                Transaction ts2 = tm.getTransaction();
                methodB();
                ts2.commit();//提交第二个事务
            } Catch(RunTimeException ex) { 
                ts2.rollback();//回滚第二个事务
            } finally { 
                //释放资源
            }
            //methodB执行完后，恢复第一个事务
            tm.resume(ts1);
            doSomeThingB();
            ts1.commit();//提交第一个事务
        } catch(RunTimeException ex) { 
            ts1.rollback();//回滚第一个事务
        } finally { 
            //释放资源
        }
    }

#### PROPAGATION\_NOT\_SUPPORTED ####

总是非事务地执行，并挂起任何存在的事务。

使用PROPAGATION\_NOT\_SUPPORTED,也需要使用JtaTransactionManager作为事务管理器。

![image][image 4]

#### PROPAGATION\_NEVER ####

总是非事务地执行，如果存在一个活动事务，则抛出异常。

#### PROPAGATION\_NESTED ####

如果一个活动的事务存在，则运行在一个嵌套的事务中。

如果没有活动事务,则按TransactionDefinition.PROPAGATION\_REQUIRED 属性执行。

这是一个嵌套事务,使用JDBC3.0驱动时,仅仅支持DataSourceTransactionManager作为事务管理器。 需要JDBC 驱动的java.sql.Savepoint类。使用PROPAGATION\_NESTED，还需要把PlatformTransactionManager的nestedTransactionAllowed属性设为true(属性值默认为false)。

![image][image 5]

@Transactional(propagation = Propagation.REQUIRED)
    methodA(){ 
        doSomeThingA();
        methodB();
        doSomeThingB();
    }
     
    @Transactional(propagation = Propagation.NEWSTED)
    methodB(){ 
        // do something
    }

单独调用methodB方法，则按REQUIRED属性执行。如果调用methodA方法，则相当于：

main(){ 
        Connection con = null;
        Savepoint savepoint = null;
        try{ 
            con = getConnection();
            con.setAutoCommit(false);
            doSomeThingA();
            savepoint = con2.setSavepoint();
            try{ 
                methodB();
            } catch(RuntimeException ex) { 
                con.rollback(savepoint);
            } finally { 
                //释放资源
            }
            doSomeThingB();
            con.commit();
        } catch(RuntimeException ex) { 
            con.rollback();
        } finally { 
            //释放资源
        }
    }

当methodB方法调用之前，调用setSavepoint方法，保存当前的状态到savepoint。如果methodB方法调用失败，则恢复到之前保存的状态。

需要注意的是，这时的事务并没有进行提交，如果后续的代码(doSomeThingB()方法)调用失败，则回滚包括methodB方法的所有操作。嵌套事务一个非常重要的概念就是内层事务依赖于外层事务。外层事务失败时，会回滚内层事务所做的动作。而内层事务操作失败并不会引起外层事务的回滚。

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

事务隔离级别定义`TransactionDefinition`

int ISOLATION_DEFAULT = -1;
    int ISOLATION_READ_UNCOMMITTED = 1;
    int ISOLATION_READ_COMMITTED = 2;
    int ISOLATION_REPEATABLE_READ = 4;
    int ISOLATION_SERIALIZABLE = 8;

<table> 
 <thead> 
  <tr> 
   <th>隔离级别</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ISOLATION_DEFAULT</td> 
   <td>这是个 PlatfromTransactionManager 默认的隔离级别， 使用数据库默认的事务隔离级别。另外四个与 JDBC 的 隔离级别相对应。</td> 
  </tr> 
  <tr> 
   <td>ISOLATION_READ_UNCOMMITTED</td> 
   <td>这是事务最低的隔离级别，它允许另外一个事务可以看 到这个事务未提交的数据。这种隔离级别会产生脏读， 不可重复读和幻像读。</td> 
  </tr> 
  <tr> 
   <td>ISOLATION_READ_COMMITTED</td> 
   <td>保证一个事务修改的数据提交后才能被另外一个事务读 取。另外一个事务不能读取该事务未提交的数据。 ISOLATION_REPEATABLE_READ</td> 
  </tr> 
  <tr> 
   <td>ISOLATION_SERIALIZABLE</td> 
   <td>这是花费最高代价但是最可靠的事务隔离级别。事务被 处理为顺序执行。</td> 
  </tr> 
 </tbody> 
</table>

### Spring事务基本配置样例 ###

<aop:aspectj-autoproxy proxy-target-class="true"/>
    	
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    	<property name="dataSource" ref="dataSource"/>
    </bean>
    
    <tx:advice id="transactionAdvice" transaction-manager="transactionManager">
    	<tx:attributes>
    		<tx:method name="add*" propagation="REQUIRED" rollback-for="Exception,RuntimeException,SQLException"/>
    		<tx:method name="remove*" propagation="REQUIRED" rollback-for="Exception,RuntimeException,SQLException"/>
    		<tx:method name="edit*" propagation="REQUIRED" rollback-for="Exception,RuntimeException,SQLException"/>
    		<tx:method name="login" propagation="NOT_SUPPORTED"/>
    		<tx:method name="query*" read-only="true"/>
    	</tx:attributes>
    </tx:advice>
    
    <aop:config>
    	<aop:advisor advice-ref="transactionAdvice" pointcut-ref="transactionPointcut"/>
        <aop:aspect ref="dataSource">
            <aop:pointcut id="transactionPointcut" expression="execution(public * com.gupaoedu..*.service..*Service.*(..))" />
        </aop:aspect>
    </aop:config>

[image]: /images/20221123/db38a7d539384104af2defe0fa505b09.png
[image 1]: /images/20221123/cbe2da085d1647e4af47c41b88aab5bf.png
[image 2]: /images/20221123/2a00edbb5df0469eb9ae8f235b435fc6.png
[image 3]: /images/20221123/6e61fd9491fd44eb8211e1cd2f7385f4.png
[image 4]: /images/20221123/b5106f9cae23485eb18f3868634b1774.png
[image 5]: /images/20221123/2bdc65a039cd4bae8dcb8d4446fa3f72.png