spring 事务隔离级别实测

最新推荐文章于 2024-06-04 22:51:33 发布
最新推荐文章于 2024-06-04 22:51:33 发布
阅读量2.9k 收藏 25
点赞数 7
分类专栏： 数据库 文章标签： Spring事务隔离级别
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xjune/article/details/90449256
版权

前言

编写缘由，发现网上事务级别介绍很多，但真正理解或者运用的感觉不是特别多，特别是结合spring进行使用有不少需要注意点。
我记录一下采坑记录便于以后查询。

spring事务传播行为

Spring事务传播行为网上一堆，不再解释，目前我主要使用spring默认事务级别PROPAGATION_REQUIRES和PROPAGATION_REQUIRES_NEW

传播行为意义
PROPAGATION_MANDATORY表示该方法必须运行在一个事务中。如果当前没有事务正在发生，将抛出一个异常
PROPAGATION_NESTED表示如果当前正有一个事务在进行中，则该方法应当运行在一个嵌套式事务中。被嵌套的事务可以独立于封装事务进行提交或回滚。如果封装事务不存在，行为就像PROPAGATION_REQUIRES一样。
PROPAGATION_NEVER表示当前的方法不应该在一个事务中运行。如果一个事务正在进行，则会抛出一个异常。
PROPAGATION_NOT_SUPPORTED表示该方法不应该在一个事务中运行。如果一个现有事务正在进行中，它将在该方法的运行期间被挂起。
PROPAGATION_SUPPORTS表示当前方法不需要事务性上下文，但是如果有一个事务已经在运行的话，它也可以在这个事务里运行。
PROPAGATION_REQUIRES_NEW表示当前方法必须在它自己的事务里运行。一个新的事务将被启动，而且如果有一个现有事务在运行的话，则将在这个方法运行期间被挂起。
PROPAGATION_REQUIRES表示当前方法必须在一个事务中运行。如果一个现有事务正在进行中，该方法将在那个事务中运行，否则就要开始一个新事务。

数据库事务

以下参考网上内容，对事务隔离级别描述比较透彻

  • 脏读（Dirty read）: 当一个事务正在访问数据并且对数据进行了修改，而这种修改还没有提交到数据库中，这时另外一个事务也访问了这个数据，然后使用了这个数据。因为这个数据是还没有提交的数据，那么另外一个事务读到的这个数据是“脏数据”，依据“脏数据”所做的操作可能是不正确的。
  • 丢失修改（Lost to modify）: 指在一个事务读取一个数据时，另外一个事务也访问了该数据，那么在第一个事务中修改了这个数据后，第二个事务也修改了这个数据。这样第一个事务内的修改结果就被丢失，因此称为丢失修改。 例如：事务1读取某表中的数据A=20，事务2也读取A=20，事务1修改A=A-1，事务2也修改A=A-1，最终结果A=19，事务1的修改被丢失。
  • 不可重复读（Unrepeatableread）: 指在一个事务内多次读同一数据。在这个事务还没有结束时，另一个事务也访问该数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改导致第一个事务两次读取的数据可能不太一样。这就发生了在一个事务内两次读到的数据是不一样的情况，因此称为不可重复读。
  • 幻读（Phantom read）: 幻读与不可重复读类似。它发生在一个事务（T1）读取了几行数据，接着另一个并发事务（T2）插入了一些数据时。在随后的查询中，第一个事务（T1）就会发现多了一些原本不存在的记录，就好像发生了幻觉一样，所以称为幻读。

不可重复度和幻读区别：

不可重复读的重点是修改，幻读的重点在于新增或者删除。

例1（同样的条件, 你读取过的数据, 再次读取出来发现值不一样了 ）：事务1中的A先生读取自己的工资为 1000的操作还没完成，事务2中的B先生就修改了A的工资为2000，导 致A再读自己的工资时工资变为 2000；这就是不可重复读。

例2（同样的条件, 第1次和第2次读出来的记录数不一样 ）：假某工资单表中工资大于3000的有4人，事务1读取了所有工资大于3000的人，共查到4条记录，这时事务2 又插入了一条工资大于3000的记录，事务1再次读取时查到的记录就变为了5条，这样就导致了幻读。

事务隔离级别

SQL 标准定义了四个隔离级别：

  • READ-UNCOMMITTED(读取未提交)： 最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读。
  • READ-COMMITTED(读取已提交)： 允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生。
  • REPEATABLE-READ(可重复读)： 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生。
  • SERIALIZABLE(可串行化)： 最高的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。
