4种事务特性，5种隔离级别，7种传播行为

什么是事务？

事务逻辑上的一组操作,组成这组操作的各个逻辑单元,要么一起成功,要么一起失败.

事务特性（4种）:

原子性（atomicity）:强调事务的不可分割.
一致性（consistency）:事务的执行的前后数据的完整性保持一致.
隔离性（isolation）:一个事务执行的过程中,不应该受到其他事务的干扰
持久性（durability） :事务一旦结束,数据就持久到数据库

如果不考虑隔离性引发安全性问题:

脏读 :一个事务读到了另一个事务的未提交的数据
不可重复读 :一个事务读到了另一个事务已经提交的 update 的数据导致多次查询结果不一致. （针对某条记录，两次查询不一致）
虚幻读 :一个事务读到了另一个事务已经提交的 insert 的数据导致多次查询结果不一致.（针对某张表，两次查询到条数不一致，查到了多的数据）

事务隔离级别（5种）

DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.
未提交读（read uncommited） :脏读，不可重复读，虚读都有可能发生
已提交读（read commited）:避免脏读。但是不可重复读和虚读有可能发生
可重复读（repeatable read） :避免脏读和不可重复读.但是虚读有可能发生.
串行化的（serializable） :避免以上所有读问题.

read uncommited：是最低的事务隔离级别，它允许另外一个事务可以看到这个事务未提交的数据。
read commited：保证一个事物提交后才能被另外一个事务读取。另外一个事务不能读取该事物未提交的数据。
repeatable read：这种事务隔离级别可以防止脏读，不可重复读。但是可能会出现幻象读。它除了保证一个事务不能被另外一个事务读取未提交的数据之外还避免了以下情况产生（不可重复读）。
serializable：这是花费最高代价但最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读之外，还避免了幻象读（避免三种）。

Mysql 默认:可重复读

Oracle 默认:读已提交

什么是事务的传播行为？

　　即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。

　　事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。
例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个新事务运行，这就是由methodB的事务传播行为决定的。

在Spring种定义有7种传播行为：

保证同一个事务中（三种）

1、PROPAGATION_REQUIRED 支持当前事务，如果不存在就新建一个(默认)

 1 @Transactional(propagation = Propagation.REQUIRED)
 2 public void methodA() {
 3  methodB();
 4 // do something
 5 }
 6  
 7 @Transactional(propagation = Propagation.REQUIRED)
 8 public void methodB() {
 9     // do something
10 }

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

2、PROPAGATION_SUPPORTS 支持当前事务，如果不存在，就不使用事务

 1 @Transactional(propagation = Propagation.REQUIRED)
 2 public void methodA() {
 3  methodB();
 4 // do something
 5 }
 6  
 7 // 事务属性为SUPPORTS
 8 @Transactional(propagation = Propagation.SUPPORTS)
 9 public void methodB() {
10     // do something
11 }

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

3、PROPAGATION_MANDATORY 支持当前事务，如果不存在，抛出异常（mandatory：强制的）

 1 @Transactional(propagation = Propagation.REQUIRED)
 2 public void methodA() {
 3  methodB();
 4 // do something
 5 }
 6  
 7 // 事务属性为MANDATORY
 8 @Transactional(propagation = Propagation.MANDATORY)
 9 public void methodB() {
10     // do something
11 }

当单独调用methodB时，因为当前没有一个活动的事务，则会抛出异常throw new IllegalTransactionStateException(“Transaction propagation ‘mandatory’ but no existing transaction found”);当调用methodA时，methodB则加入到methodA的事务中，事务地执行。

保证没有在同一个事务中（四种）

4、PROPAGATION_REQUIRES_NEW 如果有事务存在，挂起当前事务，创建一个新的事务

 1 @Transactional(propagation = Propagation.REQUIRED)
 2 public void methodA() {
 3 doSomeThingA();
 4 methodB();
 5 doSomeThingB();
 6 // do something else
 7 }
 8  
 9 @Transactional(propagation = Propagation.REQUIRES_NEW)
10 public void methodB() {
11     // do something
12 }

当执行methodA()时，相当于执行了

 1 TransactionManager tm = null;
 2 try{
 3     //获得一个JTA事务管理器
 4     tm = getTransactionManager();
 5     tm.begin();//开启一个新的事务
 6     Transaction ts1 = tm.getTransaction();
 7     doSomeThing();
 8     tm.suspend();//挂起当前事务
 9     try{
10         tm.begin();//重新开启第二个事务
11         Transaction ts2 = tm.getTransaction();
12         methodB();
13         ts2.commit();//提交第二个事务
14     } Catch(RunTimeException ex) {
15         ts2.rollback();//回滚第二个事务
16     } finally {
17         //释放资源
18     }
19     //methodB执行完后，恢复第一个事务
20     tm.resume(ts1);
21     doSomeThingB();
22     ts1.commit();//提交第一个事务
23 } catch(RunTimeException ex) {
24     ts1.rollback();//回滚第一个事务
25 } finally {
26     //释放资源
27 }

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

5、PROPAGATION_NOT_SUPPORTED 以非事务方式运行，如果有事务存在，挂起当前事务

6、PROPAGATION_NEVER 以非事务方式运行，如果有事务存在，抛出异常

7、PROPAGATION_NESTED 如果当前事务存在，则嵌套事务执行

 1 @Transactional(propagation = Propagation.REQUIRED)
 2 methodA(){
 3   doSomeThingA();
 4   methodB();
 5   doSomeThingB();
 6 }
 7  
 8 @Transactional(propagation = Propagation.NESTED)
 9 methodB(){
10   ……
11 }

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

 1 Connection con = null;
 2 Savepoint savepoint = null;
 3 try{
 4     con = getConnection();
 5     con.setAutoCommit(false);
 6     doSomeThingA();
 7     savepoint = con2.setSavepoint();
 8     try{
 9         methodB();
10     } catch(RuntimeException ex) {
11         con.rollback(savepoint);
12     } finally {
13         //释放资源
14     }
15     doSomeThingB();
16     con.commit();
17 } catch(RuntimeException ex) {
18     con.rollback();
19 } finally {
20     //释放资源
21 }

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