Spring事务的传播级别——包你一文通

一、简单说明

二、具体案例描述

2.1.PROPAGATION_REQUIRED

@Transactional(propagation=PROPAGATION_REQUIRED)
pubilc void methodA(){
        doPreSomething;
        methodB();
        doSufSomething;
}

@Transactional(propagation=PROPAGATION_REQUIRED)
pubilc void methodB(){
        doSomething;
}

在两个方法的事务传播级别都是PROPAGATION_REQURIED的时候。
如果调用方法A，会开启一个事务，在方法A内部调用方法B，由于方法A已经存在开启尚未提交的事务，方法B不会就不会再开启一个新的事务，方法B会直接加入方法A的事务中执行，这样如果在执行方法B的时候出了异常导致事务回滚，则B的方法和A的方法都会回滚。如果A的doPreSomething()和方法B都执行成功了，但是在执行doSufSomething()方法的时候抛出了异常导致事务回滚，则doSufSomething()、methodB()和doPreSomething()都会回滚。
如果不通过方法A而单独调用方法B，则会开启一个事务。
PROPAGATION_REQURIED所有方法公用一个事务，要么一起成功提交，要么一起失败回滚。
如果嵌套执行的方法要求一起执行成功或者一起回滚，则选择该事物传播级别。

执行逻辑：

开启事务
执行方法Ａ的doPreSomething
执行方法B
执行方法A的doSufSomething
提交或回滚事务

2.2.PROPAGATION_REQUIRED_NEW

@Transactional(propagation=PROPAGATION_REQUIRED)
pubilc void methodA(){
        doPreSomething;
        methodB();
        dosufSomething;
}

@Transactional(propagation=PROPAGATION_REQUIRED_NEW)
pubilc void methodB(){
       doSomething;
}

在事务的隔离级别是PROPAGATION_REQUIRED_NEW的时候。
如果调用方法A，会开启一个事务，在方法内部调用方法B，方法B会自己再开启一个事务，然后方法B在自己的事务内部执行，如果方法B执行失败抛出异常，那么事务B会进行回滚，事务A不会受到影响可以继续执行，如果在方法B执行成功，方法B的事务会单独进行提交；B提交事务之后接着执行A的doSufSomething()方法，如果执行成功提交A的事务，如果抛出异常，则只回滚A的事务，对B的事务不会进行影响，也就说B的事务不会进行回滚。
如果不通过方法A而单独调用方法B，则会开启一个事务。
PROPAGATION_REQURIED_NEW所有方法使用各自的事务，各自提交或者回滚各自的事务，相互之间不会造成影响。
如果嵌套执行的方法要求各自事务独立，不能进行相互影响，则选择本事务传播级别。

执行逻辑

开启事务
执行方法Ａ的doPreSomething
开启另一个事务2
执行方法B
提交或者回滚事务2
执行方法A的doSufSomething
提交或回滚事务

2.3.PROPAGATION_SUPPORTS

@Transactional(propagation=PROPAGATION_REQUIRED)
pubilc void methodA(){
        doPreSomething;
        methodB();
        doSufSomething;
}

@Transactional(propagation=PROPAGATION_SUPPORTS)
pubilc void methodB(){
       doSomething;
} 

在事务的隔离级别是PROPAGATION_SUPPORTS的时候。
如果调用方法A，会开启一个事务，在方法A内部调用方法B，由于方法A已经存在开启尚未提交的事务，方法B会直接加入方法A的事务中执行，这样如果在执行方法B的时候出了异常导致事务回滚，则B的方法和A的方法都会回滚。如果A的doPreSomething()和方法B都执行成功了，但是在执行doSufSomething()方法的时候抛出了异常导致事务回滚，则doSufSomething()、methodB()和doPreSomething()都会回滚。
如果不通过方法A而单独调用方法B，则方法B不会开启事务，直接会以非事务的方式执行。
PROPAGATION_SUPPORTS如果存着事务就加入和PROPAGATION_REQUIRED传播级别一致，如果当前不存在事务，则不会创建新的事务，以非事务的方式执行。
如果嵌套执行的方法要求一起执行成功或者一起回滚，单独执行时候以非事务方式执行，则选择该事物传播级别。

执行逻辑：

开启事务
执行方法Ａ的doPreSomething
执行方法B
执行方法A的doSufSomething
提交或回滚事务

2.4.PROPAGATION_NOT_SUPPORTED

@Transactional(propagation=PROPAGATION_REQUIRED)
pubilc void methodA(){
        doPreSomething;
        methodB();
        doSufSomething;
}

@Transactional(propagation=PROPAGATION_NOT_SUPPORTED)
pubilc void methodB(){
        doSomething;
} 

在事务的隔离级别是PROPAGATION_NOT_SUPPORTED的时候。
如果调用方法A，会开启一个事务，在方法A内部调用方法B，由于方法A已经存在开启尚未提交的事务，方法B不允许在事务内部执行，这时候事务就会挂起，在非事务的状态中执行方法B，不管方法B是执行成功还是执行失败，都不会对当前事务造成影响。如果A的doPreSomething()和方法B都执行成功了，但是在执行doSufSomething()方法的时候抛出了异常导致事务回滚，则doSufSomething()和doPreSomething()会回滚，而方法B不会受到任何影响，因为它是在非事务中执行的。
如果不通过方法A而单独调用方法B，则方法B不会开启事务，直接会以非事务的方式执行。
PROPAGATION_NOT_SUPPORTED如果存着事务就挂起当前事务，以非事务的方式运行自己，如果当前不存在事务，则不会创建新的事务，以非事务的方式执行。
如果嵌套执行的方法要求内部嵌套方法不会对外部方法事务造成影响并且内部方法不需要事务，单独执行时候以非事务方式执行，则选择该事物传播级别。

