Spring事务传播行为(Propagation behavior)

最新推荐文章于 2024-02-11 19:53:24 发布
最新推荐文章于 2024-02-11 19:53:24 发布
阅读量1.4k 收藏 2
点赞数 2
分类专栏： 框架 文章标签： spring 事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn_so_nice/article/details/54342534
版权

Spring事务传播行为(Propagation behavior)

有的时候，一个业务类的方法需要调用另一个业务类的方法，如下面的情形所示。

public class OuterService {
    private InnerService innerService;

    @Transactional
    public void outerMethod() {
        /*do something*/
        try {
            innerService.innerMethod();
        } catch(Exception e) {
            /*catch the exception*/
        }       
    }
}


public class InnerService {
    @Transactional
    public void innerMethod() {
        /* do something */
    }
}

OuterService类的outerMethod()需要调用InnerService类的innerMethod()方法。如果innerMethod()发生某些异常并且回滚，那么，outerMethod()是否回滚？（即事务怎么由内传播到外）

1 七个传播行为

Spring针对这种情况，定义了一些行为，叫做事务传播行为（transaction propagation behavior)。Spring事务传播行为可以分为三类：

  • REQUIRED，SUPPORTS，MANDATORY （REQUIRES_NEW)

要求方法在事务中运行。如果outer method在事务中运行，就使用当前事务。（但REQUIRES_NEW比较特殊，始终会新建一个事务，始终在事务中运行。）如果outer method不存在事务，则分别是新建一个事务、以非事务方式运行和抛出异常。

  • NOT_SUPPORTED， NEVER

要求inner method以非事务的方式运行。如果当前存在事务，则分别是将当前事务挂起和抛出异常。

  • NESTED

innerMethod()的事务与outerMethod()的事务共享同一个physical transaction，但是，这个physical transaction中有很多savepoint。每个innerMethod()可以单独还原到savepoint，outerMethod()仍然可以正常提交。但是，如果outerMethod()回滚，则innerMethod()也要回滚。

2 重点说明

REQUIRED

如下图所示，method1 (outer method)处于事务之中，当method2(inner method) 传播行为设置为REQUIRED时，它们两者处于不同的logical transaction,但是，处于相同的physical transaction。当两者有一个回滚时，他们都会回滚，因为他们处于相同的physical transaction之中。

这里写图片描述
(来源：http://docs.spring.io/spring-framework/docs/4.2.x/spring-framework-reference/html/transaction.html#transaction-declarative）

如果outer method不处于事务之中，则inner method会新建一个事务。

见下面的例子，以银行转账业务为例。假设，每次转账之后，都将一条转账的记录插入数据库之中。

  • 设置outer method抛出异常并回滚，那么inner method也会回滚。

转账相关的类：

AccountService

package com.chris.service;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.chris.dao.AccountDAO;
import com.chris.domain.Account;
import com.chris.domain.Record;


public class AccountService {
    private AccountDAO accountDAO;

    @Autowired
    private RecordService recordService;

    public AccountDAO getAccountDAO() {
        return accountDAO;
    }

    public void setAccountDAO(AccountDAO accountDAO) {
        this.accountDAO = accountDAO;
    }

    @Transactional(propagation=Propagation.REQUIRED)
    public void transfer(String from, String to, double money) {
        accountDAO.outMoney(from, money);
        accountDAO.inMoney(to, money);

        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //here the type is String, but in db, the type is datetime. However, it works.
        String currentTime = sdf.format(date);
        Record record = new Record(from, to, money, currentTime);
        try {
            recordService.insertRecord(record);
        } catch(RuntimeException e) {

        }   

        throw new RuntimeException("rollback outer transaction");       
    }

}

插入转账记录的类RecordService:

package com.chris.service;

import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.chris.dao.RecordDAO;
import com.chris.domain.Record;

public class RecordService {
    private RecordDAO recordDAO;
    public RecordDAO getRecordDAO() {
        return recordDAO;
    }

    public void setRecordDAO(RecordDAO recordDAO) {
        this.recordDAO = recordDAO;
    }
    @Transactional(propagation=Propagation.REQUIRED)
    public void insertRecord(Record record) {
        recordDAO.insertRecord(record);

        //throw new RuntimeException("rollback the inner transaction");
    }
}

测试方法

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TransferTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() {
        accountService.transfer("Jane", "Michael", 100d);
    }
}

数据库初始记录

