事务的传播行为 - 田小晖的博客

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

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

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

事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。

1
public void methodA(){
2
    methodB();
3
    //doSomething
4
}
5

6
@Transaction(Propagation=XXX)
7
public void methodB(){
8
    //doSomething
9
}

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

Spring中七种事务传播行为

事务传播行为类型说明

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

3.验证

准备工作

创建表

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;
7

8
CREATE TABLE `user2` (
9
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
10
  `name` VARCHAR(45) NOT NULL DEFAULT '',
11
  PRIMARY KEY(`id`)
12
)
13
ENGINE = InnoDB;

实体类

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

7
public class User2 {
8
    private Integer id;
9
    private String name;
10
   //get和set方法省略...
11
}

Mapper类

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

7
public interface User2Mapper {
8
    int insert(User2 record);
9
    User2 selectByPrimaryKey(Integer id);
10
    //其他方法省略...
11
}

1.PROPAGATION_REQUIRED (抛出的异常一定得是运行时异常)

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
}
10

11
@Service
12
public class User2ServiceImpl implements User2Service {
13
    //省略其他...
14
    @Override
15
    @Transactional(propagation = Propagation.REQUIRED)
16
    public void addRequired(User2 user){
17
        user2Mapper.insert(user);
18
    }
19
    @Override
20
    @Transactional(propagation = Propagation.REQUIRED)
21
    public void addRequiredException(User2 user){
22
        user2Mapper.insert(user);
23

24
        throw new RuntimeException();
25
    }
26

27
}

1.1 外围方法不开启事务

验证方法1:

1
@Override
2
public void notransaction_exception_required_required(){
3
    User1 user1=new User1();
4
    user1.setName("张三");
5
    user1Service.addRequired(user1);
6

7
    User2 user2=new User2();
8
    user2.setName("李四");
9
    user2Service.addRequired(user2);
10

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);
6

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);
7

8
    User2 user2=new User2();
9
    user2.setName("李四");
10
    user2Service.addRequired(user2);
11

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);
7

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);
7

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修饰的内部方法和外围方法均属于同一事务，只要一个方法回滚，整个事务均回滚。

2.PROPAGATION_REQUIRES_NEW

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
}

1
@Service
2
public class User2ServiceImpl implements User2Service {
3
    //省略其他...
4
    @Override
5
    @Transactional(propagation = Propagation.REQUIRES_NEW)
6
    public void addRequiresNew(User2 user){
7
        user2Mapper.insert(user);
8
    }
9

10
    @Override
11
    @Transactional(propagation = Propagation.REQUIRES_NEW)
12
    public void addRequiresNewException(User2 user){
13
        user2Mapper.insert(user);
14
        throw new RuntimeException();
15
    }
16
}

2.1 外围方法不开启事务

验证方法1:

1
@Override
2
public void notransaction_exception_requiresNew_requiresNew(){
3
    User1 user1=new User1();
4
    user1.setName("张三");
5
    user1Service.addRequiresNew(user1);
6

7
    User2 user2=new User2();
8
    user2.setName("李四");
9
    user2Service.addRequiresNew(user2);
10

11
    throw new RuntimeException();
12

13
}

验证方法2:

1
@Override
2
public void notransaction_requiresNew_requiresNew_exception(){
3
    User1 user1=new User1();
4
    user1.setName("张三");
5
    user1Service.addRequiresNew(user1);
6

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.REQUIRES_NEW)
3
public void transaction_exception_required_requiresNew_requiresNew(){
4
    User1 user1=new User1();
5
    user1.setName("张三");
6
    user1Service.addRequired(user1);
7

8
    User2 user2=new User2();
9
    user2.setName("李四");
10
    user2Service.addRequiresNew(user2);
11

12
    User2 user3=new User2();
13
    user3.setName("王五");
14
    user2Service.addRequiresNew(user3);
15

16
    throw new RuntimeException();
17
}

验证方法2:

1
@Override
2
@Transactional(propagation = Propagation.REQUIRES_NEW)
3
public void transaction_required_requiresNew_requiresNew_exception(){
4
    User1 user1=new User1();
5
    user1.setName("张三");
6
    user1Service.addRequired(user1);
7

8
    User2 user2=new User2();
9
    user2.setName("李四");
10
    user2Service.addRequiresNew(user2);
11

12
    User2 user3=new User2();
13
    user3.setName("王五");
14
    user2Service.addRequiresNewException(user3);
15
}