执行逻辑：

开启事务
执行方法Ａ的doPreSomething
挂起事务
执行方法B
重新启用挂起的事务
执行方法A的doSufSomething
提交或回滚事务

2.5.PROPAGATION_MANDATORY

@Transactional(propagation=PROPAGATION_REQUIRED)
pubilc void methodA(){
        doPreSomething;
        methodB();
        doSufSomething;
}

@Transactional(propagation=PROPAGATION_MANDATORY)
pubilc void methodB(){
       doSomething;
} 

在事务的隔离级别是PROPAGATION_MANDATORY的时候。
如果调用方法A，会开启一个事务，在方法A内部调用方法B，由于方法A已经存在开启尚未提交的事务，方法B会直接加入方法A的事务中执行，这样如果在执行方法B的时候出了异常导致事务回滚，则B的方法和A的方法都会回滚。如果A的doPreSomething()和方法B都执行成功了，但是在执行doSufSomething()方法的时候抛出了异常导致事务回滚，则doSufSomething()、methodB()和doPreSomething()都会回滚。
如果不通过方法A而单独调用方法B，则方法B会直接报错，因为方法B的事务传播级别是PROPAGATION_MANDATORY,而其不允许在没有事务的环境下执行。
PROPAGATION_SUPPORTS如果存着事务就加入和PROPAGATION_REQUIRED传播级别一致，如果当前不存在事务，会直接进行报错，不允许以非事务的方式执行。
如果嵌套执行的方法要求一起执行成功或者一起回滚，单独执行时候不允许以非事务方式执行，则选择该事物传播级别。

执行逻辑：

开启事务
执行方法Ａ的doPreSomething
执行方法B
执行方法A的doSufSomething
提交或回滚事务

2.6.PROPAGATION_NEVER

@Transactional(propagation=PROPAGATION_REQUIRED)
pubilc void methodA(){
        doPreSomething;
        methodB();
        doSufSomething;
}

@Transactional(propagation=PROPAGATION_NEVER)
pubilc void methodB(){
        doSomething;
} 

在事务的隔离级别是PROPAGATION_NERVR的时候。
如果调用方法A，会开启一个事务，在方法A内部调用方法B，由于方法A已经存在开启尚未提交的事务，方法B的传播级别为PROPAGATION_NEVER，其不允许在事务内部执行，所以这时候就会直接报错。
如果不通过方法A而单独调用方法B，则方法B会直接在没有事务的环境中执行。
PROPAGATION_NERVER如果存着事务就直接报错，如果当前不存在事务，会以非事务的方式执行。
如果嵌套执行的方法要求内部方法不允许在事务中执行，单独执行时候必须以非事务方式执行，则选择该事物传播级别。

执行逻辑：

开启事务
执行方法Ａ的doPreSomething
执行方法B，直接报错
回滚事务

2.7.PROPAGATION_NESTED

@Transactional(propagation=PROPAGATION_REQUIRED)
pubilc void methodA(){
        doPreSomething;
        methodB();
        doSufSomething;
}

@Transactional(propagation=PROPAGATION_NESTED)
pubilc void methodB(){
        doSomething;
} 

在事务的隔离级别是PROPAGATION_NESTED的时候。
如果调用方法A，会开启一个事务，在方法A内部调用方法B，由于方法A已经存在开启尚未提交的事务，方法B的传播级别为PROPAGATION_NESTED，会加入这个事务当中，但是在执行到方法B之前会创建一个事务的回滚点(savepoint),然后执行方法B，如果方法B执行失败了，事务会进行回滚，但是这时指挥回滚到回滚点，也就是之后回滚B的操作，外部方法的操作不会回滚；如果B执行成功了，接着执行A的doSufSomething()方法，如果执行出错，则会回滚整个事务，也就是doSufSomething()、methodB()和doPreSomething()的执行都会进行回滚。
如果直接调用方法B，则会开启一个事务，和PROPAGATION_REQUIRED传播级别一致。
如果嵌套执行的方法要求内部方法出错只回滚自己，外部方法执行失败回滚所有，单独执行时候自动开启一个执行，则选择该事物传播级别。

执行逻辑：

开启事务
执行方法Ａ的doPreSomething
创建回滚点savepoint
执行方法B，失败只回滚到savepoint
执行方法A的doSufSomething
提交或回滚事务

三、总结

3.1、PROPAGATION_REQUIRED

所有方法在同一个事务中运行，要么一起成功提交事务，要么一起回滚事务，如果单独执行，各自单独开启各自事务

3.2、PROPAGATION_REQUIRED_NEW

PROPAGATION_REQURIED_NEW所有方法使用各自的事务，各自提交或者回滚各自的事务，相互之间不会造成影响。
如果嵌套执行的方法要求各自事务独立，不能进行相互影响，则选择本事务传播级别。

3.3、PROPAGATION_SUPPORTS|

3.4、PROPAGATION_NOT_SUPPORTED

3.5、PROPAGATION_MANDATORY

3.6、PROPAGATION_NEVER

3.7、PROPAGATION_NESTED