mysql> select * from account;
+----+---------+-----------+
| id | name    | money     |
+----+---------+-----------+
|  1 | Michael | 1100.0000 |
|  2 | Jane    |  900.0000 |
|  3 | Kate    | 1000.0000 |
+----+---------+-----------+
3 rows in set (0.00 sec)

mysql> select * from record;
+----+-----------+---------+----------+---------------------+
| id | from_user | to_user | money    | time                |
+----+-----------+---------+----------+---------------------+
| 29 | Jane      | Michael | 100.0000 | 2017-01-11 12:45:54 |
+----+-----------+---------+----------+---------------------+
1 row in set (0.00 sec)

运行之后，数据库的记录没有变。

REQUIRES_NEW

REQUIRES_NEW始终会新建一个事务，这个事务与原来的事务处于不同的logical transaction和physical transaction。如下图所示。因此两个事务是彼此独立的，不会相互影响。当然，如果inner method出现了RuntimeException并且抛出，没有被outer method 捕获并且处理，导致outer method异常，则两个都会回滚。

requires_new

  • outer method为REQUIRED，inner method为REQUIRES_NEW
    @Transactional(propagation=Propagation.REQUIRED)
    public void transfer(String from, String to, double money) {
        accountDAO.outMoney(from, money);
        accountDAO.inMoney(to, money);      
        /*省略一部分*/
        try {
            recordService.insertRecord(record);
        } catch(RuntimeException e) {

        }
    }


    @Transactional(propagation=Propagation.REQUIRES_NEW)
    public void insertRecord(Record record) {
        recordDAO.insertRecord(record); 
        throw new RuntimeException("rollback the inner transaction");
    }

运行之前，

mysql> select * from account;
+----+---------+-----------+
| id | name    | money     |
+----+---------+-----------+
|  1 | Michael | 1100.0000 |
|  2 | Jane    |  900.0000 |
|  3 | Kate    | 1000.0000 |
+----+---------+-----------+
3 rows in set (0.00 sec)

mysql> select * from record;
+----+-----------+---------+----------+---------------------+
| id | from_user | to_user | money    | time                |
+----+-----------+---------+----------+---------------------+
| 29 | Jane      | Michael | 100.0000 | 2017-01-11 12:45:54 |
+----+-----------+---------+----------+---------------------+
1 row in set (0.00 sec)

运行之后，

mysql> select * from record;
+----+-----------+---------+----------+---------------------+
| id | from_user | to_user | money    | time                |
+----+-----------+---------+----------+---------------------+
| 29 | Jane      | Michael | 100.0000 | 2017-01-11 12:45:54 |
+----+-----------+---------+----------+---------------------+
1 row in set (0.00 sec)

mysql> select * from account;
+----+---------+-----------+
| id | name    | money     |
+----+---------+-----------+
|  1 | Michael | 1200.0000 |
|  2 | Jane    |  800.0000 |
|  3 | Kate    | 1000.0000 |
+----+---------+-----------+
3 rows in set (0.00 sec)

可见，outer transaction运行成功，inner transaction运行失败。因为，inner method抛出RuntimeException，故回滚。由于是两个独立的physical transaction，并且，outer method捕获了inner method抛出的异常并处理，故outer method不会回滚。

NESTED

innerMethod()的事务与outerMethod()的事务共享同一个physical transaction，但是，这个physical transaction中有很多savepoint。每个innerMethod()可以单独还原到savepoint，outerMethod()仍然可以正常提交。但是，如果outerMethod()回滚，则innerMethod()也要回滚。

下面的例子中，outer method为REQUIRED，inner method为NESTED。inner method抛出RuntimeException。

    @Transactional(propagation=Propagation.REQUIRED)
    public void transfer(String from, String to, double money) {
        accountDAO.outMoney(from, money);
        accountDAO.inMoney(to, money);

        /* 省略一部分*/
        Record record = new Record(from, to, money, currentTime);
        try {
            recordService.insertRecord(record);
        } catch(RuntimeException e) {

        }       
    }

    @Transactional(propagation=Propagation.NESTED)
    public void insertRecord(Record record) {
        recordDAO.insertRecord(record);

        throw new RuntimeException("rollback the inner transaction");
    }

运行之前，

mysql> select * from account;
+----+---------+-----------+
| id | name    | money     |
+----+---------+-----------+
|  1 | Michael | 1200.0000 |
|  2 | Jane    |  800.0000 |
|  3 | Kate    | 1000.0000 |
+----+---------+-----------+
3 rows in set (0.00 sec)

