java八股文面试[Spring]——事务

﹏ヽ暗。殇╰゛Y 2024-03-04 01:55 30阅读 0赞

### 事务隔离级别 ###

事务隔离级别指的是一个事务**对数据的修改**与另一个并行的事务的**隔离程度**，当多个事务同时访问相同数据时，如果没有采取必要的隔离机制，就可能发生以下问题：

<table> 
 <thead> 
  <tr> 
   <th style="width:94px;">问题</th> 
   <th style="width:594px;">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="width:94px;">脏读</td> 
   <td style="width:594px;">一个事务读到另一个事务<strong>未提交</strong>的更新数据，所谓脏读，就是指事务A读到了事务B还没有提交的数据，比如银行取钱，事务A开启事务，此时切换到事务B，事务B开启事务--&gt;取走100元，此时切换回事务A，事务A读取的肯定是数据库里面的原始数据，因为事务B取走了100块钱，并没有提交，数据库里面的账务余额肯定还是原始余额，这就是脏读</td> 
  </tr> 
  <tr> 
   <td style="width:94px;">幻读</td> 
   <td style="width:594px;">是指当事务<strong>不是独立执行时</strong>发生的一种现象，例如第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的<strong>全部数据行</strong>。 同时，第二个事务也修改这个表中的数据，这种修改是向表中<strong>插入一行</strong>新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象 发生了幻觉一样。</td> 
  </tr> 
  <tr> 
   <td style="width:94px;">不可重复读</td> 
   <td style="width:594px;">在一个事务里面的操作中发现了<strong>未被操作的数据</strong> 比方说在同一个事务中先后执行两条一模一样的select语句，期间在此次事务中没有执行过任何DDL语句，但<strong>先后得到的结果不一致</strong>，这就是不可重复读</td> 
  </tr> 
 </tbody> 
</table>

**Spring支持的隔离级别**

<table> 
 <thead> 
  <tr> 
   <th>隔离级别</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>DEFAULT</td> 
   <td>使用<strong>数据库本身使用的</strong>隔离级别&nbsp;<font> </font>ORACLE（读已提交） MySQL（可重复读）</td> 
  </tr> 
  <tr> 
   <td>READ_UNCOMITTED</td> 
   <td>读未提交（脏读）最低的隔离级别，一切皆有可能。</td> 
  </tr> 
  <tr> 
   <td>READ_COMMITED</td> 
   <td>读已提交，ORACLE默认隔离级别，有幻读以及不可重复读风险。</td> 
  </tr> 
  <tr> 
   <td>REPEATABLE_READ</td> 
   <td>可重复读，解决不可重复读的隔离级别，但还是有幻读风险。</td> 
  </tr> 
  <tr> 
   <td>SERLALIZABLE</td> 
   <td>串行化，最高的事务隔离级别，不管多少事务，挨个运行完一个事务的所有子事务之后才可以执行另外一个事务里面的所有子事务，这样就解决了脏读、不可重复读和幻读的问题了</td> 
  </tr> 
 </tbody> 
</table>

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

再必须强调一遍，**不是事务隔离级别设置得越高越好**，事务隔离级别设置得越高，意味着势必要花手段去**加锁**用以保证事务的正确性，那么**效率就要降低**，因此实际开发中往往要在效率和并发正确性之间做一个取舍，一般情况下会设置为**READ\_COMMITED**，此时避免了脏读，并发性也还不错，之后再通过一些别的手段去解决不可重复读和幻读的问题就好了。

### 事务的传播行为 ###

保证事务：ACID

事务的传播行为针对的是嵌套的关系

Spring中的7个事务传播行为:

<table> 
 <thead> 
  <tr> 
   <th>事务行为</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>PROPAGATION_<strong>REQUIRED</strong></td> 
   <td>支持当前事务，假设当前没有事务。就<strong>新建一个事务</strong></td> 
  </tr> 
  <tr> 
   <td>PROPAGATION_<strong>SUPPORTS</strong></td> 
   <td>支持当前事务，假设当前<strong>没有事务</strong>，就以非事务方式运行</td> 
  </tr> 
  <tr> 
   <td>PROPAGATION_<strong>MANDATORY</strong></td> 
   <td>支持当前事务，假设当前没有事务，就<strong>抛出异常</strong></td> 
  </tr> 
  <tr> 
   <td>PROPAGATION_REQUIRES_<strong>NEW</strong></td> 
   <td>新建事务，假设当前存在事务。把当前事务<strong>挂起</strong></td> 
  </tr> 
  <tr> 
   <td>PROPAGATION_<strong>NOT_SUPPORTED</strong></td> 
   <td>以<strong>非事务</strong>方式运行操作。假设当前存在事务，就把当前事务<strong>挂起</strong></td> 
  </tr> 
  <tr> 
   <td>PROPAGATION_<strong>NEVER</strong></td> 
   <td>以非事务方式运行，假设当前存在事务，则<strong>抛出异常</strong></td> 
  </tr> 
  <tr> 
   <td>PROPAGATION_<strong>NESTE</strong>D</td> 
   <td>如果当前存在事务，则在<strong>嵌套事务内</strong>执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。</td> 
  </tr> 
 </tbody> 
</table>

**举例说明**

ServiceA
    
    ServiceA {   
         void methodA() {
             ServiceB.methodB();
         }
    }
    ServiceB
    
    ServiceB { 
         void methodB() {
         }  
    }

**案例代码**

#### 1.PROPAGATION\_REQUIRED ####

