深入理解事务--Spring事务的传播机制

https://blog.csdn.net/yuanlaishini2010/article/details/45792069

事务的嵌套概念

所谓事务的嵌套就是两个事务方法之间相互调用。spring事务开启 ，或者是基于接口的或者是基于类的代理被创建（注意一定要是代理，不能手动new 一个对象，并且此类（有无接口都行）一定要被代理——spring中的bean只要纳入了IOC管理都是被代理的）。所以在同一个类中一个方法调用另一个方法有事务的方法，事务是不会起作用的。

###

Spring默认情况下会对运行期例外(RunTimeException)，即uncheck异常，进行事务回滚。

如果遇到checked异常就不回滚。
如何改变默认规则：

1 让checked例外也回滚：在整个方法前加上 @Transactional(rollbackFor=Exception.class)

2 让unchecked例外不回滚： @Transactional(notRollbackFor=RunTimeException.class)

3 不需要事务管理的(只查询的)方法：@Transactional(propagation=Propagation.NOT_SUPPORTED)

上面三种方式也可在xml配置

spring事务传播属性

在 spring的 TransactionDefinition接口中一共定义了六种事务传播属性：

PROPAGATION_REQUIRED -- 支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 
PROPAGATION_SUPPORTS -- 支持当前事务，如果当前没有事务，就以非事务方式执行。 
PROPAGATION_MANDATORY -- 支持当前事务，如果当前没有事务，就抛出异常。 
PROPAGATION_REQUIRES_NEW -- 新建事务，如果当前存在事务，把当前事务挂起。 
PROPAGATION_NOT_SUPPORTED -- 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 
PROPAGATION_NEVER -- 以非事务方式执行，如果当前存在事务，则抛出异常。 
PROPAGATION_NESTED -- 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。 
前六个策略类似于EJB CMT，第七个（PROPAGATION_NESTED）是Spring所提供的一个特殊变量。 
它要求事务管理器或者使用JDBC 3.0 Savepoint API提供嵌套事务行为（如Spring的DataSourceTransactionManager）

举例浅析Spring嵌套事务

ServiceA#methodA(我们称之为外部事务)，ServiceB#methodB(我们称之为外部事务)

  1. ServiceA {

  2.  

  3.  

    void methodA() {

  4.  

    ServiceB.methodB();

  5.  

    }

  6.  

  7.  

    }

  8.  

  9.  

    ServiceB {

  10.  

  11.  

    void methodB() {

  12.  

    }

  13.  

  14.  

    }

PROPAGATION_REQUIRED

假如当前正要执行的事务不在另外一个事务里，那么就起一个新的事务 
比如说，ServiceB.methodB的事务级别定义为PROPAGATION_REQUIRED, 那么由于执行ServiceA.methodA的时候

1、如果ServiceA.methodA已经起了事务，这时调用ServiceB.methodB，ServiceB.methodB看到自己已经运行在ServiceA.methodA的事务内部，就不再起新的事务。这时只有外部事务并且他们是共用的，所以这时ServiceA.methodA或者ServiceB.methodB无论哪个发生异常methodA和methodB作为一个整体都将一起回滚。

2、如果ServiceA.methodA没有事务，ServiceB.methodB就会为自己分配一个事务。这样，在ServiceA.methodA中是没有事务控制的。只是在ServiceB.methodB内的任何地方出现异常，ServiceB.methodB将会被回滚，不会引起ServiceA.methodA的回滚

PROPAGATION_SUPPORTS

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

PROPAGATION_MANDATORY

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

PROPAGATION_REQUIRES_NEW

启动一个新的, 不依赖于环境的 "内部" 事务. 这个事务将被完全 commited 或 rolled back 而不依赖于外部事务, 它拥有自己的隔离范围, 自己的锁, 等等. 当内部事务开始执行时, 外部事务将被挂起, 内务事务结束时, 外部事务将继续执行.

比如我们设计ServiceA.methodA的事务级别为PROPAGATION_REQUIRED，ServiceB.methodB的事务级别为PROPAGATION_REQUIRES_NEW，那么当执行到ServiceB.methodB的时候，ServiceA.methodA所在的事务就会挂起，ServiceB.methodB会起一个新的事务，等待ServiceB.methodB的事务完成以后，他才继续执行。他与PROPAGATION_REQUIRED 的事务区别在于事务的回滚程度了。因为ServiceB.methodB是新起一个事务，那么就是存在两个不同的事务。

1、如果ServiceB.methodB已经提交，那么ServiceA.methodA失败回滚，ServiceB.methodB是不会回滚的。

2、如果ServiceB.methodB失败回滚，如果他抛出的异常被ServiceA.methodA的try..catch捕获并处理，ServiceA.methodA事务仍然可能提交；如果他抛出的异常未被ServiceA.methodA捕获处理，ServiceA.methodA事务将回滚。

使用场景：

不管业务逻辑的service是否有异常，Log Service都应该能够记录成功，所以Log Service的传播属性可以配为此属性。最下面将会贴出配置代码。

