Spring事务传播机制&隔离级别(面试被问倒了)

妖狐艹你老母 2022-05-12 04:38 146阅读 0赞

**Spring技术学习，更多知识请访问[https://www.itkc8.com][https_www.itkc8.com]**

一、Propagation （事务的传播属性）  
  
  
Propagation ：　　key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。有以下选项可供使用：  
PROPAGATION\_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。  
PROPAGATION\_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。  
PROPAGATION\_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。  
PROPAGATION\_REQUIRES\_NEW--新建事务，如果当前存在事务，把当前事务挂起，执行当前新建事务完成以后，上下文事务恢复再执行。  
PROPAGATION\_NOT\_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起，执行当前逻辑，结束后恢复上下文的事务。  
PROPAGATION\_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。  
  
  
1： PROPAGATION\_REQUIRED  
加入当前正要执行的事务不在另外一个事务里，那么就起一个新的事务  
比如说，ServiceB.methodB的事务级别定义为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也要回滚  
  
  
2： PROPAGATION\_SUPPORTS  
如果当前在事务中，即以事务的形式运行，如果当前不再一个事务中，那么就以非事务的形式运行  
  
  
3： PROPAGATION\_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.methodA事务仍然可能提交。  
  
  
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  
理解Nested的关键是savepoint。他与PROPAGATION\_REQUIRES\_NEW的区别是，PROPAGATION\_REQUIRES\_NEW另起一个事务，将会与他的父事务相互独立，  
而Nested的事务和他的父事务是相依的，他的提交是要等和他的父事务一块提交的。也就是说，如果父事务最后回滚，他也要回滚的。  
而Nested事务的好处是他有一个savepoint。  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
ServiceA \{  
  
  
/\*\*  
\* 事务属性配置为 PROPAGATION\_REQUIRED  
\*/  
void methodA() \{  
try \{  
//savepoint  
ServiceB.methodB(); //PROPAGATION\_NESTED 级别  
\} catch (SomeException) \{  
// 执行其他业务, 如 ServiceC.methodC();  
\}  
\}  
  
  
\}  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
也就是说ServiceB.methodB失败回滚，那么ServiceA.methodA也会回滚到savepoint点上，ServiceA.methodA可以选择另外一个分支，比如  
ServiceC.methodC，继续执行，来尝试完成自己的事务。  
但是这个事务并没有在EJB标准中定义。  
  
  
那么什么是嵌套事务呢？很多人都不理解，我看过一些博客，都是有些理解偏差。  
嵌套是子事务套在父事务中执行，子事务是父事务的一部分，在进入子事务之前，父事务建立一个回滚点，叫save point，然后执行子事务，这个子事务的执行也算是父事务的一部分，然后子事务执行结束，父事务继续执行。重点就在于那个save point。看几个问题就明了了：  
1)如果子事务回滚，会发生什么？   
父事务会回滚到进入子事务前建立的save point，然后尝试其他的事务或者其他的业务逻辑，父事务之前的操作不会受到影响，更不会自动回滚。  
2)如果父事务回滚，会发生什么？   
父事务回滚，子事务也会跟着回滚！为什么呢，因为父事务结束之前，子事务是不会提交的，我们说子事务是父事务的一部分，正是这个道理。那么：  
3)事务的提交，是什么情况？   
是父事务先提交，然后子事务提交，还是子事务先提交，父事务再提交？答案是第二种情况，还是那句话，子事务是父事务的一部分，由父事务统一提交。  
  
  
  
  
  
  
Spring事务的隔离级别  
 1. ISOLATION\_DEFAULT： 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.  
      另外四个与JDBC的隔离级别相对应  
 2. ISOLATION\_READ\_UNCOMMITTED： 这是事务最低的隔离级别，它充许令外一个事务可以看到这个事务未提交的数据。  
      这种隔离级别会产生脏读，不可重复读和幻像读。  
 3. ISOLATION\_READ\_COMMITTED： 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据  
 4. ISOLATION\_REPEATABLE\_READ： 这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。  
      它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。  
 5. ISOLATION\_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。  
      除了防止脏读，不可重复读外，还避免了幻像读。  
  
  