隔离级别脏读不可重复读幻影读
READ-UNCOMMITTED√√√
READ-COMMITTED×√√
REPEATABLE-READ××√
SERIALIZABLE×××

MySQL InnoDB 存储引擎的默认支持的隔离级别是 REPEATABLE-READ（可重读）

实战演示

代码主要有如下TransactionalServiceImpl、TransactionalService2Impl两个方法

代码说明

  1. 在方法头不加上事务注解

每执行一段SQL语句，事务自动提交，即使抛异常，也不回滚

 /**
     * 无事务处理将同时插入两条记录也不回滚
     */
    @Override
    public void insertBatch() {
        Test test = new Test();
        String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        test.setName("hi：" + format);
        testMapper.insertSelective(test);
        Test2 test2 = new Test2();
        test2.setName("hi2：" + format);
        test2Mapper.insertSelective(test2);
        throw new RuntimeException("异常");

    }

    2. 在方法头加上事务注解，只要抛出异常，事务均回滚

  @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    @Override
    public void insert() {
        //方法1执行代码
        //方法2执行代码
        throw new RuntimeException("异常");
    }

     3. TransactionalServiceImpl加上Propagation.REQUIRED注解，TransactionalService2Impl 加上Propagation.REQUIRED_NEW注解。

若执行顺序为方法1 插入，方法2插入，方法1抛出异常。
结果为：方法1回滚，方法2提交

/**
     * 异常
     * service1 insert
     * service2 insert
     * service2 throw exception
     * service1 和service2事务均回滚
     * <p>
     * 异常
     * service1 insert
     * service2 insert
     * service1 throw exception
     * service1 回滚，service2不回滚
     */
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    @Override
    public void insert() {
        Test test = new Test();
        String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        test.setName("hi：" + format);
        testMapper.insertSelective(test);
        transactionalService2.insert();
        throw new RuntimeException("异常");
    }

      4.  在提交事务之前直接提交异步线程，因事务尚未提交，可能会导致异步线程无法查询到数据(该示例情况笔者之前也遇到有同学先插入表直接提交MQ并没有先提交插入表事务，大部分情况因MQ消费慢，这种BUG比较难以测试出来，当MQ没有其他消息，马上被消费者消费时就会出现无法找到插入数据情况)。