PROPAGATION_NOT_SUPPORTED

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

PROPAGATION_NEVER

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

PROPAGATION_NESTED

开始一个 "嵌套的" 事务,  它是已经存在事务的一个真正的子事务. 潜套事务开始执行时,  它将取得一个 savepoint. 如果这个嵌套事务失败, 我们将回滚到此 savepoint. 潜套事务是外部事务的一部分, 只有外部事务结束后它才会被提交.

比如我们设计ServiceA.methodA的事务级别为PROPAGATION_REQUIRED，ServiceB.methodB的事务级别为PROPAGATION_NESTED，那么当执行到ServiceB.methodB的时候，ServiceA.methodA所在的事务就会挂起，ServiceB.methodB会起一个新的子事务并设置savepoint，等待ServiceB.methodB的事务完成以后，他才继续执行。。因为ServiceB.methodB是外部事务的子事务，那么

1、如果ServiceB.methodB已经提交，那么ServiceA.methodA失败回滚，ServiceB.methodB也将回滚。

2、如果ServiceB.methodB失败回滚，如果他抛出的异常被ServiceA.methodA的try..catch捕获并处理，ServiceA.methodA事务仍然可能提交；如果他抛出的异常未被ServiceA.methodA捕获处理，ServiceA.methodA事务将回滚。

理解Nested的关键是savepoint。他与PROPAGATION_REQUIRES_NEW的区别是：

PROPAGATION_REQUIRES_NEW 完全是一个新的事务,它与外部事务相互独立； 而 PROPAGATION_NESTED 则是外部事务的子事务, 如果外部事务 commit, 嵌套事务也会被 commit, 这个规则同样适用于 roll back.

在 spring 中使用 PROPAGATION_NESTED的前提：

1. 我们要设置 transactionManager 的 nestedTransactionAllowed 属性为 true, 注意, 此属性默认为 false!!!

2. java.sql.Savepoint 必须存在, 即 jdk 版本要 1.4+

3. Connection.getMetaData().supportsSavepoints() 必须为 true, 即 jdbc drive 必须支持 JDBC 3.0

确保以上条件都满足后, 你就可以尝试使用 PROPAGATION_NESTED 了.

##############################################################################

Log Service配置事务传播

不管业务逻辑的service是否有异常，Log Service都应该能够记录成功，通常有异常的调用更是用户关心的。Log Service如果沿用业务逻辑Service的事务的话在抛出异常时将没有办法记录日志(事实上是回滚了)。所以希望Log Service能够有独立的事务。日志和普通的服务应该具有不同的策略。Spring 配置文件transaction.xml:

  1. <?xml version="1.0" encoding="UTF-8"?>

  2.  

    <beans xmlns="http://www.springframework.org/schema/beans"

  3.  

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"

  4.  

    xmlns:tx="http://www.springframework.org/schema/tx"

  5.  

    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">

  6.  

    <!-- configure transaction -->

  7.  

  8.  

    <tx:advice id="defaultTxAdvice" transaction-manager="transactionManager">

  9.  

    <tx:attributes>

  10.  

    <tx:method name="get*" read-only="true" />

  11.  

    <tx:method name="query*" read-only="true" />

  12.  

    <tx:method name="find*" read-only="true" />

  13.  

    <tx:method name="*" propagation="REQUIRED" rollback-for="java.lang.Exception" />

  14.  

    </tx:attributes>

  15.  

    </tx:advice>

  16.  

  17.  

    <tx:advice id="logTxAdvice" transaction-manager="transactionManager">

  18.  

    <tx:attributes>

  19.  

    <tx:method name="get*" read-only="true" />

  20.  

    <tx:method name="query*" read-only="true" />

  21.  

    <tx:method name="find*" read-only="true" />

  22.  

    <tx:method name="*" propagation="REQUIRES_NEW"

  23.  

    rollback-for="java.lang.Exception" />

  24.  

    </tx:attributes>

  25.  

    </tx:advice>

  26.  

  27.  

    <aop:config>

  28.  

    <aop:pointcut id="defaultOperation"

  29.  

    expression="@within(com.homent.util.DefaultTransaction)" />

  30.  

    <aop:pointcut id="logServiceOperation"

  31.  

    expression="execution(* com.homent.service.LogService.*(..))" />

  32.  

  33.  

    <aop:advisor advice-ref="defaultTxAdvice" pointcut-ref="defaultOperation" />

  34.  

    <aop:advisor advice-ref="logTxAdvice" pointcut-ref="logServiceOperation" />

  35.  

    </aop:config>

  36.  

    </beans>

如上面的Spring配置文件所示，日志服务的事务策略配置为propagation="REQUIRES_NEW"，告诉Spring不管上下文是否有事务，Log Service被调用时都要求一个完全新的只属于Log Service自己的事务。通过该事务策略，Log Service可以独立的记录日志信息，不再受到业务逻辑事务的干扰。

原文地址：https://www.cnblogs.com/yuluoxingkong/p/9270549.html

时间： 2024-07-29 16:24:45