数据库并发操作存在的异常情况：  
1. 更新丢失（Lost update）： 两个事务都同时更新一行数据但是第二个事务却中途失败退出导致对数据两个修改都失效了这是系统没有执 行任何锁操作因此并发事务并没有被隔离开来。  
2. 脏读取（Dirty Reads）： 一个事务开始读取 了某行数据但是另外一个事务已经更新了此数据但没有能够及时提交。这是相当危险很可能所有操作都被回滚。  
3. 不可重复读取（Non-repeatable Reads）： 一 个事务对同一行数据重复读取两次但是却得到了不同结果。例如在两次读取中途有另外一个事务对该行数据进行了修改并提交。  
4. 两次更新问题（Second lost updates problem）： 无法重复读取特例，有两个并发事务同时读取同一行数据然后其中一个对它进行修改提交而另一个也进行了修改提交这就会造成 第一次写操作失效。  
5. 幻读（Phantom Reads）： 也称为幻像（幻 影）。事务在操作过程中进行两次查询，第二次查询结果包含了第一次查询中未出现的数据（这里并不要求两次查询SQL语句相同）这是因为在两次查询过程中有 另外一个事务插入数据造成的。  
      为了避免上面出现几种情况在标准SQL规范中定义了4个事务隔离级别，不同隔离级别对事务处理不同 。  
1.未授权读取（Read Uncommitted）： 也称 未提交读。允许脏读取但不允许更新丢失，如果一个事务已经开始写数据则另外一个数据则不允许同时进行写操作但允许其他事务读此行数据。该隔离级别可以通过 “排他写锁”实现。事务隔离的最低级别，仅可保证不读取物理损坏的数据。与READ COMMITTED 隔离级相反，它允许读取已经被其它用户修改但尚未提交确定的数据。  
2. 授权读取（Read Committed）： 也称提交 读。允许不可重复读取但不允许脏读取。这可以通过“瞬间共享读锁”和“排他写锁”实现，读取数据的事务允许其他事务继续访问该行数据，但是未提交写事务将 会禁止其他事务访问该行。SQL Server 默认的级别。在此隔离级下，SELECT 命令不会返回尚未提交（Committed） 的数据，也不能返回脏数据。  
3. 可重复读取（Repeatable Read）： 禁止 不可重复读取和脏读取。但是有时可能出现幻影数据，这可以通过“共享读锁”和“排他写锁”实现，读取数据事务将会禁止写事务（但允许读事务），写事务则禁 止任何其他事务。在此隔离级下，用SELECT 命令读取的数据在整个命令执行过程中不会被更改。此选项会影响系统的效能，非必要情况最好不用此隔离级。  
4. 串行（Serializable）： 也称可串行读。提 供严格的事务隔离，它要求事务序列化执行，事务只能一个接着一个地执行，但不能并发执行。如果仅仅通过“行级锁”是无法实现事务序列化的，必须通过其他机 制保证新插入的数据不会被刚执行查询操作事务访问到。事务隔离的最高级别，事务之间完全隔离。如果事务在可串行读隔离级别上运行，则可以保证任何并发重叠 事务均是串行的。  
  
  
隔离级别     更新丢失 脏读取 重复读取 幻读   
未授权读取     N            Y         Y          Y   
授权读取        N            N         Y          Y   
可重复 读取     N            N         N         Y   
串行               N            N         N         N  
  
  
所以最安全的，是Serializable，但是伴随而来也是高昂的性能开销。  
另外，事务常用的两个属性：readonly和timeout  
一个是设置事务为只读以提升性能。  
另一个是设置事务的超时时间，一般用于防止大事务的发生。还是那句话，事务要尽可能的小！  
  
  
最后引入一个问题：  
一个逻辑操作需要检查的条件有20条，能否为了减小事务而将检查性的内容放到事务之外呢？   
  
  
很多系统都是在DAO的内部开始启动事务，然后进行操作，最后提交或者回滚。这其中涉及到代码设计的问题。小一些的系统可以采用这种方式来做，但是在一些比较大的系统，  
逻辑较为复杂的系统中，势必会将过多的业务逻辑嵌入到DAO中，导致DAO的复用性下降。所以这不是一个好的实践。  
  
