前言

Spring在TransactionDefinition接口中规定了7种类型的事务传播行为。事务传播行为是Spring框架独有的事务增强特性，他不属于的事务实际提供方数据库行为。这是Spring为我们提供的强大的工具箱，使用事务传播行可以为我们的开发工作提供许多便利。但是人们对他的误解也颇多，你一定也听过“service方法事务最好不要嵌套”的传言。要想正确的使用工具首先需要了解工具。本文对七种事务传播行为做详细介绍，内容主要代码示例的方式呈现。

Spring事务过程

  1. -- Mysql查看数据库连接个数
  2. show status like 'Threads%';

过程：

  1. public void test(){
  2.     //建立数据库连接 conn
  3.     //conn.isautocommit=false
  4.     //conn.begin();
  6.     try{
  7.         target.test();  //sql1 , sql2
  8.     }catch(){
  9.         conn.rollback();
  10.     }
  12.     //conn.commit();
  13. }

注意

  • Spring事务针对的是代理对象，如果调用同一个类中直接调用方法，事务不生效（可以自己注入自己调用）

    基础概念

    1. 什么是事务传播行为？

    事务传播行为用来描述由某一个事务传播行为修饰的方法被嵌套进另一个方法的时事务如何传播。
    用伪代码说明：

    1. public void methodA(){
    2.   methodB();
    3.   //doSomething
    4. }
    6. @Transaction(Propagation=XXX)
    7. public void methodB(){
    8.   //doSomething
    9. }

    代码中methodA()方法嵌套调用了methodB()方法，methodB()的事务传播行为由@Transaction(Propagation=XXX)设置决定。这里需要注意的是methodA()并没有开启事务，某一个事务传播行为修饰的方法并不是必须要在开启事务的外围方法中调用。

    2. Spring中七种事务传播行为

    | 事务传播行为类型 | 说明 | | —- | —- | | PROPAGATION_REQUIRED | 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。 | | PROPAGATION_SUPPORTS | 支持当前事务，如果当前没有事务，就以非事务方式执行。 | | PROPAGATION_MANDATORY | 使用当前的事务，如果当前没有事务，就抛出异常。 | | PROPAGATION_REQUIRES_NEW | 新建事务，如果当前存在事务，把当前事务挂起。 | | PROPAGATION_NOT_SUPPORTED | 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 | | PROPAGATION_NEVER | 以非事务方式执行，如果当前存在事务，则抛出异常。 | | PROPAGATION_NESTED | 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。 |

定义非常简单，也很好理解，下面我们就进入代码测试部分，验证我们的理解是否正确。

代码验证

文中代码以传统三层结构中两层呈现，即Service和Dao层，由Spring负责依赖注入和注解式事务管理，DAO层由Mybatis实现，你也可以使用任何喜欢的方式，例如，Hibernate,JPA,JDBCTemplate等。数据库使用的是MySQL数据库，你也可以使用任何支持事务的数据库，并不会影响验证结果。
首先我们在数据库中创建两张表：
user1

  1. CREATE TABLE `user1` (
  2.   `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  3.   `name` VARCHAR(45) NOT NULL DEFAULT '',
  4.   PRIMARY KEY(`id`)
  5. )
  6. ENGINE = InnoDB;

user2

  1. CREATE TABLE `user2` (
  2.   `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  3.   `name` VARCHAR(45) NOT NULL DEFAULT '',
  4.   PRIMARY KEY(`id`)
  5. )
  6. ENGINE = InnoDB;

然后编写相应的Bean和DAO层代码：
User1

  1. public class User1 {
  2.     private Integer id;
  3.     private String name;
  4.     //get和set方法省略...
  5. }

User2

  1. public class User2 {
  2.     private Integer id;
  3.     private String name;
  4.     //get和set方法省略...
  5. }

User1Mapper

  1. public interface User1Mapper {
  2.     int insert(User1 record);
  3.     User1 selectByPrimaryKey(Integer id);
  4.     //其他方法省略...
  5. }