假如当前正要运行的事务**不在另外一个事务里**，那么就起一个新的事务 比方说，ServiceB.method**B**的事务级别定义PROPAGATION\_REQUIRED, 那么因为执行ServiceA.methodA的时候，ServiceA.methodA**已经起了事务**。这时调用ServiceB.methodB，ServiceB.methodB看到自己已经执行在ServiceA.methodA的事务内部。就**不再起**新的事务。而假如ServiceA.methodA执行的时候发现自己没有在事务中，他就会**为自己分配**一个事务。这样，在ServiceA.methodA或者在ServiceB.methodB内的不论什么地方出现异常。**事务都会被回滚**。即使ServiceB.methodB的事务已经被提交，可是ServiceA.methodA在接下来fail要回滚，ServiceB.methodB**也要回滚** ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTI2NTcz_size_16_color_FFFFFF_t_70]

#### 2.PROPAGATION\_SUPPORTS ####

假设当前在事务中。即以事务的形式执行。假设当前不在一个事务中，那么就以非事务的形式执行

#### 3PROPAGATION\_MANDATORY ####

必须在一个事务中执行。也就是说，他仅仅能被一个父事务调用。否则，他就要抛出异常

#### 4.PROPAGATION\_REQUIRES\_NEW ####

这个就比较**绕口**了。 比方我们设计ServiceA.methodA的事务级别为PROPAGATION\_REQUIRED，ServiceB.methodB的事务级别为PROPAGATION\_REQUIRES\_NEW。那么当运行到ServiceB.methodB的时候，ServiceA.methodA所在的事务就会**挂起**。ServiceB.methodB会起一个新的事务。等待ServiceB.methodB的事务完毕以后，他才继续运行。 他与PROPAGATION\_REQUIRED 的事务差别在于事务的**回滚程度**了。由于ServiceB.methodB是新起一个事务，那么就是**存在两个不同的事务**。假设ServiceB.methodB已经提交，那么ServiceA.methodA失败回滚。ServiceB.methodB是**不会回滚**的。假设ServiceB.methodB失败回滚，假设他抛出的异常被ServiceA.methodA**捕获**，ServiceA.method**A事务仍然可能提交**。 ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTI2NTcz_size_16_color_FFFFFF_t_70 1]

#### 5.PROPAGATION\_NOT\_SUPPORTED ####

当前不支持事务。比方ServiceA.methodA的事务级别是PROPAGATION\_REQUIRED 。而ServiceB.methodB的事务级别是PROPAGATION\_NOT\_SUPPORTED ，那么当执行到ServiceB.methodB时。ServiceA.methodA的**事务挂起**。而他以非事务的状态执行完，再继续ServiceA.methodA的事务。

#### 6.PROPAGATION\_NEVER ####

不能在事务中执行。 如果ServiceA.methodA的事务级别是PROPAGATION\_REQUIRED。 而ServiceB.methodB的事务级别是PROPAGATION\_NEVER ，那么ServiceB.methodB就要抛出异常了。

#### 7.PROPAGATION\_NESTED ####

如果当前存在事务，则在**嵌套事务内**执行。如果当前没有事务，则执行与PROPAGATION\_REQUIRED类似的操作。

场景对比：

![cd92e92c12ea05362c420cc4f790254b.png][]

Required 内外一起回滚

New内外互不影响

Nested 外层影响内层

### Spring事务实现的方式 ###

**编程式事务管理**：这意味着你可以通过编程的方式管理事务，这种方式带来了很大的灵活性，但很难维护。

**声明式事务管理**：这种方式意味着你可以将事务管理和业务代码分离。你只需要通过**注解或者XML**配置管理事务。

### 事务注解的本质是什么 ###

@Transactional 这个注解仅仅是一些（和事务相关的）**元数据**，在运行时被事务**基础设施**读取消费，并使用这些元数据来配置bean的事务行为。 大致来说具有两方面功能，一是表明该方法要**参与事务**，二是配置相关属性来**定制**事务的参与方式和运行行为

声明式事务主要是得益于Spring **AOP**。使用一个**事务拦截器**，在方法调用的**前后**/**周围**进行事务性**增强（advice）**，来驱动事务完成。

@Transactional注解既可以标注在**类上**，也可以标注在**方法**上。当在类上时，默认应用到类里的**所有方法**。如果此时方法上也标注了，则**方法上的优先级高**。 另外注意方法一定要是**public**的。

[10-Spring源码-事务源码分析 枫叶云笔记][10-Spring_-_]

知识来源：马士兵教育

[https://www.cnblogs.com/lcmlyj/p/13786617.html][https_www.cnblogs.com_lcmlyj_p_13786617.html]

[Spring通过什么方式实现事务传播级别的？ - 知乎][Spring_ -]

[20190703000608167.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/04/5573f2e057234d6da9f61a910bcb48fd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTI2NTcz_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/04/73134952466c405b8d4e7b9f13168920.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NTI2NTcz_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/04/e885bd167e7d4379b0afa6cd3cfaacc9.png
[cd92e92c12ea05362c420cc4f790254b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/04/b51aac071e304c4e9dcf7cade581dc1e.png
[10-Spring_-_]: https://cloud.fynote.com/share/d/IVeyV0Jp
[https_www.cnblogs.com_lcmlyj_p_13786617.html]: https://www.cnblogs.com/lcmlyj/p/13786617.html
[Spring_ -]: https://www.zhihu.com/question/22085811