太难了~面试官让我结合案例讲讲本身对Spring事务传播行为的理解

时间  2020-07-09
标签 太难 面试 结合 案例 讲讲 本身 spring 事务 传播 行为 理解 栏目 快乐工作 繁體版
原文   原文链接


因为细节内容实在太多啦，因此只把部分知识点截图出来粗略的介绍，每一个小节点里面都有更细化的内容！git

整理了一份Java核心知识点。覆盖了JVM、锁、并发、Java反射、Spring原理、微服务、Zookeeper、数据库、数据结构等大量知识点。github

若是须要获取到这个【资料】文档的话能够扫一扫下面数据库


接下来开始分享啦
bash

前言数据结构

你们好，我是哪吒！最近在从新整理 Spring 事务相关的内容，在看 Spring 事务传播行为这块内容的时候，发现了这篇优秀的文章，分享一下。并发

Spring 在 TransactionDefinition 接口中规定了 7 种类型的事务传播行为。事务传播行为是 Spring 框架独有的事务加强特性，他不属于的事务实际提供方数据库行为。app

这是 Spring 为咱们提供的强大的工具箱，使用事务传播行能够为咱们的开发工做提供许多便利。框架

可是人们对他的误解也颇多，你必定也听过“service 方法事务最好不要嵌套”的传言。ide

要想正确的使用工具首先须要了解工具。本文对七种事务传播行为作详细介绍，内容主要代码示例的方式呈现。微服务

基础概念

1. 什么是事务传播行为？

事务传播行为用来描述由某一个事务传播行为修饰的方法被嵌套进另外一个方法的时事务如何传播。

用伪代码说明：

public void methodA(){
    methodB();
    //doSomething
 }

 @Transaction(Propagation=XXX)
 public void methodB(){
    //doSomething
 }复制代码

代码中methodA()方法嵌套调用了methodB()方法，methodB()的事务传播行为由@Transaction(Propagation=XXX)设置决定。这里须要注意的是methodA()并无开启事务，某一个事务传播行为修饰的方法并非必需要在开启事务的外围方法中调用。

2. Spring 中七种事务传播行为

定义很是简单，也很好理解，下面咱们就进入代码测试部分，验证咱们的理解是否正确。

代码验证

文中代码以传统三层结构中两层呈现，即 Service 和 Dao 层，由 Spring 负责依赖注入和注解式事务管理，DAO 层由 Mybatis 实现，你也可使用任何喜欢的方式，例如，Hibernate,JPA,JDBCTemplate 等。数据库使用的是 MySQL 数据库，你也可使用任何支持事务的数据库，并不会影响验证结果。

首先咱们在数据库中建立两张表：

user1

CREATE TABLE `user1` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(45) NOT NULL DEFAULT '',
  PRIMARY KEY(`id`)
)
ENGINE = InnoDB;复制代码

user2

CREATE TABLE `user2` (
  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(45) NOT NULL DEFAULT '',
  PRIMARY KEY(`id`)
)
ENGINE = InnoDB;复制代码

而后编写相应的 Bean 和 DAO 层代码：

User1

public class User1 {
    private Integer id;
    private String name;
   //get和set方法省略...
}复制代码

User2

public class User2 {
    private Integer id;
    private String name;
   //get和set方法省略...
}复制代码

User1Mapper

public interface User1Mapper {
    int insert(User1 record);
    User1 selectByPrimaryKey(Integer id);
    //其余方法省略...
}复制代码

User2Mapper

public interface User2Mapper {
    int insert(User2 record);
    User2 selectByPrimaryKey(Integer id);
    //其余方法省略...
}复制代码

最后也是具体验证的代码由 service 层实现，下面咱们分状况列举。

1.PROPAGATION_REQUIRED

咱们为 User1Service 和 User2Service 相应方法加上Propagation.REQUIRED属性。

User1Service 方法：

@Service
public class User1ServiceImpl implements User1Service {
    //省略其余...
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void addRequired(User1 user){
        user1Mapper.insert(user);
    }
}复制代码

User2Service 方法：

@Service
public class User2ServiceImpl implements User2Service {
    //省略其余...
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void addRequired(User2 user){
        user2Mapper.insert(user);
    }
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void addRequiredException(User2 user){
        user2Mapper.insert(user);
        throw new RuntimeException();
    }

}复制代码

1.1 场景一

此场景外围方法没有开启事务。

验证方法 1：

@Override
    public void notransaction_exception_required_required(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addRequired(user1);

        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequired(user2);

        throw new RuntimeException();
    }复制代码

验证方法 2：

@Override
    public void notransaction_required_required_exception(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addRequired(user1);

        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiredException(user2);
    }复制代码

分别执行验证方法，结果：

结论：经过这两个方法咱们证实了在外围方法未开启事务的状况下Propagation.REQUIRED修饰的内部方法会新开启本身的事务，且开启的事务相互独立，互不干扰。