User2Mapper

  1. public interface User2Mapper {
  2.     int insert(User2 record);
  3.     User2 selectByPrimaryKey(Integer id);
  4.     //其他方法省略...
  5. }

最后也是具体验证的代码由service层实现，下面我们分情况列举。

1.PROPAGATION_REQUIRED

我们为User1Service和User2Service相应方法加上Propagation.REQUIRED属性。
User1Service方法：

  1. @Service
  2. public class User1ServiceImpl implements User1Service {
  3.     //省略其他...
  4.     @Override
  5.     @Transactional(propagation = Propagation.REQUIRED)
  6.     public void addRequired(User1 user){
  7.         user1Mapper.insert(user);
  8.     }
  9. }

User2Service方法：

  1. @Service
  2. public class User2ServiceImpl implements User2Service {
  3.     //省略其他...
  4.     @Override
  5.     @Transactional(propagation = Propagation.REQUIRED)
  6.     public void addRequired(User2 user){
  7.         user2Mapper.insert(user);
  8.     }
  9.     @Override
  10.     @Transactional(propagation = Propagation.REQUIRED)
  11.     public void addRequiredException(User2 user){
  12.         user2Mapper.insert(user);
  13.         throw new RuntimeException();
  14.     }
  16. }

1.1 场景一

此场景外围方法没有开启事务。
验证方法1：

  1. @Override
  2. public void notransaction_exception_required_required(){
  3.     User1 user1=new User1();
  4.     user1.setName("张三");
  5.     user1Service.addRequired(user1);
  7.     User2 user2=new User2();
  8.     user2.setName("李四");
  9.     user2Service.addRequired(user2);
  11.     throw new RuntimeException();
  12.     }

验证方法2：

  1. @Override
  2. public void notransaction_required_required_exception(){
  3.     User1 user1=new User1();
  4.     user1.setName("张三");
  5.     user1Service.addRequired(user1);
  7.     User2 user2=new User2();
  8.     user2.setName("李四");
  9.     user2Service.addRequiredException(user2);
  10.     }

分别执行验证方法，结果：

验证方法序号 数据库结果 结果分析
1 “张三”、“李四”均插入。 外围方法未开启事务，插入“张三”、“李四”方法在自己的事务中独立运行，外围方法异常不影响内部插入“张三”、“李四”方法独立的事务。
2 “张三”插入，“李四”未插入。 外围方法没有事务，插入“张三”、“李四”方法都在自己的事务中独立运行,所以插入“李四”方法抛出异常只会回滚插入“李四”方法，插入“张三”方法不受影响。

结论：通过这两个方法我们证明了在外围方法未开启事务的情况下**Propagation.REQUIRED**修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。

1.2 场景二

外围方法开启事务，这个是使用率比较高的场景。
验证方法1：

  1. @Override
  2. @Transactional(propagation = Propagation.REQUIRED)
  3. public void transaction_exception_required_required(){
  4.     User1 user1=new User1();
  5.     user1.setName("张三");
  6.     user1Service.addRequired(user1);
  8.     User2 user2=new User2();
  9.     user2.setName("李四");
  10.     user2Service.addRequired(user2);
  12.     throw new RuntimeException();
  13.     }

验证方法2：

  1. @Override
  2. @Transactional(propagation = Propagation.REQUIRED)
  3. public void transaction_required_required_exception(){
  4.     User1 user1=new User1();
  5.     user1.setName("张三");
  6.     user1Service.addRequired(user1);
  8.     User2 user2=new User2();
  9.     user2.setName("李四");
  10.     user2Service.addRequiredException(user2);
  11.     }

验证方法3：

  1. @Transactional
  2. @Override
  3. public void transaction_required_required_exception_try(){
  4.     User1 user1=new User1();
  5.     user1.setName("张三");
  6.     user1Service.addRequired(user1);
  8.     User2 user2=new User2();
  9.     user2.setName("李四");
  10.     try {
  11.         user2Service.addRequiredException(user2);
  12.     } catch (Exception e) {
  13.         System.out.println("方法回滚");
  14.     }
  15.     }

分别执行验证方法，结果：

