Spring事务传播机制

1.Spring对事物的支持一般有两种方式

• 编程式事务管理：通过 TransactionTemplate或者TransactionManager手动管理事务，实际应用中很少使用，这不是本文的重点，就不在这里赘述。
  
• 声明式事务管理：使用场景最多，也是最推荐使用的方式，直接加上@Transactional注解即可。
  

2.Transactional注解几大参数解释

@Transactional 注解是用于声明事务性方法的注解，通常用于标记在服务层的方法上。该注解提供了一些参数，用于配置事务的一些属性。以下是几个常用的参数及其解释：

• propagation（传播行为）：
  
• - 用于指定事务的传播行为。包括诸如 `REQUIRED`、`REQUIRES_NEW`、`SUPPORTS`、`NOT_SUPPORTED` 等。该参数定义了方法被嵌套调用时，事务如何传播。
  
• 2. isolation（隔离级别）：
  
• - 用于指定事务的隔离级别。包括 `DEFAULT`、`READ_UNCOMMITTED`、`READ_COMMITTED`、`REPEATABLE_READ`、`SERIALIZABLE`。该参数定义了事务处理过程中对数据的隔离程度。
  
• 3. readOnly（只读）：
  
• - 用于指定事务是否是只读的。如果设置为 `true`，表示只读取数据而不修改，可以优化事务处理。默认值为 `false`。
  
• 4. timeout`（超时时间）：
  
• - 用于指定事务的超时时间，单位为秒。如果事务执行时间超过指定的时间，则会被强制回滚。默认值为 `-1`，表示没有超时限制。
  
• 5. rollbackFor` 和 noRollbackFor：
  
• - 用于指定在哪些异常情况下回滚事务。`rollbackFor` 指定哪些异常时回滚，`noRollbackFor` 指定哪些异常时不回滚。可以传入异常类型的数组
  

 重点讲解propagation（传播行为）

七大参数设置： 

 场景：
假设有这样的场景 有A类和B类 A类内部有一个事务方法 B类有一个事务方法

1. class A{
2.     public B b;
3.     @Transactional
4.     public void a(){
5.         //1.对数据表A进行插入操作方法
6.         System.out.println("往A插入数据");
7.         //2.对数据表B进行插入操作方法
8.         b.b();
9.         //
10.         System.out.println("往A继续插入数据");
11.     }
12. }
14. class B{
15.     @Transactional
16.     public void b(){
17.         //对数据库进行插入操作方法
18.         System.out.println("更新表单 插入数据");
19.     }
20. }

复制代码

这种是一种常见的嵌套事务 如果都存在事务可能它的SQL是这样的

1. BEGIN
2. UPDATE A;
3.     -- B类的事务来了
4.     BEGIN
5.     UPDATE B;
6.     COMMIT;
7.     --     
8. UPDATE A;
9. COMMIT;

复制代码

这种写法在MYSQL是不支持的，如果执行了B事务那么A的部门事务失效。如果想要实现这两个事务都存在怎么办？那我们可以直接把B事务的BEGIN和COMMIT去掉 让B事务融入到A事务中即可。

1. BEGIN
2. UPDATE A;
3.     -- B类的事务来了
4.     UPDATE B;
5.     --     
6. UPDATE A;
7. COMMIT;

复制代码

这种情况其实就代表了传播行为的 REQUIRED 传播行为
具体来说，当一个方法使用 @Transactional(propagation = Propagation.REQUIRED) 进行标记时，它的行为如下：

• 存在事务时： 方法将在当前事务中运行，与调用该方法的外部事务合并为一个事务。
  
• 不存在事务时： 方法将启动一个新的事务。
  

这种情况会出现一个问题 就是外部的事务融入到当前事务中的时候如果出错那么整个事务都会进行回滚。
解决这种情况有一个名词叫挂起 挂起解释就是使用其他线程获取不同的数据库连接 如果执行两个不同的事务 这样就不会影响原本事务的流程。

1. -- 线程1获取到数据库连接1 执行A事务的流程
2. BEGIN
3. UPDATE A;
4.     -- B类的事务来了 线程2获取到数据库连接2 执行B事务的流程
5.     BEGIN
6.     UPDATE B;
7.     COMMIT;
8.     --  执行后 重新将线程B切换到线程A 来执行后续流程
9. UPDATE A;
10. COMMIT;

复制代码

这种情况也是传播行为中的REQUIRES_NEW 传播行为
具体来说，当一个方法使用 @Transactional(propagation = Propagation.REQUIRES_NEW) 进行标记时，它的行为如下：

• 存在事务时： 方法将挂起当前的事务，并启动一个新的事务。在该方法执行完毕后，新事务将被提交或回滚，然后恢复挂起的事务。
  
• 不存在事务时： 方法将启动一个新的事务。
  

还有一种情况就是嵌套事务，MySQL是不支持嵌套事务的，但Mybatis在这个层面加入了保存点和回滚点来支持。

1. BEGIN
2.     UPDATE a set score=100 where id=1;
3.     Savepoint a;
4.     update b set score=200 where id=2;
5.     ROLLBACK to a;
6. --     如果B事务出现问题 不会影响后面的事务
7.         UPDATE a set score=300 where id=3;
8. COMMIT;

复制代码

当一个方法使用 @Transactional(propagation = Propagation.NESTED) 进行标记时，它的行为如下：

• 存在事务时： 方法将在一个嵌套事务中运行。如果当前存在事务，则将创建一个新的保存点，并在方法执行时将该保存点设为当前事务的回滚点。如果方法执行后，嵌套事务回滚，则只会回滚到该保存点，而不会影响外部事务。
  
• 不存在事务时： 方法将启动一个新的事务，行为与 REQUIRED 类似。
  

上面三种情况其实就能解决掉百分之99%的事务嵌套问题，Spring为我们提供了七个事务传播行为，解释后四个

• SUPPORTS：支持当前事务，B事务设置了这个传播行为，如果A有事务就融入到A事务中，如果没有就不开启事务，这个使用场景适用于只读和只有多SELECT场景下。
  
•  MANDATORY：只支持当前事务，B事务如果设置了这个传播行为，那么它必须要被传入到一个有事务的方法中，不然就会抛出异常。
  
• NOT_SUPPORTED：不支持事务，如果B事务设置了这个传播行为，那么它如果被传入到A事务方法内，那么它会将A事务进行挂起已非事务的方法来运行。
  
• NEVER：不支持事务，只要有事务运行，就直接抛出异常。
  

 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！