深入理解事务--Spring事务的传播机制的相关文章

Spring事务隔离级别与传播机制，spring+mybatis+atomikos实现分布式事务管理

本文转载于本人另一博客[http://blog.csdn.net/liaohaojian/article/details/68488150] 1.事务的定义:事务是指多个操作单元组成的合集,多个单元操作是整体不可分割的,要么都操作不成功,要么都成功.其必须遵循四个原则(ACID). 原子性(Atomicity):即事务是不可分割的最小工作单元,事务内的操作要么全做,要么全不做: 一致性(Consistency):在事务执行前数据库的数据处于正确的状态,而事务执行完成后数据库的数据还是应该处于正确

数据库的特性与隔离级别和spring事务的传播机制和隔离级别

首先数据库的特性就是 ACID: Atomicity 原子性:所有事务是一个整体,要么全部成功,要么失败 Consistency 一致性:在事务开始和结束前,要保持一致性状态 Isolation 隔离性: 对于同一个表的操作,每个事务都是单独的,不会影响其他事务. Durability 持久性: 事务一旦提交,数据库中的数据就是永久的了. 对于以上四种特性中的隔离性,不同的策略会有不同的弊端:脏读,不可重复读,幻读. 脏读: 就是一个事务读取了别的事务执行过程中未提交的数据. 不可重复读: 就是

事务的传播机制

事务的传播机制有7种,下面的传播机制都是针对于被调用的方法来说的,理解起来需要想象成两个service,本文的案例主要讲的是传播机制中的PROPAGATION_REQUIRES_NEW和PROPAGATION_NESTED. (1)PROPAGATION_REQUIRED(默认):支持使用当前事务,如果当前事务不存在,创建一个新事务. (2)PROPAGATION_SUPPORTS:支持使用当前事务,如果当前事务不存在,则不使用事务. (3)PROPAGATION_MANDATORY:中文翻译为

spring事务代码实践

事务一般是指数据库事务,是指作为一个程序执行单元执行的一系列操作,要么完全执行,要么完全不执行.事务就是判断以结果为导向的标准. 一.spring的特性(ACID) (1).原子性(atomicity)       原子性就是一个不可分割的工作单元.简单的说,就是指事务包含的所有操作要么全部成功,要么全部失败回滚.因此事务的操作如果成功就必须要完全应用到数据库,如果失败则不能对数据库有任何影响.    (2).一致性(consistency)     一致性就是事务必须是使一个一致性状态变成另一

Spring事务

事务首先是一系列操作组成的工作单元,该工作单元内的操作是不可分割的,即要么所有操作都做,要么所有操作都不做 ACID 1.原子性(Atomicity)    即事务是不可分割的最小工作单元,事务内的操作要么全做,要么全不做2.一致性(Consistency)    在事务执行前数据库的数据处于正确的状态,而事务执行完成后数据库的数据还是处于正确的状态,即数据完整性约束没有被破坏    如银行转帐,A转帐给B,必须保证A的钱一定转给B,一定不会出现A的钱转了但B没收到,否则数据库的数据就处于不一致

spring 事务 笔记3.1

Spring事务 以前的事务都是编程式事务,需要开启和关闭,然后程序写在这里面 spring,声明式事务 Spring事务隔离级别 DEFAULT 使用数据库默认隔离级别 READ_UNCOMMITTED  允许读取尚未提交的数据.可能导致脏读.幻读或不可重复读. READ_COMMITTED   允许从已经提交的并发事务读取.可以防止脏读,但依然会出现幻读和不可重复读. REPEATABLE_READ   对相同字段的多次读取结果是相同的,除非数据被当前事务改变.可以防止脏读和不可重  复读,

手写Spring事务框架

Spring事务基于AOP环绕通知和异常通知 编程事务 声明事务 Spring事务底层使用编程事务+AOP进行包装的   = 声明事务 AOP应用场景:  事务 权限 参数验证 什么是AOP技术 AOP技术应用场景 面向切面编程  解决代码复用问题 AOP编程核心点: 在方法之前或者之后处理事情 AOP底层实现原理:代理设计模式 Spring事务基于AOP的环绕通知 为什么用AOP: 复用 解耦 AOP: 静态代需要生成目标代理对象 动态代理不需要生成目标代理对象 动态代理分为:JDK动态代理 

Spring事务传播机制

Spring的 事务传播行为类型 PROPAGATION_REQUIRED 如果当前没有事务,就新建一个事务,如果已经存在一个事务中,加入到这个事务中.这是 最常见的选择. PROPAGATION_SUPPORTS 支持当前事务,如果当前没有事务,就以非事务方式执行. PROPAGATION_MANDATORY 使用当前的事务,如果当前没有事务,就抛出异常. PROPAGATION_REQUIRES_NEW 新建事务,如果当前存在事务,把当前事务挂起. PROPAGATION_NOT_SUPPO

Spring 管理Hibernate事务之事务传播机制

public enum Propagation {    REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),    SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),    MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),    NOT_SUPPORTED(TransactionDefinition.PROPAGATION_