mysql> select * from record;
+----+-----------+---------+----------+---------------------+
| id | from_user | to_user | money    | time                |
+----+-----------+---------+----------+---------------------+
| 29 | Jane      | Michael | 100.0000 | 2017-01-11 12:45:54 |
+----+-----------+---------+----------+---------------------+
1 row in set (0.00 sec)

运行之后，

mysql> select * from record;
+----+-----------+---------+----------+---------------------+
| id | from_user | to_user | money    | time                |
+----+-----------+---------+----------+---------------------+
| 29 | Jane      | Michael | 100.0000 | 2017-01-11 12:45:54 |
+----+-----------+---------+----------+---------------------+
1 row in set (0.00 sec)

mysql> select * from account;
+----+---------+-----------+
| id | name    | money     |
+----+---------+-----------+
|  1 | Michael | 1400.0000 |
|  2 | Jane    |  600.0000 |
|  3 | Kate    | 1000.0000 |
+----+---------+-----------+
3 rows in set (0.00 sec)

可见，虽然inner method异常，且处于同一个physical transaction， 但是，outer method仍然运行成功。

注意 如果inner method和outer method处于同一个service类中，则以上的叙述不保证正确。

3 总结

REQUIRED、REQUIRES_NEW和NESTED为比较常用的三个属性。

如有疑问，还请提出，共同进步。

参考

