spring事务传播方式

7种：

 新建事务

 required

 required_new   - 挂起当前

非事务方式运行

supports

not_supported  - 挂起当前

never  

嵌套事务：

nested

抛异常

 mandatory   

 never

Spring定义了一下几种事务传播方式：

PROPAGATION_REQUIRED        支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

PROPAGATION_SUPPORTS            支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY         支持当前事务，如果当前没有事务，就抛出异常。

 

 

PROPAGATION_REQUIRES_NEW     新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED   以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

PROPAGATION_NEVER                 以非事务方式执行，如果当前存在事务，则抛出异常。

PROPAGATION_NESTED            如果当前事务存在，则以嵌套事务的方式执行。否则就按照它自己的事务方式执行。

 

required
supports
mandatory   //命令的；强制的
requires_new
not_supported
nerver
nested

 

1： PROPAGATION_REQUIRED

加入当前正要执行的事务不在另外一个事务里，那么就起一个新的事务

比如说，ServiceB.methodB的事务级别定义为PROPAGATION_REQUIRED, 那么由于执行ServiceA.methodA的时候， ServiceA.methodA已经起了事务，这时调用ServiceB.methodB，ServiceB.methodB看到自己已经运行在ServiceA.methodA 的事务内部，就不再起新的事务。而假如ServiceA.methodA运行的时候发现自己没有在事务中，他就会为自己分配一个事务。 这样，在ServiceA.methodA或者在ServiceB.methodB内的任何地方出现异常，事务都会被回滚。即使ServiceB.methodB的事务已经被提交，但是ServiceA.methodA在接下来fail要回滚，ServiceB.methodB也要回滚。

 

2： PROPAGATION_SUPPORTS

如果当前在事务中，即以事务的形式运行，如果当前不再一个事务中，那么就以非事务的形式运行。

 

3： PROPAGATION_MANDATORY

必须在一个事务中运行。也就是说，他只能被一个父事务调用。否则，他就要抛出异常。

 

4： PROPAGATION_REQUIRES_NEW

这个就比较绕口了。 比如我们设计ServiceA.methodA的事务级别为PROPAGATION_REQUIRED，ServiceB.methodB的事务级别为PROPAGATION_REQUIRES_NEW，那么当执行到ServiceB.methodB的时候，ServiceA.methodA所在的事务就会挂起，ServiceB.methodB会起一个新的事务，等待ServiceB.methodB的事务完成以后，他才继续执行。他与PROPAGATION_REQUIRED 的事务区别在于事务的回滚程度了。因为ServiceB.methodB是新起一个事务，那么就是存在两个不同的事务。如果ServiceB.methodB已经提交，那么ServiceA.methodA失败回滚，ServiceB.methodB是不会回滚的。如果ServiceB.methodB失败回滚，如果他抛出的异常被ServiceA.methodA捕获，ServiceA.methodA事务仍然可能提交。

 

5： PROPAGATION_NOT_SUPPORTED

当前不支持事务。比如ServiceA.methodA的事务级别是PROPAGATION_REQUIRED ，而ServiceB.methodB的事务级别是PROPAGATION_NOT_SUPPORTED ，那么当执行到ServiceB.methodB时，ServiceA.methodA的事务挂起，而他以非事务的状态运行完，再继续ServiceA.methodA的事务。

 

6： PROPAGATION_NEVER

不能在事务中运行。假设ServiceA.methodA的事务级别是PROPAGATION_REQUIRED， 而ServiceB.methodB的事务级别是PROPAGATION_NEVER ，那么ServiceB.methodB就要抛出异常了。

 

7： PROPAGATION_NESTED

理解Nested的关键是savepoint。他与PROPAGATION_REQUIRES_NEW的区别是，PROPAGATION_REQUIRES_NEW另起一个事务，将会与他的父事务相互独立， 而Nested的事务和他的父事务是相依的，他的提交是要等和他的父事务一块提交的。也就是说，如果父事务最后回滚，他也要回滚的。

而Nested事务的好处是他有一个savepoint。也就是说ServiceB.methodB失败回滚，那么ServiceA.methodA也会回滚到savepoint点上，ServiceA.methodA可以选择另外一个分支，比如 ServiceC.methodC，继续执行，来尝试完成自己的事务。 但是这个事务并没有在EJB标准中定义。

理解事务传播方式对于我们使用事务，处理业务逻辑异常，jdbc本身异常有更清晰的认识。 
现在举例说明： 
1． 如果在同一个service中方法互掉。methodA方法是PROPAGATION_REQUIRED传播方式，如果methodA方法调用同一个service中的methodB方法（可以更多），那么声明事务的方式只对methodA方法（名称）有作用，且这些方法都处于同一个事务中。所以这种同一个service中的方法调用形同一个方法。 
2． 如果一个service的方法调用另外一个service的方法。如果serviceA的方法methodA1和serviceB的方法methodB1都是PROPAGATION_REQUIRED方式，methodA1调用methodB1方法，则这两个方法处于同一个事务中。 
3． 如果一个service的方法调用另外一个service的方法。如果serviceA的方法methodA1是PROPAGATION_REQUIRED方式，而serviceB的方法methodB1是PROPAGATION_REQUIRES_NEW方式，methodA1调用methodB1方法，则这两个方法处于各自的事务中，可以完全独立。 

问题个关键是同一个事务的概念以及表现： 比如有多个数据库操作（增删改），本质上同一个事务就是让这些操作同时执行（不管调用的先后顺序）。Spring的声明性事务使用AOP实现，那么我们写的dao和service方法的本身没有任何的事务打开和关闭，所以要捕获jdbc提交时候的错误（比如主键重复，字段超过最大值等错误），只有调用具有完整事务周期service方法的其它方法（比如action类的方法）才能捕获这些异常。比如上面的第三种情况描述的两个独立事务的调用，methodA1中就可以捕获methodB1的jdbc异常，因为这两个事务完全隔离的。 

关于spring的dao和service异常处理，如果是来自jdbc运行时候产生的异常，在dao和service方法内部是捕获不到这些异常，这些异常只能在事务提交的时候产生，如果我们使用spring的声明性事务（AOP实现），那么这个异常是在service类的代理类中抛出的（这个时候执行service的方法，提交事务，有异常产生，然后向外抛出），所以我们在service层肯定无法捕获这种异常（当然也不是绝对的，如果service中调用其它service的方法，而且这个被调用的PROPAGATION_REQUIRES_NEW是这种事务传播类型，这个被调用service方法的异常是可以捕获的）

转载自：http://uule.iteye.com/blog/1420799