验证方法序号 数据库结果 结果分析
1 “张三”、“李四”均未插入。 外围方法开启事务，内部方法加入外围方法事务，外围方法回滚，内部方法也要回滚。
2 “张三”、“李四”均未插入。 外围方法开启事务，内部方法加入外围方法事务，内部方法抛出异常回滚，外围方法感知异常致使整体事务回滚。
3 “张三”、“李四”均未插入。 外围方法开启事务，内部方法加入外围方法事务，内部方法抛出异常回滚，即使方法被catch不被外围方法感知，整个事务依然回滚。

结论：以上试验结果我们证明在外围方法开启事务的情况下**Propagation.REQUIRED**修饰的内部方法会加入到外围方法的事务中，所有**Propagation.REQUIRED**修饰的内部方法和外围方法均属于同一事务，只要一个方法回滚，整个事务均回滚。
注意：调用者和被调用者是否在同一个类中效果不同。(是因为Spring的事务使用的是代理的方式)
目前的demo是不同类的，catch异常后回滚；
然而，如果在同一个类中，catch却不回滚。
(在同一个类中是自我调用，事务注解不会生效的，所以只有外围方法的事务，try catch异常当然不会回滚
spring声明式事务 同一类内方法调用事务失效

2.PROPAGATION_REQUIRES_NEW

我们为User1Service和User2Service相应方法加上Propagation.REQUIRES_NEW属性。
User1Service方法：

  1. @Service
  2. public class User1ServiceImpl implements User1Service {
  3.     //省略其他...
  4.     @Override
  5.     @Transactional(propagation = Propagation.REQUIRES_NEW)
  6.     public void addRequiresNew(User1 user){
  7.         user1Mapper.insert(user);
  8.     }
  9.     @Override
  10.     @Transactional(propagation = Propagation.REQUIRED)
  11.     public void addRequired(User1 user){
  12.         user1Mapper.insert(user);
  13.     }
  14. }

User2Service方法：

  2. @Service
  3. public class User2ServiceImpl implements User2Service {
  4.     //省略其他...
  5.     @Override
  6.     @Transactional(propagation = Propagation.REQUIRES_NEW)
  7.     public void addRequiresNew(User2 user){
  8.         user2Mapper.insert(user);
  9.     }
  11.     @Override
  12.     @Transactional(propagation = Propagation.REQUIRES_NEW)
  13.     public void addRequiresNewException(User2 user){
  14.         user2Mapper.insert(user);
  15.         throw new RuntimeException();
  16.     }
  17. }

2.1 场景一

外围方法没有开启事务。
验证方法1：

  1. @Override
  2. public void notransaction_exception_requiresNew_requiresNew(){
  3.     User1 user1=new User1();
  4.     user1.setName("张三");
  5.     user1Service.addRequiresNew(user1);
  7.     User2 user2=new User2();
  8.     user2.setName("李四");
  9.     user2Service.addRequiresNew(user2);
  10.     throw new RuntimeException();
  12.     }

验证方法2：

  1. @Override
  2. public void notransaction_requiresNew_requiresNew_exception(){
  3.     User1 user1=new User1();
  4.     user1.setName("张三");
  5.     user1Service.addRequiresNew(user1);
  7.     User2 user2=new User2();
  8.     user2.setName("李四");
  9.     user2Service.addRequiresNewException(user2);
  10.     }

分别执行验证方法，结果：

验证方法序号 数据库结果 结果分析
1 “张三”插入，“李四”插入。 外围方法没有事务，插入“张三”、“李四”方法都在自己的事务中独立运行,外围方法抛出异常回滚不会影响内部方法。
2 “张三”插入，“李四”未插入 外围方法没有开启事务，插入“张三”方法和插入“李四”方法分别开启自己的事务，插入“李四”方法抛出异常回滚，其他事务不受影响。

结论：通过这两个方法我们证明了在外围方法未开启事务的情况下**Propagation.REQUIRES_NEW**修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。

2.2 场景二

外围方法开启事务。
验证方法1：

  1. @Override
  2. @Transactional(propagation = Propagation.REQUIRED)
  3. public void transaction_exception_required_requiresNew_requiresNew(){
  4.     User1 user1=new User1();
  5.     user1.setName("张三");
  6.     user1Service.addRequired(user1);
  8.     User2 user2=new User2();
  9.     user2.setName("李四");
  10.     user2Service.addRequiresNew(user2);
  12.     User2 user3=new User2();
  13.     user3.setName("王五");
  14.     user2Service.addRequiresNew(user3);
  15.     throw new RuntimeException();
  16.     }

验证方法2：

  1. @Override
  2. @Transactional(propagation = Propagation.REQUIRED)
  3. public void transaction_required_requiresNew_requiresNew_exception(){
  4.     User1 user1=new User1();
  5.     user1.setName("张三");
  6.     user1Service.addRequired(user1);
  8.     User2 user2=new User2();
  9.     user2.setName("李四");
  10.     user2Service.addRequiresNew(user2);
  12.     User2 user3=new User2();
  13.     user3.setName("王五");
  14.     user2Service.addRequiresNewException(user3);
  15.     }

验证方法3：

  1. @Override
  2. @Transactional(propagation = Propagation.REQUIRED)
  3. public void transaction_required_requiresNew_requiresNew_exception_try(){
  4.     User1 user1=new User1();
  5.     user1.setName("张三");
  6.     user1Service.addRequired(user1);
  8.     User2 user2=new User2();
  9.     user2.setName("李四");
  10.     user2Service.addRequiresNew(user2);
  11.     User2 user3=new User2();
  12.     user3.setName("王五");
  13.     try {
  14.         user2Service.addRequiresNewException(user3);
  15.     } catch (Exception e) {
  16.         System.out.println("回滚");
  17.     }
  18.     }

分别执行验证方法，结果：

验证方法序号 数据库结果 结果分析
1 “张三”未插入，“李四”插入，“王五”插入。 外围方法开启事务，插入“张三”方法和外围方法一个事务，插入“李四”方法、插入“王五”方法分别在独立的新建事务中，外围方法抛出异常只回滚和外围方法同一事务的方法，故插入“张三”的方法回滚。
2 “张三”未插入，“李四”插入，“王五”未插入。 外围方法开启事务，插入“张三”方法和外围方法一个事务，插入“李四”方法、插入“王五”方法分别在独立的新建事务中。插入“王五”方法抛出异常，首先插入 “王五”方法的事务被回滚，异常继续抛出被外围方法感知，外围方法事务亦被回滚，故插入“张三”方法也被回滚。
3 “张三”插入，“李四”插入，“王五”未插入。 外围方法开启事务，插入“张三”方法和外围方法一个事务，插入“李四”方法、插入“王五”方法分别在独立的新建事务中。插入“王五”方法抛出异常，首先插入“王五”方法的事务被回滚，异常被catch不会被外围方法感知，外围方法事务不回滚，故插入“张三”方法插入成功。

结论：在外围方法开启事务的情况下**Propagation.REQUIRES_NEW**修饰的内部方法依然会单独开启独立事务，且与外部方法事务也独立，内部方法之间、内部方法和外部方法事务均相互独立，互不干扰。

3.PROPAGATION_NESTED

我们为User1Service和User2Service相应方法加上Propagation.NESTED属性。
User1Service方法：

  1. @Service
  2. public class User1ServiceImpl implements User1Service {
  3.     //省略其他...
  4.     @Override
  5.     @Transactional(propagation = Propagation.NESTED)
  6.     public void addNested(User1 user){
  7.         user1Mapper.insert(user);
  8.     }
  9. }

User2Service方法：

  1. @Service
  2. public class User2ServiceImpl implements User2Service {
  3.     //省略其他...
  4.     @Override
  5.     @Transactional(propagation = Propagation.NESTED)
  6.     public void addNested(User2 user){
  7.         user2Mapper.insert(user);
  8.     }
  10.     @Override
  11.     @Transactional(propagation = Propagation.NESTED)
  12.     public void addNestedException(User2 user){
  13.         user2Mapper.insert(user);
  14.         throw new RuntimeException();
  15.     }
  16. }

3.1 场景一

此场景外围方法没有开启事务。
验证方法1：

  1. @Override
  2. public void notransaction_exception_nested_nested(){
  3.     User1 user1=new User1();
  4.     user1.setName("张三");
  5.     user1Service.addNested(user1);
  7.     User2 user2=new User2();
  8.     user2.setName("李四");
  9.     user2Service.addNested(user2);
  10.     throw new RuntimeException();
  11.     }

验证方法2：

  1. @Override
  2. public void notransaction_nested_nested_exception(){
  3.     User1 user1=new User1();
  4.     user1.setName("张三");
  5.     user1Service.addNested(user1);
  7.     User2 user2=new User2();
  8.     user2.setName("李四");
  9.     user2Service.addNestedException(user2);
  10.     }

分别执行验证方法，结果：

验证方法序号 数据库结果 结果分析
1 “张三”、“李四”均插入。 外围方法未开启事务，插入“张三”、“李四”方法在自己的事务中独立运行，外围方法异常不影响内部插入“张三”、“李四”方法独立的事务。
2 “张三”插入，“李四”未插入。 外围方法没有事务，插入“张三”、“李四”方法都在自己的事务中独立运行,所以插入“李四”方法抛出异常只会回滚插入“李四”方法，插入“张三”方法不受影响。

结论：通过这两个方法我们证明了在外围方法未开启事务的情况下**Propagation.NESTED**和**Propagation.REQUIRED**作用相同，修饰的内部方法都会新开启自己的事务，且开启的事务相互独立，互不干扰。

3.2 场景二

外围方法开启事务。
验证方法1：

  1. @Transactional
  2. @Override
  3. public void transaction_exception_nested_nested(){
  4.     User1 user1=new User1();
  5.     user1.setName("张三");
  6.     user1Service.addNested(user1);
  8.     User2 user2=new User2();
  9.     user2.setName("李四");
  10.     user2Service.addNested(user2);
  11.     throw new RuntimeException();
  12.     }

验证方法2：

  1. @Transactional
  2. @Override
  3. public void transaction_nested_nested_exception(){
  4.     User1 user1=new User1();
  5.     user1.setName("张三");
  6.     user1Service.addNested(user1);
  8.     User2 user2=new User2();
  9.     user2.setName("李四");
  10.     user2Service.addNestedException(user2);
  11.     }

验证方法3：

  1. @Transactional
  2. @Override
  3. public void transaction_nested_nested_exception_try(){
  4.     User1 user1=new User1();
  5.     user1.setName("张三");
  6.     user1Service.addNested(user1);
  8.     User2 user2=new User2();
  9.     user2.setName("李四");
  10.     try {
  11.         user2Service.addNestedException(user2);
  12.     } catch (Exception e) {
  13.         System.out.println("方法回滚");
  14.     }
  15.     }

分别执行验证方法，结果：

验证方法序号 数据库结果 结果分析
1 “张三”、“李四”均未插入。 外围方法开启事务，内部事务为外围事务的子事务，外围方法回滚，内部方法也要回滚。
2 “张三”、“李四”均未插入。 外围方法开启事务，内部事务为外围事务的子事务，内部方法抛出异常回滚，且外围方法感知异常致使整体事务回滚。
3 “张三”插入、“李四”未插入。 外围方法开启事务，内部事务为外围事务的子事务，插入“李四”内部方法抛出异常，可以单独对子事务回滚。

结论：以上试验结果我们证明在外围方法开启事务的情况下**Propagation.NESTED**修饰的内部方法属于外部事务的子事务，外围主事务回滚，子事务一定回滚，而内部子事务可以单独回滚而不影响外围主事务和其他子事务
（父连子，子不连父）

异同 REQUIRED,REQUIRES_NEW,NESTED

由“1.2 场景二”和“3.2 场景二”对比，我们可知：
NESTED和REQUIRED修饰的内部方法都属于外围方法事务，如果外围方法抛出异常，这两种方法的事务都会被回滚。但是REQUIRED是加入外围方法事务，所以和外围事务同属于一个事务，一旦REQUIRED事务抛出异常被回滚，外围方法事务也将被回滚。而NESTED是外围方法的子事务，有单独的保存点，所以NESTED方法抛出异常被回滚，不会影响到外围方法的事务。（父连子，子不连父）

由“2.2 场景二”和“3.2 场景二”对比，我们可知：
NESTED和REQUIRES_NEW都可以做到内部方法事务回滚而不影响外围方法事务。但是因为NESTED是嵌套事务，所以外围方法回滚之后，作为外围方法事务的子事务也会被回滚。而REQUIRES_NEW是通过开启新的事务实现的，内部事务和外围事务是两个事务，外围事务回滚不会影响内部事务。

4. PROPAGATION_SUPPORTS

如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。但是对于事务同步的事务管理器，PROPAGATION_SUPPORTS与不使用事务有少许不同。

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

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

5. PROPAGATION_MANDATORY

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

  1. @Transactional(propagation = Propagation.REQUIRED)
  2. public void methodA() {
  3.  methodB();
  4. // do something
  5. }
  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的事务中，事务地执行。

6. PROPAGATION_NOT_SUPPORTED

PROPAGATION_NOT_SUPPORTED 总是非事务地执行，并挂起任何存在的事务。使用PROPAGATION_NOT_SUPPORTED,也需要使用JtaTransactionManager作为事务管理器。
方法A包含方法B调用，执行到方法B时，会挂起事务A，然后以非事务的方式执行方法B。

7. PROPAGATION_NEVER

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

模拟用例

介绍了这么多事务传播行为，我们在实际工作中如何应用呢？下面我来举一个示例：
假设我们有一个注册的方法，方法中调用添加积分的方法，如果我们希望添加积分不会影响注册流程（即添加积分执行失败回滚不能使注册方法也回滚），我们会这样写：

  1. @Service
  2. public class UserServiceImpl implements UserService {
  4.     @Transactional
  5.     public void register(User user){
  7.         try {
  8.             membershipPointService.addPoint(Point point);
  9.         } catch (Exception e) {
  10.             //省略...
  11.         }
  12.         //省略...
  13.     }
  14.     //省略...
  15.    }

我们还规定注册失败要影响addPoint()方法（注册方法回滚添加积分方法也需要回滚），那么addPoint()方法就需要这样实现：

  1. @Service
  2. public class MembershipPointServiceImpl implements MembershipPointService{
  4.     @Transactional(propagation = Propagation.NESTED)
  5.     public void addPoint(Point point){
  7.         try {
  8.             recordService.addRecord(Record record);
  9.         } catch (Exception e) {
  10.             //省略...
  11.         }
  12.         //省略...
  13.     }
  14.     //省略...
  15.    }

我们注意到了在addPoint()中还调用了addRecord()方法，这个方法用来记录日志。他的实现如下：

  1. @Service
  2. public class RecordServiceImpl implements RecordService{
  4.     @Transactional(propagation = Propagation.NOT_SUPPORTED)
  5.     public void addRecord(Record record){
  8.         //省略...
  9.     }
  10.     //省略...
  11.    }

我们注意到addRecord()方法中propagation = Propagation.NOT_SUPPORTED，因为对于日志无所谓精确，可以多一条也可以少一条，所以addRecord()方法本身和外围addPoint()方法抛出异常都不会使addRecord()方法回滚，并且addRecord()方法抛出异常也不会影响外围addPoint()方法的执行。
通过这个例子相信大家对事务传播行为的使用有了更加直观的认识，通过各种属性的组合确实能让我们的业务实现更加灵活多样。

事务失效的问题

数据库引擎不支持事务

从 MySQL 5.5.5 开始的默认存储引擎是：InnoDB，之前默认的都是：MyISAM .
其 MyISAM 引擎是不支持事务操作的，InnoDB 才是支持事务的引擎，一般要支持事务都会使用 InnoDB。

没有被 Spring 管理

  1. // @Service    //如果此时把 @Service 注解注释掉，这个类就不会被加载成一个 Bean，那这个类就不会被 Spring 管理了，事务自然就失效了。
  2. public class OrderServiceImpl implements OrderService {
  4.     @Transactional
  5.     public void updateOrder(Order order) {
  6.         // update order
  7.     }
  9. }

自身调用问题

详见AOP

不支持事务

异常被吃了

  1. // @Service
  2. public class OrderServiceImpl implements OrderService {
  4.     @Transactional
  5.     public void updateOrder(Order order) {
  6.         try {
  7.             // update order    
  8.         } catch {
  9.                 //把异常吃了，然后又不抛出来，事务怎么回滚吧！
  10.         }
  11.     }
  13. }

异常类型错误

  1. // @Service
  2. public class OrderServiceImpl implements OrderService {
  4.     @Transactional
  5.     public void updateOrder(Order order) {
  6.         try {
  7.             // update order
  8.         } catch {
  9.             throw new Exception("更新错误");
  10.         }
  11.     }
  13. }

这样事务也是不生效的，因为默认回滚的是：RuntimeException，如果你想触发其他异常的回滚，需要在注解上配置一下，如：

  1. @Transactional(rollbackFor = Exception.class)

这个配置仅限于 Throwable 异常类及其子类。
需要两个方法上都加上注解，Spring事务中，默认是只有运行时异常（RuntimeException及其子类）才会回滚，而且使用的默认传播性是REQUIRED。

  1. @Transactional(rollbackFor=RuntimeException.class) // 运行时异常才回滚。可以把 rollbackFor 设置为 Exception.class 异常就回滚。

区别

  • PROPAGATION_NESTED 与PROPAGATION_REQUIRES_NEW的区别:
    它们非常类似,都像一个嵌套事务，如果不存在一个活动的事务，都会开启一个新的事务。
    使用 PROPAGATION_REQUIRES_NEW时，内层事务与外层事务就像两个独立的事务一样，一旦内层事务进行了提交后，外层事务不能对其进行回滚。两个事务互不影响。两个事务不是一个真正的嵌套事务。同时它需要JTA事务管理器的支持。
    使用PROPAGATION_NESTED时，外层事务的回滚可以引起内层事务的回滚。而内层事务的异常并不会导致外层事务的回滚，它是一个真正的嵌套事务。DataSourceTransactionManager使用savepoint支持PROPAGATION_NESTED时，需要JDBC 3.0以上驱动及1.4以上的JDK版本支持。其它的JTATrasactionManager实现可能有不同的支持方式。
    PROPAGATION_REQUIRES_NEW 启动一个新的, 不依赖于环境的 “内部” 事务. 这个事务将被完全 commited 或 rolled back 而不依赖于外部事务, 它拥有自己的隔离范围, 自己的锁, 等等. 当内部事务开始执行时, 外部事务将被挂起, 内务事务结束时, 外部事务将继续执行。
    另一方面, PROPAGATION_NESTED 开始一个 “嵌套的” 事务, 它是已经存在事务的一个真正的子事务. 潜套事务开始执行时, 它将取得一个 savepoint. 如果这个嵌套事务失败, 我们将回滚到此 savepoint. 潜套事务是外部事务的一部分, 只有外部事务结束后它才会被提交。
    由此可见, PROPAGATION_REQUIRES_NEW 和 PROPAGATION_NESTED 的最大区别在于, PROPAGATION_REQUIRES_NEW 完全是一个新的事务, 而 PROPAGATION_NESTED 则是外部事务的子事务, 如果外部事务 commit, 嵌套事务也会被 commit, 这个规则同样适用于 roll back.

    服务挂起

    前提：方法A支持事务，方法B不支持事务，方法A调用方法B。
    解读：在方法A开始运行时，系统为它建立Transaction,方法A中对于数据库的处理操作，会在该Transaction的控制之下。这时，方法A调用方法B,方法A打开的 Transaction将挂起，方法B中任何数据库操作，都不在该Transaction的管理之下。当方法B返回，方法A继续运行，之前的Transaction回复，后面的数据库操作继续在该Transaction的控制之下 提交或回滚。

参考资料