CupOnDesk
关注
专栏目录
EJB3 QL
持续改进
06-24 1358
1.Entity 获取 find()或 getReference()           1)如果知道 Entity的唯一标示符，我们可以用 find()或 getReference()方法来获得 Entity。           2)当在数据库中没有找到记录时，getReference()和 find()是有区别的，find()方法会返回 null，而 getReference()方法
Spring 事务传播行为
qq_34233308的博客
02-20 190
Spring 事务传播行为
SpringBoot中的Transaction研究（二）PropagationBehavior
Qbit编程学习笔记
10-28 494
文章目录从外在要求的视角从相应策略上看从当前状态来看required、required_new、nestedsupportednot_supportedmandatorynever 从外在要求的视角 Propagation可以分为两大类，一类对于当前transaction有要求，一类没有要求，其中前者又可以分为要求有和要求无两个小类，第一个小类就是MANDATORY，而第二个小类就是NEVER. 其中无要求又可以分为2*2=4种情况，其中有->无，无->有这种情况太奇怪就没有了 从相应策略上看
Spring事务的传播行为（Propagation Behavior）
u011614717的博客
09-01 189
例如，如果methodA()在一个事务中调用methodB()，而methodB()没有事务，那么根据@Transactional注解的设置，methodB()将在自己的事务中执行，或者与methodA()的事务共享数据（如果@Transactional注解的传播属性设置为PROPAGATION_NESTED）。需要注意的是，事务传播是在方法调用时发生的，因此在一个事务中的方法调用另一个没有事务的方法时，将会根据@Transactional注解的设置来决定是否创建新的事务。
事务属性之传播行为Propagation Behavior
持续改进
06-24 1679
最常见的事务是定义在session bean的方法上，方法中所有的数据库操作只有在方法正常退出时才会提交，如果方法抛出未捕获的异常，事务管理将回滚所有的变更。@TransactionAttribute 注释用作定义一个需要事务的方法。它可以有以下参数：1.REQUIRED:方法在一个事务中执行，如果调用的方法已经在一个事务中，则使用该事务，否则将创建一个新的事务。2.MANDATORY:方
【老王读Spring Transaction-5】Spring事务传播行为propagation behavior的实现原理
老王的专栏
02-15 429
Spring 对事务的封装除了实现了基本的事务管理之外，还提供了事务传播行为(propagation behavior)的高级特性。通常，事务范围内的所有代码都会在该事务中运行。但是，如果在事务上下文已经存在的情况下再去执行其他事务方法，则可以指定事务的传播行为。例如，代码可以在现有事务中继续运行（常见情况），或者可以暂停现有事务并创建新事务。事务传播行为的作用是将多个事务操作进行合并或者隔离。
Spring - 事务之传播行为
牧码的博客
11-25 356
事务的第一个方面是传播行为（propagation behavior）。当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。Spring定义了七种传播行为： （1）PROPAGATION_REQUIRED 如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。 //事务属性 PROPA...
Spring 事务传播行为-测试代码+源码分析
wuhulala的休息室
04-15 989
spring事务有如下七种类型 REQUIRED 默认，需要事务，没有则新建 REQUIRED_NEW 需要新事务，每次都新建 SUPPORTS 支持事务但不强制有事务 NOT_SUPPORTS 不支持事务，有事务挂起事务，执行完方法再唤醒 MONDATORY 强制事务，没有事务抛出异常 NEVER 当前方法不能有事务，否则抛出异常 NESTED 嵌套事务，无论是否有事务都会创建一个内部事务事...
Spring在Transaction事务传播行为种类
04-14
Spring框架提供了丰富的事务管理功能，其中包括了事务传播行为（Propagation Behavior）。本文将详细介绍Spring框架中定义的七种不同的事务传播行为类型及其应用场景。 #### 二、事务传播行为概述 事务传播行为是指...
深入理解Spring的事务传播行为
凯耐的博客
10-22 858
前言 Spring在TransactionDefinition接口中规定了7种类型的事务传播行为。事务传播行为是Spring框架独有的事务增强特性，它不属于的事务实际提供方数据库行为。这是Spring为我们提供的强大的工具箱，使用事务传播行可以为我们的开发工作提供许多便利。但是人们对他的误解也颇多，你一定也听过“service方法事务最好不要嵌套”的传言。要想正确的使用工具首先需要了解工具。本文...
Spring（事务管理，事务传播行为，集成MyBatis）
qq_53677566的博客
01-05 453
这里写目录标题八.Spring事务管理九.事务传播行为十.Spring集成MyBatis 八.Spring事务管理 事务可以看作是对数据库若干操作组成的一个单元**（整体）**。我们在开发企业应用时，对于业务成员最常见的操作是对数据读写的多步操作的结合。由与数据库在顺序执行的过程中，任何一步都可能发生异常，异常会导致后续操作无法完成，此时由于业务逻辑并未正确的完成，之前的成功操作的数据并不可靠，需要在这种情况下进行回退。 事务的作用就是为了保证用户的每一个操作都是可靠的，事务的每一步操作都必须成功执行，只要
spring事务传播行为&集成mybatis&springMVC概述
weixin_43645809的博客
04-19 203
Spring事务传播行为 传播：至少有两个东西，才可发生传播。也就是至少两个方法之间在相互调用 事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 A方法 调用B方法 那么B方法应该如何执行 事务是数据库的行为 事务传播行为，是spring框架自己添加的功能 spring定义了七种传播行为： 事务传播行为类型 说明 PROPAGATION_REQUIRED 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，
Spring的事务传播行为（Transaction Propagation Behavior）
chenli4707的博客
08-05 146
1、PROPAGATION_REQUIRED：如果没有，就新建一个；如果有，就加入当前事务。 2、PROPAGATION_REQUIRED_NEW：如果没有，就新建一个；如果有，就将当前事务挂起， 意思是创建了一个新事务，它和原来的事务已无关系。 3、PROPAGATION_NES...
详述 Spring 中 Bean 的作用域、事务的隔离级别以及传播行为
CG国斌的博客
08-26 2182
详述 Spring 中 Bean 的作用域以及事务传播级别
一看就理解_Spring事务的7种传播行为
wushijuewu
09-30 1018
事务传播行为 什么叫事务传播行为？听起来挺高端的，其实很简单。 即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。 事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个新事务运行，这就是由methodB的事务传播行为决定的。 Spring定义了七种传播行为： 现在来
Spring事务的传播行为
黄先生的博客
04-04 391
Spring 框架中的事务传播行为用来描述在一个方法调用另一个带有事务性的方法时，该事务如何传播。这是 Spring 命令式事务基础架构中的中央接口。应用程序可以直接使用它，但它主要不是作为 API：通常，应用程序将使用事务模板或通过 AOP 进行声明性事务划分。//根据指定的传播行为返回当前活动的事务或创建新事务。//提交给定的事务，关于其状态。如果事务已以编程方式标记为仅回滚，请执行回滚。//执行给定事务的回滚。获取事务提交事务回滚事务。
Spring事务的 7 种传播行为
最新发布
qq_45110186的博客
02-11 3993
Spring 框架中的事务传播行为定义了在多个事务操作嵌套执行时，如何处理事务的传播和管理。Spring 提供了多种事务传播行为，以满足不同的业务需求。
Spring(1) Spring的7种事务传播行为
ACGkaka的博客
03-07 2464
Spring（一）Spring的7种事务传播行为
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值