insertTest() 如果不作为单独方法调用，直接把 testMapper.insertSelective(test) 写入到insertOkAsync，因为在提交异步线程之前insertOkAsync方法有可能还未执行完毕，事务还未提交，asyncJob 无法查询到数据

 /**
     * 方法中执行insert 在新方法直接提交异步线程
     */
    @Override
    public void insertOkAsync() {
        Long id = insertTest();
       
        transactionalService2.asyncJob(id);
        System.out.println("after insert2.1" + new Date());

    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public Long insertTest() {
        Test test = new Test();
        String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        test.setName("hi：" + format);

        testMapper.insertSelective(test);
        System.out.println("after insert1" + new Date());
        return test.getId();
    }
    
    //TransactionalService2Impl
    @Async("asyncServiceExecutor")
    public void asyncJob(Long id) {
        /*try {
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }*/
        Test test = testMapper.selectByPrimaryKey(id);
        System.out.println("GET TEST2:"+test+new Date());
    }

   5. 同一个方法内，事务切面不起作用

方法1 Propagation.REQUIRES_NEW事务，方法2 Propagation.REQUIRES_NEW事务。 调用方法2相当于直接调用，并不能新启动事务。方法1 抛出异常后，方法1和方法2均回滚

@Transactional(rollbackFor = Exception.class)
    @Override
    public void insertSecond() {
        Test test = new Test();
        String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        test.setName("hi：" + format);
        testMapper.insertSelective(test);
    }

    /**
     * 测试service1 填写注解，同方法调用
     * 由于insertRequiresNew抛出异常，并且 insertRequiresNew和insert2为同一个service，数据均回滚
     */
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
    @Override
    public void insertRequiresNew() {
        Test test = new Test();
        String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        test.setName("hi：" + format);
        testMapper.insertSelective(test);
        insert2();
        throw new RuntimeException("异常");
    }

源码

  • TransactionalServiceImpl
package com.test.springtest.transaction.service.impl;

import com.test.springtest.transaction.domain.Test;
import com.test.springtest.transaction.domain.Test2;
import com.test.springtest.transaction.mapper.Test2Mapper;
import com.test.springtest.transaction.mapper.TestMapper;
import com.test.springtest.transaction.service.TransactionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * service
 *
 * @author junqiang.xiao
 * @date 2019/4/22 下午2:19
 */
@Service
public class TransactionalServiceImpl implements TransactionService {
    @Autowired
    private TestMapper testMapper;
    @Autowired
    private Test2Mapper test2Mapper;
    @Autowired
    private TransactionalService2Impl transactionalService2;

    @Autowired
    private ApplicationContext applicationContext;

    /**
     * 异常
     * service1 insert
     * service2 insert
     * service2 throw exception
     * service1 和service2事务均回滚
     * <p>
     * 异常
     * service1 insert
     * service2 insert
     * service1 throw exception
     * service1 回滚，service2不回滚
     */
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    @Override
    public void insert() {
        Test test = new Test();
        String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        test.setName("hi：" + format);
        testMapper.insertSelective(test);
        transactionalService2.insert();
        throw new RuntimeException("异常");
    }

    /**
     * 无事务处理将同时插入两条记录也不回滚
     */
    @Override
    public void insertBatch() {
        Test test = new Test();
        String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        test.setName("hi：" + format);
        testMapper.insertSelective(test);
        Test2 test2 = new Test2();
        test2.setName("hi2：" + format);
        test2Mapper.insertSelective(test2);
        throw new RuntimeException("异常");

    }


    /**
     * 测试在数据库提交线程之前，线程执行情况
     * 测试结果
     * 1. 若数据库commit之前，线程已经执行，会查询不到最新记录
     * 2. Async 在同一个方法中不起作用，同理为Transaction
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void insertAsync() {
        Test test = new Test();
        String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        test.setName("hi：" + format);

        testMapper.insertSelective(test);
        System.out.println("after insert1" + new Date());

        transactionalService2.asyncJob(test.getId());
        System.out.println("after insert1.1" + new Date());
        //asyncJob(test.getId()) //该方式无法正常切入切面，因为是同方法调用aop this指的是当前类而不是代理类
        TransactionService self2 = applicationContext.getBean(TransactionService.class);
        self2.asyncJob(test.getId());
        System.out.println("after insert1.2" + new Date());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Test test2 = new Test();
        test2.setName("hi：" + format);
        testMapper.insertSelective(test2);
        System.out.println("after insert2.1" + new Date());

    }


    /**
     * 方法中执行insert 在新方法直接提交异步线程
     */
    @Override
    public void insertOkAsync() {
        Long id = insertTest();
        transactionalService2.asyncJob(id);
        System.out.println("after insert2.1" + new Date());

    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public Long insertTest() {
        Test test = new Test();
        String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        test.setName("hi：" + format);

        testMapper.insertSelective(test);
        System.out.println("after insert1" + new Date());
        return test.getId();
    }

    @Async("asyncServiceExecutor")
    @Override
    public void asyncJob(Long id) {
        try {
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Test test = testMapper.selectByPrimaryKey(id);
        System.out.println("GET TEST1:" + test + new Date());
    }

    /**
     * 事务会传递到内层，直至整个方法执行完毕
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void standardInsertBatch() {
        Test test = new Test();
        String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        test.setName("hi：" + format);
        testMapper.insertSelective(test);
        insertSecond();
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public void insertSecond() {
        Test test = new Test();
        String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        test.setName("hi：" + format);
        testMapper.insertSelective(test);
    }

    /**
     * 测试service1 填写注解，同方法调用
     * 由于insertRequiresNew抛出异常，并且 insertRequiresNew和insert2为同一个service，数据均回滚
     */
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
    @Override
    public void insertRequiresNew() {
        Test test = new Test();
        String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        test.setName("hi：" + format);
        testMapper.insertSelective(test);
        insert2();
        throw new RuntimeException("异常");
    }

    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
    @Override
    public void insert2() {
        Test test = new Test();
        String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        test.setName("hi2：" + format);
        testMapper.insertSelective(test);
    }


}
  • TransactionalServiceImpl2
package com.test.springtest.transaction.service.impl;

import com.test.springtest.transaction.domain.Test;
import com.test.springtest.transaction.domain.Test2;
import com.test.springtest.transaction.mapper.Test2Mapper;
import com.test.springtest.transaction.mapper.TestMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

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

/**
 * service2
 *
 * @author junqiang.xiao
 * @date 2019/4/26 下午3:50
 */
@Service
public class TransactionalService2Impl {

    @Autowired
    private TestMapper testMapper;
    @Autowired
    private Test2Mapper test2Mapper;

    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
    public void insert() {
        Test2 test = new Test2();
        String format= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        test.setName("hi2："+format);
        test2Mapper.insertSelective(test);
    }
    @Async("asyncServiceExecutor")
    public void asyncJob(Long id) {
        /*try {
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }*/
        Test test = testMapper.selectByPrimaryKey(id);
        System.out.println("GET TEST2:"+test+new Date());
    }
}

 

xjune
关注
  • 7
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Spring事务隔离级别简介及实例解析
08-28
Spring事务隔离级别简介及实例解析 本文主要介绍了Spring事务隔离级别的概念和实例解析，涵盖了四个事务隔离级别：READ_UNCOMMITTED、READ_COMMITTED、REPEATABLE_READ和SERIALIZABLE。同时，文章还提供了相关代码...
Spring的事务隔离级别
qq_43795369的博客
07-27 5288
在该隔离级别下，其他事务不能修改当前事务已经读取的数据，避免了不可重复读问题。2. READ_UNCOMMITTED（读取未提交数据）：最低的隔离级别，允许一个事务读取另一个事务未提交的数据。3. READ_COMMITTED（读取已提交数据）：保证一个事务只能读取到已经提交的数据，避免脏读问题。以上就是Spring框架中的事务隔离级别的简要介绍。根据具体的业务需求和并发访问情况，选择合适的隔离级别可以确保数据的一致性和并发操作的正确性。Spring的事务隔离级别是用于控制事务并发访问数据库时的行为。
Spring事务隔离级别
qq_58098264的博客
09-09 2071
Spring事务隔离级别共有五种：DEFAULT、READ_UNCOMMITTED、READ_COMMITTED、REPEATBLE_READ、SERIALIZABLE。下面对这五个级别进行简单的介绍。
【Spring事务隔离机制】
最新发布
记录日常码代码的点点滴滴
06-04 1076
Spring事务隔离机制和mysql事物隔离机制实战
Spring事务的隔离级别
weixin_37799575的博客
08-23 2576
之前我们说过了事务的四个特性(ACID), 不了解的可以点击这里看看 ->今天来简单说一说隔离级别 …在操作数据的时候, 一般就会牵扯到数据库事务, 而事务需要满足四个特性, 也就是ACID, 原子性(Atomicity)、一致性(Consistency)、隔离性(Isolation) 和 持久性(Durability).所谓事务的隔离性，其实事务的这个属性是针对数据库访问的并发性问题而言的。
数据库（Spring）事务的四种隔离级别
ManuMAX的博客
02-12 1344
Q1:为什么会出现脏读A1：因为没有“select”操作没有规矩Q2：为什么会出现不可重复读A2：因为“update”操作没有规矩Q3：为什么会出现幻读A3：因为“insert”和“delete”操作没有规矩Q4：“读未提交（Read Uncommitted）”能预防啥？A4：啥都预防不了Q5：“读提交（Read Committed）”能预防啥？A5：使用“快照读（Snapshot Read）”，避免“脏读”，但是可能出现“不可重复读”和“幻读”Q6：“
MySQL事务及Spring隔离级别实现原理详解
09-08
在Spring框架中，`@Transactional`注解提供了设置事务隔离级别的能力，可以通过`isolation`参数调整Session级别的隔离。 至于死锁，它是并发控制中常见的问题，发生在两个或更多事务互相等待对方释放资源而陷入僵局...
Spring中的事务隔离级别的介绍
08-26
在Spring事务管理中，事务隔离级别是一个非常重要的概念，它定义了事务在并发执行时如何避免互相干扰和保持数据一致性。今天，我们将详细介绍Spring中的事务隔离级别，了解其特性和解决的问题。 事务简介 -------- ...
spring事务隔离级别
06-15
本文档介绍了spring事务隔离级别的使用及详解
spring事务的隔离级别
02-11
spring事务的隔离级别
Spring 有几种事务隔离级别？
热门推荐
知识分享官
09-19 1万+
事务隔离级别是对事务 4 大特性中隔离性的具体体现，使用事务隔离级别可以控制并发事务在同时执行时的某种行为。比如，有两个事务同时操作同一张表，此时有一个事务修改了这张表的数据，但尚未提交事务，那么在另一个事务中，要不要（或者说能不能）看到其他事务尚未提交的数据呢？这个问题的答案就要看事务的隔离级别了，不同的事务隔离级别，对应的行为模式也是不一样的（有些隔离级别可以看到其他事务尚未提交的数据，有些事务隔离级别看不到其他事务尚未提交的数据），这就是事务隔离级别的作用。
spring事务的传播级别
weixin_62988359的博客
12-08 5406
原子性操作，也被称为原子操作，是一个不可分割的操作单元。这意味着在执行过程中，该操作不会被其他线程或进程中断，要么完整地执行，要么完全不执行。例如，将一个整数从1增加到2的过程就是一个原子性操作，因为这个操作只涉及到一个赋值操作，即i=i+1。在数据库中，原子性操作同样非常重要。以转账为例，从A账户向B账户转账1000块钱的整个过程，包括从A账户中扣除1000块钱和向B账户中增加1000块钱这两个步骤，被统称为一个事务。如果其中任何一个步骤失败，整个事务都会回滚到原始状态，这确保了数据的一致性和完整性。
【Spring事务学习】事务分类 && 隔离级别 && 事务传播机制
qq_48479056的博客
07-31 1554
将一组操作封装成⼀个执行（封装到一起），要么全部成功，要么全部失败。比如转账分为两个操作：（1）：A账户+100元；（2）：B账户-100元；如果没有事务，AB两个账户是分离的，当B账户给A转账成功，B账户少了100，但是A账户却没有反应；如果使用事务，那么AB两个账户的钱数是联动的，B账户给A转账少100元与A账户增加100元这个操作，是一起成功或者失败的。
spring的事务隔离级别
lamwolf的博客
01-03 8067
3、ISOLATION_READ_COMMITTED：读已提交，一个事务提交后才能被其他事务读取到（会造成幻读、不可重复度），SQL server的默认级别。mysql的默认隔离级别。2、ISOLATION_READ_UNCOMMITTED：读未提交，最低隔离级别、事务未提交前，就可被其他事务读取（会出现幻读、脏读、不可重复读）5、ISOLATION_SERIALIZABLE：序列化，代价最高最可靠的隔离级别，该隔离级别能防止脏读、不可重复读、幻读。
spring事务特性和事务传播
08-15 147
事务特性： 原子性 一致性 隔离性(不同事务相互隔离) 持久性(一旦完成不可逆转) 事务传播七大行为 无事务 required supports 如果当前程序存在事务就加入该事务运行，如果不存在事务则在非事务中运行 mandatory 必须在一个事务中运行，否则就会抛出异常mandatory 这个单词有强制性的意思我们默认用required 而不用mandatory，是因为mandatory不能自动创建事务 required _new 不管事务是不是存在，都会另起一个事务，如果事.
Spring事务之四大隔离级别
qq_34197740的博客
07-23 593
多个事务之间会产生的问题 在一个典型的应用程序中，多个事务同时运行，经常会为了完成他们的工作而操作同一个数据。数据库的隔离性与并发控制有很大关系。并发虽然是必需的，但是会导致以下问题： 脏读（Dirty read） 脏读发生在一个事务读取了被另一个事务改写但尚未提交的数据时。如果这些改变在稍后被回滚了， 那么第一个事务读取的数据就会是无效的。 不可重复读（Nonrepeatable read） 不可重复读发生在一个事务执行相同的查询两次或两次以上，但每次查询结果都不相同时。这通常是由于另一个并发事务在两次
Spring 事务七大传播机制 —— REQUIRED、SUPPORTS、MANDATORY、REQUIRES_NEW、NOT_SUPPORTED、NEVER、NESTED
流华追梦的专栏
03-14 2316
首先简单了解一下 Spring 中事务传播行为是什么？听起来很高端，但是真正用起来的时候，稍有不慎，就会让自己陷入困境之中，所以在使用之前，我们必须要十分耐心认真的学习它。从名字理解起来，事务传播行为，既然为传播就肯定发生在两个实体之间，否则单个实体又如何发生行为呢。通俗点讲就是“一个巴掌拍不响”。下面是定义。事务传播行为主要用来描述由某一个事务传播行为修饰的方法被嵌套进另一个方法的事务中，该事务如何传播。这个概述可能不好理解，换句话就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。
spring事务隔离级别大于 mysql 有效
09-02
Spring事务隔离级别是用来定义多个事务之间的隔离程度，以保证数据库在并发操作时的数据一致性和可靠性。事务隔离级别分为 读未提交（Read Uncommitted）、读已提交（Read Committed）、可重复读（Repeatable Read）...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值