1.2 场景二

外围方法开启事务，这个是使用率比较高的场景。

验证方法 1：

@Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void transaction_exception_required_required(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addRequired(user1);

        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequired(user2);

        throw new RuntimeException();
    }复制代码

验证方法 2：

@Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void transaction_required_required_exception(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addRequired(user1);

        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiredException(user2);
    }复制代码

验证方法 3：

@Transactional
    @Override
    public void transaction_required_required_exception_try(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addRequired(user1);

        User2 user2=new User2();
        user2.setName("李四");
        try {
            user2Service.addRequiredException(user2);
        } catch (Exception e) {
            System.out.println("方法回滚");
        }
    }复制代码

分别执行验证方法，结果：

结论：以上试验结果咱们证实在外围方法开启事务的状况下Propagation.REQUIRED修饰的内部方法会加入到外围方法的事务中，全部Propagation.REQUIRED修饰的内部方法和外围方法均属于同一事务，只要一个方法回滚，整个事务均回滚。

2.PROPAGATION_REQUIRES_NEW

咱们为 User1Service 和 User2Service 相应方法加上Propagation.REQUIRES_NEW属性。User1Service 方法：

@Service
public class User1ServiceImpl implements User1Service {
    //省略其余...
    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void addRequiresNew(User1 user){
        user1Mapper.insert(user);
    }
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void addRequired(User1 user){
        user1Mapper.insert(user);
    }
}复制代码

User2Service 方法：

@Service
public class User2ServiceImpl implements User2Service {
    //省略其余...
    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void addRequiresNew(User2 user){
        user2Mapper.insert(user);
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void addRequiresNewException(User2 user){
        user2Mapper.insert(user);
        throw new RuntimeException();
    }
}复制代码

2.1 场景一

外围方法没有开启事务。

验证方法 1：

@Override
    public void notransaction_exception_requiresNew_requiresNew(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addRequiresNew(user1);

        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiresNew(user2);
        throw new RuntimeException();

    }复制代码

验证方法 2：

@Override
    public void notransaction_requiresNew_requiresNew_exception(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addRequiresNew(user1);

        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiresNewException(user2);
    }复制代码

分别执行验证方法，结果：

结论：经过这两个方法咱们证实了在外围方法未开启事务的状况下Propagation.REQUIRES_NEW修饰的内部方法会新开启本身的事务，且开启的事务相互独立，互不干扰。

2.2 场景二

外围方法开启事务。

验证方法 1：

@Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void transaction_exception_required_requiresNew_requiresNew(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addRequired(user1);

        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiresNew(user2);

        User2 user3=new User2();
        user3.setName("王五");
        user2Service.addRequiresNew(user3);
        throw new RuntimeException();
    }复制代码

验证方法 2：

@Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void transaction_required_requiresNew_requiresNew_exception(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addRequired(user1);

        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiresNew(user2);

        User2 user3=new User2();
        user3.setName("王五");
        user2Service.addRequiresNewException(user3);
    }复制代码

验证方法 3：

@Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void transaction_required_requiresNew_requiresNew_exception_try(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addRequired(user1);

        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiresNew(user2);
        User2 user3=new User2();
        user3.setName("王五");
        try {
            user2Service.addRequiresNewException(user3);
        } catch (Exception e) {
            System.out.println("回滚");
        }
    }复制代码

分别执行验证方法，结果：

结论：在外围方法开启事务的状况下Propagation.REQUIRES_NEW修饰的内部方法依然会单独开启独立事务，且与外部方法事务也独立，内部方法之间、内部方法和外部方法事务均相互独立，互不干扰。

3.PROPAGATION_NESTED

咱们为 User1Service 和 User2Service 相应方法加上Propagation.NESTED属性。User1Service 方法：

@Service
public class User1ServiceImpl implements User1Service {
    //省略其余...
    @Override
    @Transactional(propagation = Propagation.NESTED)
    public void addNested(User1 user){
        user1Mapper.insert(user);
    }
}复制代码

User2Service 方法：

@Service
public class User2ServiceImpl implements User2Service {
    //省略其余...
    @Override
    @Transactional(propagation = Propagation.NESTED)
    public void addNested(User2 user){
        user2Mapper.insert(user);
    }