验证方法3:

1
@Override
2
@Transactional(propagation = Propagation.REQUIRES_NEW)
3
public void transaction_required_requiresNew_requiresNew_exception_try(){
4
    User1 user1=new User1();
5
    user1.setName("张三");
6
    user1Service.addRequired(user1);
7

8
    User2 user2=new User2();
9
    user2.setName("李四");
10
    user2Service.addRequiresNew(user2);
11

12
    User2 user3=new User2();
13
    user3.setName("王五");
14
    try {
15
        user2Service.addRequiresNewException(user3);
16
    } catch (Exception e) {
17
        System.out.println("回滚");
18
    }
19
}

结果：

验证方法序号数据库结果结果分析

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

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

3.PROPAGATION_NESTED

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
}

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
    }
9

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);
6

7
    User2 user2=new User2();
8
    user2.setName("李四");
9
    user2Service.addNested(user2);
10

11
    throw new RuntimeException();
12
}

验证方法2:

1
@Override
2
public void notransaction_nested_nested_exception(){
3
    User1 user1=new User1();
4
    user1.setName("张三");
5
    user1Service.addNested(user1);
6

7
    User2 user2=new User2();
8
    user2.setName("李四");
9
    user2Service.addNestedException(user2);
10
}

结果：

验证方法序号数据库结果结果分析

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

3.2 外围方法开启事务

验证方法1:

1
@Transactional(propagation = Propagation.NESTED)
2
@Override
3
public void transaction_exception_nested_nested(){
4
    User1 user1=new User1();
5
    user1.setName("张三");
6
    user1Service.addNested(user1);
7

8
    User2 user2=new User2();
9
    user2.setName("李四");
10
    user2Service.addNested(user2);
11

12
    throw new RuntimeException();
13
}

验证方法2:

1
@Transactional(propagation = Propagation.NESTED)
2
@Override
3
public void transaction_nested_nested_exception(){
4
    User1 user1=new User1();
5
    user1.setName("张三");
6
    user1Service.addNested(user1);
7

8
    User2 user2=new User2();
9
    user2.setName("李四");
10
    user2Service.addNestedException(user2);
11
}

验证方法3:

1
@Transactional(propagation = Propagation.NESTED)
2
@Override
3
public void transaction_nested_nested_exception_try(){
4
    User1 user1=new User1();
5
    user1.setName("张三");
6
    user1Service.addNested(user1);
7

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修饰的内部方法属于外部事务的子事务，外围主事务回滚，子事务一定回滚，而内部子事务可以单独回滚而不影响外围主事务和其他子事务

4.PROPAGATION_MANDATORY

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

1
@Service
2
public class User2ServiceImpl implements User2Service {
3
  //省略其他...
4
    @Override
5
    public void addMandatory(User2 user) {
6
        user2Mapper.insert(user);
7
    }
8
}

4.1 外围方法不开启事务

验证方法1:

1
  @Override
2
  public void notransaction_mandatory() {
3
      User1 user1 = new User1();
4
      user1.setName("张三");
5
      user1Service.addMandatory(user1);
6

7
      User2 user2 = new User2();
8
      user2.setName("李四");
9
      user2Service.addMandatory(user2);
10
  }

4.2 外围方法开启事务

验证方法2:

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

结果：

验证方法序号数据库结果结果分析

1“张三”、“李四”均未插入。外围方法没有开启事务,张三设置成MANDATORY,李四未设置,李四报异常.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation ‘mandatory’ 不能正常插入,受异常影响,张三也不能插入 2“张三”、“李四”均插入。外围方法开启事务，且传播行为不能是PROPAGATION_MANDATORY ,数据都可以正常插入

结论：外围方法调用开启了PROPAGATION_MANDATORY的方法时,自身必须开启事务,且自身事务的传播行为不能是PROPAGATION_MANDATORY,否则会报异常

5.PROPAGATION_NEVER

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

1
  @Service
2
  public class User2ServiceImpl implements User2Service {
3
    //省略其他...
4
      @Override
5
      @Transactional(propagation = Propagation.NEVER)
6
      public void addNever(User2 user) {
7
          user2Mapper.insert(user);
8
      }
9
  }

5.1 外围方法不开启事务

验证方法1:

1
@Override
2
public void notransaction_never() {
3
    User1 user1 = new User1();
4
    user1.setName("张三");
5
    user1Service.addNever(user1);
6

7
    User2 user2 = new User2();
8
    user2.setName("李四");
9
    user2Service.addNever(user2);
10
}

5.2 外围方法开启事务

验证方法2:

1
@Override
2
@Transactional
3
public void transaction_never() {
4
    User1 user1 = new User1();
5
    user1.setName("张三");
6
    user1Service.addNever(user1);
7

8
    User2 user2 = new User2();
9
    user2.setName("李四");
10
    user2Service.addNever(user2);
11
}

结果：

验证方法序号数据库结果结果分析

1“张三”、“李四”均插入。外围方法没有开启事务,数据正常插入 2“张三”、“李四”均未插入。外围方法开启事务，李四的传播行为是NEVER,报异常org.springframework.transaction.IllegalTransactionStateException: Existing transaction found for transaction marked with propagation ‘never’,李四不能插入,受异常影响,张三也不能插入

结论：开启了事务的方法不能调用开启PROPAGATION_NEVER的方法,否则会报异常

6.PROPAGATION_SUPPORTS

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

11
@Service
12
public class User2ServiceImpl implements User2Service {
13
    //省略其他...
14
    @Override
15
    @Transactional(propagation = Propagation.SUPPORTS)
16
    public void addSupports(User2 user) {
17
        user2Mapper.insert(user);
18
    }
19

20
    @Override
21
    @Transactional(propagation = Propagation.SUPPORTS)
22
    public void addSupportsException(User2 user) {
23
        user2Mapper.insert(user);
24
        throw new RuntimeException();
25
    }
26

27
}

6.1 外围方法不开启事务

验证方法1:

1
@Override
2
public void notransaction_exception_supports_supports() {
3
    User1 user1 = new User1();
4
    user1.setName("张三");
5
    user1Service.addSupports(user1);
6

7
    User2 user2 = new User2();
8
    user2.setName("李四");
9
    user2Service.addSupports(user2);
10

11
    throw new RuntimeException();
12
}

验证方法2:

1
@Override
2
public void notransaction_supports_supports_exception() {
3
    User1 user1 = new User1();
4
    user1.setName("张三");
5
    user1Service.addSupports(user1);
6

7
    User2 user2 = new User2();
8
    user2.setName("李四");
9
    user2Service.addSupportsException(user2);
10
}

结果 :

验证方法序号数据库结果结果分析

1“张三”、“李四”均插入。外围方法未开启事务，则插入“张三”、“李四”方法以无事务方式运行，外围方法异常不影响内部插入 2“张三”、“李四”均插入。外围方法未开启事务，则插入“张三”、“李四”方法以无事务方式运行,内部异常没有事务李四也不会回滚

结论：通过这两个方法我们证明了在外围方法未开启事务的情况下Propagation.SUPPORTS修饰的内部方法会以非事务的方式运行，插入成功后出现异常，数据不会因异常回滚

6.2 外围方法开启事务

验证方法1:

1
@Override
2
@Transactional
3
public void transaction_exception_supports_supports(){
4
    User1 user1=new User1();
5
    user1.setName("张三");
6
    user1Service.addSupports(user1);
7

8
    User2 user2=new User2();
9
    user2.setName("李四");
10
    user2Service.addSupports(user2);
11

12
    throw new RuntimeException();
13
}

验证方法2:

1
@Override
2
@Transactional
3
public void transaction_supports_supports_exception(){
4
    User1 user1 = new User1();
5
    user1.setName("张三");
6
    user1Service.addSupports(user1);
7

8
    User2 user2 = new User2();
9
    user2.setName("李四");
10
    user2Service.addSupportsException(user2);
11
}

验证方法3:

1
@Transactional
2
@Override
3
public void transaction_supports_supports_exception_try(){
4
    User1 user1=new User1();
5
    user1.setName("张三");
6
    user1Service.addSupports(user1);
7

8
    User2 user2=new User2();
9
    user2.setName("李四");
10
    try {
11
        user2Service.addSupportsException(user2);
12
    } catch (Exception e) {
13
        System.out.println("方法回滚");
14
    }
15
}

结果:

验证方法序号数据库结果结果分析

1“张三”、“李四”均未插入。外围方法开启事务，内部方法支持当前事务，外围方法回滚，内部方法也要回滚。 2“张三”、“李四”均未插入。外围方法开启事务，内部方法支持当前事务，内部方法抛出异常回滚，外围方法感知异常致使整体事务回滚。 3“张三”、“李四”均未插入。外围方法开启事务，内部方法加入外围方法事务，内部方法抛出异常回滚，即使方法被catch不被外围方法感知，因为使用的是同一个事务,整个事务依然回滚。

结论：以上试验结果我们证明在外围方法开启事务的情况下Propagation.SUPPORTS修饰的内部方法会加入到外围方法的事务中，所有Propagation.SUPPORTS修饰的内部方法和外围方法均属于同一事务，只要一个方法回滚，整个事务均回滚。

7.PROPAGATION_NOT_SUPPORTED

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

11
@Service
12
public class User2ServiceImpl implements User2Service {
13
    //省略其他...
14
    @Override
15
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
16
    public void addNotSupported(User2 user) {
17
        user2Mapper.insert(user);
18
    }
19

20
    @Override
21
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
22
    public void addNotSupportedException(User2 user) {
23
        user2Mapper.insert(user);
24
        throw new RuntimeException();
25
    }
26

27
}

7.1 外围方法不开启事务

验证方法1:

1
@Override
2
public void notransaction_exception_notSupported_notSupported() {
3
    User1 user1 = new User1();
4
    user1.setName("张三");
5
    user1Service.addNotSupported(user1);
6

7
    User2 user2 = new User2();
8
    user2.setName("李四");
9
    user2Service.addNotSupported(user2);
10

11
    throw new RuntimeException();
12
}

验证方法2:

1
@Override
2
public void notransaction_supports_supports_exception() {
3
    User1 user1 = new User1();
4
    user1.setName("张三");
5
    user1Service.addSupports(user1);
6

7
    User2 user2 = new User2();
8
    user2.setName("李四");
9
    user2Service.addSupportsException(user2);
10
}

结果 :

验证方法序号数据库结果结果分析

1“张三”、“李四”均插入。外围方法未开启事务，外围方法异常不影响内部插入 2“张三”、“李四”均插入。外围方法未开启事务，内部异常没有事务李四也不会回滚

结论：通过这两个方法我们证明了在外围方法未开启事务的情况下Propagation.NOT_SUPPORTED修饰的内部方法没有事务可挂起也会以没有事务的方式运行，插入成功后出现异常，数据不会因异常回滚

7.2 外围方法开启事务

验证方法1:

1
@Override
2
@Transactional
3
public void transaction_exception_supports_supports(){
4
    User1 user1=new User1();
5
    user1.setName("张三");
6
    user1Service.addSupports(user1);
7

8
    User2 user2=new User2();
9
    user2.setName("李四");
10
    user2Service.addSupports(user2);
11

12
    throw new RuntimeException();
13
}

验证方法2:

1
@Override
2
@Transactional
3
public void transaction_supports_supports_exception(){
4
    User1 user1 = new User1();
5
    user1.setName("张三");
6
    user1Service.addSupports(user1);
7

8
    User2 user2 = new User2();
9
    user2.setName("李四");
10
    user2Service.addSupportsException(user2);
11
}

验证方法3:

1
@Transactional
2
@Override
3
public void transaction_supports_supports_exception_try(){
4
    User1 user1=new User1();
5
    user1.setName("张三");
6
    user1Service.addSupports(user1);
7

8
    User2 user2=new User2();
9
    user2.setName("李四");
10
    try {
11
        user2Service.addSupportsException(user2);
12
    } catch (Exception e) {
13
        System.out.println("方法回滚");
14
    }
15
}

结果:

验证方法序号数据库结果结果分析

1“张三”、“李四”均插入。外围方法开启事务，内部方法挂起当前事务，外围方法异常不影响内部插入 2“张三”、“李四”均插入。外围方法开启事务，内部方法挂起当前事务，外围方法异常不影响内部插入，内部异常没有事务李四也不会回滚 3“张三”、“李四”均插入。外围方法开启事务，内部方法挂起当前事务，李四没有事务,李四方法抛出异常也不会回滚

结论：以上试验结果我们证明在外围方法开启事务的情况下Propagation.NOT_SUPPORTED修饰的内部方法会挂起外围方法的事务中，所有Propagation.NOT_SUPPORTED修饰的内部方法会以没有事务的方式运行，即使发生了异常也不会回滚。

参考文章

源码地址

音乐

音乐

文章分享