来回答这个问题：能否为了缩小事务，而将一些业务逻辑检查放到事务外面？答案是：对于核心的业务检查逻辑，不能放到事务之外，而且必须要作为分布式下的并发控制！  
一旦在事务之外做检查，那么势必会造成事务A已经检查过的数据被事务B所修改，导致事务A徒劳无功而且出现并发问题，直接导致业务控制失败。  
所以，在分布式的高并发环境下，对于核心业务逻辑的检查，要采用加锁机制。  
比如事务开启需要读取一条数据进行验证，然后逻辑操作中需要对这条数据进行修改，最后提交。  
这样的一个过程，如果读取并验证的代码放到事务之外，那么读取的数据极有可能已经被其他的事务修改，当前事务一旦提交，又会重新覆盖掉其他事务的数据，导致数据异常。  
所以在进入当前事务的时候，必须要将这条数据锁住，使用for update就是一个很好的在分布式环境下的控制手段。  
  
  
一种好的实践方式是使用编程式事务而非生命式，尤其是在较为规模的项目中。对于事务的配置，在代码量非常大的情况下，将是一种折磨，而且人肉的方式，绝对不能避免这种问题。  
将DAO保持针对一张表的最基本操作，然后业务逻辑的处理放入manager和service中进行，同时使用编程式事务更精确的控制事务范围。  
特别注意的，对于事务内部一些可能抛出异常的情况，捕获要谨慎，不能随便的catch Exception 导致事务的异常被吃掉而不能正常回滚。  
   
   
Spring配置声明式事务：  
\* 配置SessionFactory  
\* 配置事务管理器  
\* 事务的传播特性  
\* 那些类那些方法使用事务  
   
编写业务逻辑方法  
\* 继承HibernateDaoSupport类，使用HibernateTemplate来持久化，HibernateTemplate是  
   hibernate Session的轻量级封装  
\* 默认情况下运行期异常才会回滚（包括继承了RuntimeException子类），普通异常是不会滚的  
\* 编写业务逻辑方法时，最好将异常一直向上抛出，在表示层（struts）处理  
\* 关于事务边界的设置，通常设置到业务层，不要添加到Dao上  
   
  
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
    <property name="configLocation">  
     <value>classpath:hibernate.cfg.xml</value>  
    </property>  
</bean>  
  
  
  
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
    <property name="sessionFactory" ref="sessionFactory"/>  
</bean>  
  
  
  
<tx:advice id="txAdvice" transaction-manager="transactionManager">  
    <tx:attributes>  
     <tx:method name="add\*" propagation="REQUIRED"/>  
     <tx:method name="del\*" propagation="REQUIRED"/>  
     <tx:method name="modify\*" propagation="REQUIRED"/>  
     <tx:method name="\*" propagation="REQUIRED" read-only="true"/>  
    </tx:attributes>  
</tx:advice>  
  
  
  
<aop:config>  
    <aop:pointcut expression="execution(\* com.service.\*.\*(..))" id="transactionPC"/>  
    <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPC"/>  
</aop:config>  
  
  
  
<bean id="userManager" class="com.service.UserManagerImpl">  
    <property name="logManager" ref="logManager"/>  
    <property name="sessionFactory" ref="sessionFactory"/>  
</bean>  
<bean id="logManager" class="com.service.LogManagerImpl">  
    <property name="sessionFactory" ref="sessionFactory"/>  
</bean>  
**Spring技术学习，更多知识请访问[https://www.itkc8.com][https_www.itkc8.com]**

[https_www.itkc8.com]: https://www.itkc8.com