    @Override
    @Transactional(propagation = Propagation.NESTED)
    public void addNestedException(User2 user){
        user2Mapper.insert(user);
        throw new RuntimeException();
    }
}复制代码

3.1 场景一

此场景外围方法没有开启事务。

验证方法 1：

@Override
    public void notransaction_exception_nested_nested(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addNested(user1);

        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addNested(user2);
        throw new RuntimeException();
    }复制代码

验证方法 2：

@Override
    public void notransaction_nested_nested_exception(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addNested(user1);

        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addNestedException(user2);
    }复制代码

分别执行验证方法，结果：

结论：经过这两个方法咱们证实了在外围方法未开启事务的状况下Propagation.NESTED和Propagation.REQUIRED做用相同，修饰的内部方法都会新开启本身的事务，且开启的事务相互独立，互不干扰。

3.2 场景二

外围方法开启事务。

验证方法 1：

@Transactional
    @Override
    public void transaction_exception_nested_nested(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addNested(user1);

        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addNested(user2);
        throw new RuntimeException();
    }复制代码

验证方法 2：

@Transactional
    @Override
    public void transaction_nested_nested_exception(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addNested(user1);

        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addNestedException(user2);
    }复制代码

验证方法 3：

@Transactional
    @Override
    public void transaction_nested_nested_exception_try(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addNested(user1);

        User2 user2=new User2();
        user2.setName("李四");
        try {
            user2Service.addNestedException(user2);
        } catch (Exception e) {
            System.out.println("方法回滚");
        }
    }复制代码

分别执行验证方法，结果：

结论：以上试验结果咱们证实在外围方法开启事务的状况下Propagation.NESTED修饰的内部方法属于外部事务的子事务，外围主事务回滚，子事务必定回滚，而内部子事务能够单独回滚而不影响外围主事务和其余子事务

4. REQUIRED,REQUIRES_NEW,NESTED 异同

由“1.2 场景二”和“3.2 场景二”对比，咱们可知：NESTED 和 REQUIRED 修饰的内部方法都属于外围方法事务，若是外围方法抛出异常，这两种方法的事务都会被回滚。可是 REQUIRED 是加入外围方法事务，因此和外围事务同属于一个事务，一旦 REQUIRED 事务抛出异常被回滚，外围方法事务也将被回滚。而 NESTED 是外围方法的子事务，有单独的保存点，因此 NESTED 方法抛出异常被回滚，不会影响到外围方法的事务。

由“2.2 场景二”和“3.2 场景二”对比，咱们可知：NESTED 和 REQUIRES_NEW 均可以作到内部方法事务回滚而不影响外围方法事务。可是由于 NESTED 是嵌套事务，因此外围方法回滚以后，做为外围方法事务的子事务也会被回滚。而 REQUIRES_NEW 是经过开启新的事务实现的，内部事务和外围事务是两个事务，外围事务回滚不会影响内部事务。

5. 其余事务传播行为

鉴于文章篇幅问题，其余事务传播行为的测试就不在此一一描述了，感兴趣的读者能够去源码中本身寻找相应测试代码和结果解释。传送门：https://github.com/TmTse/transaction-test

模拟用例

介绍了这么多事务传播行为，咱们在实际工做中如何应用呢？下面我来举一个示例：

假设咱们有一个注册的方法，方法中调用添加积分的方法，若是咱们但愿添加积分不会影响注册流程（即添加积分执行失败回滚不能使注册方法也回滚），咱们会这样写：

@Service
   public class UserServiceImpl implements UserService {

        @Transactional
        public void register(User user){

            try {
                membershipPointService.addPoint(Point point);
            } catch (Exception e) {
               //省略...
            }
            //省略...
        }
        //省略...
   }复制代码

咱们还规定注册失败要影响addPoint()方法（注册方法回滚添加积分方法也须要回滚），那么addPoint()方法就须要这样实现：

@Service
   public class MembershipPointServiceImpl implements MembershipPointService{

        @Transactional(propagation = Propagation.NESTED)
        public void addPoint(Point point){

            try {
                recordService.addRecord(Record record);
            } catch (Exception e) {
               //省略...
            }
            //省略...
        }
        //省略...
   }复制代码

咱们注意到了在addPoint()中还调用了addRecord()方法，这个方法用来记录日志。他的实现以下：

@Service
   public class RecordServiceImpl implements RecordService{

        @Transactional(propagation = Propagation.NOT_SUPPORTED)
        public void addRecord(Record record){


            //省略...
        }
        //省略...
   }复制代码

咱们注意到addRecord()方法中propagation = Propagation.NOT_SUPPORTED，由于对于日志无所谓精确，能够多一条也能够少一条，因此addRecord()方法自己和外围addPoint()方法抛出异常都不会使addRecord()方法回滚，而且addRecord()方法抛出异常也不会影响外围addPoint()方法的执行。

经过这个例子相信你们对事务传播行为的使用有了更加直观的认识，经过各类属性的组合确实能让咱们的业务实现更加灵活多样。

结论

经过上面的介绍，相信你们对 Spring 事务传播行为有了更加深刻的理解，但愿你们平常开发工做有所帮助。

因为细节内容实在太多啦，因此只把部分知识点截图出来粗略的介绍，每一个小节点里面都有更细化的内容！

整理了一份Java核心知识点。覆盖了JVM、锁、并发、Java反射、Spring原理、微服务、Zookeeper、数据库、数据结构等大量知识点。

若是须要获取到这个【资料】文档的话能够扫一扫下面

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程