Spring事务的传播行为

Spring事务的传播行为

Spring事务的传播行为有七种，对应着事务定义接口TransactionDefinition中的七种状态。PROPAGATION_REQUIRED、PROPAGATION_SUPPORTS、PROPAGATION_MANDATORY、PROPAGATION_REQUIRES_NEW、PROPAGATION_NOT_SUPPORTED、PROPAGATION_NEVER、PROPAGATION_NESTED。

1. PROPAGATION_REQUIRED

如果当前上下文中没有事务，就创建一个事务；如果当前存在事务，就加入该事务，这是最常用的默认设置。单独调用methodB时，因为上下文中没有事务，会开启一个新的事务，异常时会回滚；调用methodA时，因为上下文不存在事务，会开启一个新的事务，当执行到methodB时，methodB发现上下文有事务，就加入到当前事务中，如果methodB发生异常，触发事务回滚，methodA中的事务也会回滚。

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
    methodB();
    //do something
}

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

2. PROPAGATION_SUPPORTS

支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就以非事务的方式执行。如果调用methodA，执行到methodB时，methodB会加入到methodA开启的事务中。如果直接调用methodB，当前没有事务，就以非事务的方式执行，methodB发生异常也不会回滚。

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
    methodB();
    //do something
}

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

3. PROPAGATION_MANDATORY

支持当前事务，如果当前存在事务，就加入到该事务；如果当前不存在事务，就抛出异常。单独调用methodB，由于当前没有事务，就会跑出非法事务状态异常；如果调用methodA，执行到methodB时，就会添加到methodA开启的事务当中。

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
    methodB();
    //do something
}

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

4. PROPAGATION_REQUIRES_NEW

如果当前已有事务，会先挂起，然后开启一个新的事务。事务管理器需要使用JtaTransactionManager。当调用methodA，会先开启事务，执行A的pre部分的代码，然后调用methodB，methodB会开启一个新的事务后执行自身的代码，最后再执行methodA的post部分的代码。如果methodB发生异常回滚，只是methodB中的代码回滚，不影响methodA中的代码。如果methodA发生异常回滚，只会滚methodA中的代码，不影响methodB中的代码。外层事务和内层事务互不影响。

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
    //do something pre
    methodB();
    //do something post
}

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

5. PROPAGATION_NOT_SUPPORTED

不支持事务，如果当前存在事务，就把事务挂起来。调用methodA，再调用methodB，methodA开启的事务会被挂起，methodB内部抛出异常不会回滚。methodA发生异常会回滚。直接调用methodB，不会开启事务。

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
    methodB();
    //do something
}

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

6. PROPAGATION_NEVER

以非事务的方式执行，存在事务就抛出异常。先调用methodA，再调用methodB会报错。

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
    methodB();
    //do something
}

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

7. PROPAGATION_NESTED

如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，就按照PROPAGATION_REQUIRED属性执行。单独调用methodB，就按照PROPAGATION_REQUIRED执行。如果调用methodA，开启一个事务，执行pre部分的代码，设置回滚点，再调用methodB，如果methodB发生错误，此时会回滚到之前的回滚点，此时的事务并没有提交，如果后续的post部分调用失败，则回滚包括methodB的所有操作。内层事务依赖于外层事务，外层事务失败会回滚内层事务所做的动作，而内层事务操作失败并不会引起外层事务的回滚。

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
    //do something pre
    methodB();
    //do something post
}

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