精华内容
下载资源
问答
  • spring事务传播机制
    2022-05-26 14:11:27

    Spring事务传播机制
    大家都知道spring的有个很重要的概念就是事务,事务传播是如果a方法中调用了b方法,那么b方法是用a的事务呢还是单独开启另外的事务呢?

    这就牵扯到了Spring的事务传播机制

    Spring有7中事务传播机制,我一一给大家做个简单的介绍

    REQUIRED
    这是Spring默认的传播机制,如果a方法没有开启事务b就会自己新建一个事务,如果a开启了事务,b就会使用a的事务

    REQUIRES_NEW
    显然这时候b需要创建一个新的事务,如果a开启了事务,b会挂起当前的事务,不管a有没有事务,b都会使用新的事务

    SUPPORTS
    如果a开启了事务,b就用a的事务,如果a没有事务,b也不会新建事务,也会以非事务的方式运行

    NOT_SUPPORTED
    如果a开启了事务,b会把这个事务挂起,也就是说方法会以非事务的形式运行

    NEVER
    显然这个比NOT_SUPPORTED更加的强势,它会让a和b都不使用事务,如果存在事务的话就会抛出异常

    NESTED
    当a事务有的话,b会嵌套一个事务,当b出现异常的时候b会回滚,a不受影响,a回滚的话b也会回滚。也就是b不会影响a,a影响b

    MANDATORY
    MANDATORY是强制性的意思,a如果有事务,b就会和a共用同一个事务,如果a没有事务,b就抛出异常信息

    总结
    本篇主要介绍了spring的7中事务传播机制,默认是REQUIRED,理解它并在合适的场景下选择合适的事务传播机制。

     

    更多相关内容
  • spring事务传播机制

    千次阅读 2021-07-26 15:12:52
    spring事务传播机制前言一、7种事务传播类型1.1 支持当前事务1.2 不支持当前事务1.3 NESTED二、示例2.1 required2.读入数据总结 前言 spring事务传播行为的含义: 简单的理解就是多个事务方法相互调用时,事务如何...
    桃李不言,下自成蹊。

    桃树李树虽不会说话,但是它们果实甜美,惹人喜爱,人们在它下面走来走去,走成了一条小路。


    前言

    spring事务传播行为的含义:

    简单的理解就是多个事务方法相互调用时,事务如何在这些方法间传播。
    默认是REQUIRED。

    一、7种事务传播类型

    7种事务传播类型分别是:
    REQUIRED、SUPPORTS、MANDATORY
    REQUIRES_NEW、NOT_SUPPORTED、NEVER
    NESTED

    这种东西没必要刻意去记,死记硬背过后也是会遗忘的,我们要真正理解其含义。
    spring事务传播机制可以分为三组

    1.1 支持当前事务

    支持当前事务的传播机制有三种,分别是
    1 REQUIRED (必须有)

    含义:如果当前方法没有事务,新建一个事务,如果已经存在一个事务中,则加入到这个事务中。

    2 SUPPORTS (可有可无)

    含义:支持当前事务,如果当前没有事务,就以非事务方式执行

    3 MANDATORY (强制)

    含义:使用当前的事务,如果当前没有事务,就抛出异常。

    1.2 不支持当前事务

    4 REQUIRES_NEW

    含义:新建事务,如果当前存在事务,把当前事务挂起。

    5 NOT_SUPPORTED

    含义:以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。

    6 NEVER

    含义: 以非事务方式执行,如果当前存在事务,则抛出异常。

    1.3 NESTED

    含义: 如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则执行与PROPAGATION_REQUIRED类似的操作。

    二、示例

    案例场景:每次调用创建用户接口的同时,都要记录一下该操作日志;创建用户方法会向user表中插入一条数据,操作日志方法会向log表中插入一条数据。

    2.1 saveUser 配置事务 required, saveLog 无事务

    @Service
    public class UserServiceImpl implements UserService {
      @Autowired
      private UserRepository userRepository;
    
      @Autowired
      private LogService logService;
      
      @Override
      @Transactional(propagation = Propagation.REQUIRED)
      public void saveUser() {
        User user = new User();
        user.setName("dly");
    
        userRepository.save(user);
    
        saveLog();
    
      }
    
      @Override
      public void saveLog() {
        Log log = new Log();
        log.setContent("新增用户");
    
        logService.saveLog(log);
       
        // 异常 / by zero
        int i = 1 / 0;
      }
     }
    

    结论:在这个案例中user、log都不会存储成功。
    原因: 1. addUser 方法中配置事务为required
    2. saveLog未配置事务,但是addUser调用了saveLog,由于事务传播类型为requried,所以saveLog也是有事务的, 所以出现异常时,触发回滚,哪个也存不进去。

    2.2 saveUser 无事务, saveLog事务为required

    @Service
    public class UserServiceImpl implements UserService {
      @Autowired
      private UserRepository userRepository;
    
      @Autowired
      private LogService logService;
    
      @Autowired
      private UserService userService;
    
      @Override
      public void saveUser() {
        User user = new User();
        user.setName("dly");
    
        userRepository.save(user);
    
        userService.saveLog();
    
      }
    
      @Override
      @Transactional(propagation = Propagation.REQUIRED)
      public void saveLog() {
        Log log = new Log();
        log.setContent("新增用户");
    
        logService.saveLog(log);
    
        // 异常
        int i = 1 / 0;
      }
    
    

    结论:user插入成功,log失败
    原因:1.saveUser方法没有事务
    2.saveUser调用了saveLog,saveLog方法的事务只作用在当前方法上面,因此发生异常时,log回滚,user没有事务,不回滚。

    补充:因为spring 中事务的实现使用的是AOP,也就是通过动态代理实现的,因此,在案例中需要注入Service类型,借助通过spring代理的service对象来完成同一个类中方法的相互调用,不能使用this.方法名(),直接this调用是没有事务的。

    2.3 saveUser 配置事务required,saveLog配置事务not_supported

    @Service
    public class UserServiceImpl implements UserService {
      @Autowired
      private UserRepository userRepository;
    
      @Autowired
      private LogService logService;
    
      @Autowired
      private UserService userService;
    
      @Override
      @Transactional(propagation = Propagation.REQUIRED)
      public void saveUser() {
        User user = new User();
        user.setName("dly");
    
        userRepository.save(user);
    
        userService.saveLog();
    
      }
    
      @Override
      @Transactional(propagation = Propagation.NOT_SUPPORTED)
      public void saveLog() {
        Log log = new Log();
        log.setContent("新增用户");
    
        logService.saveLog(log);
    
        // 异常
        int i = 1 / 0;
      }
    
    
    

    结论:user 插入失败,log插入成功
    原因:1.saveUser 事务是required
    2.saveLog事务是not_supported,意思是以非事务方式运行,如果存在事务,则把事务挂起,因此可以理解为saveLog方法是没有事务的,所以抛处异常后,user回滚,log不回滚。

    not_supported,以非事务方式运行在记录日志这种场景时是很合适的,就日志而言,不管你成功与否,我都要记录。

    2.4 saveUser事务required,saveLog配置事务never

    @Service
    public class UserServiceImpl implements UserService {
      @Autowired
      private UserRepository userRepository;
    
      @Autowired
      private LogService logService;
    
      @Autowired
      private UserService userService;
    
      @Override
      @Transactional(propagation = Propagation.REQUIRED)
      public void saveUser() {
        User user = new User();
        user.setName("dly");
    
        userRepository.save(user);
    
        userService.saveLog();
    
      }
    
      @Override
      @Transactional(propagation = Propagation.NEVER)
      public void saveLog() {
        Log log = new Log();
        log.setContent("新增用户");
    
        logService.saveLog(log);
    
      }
    
    

    结论:user、log 都插入失败
    原因:1.saveLog中配置的事务机制为never,表示如果存在事务,则抛处异常,因此user、log全部回滚。
    抛出的异常为:
    IllegalTransactionStateException: Existing transaction found for transaction marked with propagation ‘never’

    总结

    spring的事务传播默认使用的是required, 也是最常用的,而且spring的事务处理是使用aop动态代理来实现的,如果使用不当就会出现spring事务失效的问题。

    展开全文
  • spring传播机制个人学习
  • 大家好,Spring事务传播机制大家应该都知道,不管是平时的工作还是备战面试,都会被问到,很多时候我们都跟背八股文一样背这个规律,但是却没有实践过,今天我打算用一个实践的操作来跟大家一起温习一下这些事务传播...

    大家好,Spring事务传播机制大家应该都知道,不管是平时的工作还是备战面试,都会被问到,很多时候我们都跟背八股文一样背这个规律,但是却没有实践过,今天我打算用一个实践的操作来跟大家一起温习一下这些事务传播机制。

    首先我们知道事务传播机制分为以下几种

    事务传播级别含义外层有事务外层无事务备注
    REQUIRED 默认事务级别加入外层事务新建一个事务
    SUPPORTS支持当前事务加入外层事务以非事务方式运行
    MANDATORY强制事务执行加入外层事务报错
    REQUIRES_NEW新建一个新事务挂起并新建一个事务新建一个事务新老事务相互独立
    NOT_SUPPORTED以非事务方式运行挂起外层事务以非事务方式运行
    NEVER以非事务方式运行报错以非事务方式运行
    NESTED嵌套事务加入外层事务新建一个事务

    外层回滚,内层也要回滚,

    内层回滚,外层不用回滚。

    接着我以一些实践操作来证实上面的结论。

    1、REQUIRED

    ①  外层没有事务,则新建一个事务

    外层代码:

        /**
         * 默认事务,外层没有事务,开启一个新的事务
         * 数据正常保存到数据库
         */
        @Test
        public void save() {
            requiredService.save("chenhuaijie");
        }

    内层代码:

    
        /**
         * 默认配置事务配置
         *
         * @param username
         */
        @Transactional
        public void save(String username) {
            User user = User.builder().username(username).build();
            userRepository.save(user);
        }

    结果:

     ② 外层有事务,则加入外层事务

    外层代码:

     /**
         * 外层事务
         *
         * @param username
         */
        @Transactional
        public void save(String username) {
            requiredService.save(username);
        }

    内层代码:

        /**
         * 默认配置事务配置
         *
         * @param username
         */
        @Transactional
        public void save(String username) {
            User user = User.builder().username(username).build();
            userRepository.save(user);
        }

    结果

     

    2、SUPPORTS

    ① 外层无事务,以非事务方式运行

    外层代码

        /**
         * 非事务方式运行
         * 正常保存数据
         *
         * @param username
         */
        public void save(String username) {
            supportsService.save(username);
        }
    

    内层代码

        /**
         * Support事务配置
         *
         * @param username
         */
        @Transactional(propagation = Propagation.SUPPORTS)
        public void save(String username) {
            User user = User.builder().username(username).build();
            userRepository.save(user);
        }

    结果,在service层并没有创建事务

     

    ② 外层有事务,加入外层事务

    外层代码

        /**
         * 以事务方式运行
         * 正常保存数据
         *
         * @param username
         */
        @Transactional
        public void saveWithTransaction(String username) {
            supportsService.save(username);
        }

    内层代码

        /**
         * Support事务配置
         *
         * @param username
         */
        @Transactional(propagation = Propagation.SUPPORTS)
        public void save(String username) {
            User user = User.builder().username(username).build();
            userRepository.save(user);
        }

    结果

    3、MANDATORY

    ①外层有事务,加入外层事务

    外层代码

        /**
         * 加入当前事务
         * 数据保存正常
         *
         * @param username
         */
        @Transactional
        public void saveWithTransaction(String username) {
            mandatoryService.save(username);
        }

    内层代码

        /**
         * 外层有事务就跟着外层事务,外层没有事务就报错
         *
         * @param username
         */
        @Transactional(propagation = Propagation.MANDATORY)
        public void save(String username) {
            User user = User.builder().username(username).build();
            userRepository.save(user);
        }

    结果

     

    ②外层无事务,报错

    外层代码

        /**
         * 报错
         *
         * @param username
         */
        public void save(String username) {
            mandatoryService.save(username);
        }

    内层代码

        /**
         * 外层有事务就跟着外层事务,外层没有事务就报错
         *
         * @param username
         */
        @Transactional(propagation = Propagation.MANDATORY)
        public void save(String username) {
            User user = User.builder().username(username).build();
            userRepository.save(user);
        }

    结果

     

    4、REQUIRES_NEW

    ①外层有事务,挂起外层事务并新建一个事务

    外层代码

        /**
         * 存在事务,则新启动一个新的事务
         *
         * @param username
         */
        @Transactional
        public void saveWithTransaction(String username) {
            requiredNewService.save(username);
        }

    内层代码

        /**
         * 要求启动一个新的事务
         *
         * @param username
         */
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        public void save(String username) {
            User user = User.builder().username(username).build();
            userRepository.save(user);
        }
    

    结果

     

    ②外层无事务,新建一个事务

    外层代码

        /**
         * 没有事务,以事务方式运行
         *
         * @param username
         */
        public void save(String username) {
            requiredNewService.save(username);
        }

    内层代码

        /**
         * 要求启动一个新的事务
         *
         * @param username
         */
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        public void save(String username) {
            User user = User.builder().username(username).build();
            userRepository.save(user);
        }

    结果

     

    5、NOT_SUPPORTED

    ①:外层有事务,挂起外层事务

    外层代码

    
        @Transactional
        public void saveWithTransaction(String username) {
            notSupportedService.save(username);
        }

    内层代码

        /**
         * 如果当前事务存在则挂起当前事务
         *
         * @param username
         */
        @Transactional(propagation = Propagation.NOT_SUPPORTED)
        public void save(String username) {
            User user = User.builder().username(username).build();
            userRepository.save(user);
        }

    结果

     

    ②:外层无事务,以非事务方式运行

    外层代码

        public void save(String username) {
            notSupportedService.save("chenhuaijie");
        }

    内层代码

        /**
         * 如果当前事务存在则挂起当前事务
         *
         * @param username
         */
        @Transactional(propagation = Propagation.NOT_SUPPORTED)
        public void save(String username) {
            User user = User.builder().username(username).build();
            userRepository.save(user);
        }

    结果

     

    6、NEVER

    ①:外层有事务,报错

    外层代码

        /**
         * 报错
         *
         * @param username
         */
        @Transactional
        public void saveWithTransaction(String username) {
            neverService.save(username);
        }

    内层代码

    
        /**
         * 外层有事务就跟着外层事务,外层没有事务就报错
         *
         * @param username
         */
        @Transactional(propagation = Propagation.NEVER)
        public void save(String username) {
            User user = User.builder().username(username).build();
            userRepository.save(user);
        }

    结果

     

    ②:外层无事务,以非事务方式运行

    外层代码

        /**
         * 非事务方式运行
         * 数据保存正常
         *
         * @param username
         */
        public void save(String username) {
            neverService.save(username);
        }

    内层代码

        /**
         * 外层有事务就跟着外层事务,外层没有事务就报错
         *
         * @param username
         */
        @Transactional(propagation = Propagation.NEVER)
        public void save(String username) {
            User user = User.builder().username(username).build();
            userRepository.save(user);
        }

    结果

     

    7、NESTED

    jpa不支持nested事务传播机制,nested的特点是,

    ① 外层有事务,加入外层事务,类似于REQUIRED

    外层代码

        /**
         * 如果外层有事务,则内层新增一个嵌套事务
         */
        @Transactional(transactionManager = "dataSourceTransactionManager")
        public void saveWithTransaction(String username) {
            nestedService.save(username);
        }

    内层代码

        /**
         * 如果当前存在事务则执行一个嵌套事务,如果当前没有事务则新建一个事务
         * 如果外层事务回滚了,内层事务要跟着回滚;如果内层事务回滚了,外层事务不需要回滚
         *
         * @param username
         */
        @Transactional(transactionManager = "dataSourceTransactionManager", propagation = Propagation.NESTED)
        public void save(String username) {
            User user = User.builder().username(username).build();
            userTemplate.save(user);
        }

    结果

    ② 外层无事务,新建一个事务,类似于REQUIRED_NEW

    外层代码

        /**
         * 外层没有事务,则内层新建一个事务,此时类似于REQUIRED_NEW
         */
        public void save(String username) {
            nestedService.save(username);
        }
    

    内层代码

        /**
         * 如果当前存在事务则执行一个嵌套事务,如果当前没有事务则新建一个事务
         * 如果外层事务回滚了,内层事务要跟着回滚;如果内层事务回滚了,外层事务不需要回滚
         *
         * @param username
         */
        @Transactional(transactionManager = "dataSourceTransactionManager", propagation = Propagation.NESTED)
        public void save(String username) {
            User user = User.builder().username(username).build();
            userTemplate.save(user);
        }

    结果

     

    外层回滚带动内层回滚:这种看起来是一个事务的效果

    内层回滚不影响外层事务提:这种看起来是独立事务的效果

    在一个注解上可以实现两种效果,这也是嵌套事务的巧妙之处。

    外层代码:

    
        /**
         * 实现如下场景:
         * 外事务回滚,内事务也要回滚
         * 但是如果内事务回滚了,外事务不用回滚
         */
        @Transactional(transactionManager = "dataSourceTransactionManager", rollbackFor = NullPointerException.class)
        public void save(boolean rollbackOuter, boolean rollbackInner) {
            userTemplate.save(User.builder().username("1").build());
    
            try {
                nestedService.saveWithNullPointException("2", rollbackInner);
            } catch (Exception e) {
    
            }
    
            if (rollbackOuter) {
                throw new NullPointerException();
            }
        }

    内层代码:

        @Transactional(transactionManager = "dataSourceTransactionManager", propagation = Propagation.REQUIRES_NEW)
        public void saveWithNullPointException(String username, boolean rollback) {
            User user = User.builder().username(username).build();
            userTemplate.save(user);
            if (rollback) {
                int i = 10 / 0;
            }
        }

    测试代码:

        // ====================================================================================================
        // 只有将传播机制设置为NESTED级别,才会同时实现如下两种场景的要求,改成REQUIRED或者REQUIRES_NEW都只能满足其中一种
    
        /**
         * 内事务回滚,外事务不回滚
         */
        @Test
        public void save1() {
            nestedOuterService.save(false, true);
        }
    
        /**
         * 外事务回滚,内事务一起回滚
         */
        @Test
        public void save2() {
            nestedOuterService.save(true, false);
        }
        // ====================================================================================================

    展开全文
  • Spring 事务传播机制

    2020-07-13 17:55:39
    Spring事务传播机制、隔离级别和回滚策略

    事务传播机制

    什么是事务传播?

    比如 A 方法开启了事务,A 方法中调用了 B 方法,B 方法也开启了事务,那么这时候 A 和 B 之间的事务是独立进行的还是一起作用的?

    Spring 在这方面为我们提供了管理的方法,也就是今天我们讨论的 Spring 的事务传播机制。

    首先我们看 TransactionDefinition 接口的注释。

    /**Interface that defines Spring-compliant transaction properties.
    * Based on the propagation behavior definitions analogous to EJB CMT attributes.
    大概说这个接口定义了 Spring 兼容的事务属性。基于类似于EJB CMT属性的传播行为定义。
    */
    

    那什么是 EJB CMT 呢?参考维基百科的解释,EJB 容器必须支持 Container-managed transaction(CMT)来管理 ACID 特性的事务和 Bean managed transaction(BMT)。

    对应到 Spring 框架就是我们常说的 Spring 事务的传播机制以及隔离级别。

    这两个容器的目的就是不需要显式复杂的配置,事务管理可以通过简单的注解进行。

    Spring 通过 Spring AOP 来进行事务的管理,比如我们常用的 @Transactional 注解。

    那当我们在方法中互相调用开启了事务功能的方法时,方法之间定义的事务是怎么起作用的呢?

    相关的定义在 Spring 的 TransactionDefinition 接口文件中。Spring 定义了 6 中传播行为。

    REQUIRED

    支持当前的事务;如果当前没有,那么创建一个新的。这也是 Spring 默认的传播行为。

    比如,方法 A 调用了方法 B,A B都开启 REQUIRED 级别的事务。那么,B 方法会发现有了当前事务 A,那么 B 就会加入到 A 的事务中。

    如果 A 没有开启事务,B 仍旧开启自己的事务。

    SUPPORTS

    支持当前事务;如果没有当前事务以非事务的方式运行。

    也可以从字面上理解,supports 看起来就没有 required 那么强势。如果没有当前事务就非事务运行好了。

    MANDATORY(强制性)

    支持当前事务;如果没有会抛出异常;

    REQUIRES_NEW

    始终创建一个新的事务;如果有当前事务,会把当前事务挂起;

    NOT_SUPPORTED

    不支持当前事务;总是以非事务方式执行。

    NEVER

    不支持当前事务;如果有当前事务会抛出异常。

    NESTED(嵌套)

    如果当前事务存在,就以嵌套的方式运行。行为和 REQUIRED 很像。

    自调用的问题

    Stackover Flow 上有一个相关的问答,大意是在方法中调用了同一个 service 的方法,比如方法 A (REQUIRED)调用了方法 B,即使 B 声明了 **REQUIRS_NEW **的传播行为(始终创建一个新事务执行),但在 A 方法抛出异常的时候,B 方法还是会回滚。

    这个问题需要从 Spring AOP 中动态代理的角度来分析。

    Spring AOP 使用 JDK / Cglib 进行动态代理,它会通过代理,织入增强代码。比如调用带 @Transactional 注解的方法,会通过调用**代理对象(增强后)**的该方法进行。

    但当进行自调用的时候,方法内部调用的方法还是使用原对象进行。也就是说,Spring AOP 的代理对象只会在不同的 bean 之间相互调用的时候使用。

    一般遇到自调用的问题时,一个解决办法是新建一个帮助类,然后去调用它。

    大家也可以看看 Spring doc 中的 1.4.6 节,有关自调用方面的说明。

    Spring 官方还建议把 @Transactional 注解使用在具体的类上,不建议用在 接口 上。

    原因是,当你使用了基于 类 的代理方式时,使用在 接口 上的注解就失效了。

    事务隔离级别

    Spring 的事务隔离级别和数据库的没有什么区别。

    • 读未提交
    • 读提交
    • 可重复读
    • 串行化

    Spring 有一个 ISOLATION_DEFAULT 级别,作用是采用和 数据库 一致的隔离级别。

    异常回滚

    @Transactional 还有一个 rollbackFor() 属性。

    接口上的注释大意是,这个属性定义了发生什么类型的异常会触发事务的回滚。

    By default,事务会因为发生非受检异常回滚,受检异常发生了不会回滚。

    你可以这么用,来定义自己的异常回滚策略。

    @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    

    总结

    最后做一个总结,Spring 利用 Spring AOP 提供了方便的事务管理功能。在此基础上,通过配置事务的传播机制,进一步解决实际上使用事务时可能存在的问题。

    因为 Spring AOP 动态代理的特性,在自调用的时候会出现事务失效的问题。除了刚才提到的使用帮助类来调用,还有一种方法是使用 AspectJ ,这是另一种 AOP 方案,其原理是通过在编译期在字节码层面织入代码实现增强功能。

    最后就是事务的隔离级别。隔离级别这方面需要了解比如脏读,幻读等问题。

    (=・ω・=)

    展开全文
  • 一.Spring事务传播机制 首先一定是基于嵌套事务来讨论的,如果是一个事务就没什么意义了 比如现在有一个这样的例子::test调用methodB,methodB有Transactional,methodB调用 methodA,methodA也有事务 ,这...
  • 但是Spring事务有自己的特点,也就是事务传播机制。 所谓事务传播机制,也就是在事务在多个方法的调用中是如何传递的,是重新创建事务还是使用父方法的事务?父方法的回滚对子方法的事务是否有影响?这些都是可以...
  • Spring事务传播机制就是多个事务方法相互调用时,事务如何在这些方法间传播。 举个栗子,方法A是一个事务的方法,方法A执行过程中调用了方法B,那么方法B有无事务以及方法B对事务的要求不同都会对方法A的事务具体执行...
  • Spring事务传播机制 一、何为Spring传播机制: Spring事务的传播机制就是,事务如何在方法的调用如何传播。 二、使用传播机制的时候的关键点: 使用声明式的事务时,调用方法和被调用方法不能在同一个类。比如同在...
  • 主要介绍了Spring事务传播属性和隔离级别详细介绍,同时涉及传播行为介绍,超时设置等相关内容,需要的朋友可以参考下。
  • spring事务传播机制之《REQUIRED》

    千次阅读 2022-03-14 23:59:29
    spring事务传播指一个service方法调用多个其他service的方法时事务的范围。即各个被调用的方法和调用者之间怎样处理数据库事务。 spring中共有七中事务类型:REQUIRED、SUPPORTS、MANDATORY、REQUIRES_NEW、NOT_...
  • 环境: Springboot:2.2.3.RELEASE Spring:5.2.3.RELEASE 事务传播行为枚举参见Spring源码:org.spring...先来了解一下Spring事务传播机制(由于英语不好,直接google翻译了) 简单终结一下: 枚举 ...
  • spring事务传播机制和隔离级别

    千次阅读 2020-07-01 18:16:49
    spring事务传播机制和隔离级别 一、spring事务的7种传播机制 1、PROPAGATION_REQUIRED 若当前存在事务,则加入该事务,若不存在事务,则新建一个事务。 class C1(){ @Transactional(propagation = Propagation....
  • 有道云笔记 整理了一下,希望对看到的人有所帮助
  • Spring事务详解 事务(Transaction)是由一系列对系统中数据进行访问与更新的操作所组成的一个程序执行逻辑单元。 数据库事务只有隔离级别,没有传播机制,Spring传播机制是由Spring控制的,与数据库无关。而Spring...
  • spring事务传播机制定义在 TransactionDefinition 接口中,定义了如下传播类型 PROPAGATION_REQUIRED 支持当前事务,如果没有当前事务就创建一个新的事务,是默认的传播行为。 外围方法未开启事务 内部会创建...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,848
精华内容 9,139
关键字:

spring事务传播机制

spring 订阅
友情链接: DSP320F2812.rar