18个实列详解 Spring 事务传播机制

最新推荐文章于 2024-08-25 13:56:04 发布
最新推荐文章于 2024-08-25 13:56:04 发布
阅读量208 收藏 2
点赞数 1
文章标签： spring java 后端 经验分享 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Java4396/article/details/122611018
版权

 什么是事务传播机制

事务的传播机制，顾名思义就是多个事务方法之间调用，事务如何在这些方法之间传播。

举个例子，方法 A 是一个事务的方法，方法 A 执行的时候调用了方法 B,此时方法 B 有无事务以及是否需要事务都会对方法 A 和方法 B 产生不同的影响，而这个影响是由两个方法的事务传播机制决定的。

传播属性 Propagation 枚举

Spring 对事务的传播机制在 http://​ Propagation​ 枚举中定义了7个分类：

  • REQUIRED 默认
  • SUPPORTS 支持
  • MANDATORY 强制
  • REQUIRES_NEW 新建
  • NOT_SUPPORTED 不支持
  • NEVER 从不
  • NESTED 嵌套

事务的传播机制，是 spring 规定的。因为在开发中，最简单的事务是，业务代码都处于同一个事务下，这也是默认的传播机制，如果出现的报错，所有的数据回滚。 但是在处理复杂的业务逻辑时，方法之间的调用，有以下的需求：

  • 调用的方法需要新增一个事务，新事务和原来的事务各自独立。
  • 调用的方法不支持事务
  • 调用的方法是一个嵌套的事务

7种传播机制详解

首先创建两个方法 A 和 B 实现数据的插入，插入数据A:

public class AService {
    public void A(String name) {
        userService.insertName("A-" + name);
    }

}
复制代码

插入数据B:

public class BService {
    public void B(String name) {
        userService.insertName("B-" + name);
    }

}
复制代码

使用伪代码创建 mainTest 方法和 childTest 方法

   public void mainTest(String name)  {
        // 存入a1
        A(a1);
        childTest(name);
    }
复制代码

main 调用 test 方法，其中

   public void childTest(String name)  {
        // 存入b1
        B(b1);
       throw new RuntimeException(); 
       // 存入 b2
       B2(b2);
    }
复制代码

以上伪代码，调用 mainTest 方法，如果mainTest 和childTest 都不使用事务的话，数据存储的结果是如何呢？

因为都没使用事务，所以 a1 和 b1 都存到成功了，而之后抛出异常之后，b2是不会执行的。所以 a1 和 b1 都插入的数据，而 b2 没有插入数据。

REQUIRED（默认事务）

      /**
	 * Support a current transaction, create a new one if none exists.
	 * Analogous to EJB transaction attribute of the same name.
	 * <p>This is the default setting of a transaction annotation.
	 */
	REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),
复制代码

如果当前不存在事务，就新建一个事务。如果存在事务，就加入到当前事务。这是一个默认的事务。

示例1：根据场景举个例子，在 childTest 添加事务，设置传播属性为 REQUIRED，伪代码如下：

   public void mainTest(String name)  {
        // 存入a1
        A(a1);
        childTest(name);
    }
   @Transactional(propagation = Propagation.REQUIRED)
   public void childTest(String name)  {
        // 存入b1
        B(b1);
       throw new RuntimeException(); 
    }
复制代码

因为 mainTest 没有事务，而 childTest 又是新建一个事务，所以 a1 添加成功。在 childTest 因为抛出了异常，不会执行 b2 添加，而 b1 添加回滚。最终 a1 添加成功，b1没添加成功。

示例2：在 mainTest 和 childTest 都添加事务，传播属性都为 REQUIRED，伪代码如下：

   @Transactional(propagation = Propagation.REQUIRED)
   public void mainTest(String name) {
        // 存入a1
        A(a1);
        childTest(name);
    }
   @Transactional(propagation = Propagation.REQUIRED)
   public void childTest(String name) {
        // 存入b1
        B(b1);
       throw new RuntimeException(); 
   }
复制代码

根据 REQUIRED 传播属性，如果存在事务，就加入到当前事务。两个方法都属于同一个事务，同一个事务的话，如果有发生异常，则全部都回滚。所以 a1 和 b1 都没添加成功。

SUPPORTS

/**
	 * Support a current transaction, execute non-transactionally if none exists.
	 * Analogous to EJB transaction attribute of the same name.
	 * <p>Note: For transaction managers with transaction synchronization,
	 */
复制代码

如果当前没有事务，则以非事务的方式运行。如果存在事务，就加入到当前事务。

示例3：childTest 添加事务，传播属性设置为 SUPPORTS，伪代码如下：

   public void mainTest(String name) {
        A(a1);
        childTest(name);
    }
   @Transactional(propagation = Propagation.SUPPORTS)
   public void childTest(String name) {
        B(b1);
       throw new RuntimeException(); 
    }
复制代码

传播属性为 SUPPORTS，如果没有事务，就以非事务的方式运行。表明两个方法都没有使用事务，没有事务的话，a1、b1 都添加成功。

示例4：mainTest 添加事务，设置传播属性为 REQUIRED。childTest 添加事务，设置传播属性为 SUPPORTS，伪代码如下：

   @Transactional(propagation = Propagation.REQUIRED)
   public void mainTest(String name) {
        A(a1);
        childTest(name);
    }
   @Transactional(propagation = Propagation.SUPPORTS)
   public void childTest(String name) {
        B(b1);
       throw new RuntimeException(); 
       B2(b2);
    }
复制代码

SUPPORTS 传播属性，如果存在事务，就加入到当前事务。mainTest 和 childTest 都属于同一个事务，而 childTest 抛出异常，a1 和b1 添加都回滚，最终 a1、b1 添加失败。

MANDATORY

/**
	 * Support a current transaction, throw an exception if none exists.
	 * Analogous to EJB transaction attribute of the same name.
	 */
复制代码

如果存在事务，就加入到当前事务。如果不存在事务，就报错。 这就说明如果想调用 MANDATORY 传播属性的方法，一定要有事务，不然就会报错。

MANDATORY 类似功能限制，必须要被有事务的方法的调用，不然就会报错。

示例5： 首先在 childTest 添加事务，设置传播属性为 MANDATORY，伪代码如下：

  public void mainTest(String name) {
       A(a1);
       childTest(name);
   }
  @Transactional(propagation = Propagation.MANDATORY)
  public void childTest(String name) {
       B(b1);
      throw new RuntimeException(); 
      B2(b2);
   }
复制代码

在控制台直接报错：

No existing transaction found for transaction marked with propagation 'mandatory'
复制代码

说明被标记为 mandatory 传播属性没找到事务，直接报错。因为 mainTest 没有事务，a1 添加成功。而 childTest 由于报错，b1 添加失败。

示例6： mainTest 添加事务，设置传播属性为 REQUIRED。childTest 添加事务，设置传播属性为 MANDATOR，伪代码如下：

  @Transactional(propagation = Propagation.REQUIRED)
  public void mainTest(String name) {
       A(a1);
       childTest(name);
   }
  @Transactional(propagation = Propagation.MANDATORY)
  public void childTest(String name) {
       B(b1);
      throw new RuntimeException(); 
   }
复制代码

如果存在事务，就把事务加入到当前事务。同一个事务中 childTest 抛出异常，a1 和 b1 添加被回滚，所以a1 和 b1添加失败。

REQUIRES_NEW

   /**
	 * Create a new transaction, and suspend the current transaction if one exists.
	 * Analogous to the EJB transaction attribute of the same name.
	 * <p><b>NOTE:</b> Actual transaction suspension will not work out-of-the-box
	 */
复制代码

创建一个新的事务。如果存在事务，就将事务挂起。

无论是否有事务，都会创建一个新的事务。

示例7：childTest 添加事务，设置传播属性为 REQUIRES_NEW，伪代码如下：

  public void mainTest(String name) {
       A(a1);
       childTest(name);
   }
  @Transactional(propagation = Propagation.REQUIRES_NEW)
  public void childTest(String name) {
       B(b1);
      throw new RuntimeException(); 
   }
复制代码

mainTest 不存在事务，a1 添加成功，childTest 新建了一个事务，报错，回滚 b1。所以 a1 添加成功，b1 添加失败。

示例8：mainTest 添加事务，设置传播属性为 REQUIRED。childTest 添加事务，设置传播属性为 REQUIRES_NEW，伪代码如下：

  @Transactional(propagation = Propagation.REQUIRED)
  public void mainTest(String name) {
       A(a1);
       childTest(name);
   }
  @Transactional(propagation = Propagation.REQUIRES_NEW)
  public void childTest(String name) {
       B(b1);
      throw new RuntimeException(); 
   }
复制代码

mainTest 创建了一个事务，childTest 新建一个事务，在 childTest 事务中，抛出异常，b1 回滚，异常抛到 mainTest 方法，a1 也回滚，最终 a1 和 b1 都回滚。

示例9：在示例8中，如果不想让 REQUIRES_NEW 传播属性影响到被调用事务，将异常捕获就不会影响到被调用事务。

  @Transactional(propagation = Propagation.REQUIRED)
  public void mainTest(String name) {
       A(a1);
       try {
              childTest(name);
       } catch (Exception e) {
           e.printStackTrace();
       }   
   }
  @Transactional(propagation = Propagation.REQUIRES_NEW)
  public void childTest(String name) {
       B(b1);
      throw new RuntimeException(); 
   }
复制代码

childTest 抛出了异常，在 mainTest 捕获了，对 mainTest 没有影响，所以 b1 被回滚，b1 添加失败，a1 添加成功。

示例10：mainTest 设置传播属性为 REQUIRED，并在 mainTest 抛出异常。childTest 同样设置 REQUIRES_NEW 传播属性，伪代码如下：

  @Transactional(propagation = Propagation.REQUIRED)
  public void mainTest(String name) {
       A(a1);
       childTest(name);
       throw new RuntimeException();    
   }
  @Transactional(propagation = Propagation.REQUIRES_NEW)
  public void childTest(String name) {
       B(b1);  
       B2(b2);
   }
复制代码

childTest 是一个新建的事务，只要不抛出异常是不会回滚，所以 b1 添加成功，而 mainTest 抛出了异常，a1 添加失败。

REQUIRES_NEW 传播属性如果有异常，只会从被调用方影响调用方，而调用方不会影响调用方，即 childTest 抛出异常会影响 mainTest，而 mainTest 抛出异常不会到 childTest。

NOT_SUPPORTED

  /**
	 * Execute non-transactionally, suspend the current transaction if one exists.
	 * Analogous to EJB transaction attribute of the same name.
	 * <p><b>NOTE:</b> Actual transaction suspension will not work out-of-the-box
	 */
复制代码

无论是否存在当前事务，都是以非事务的方式运行。

示例11：childTest 添加事务，设置传播属性为 NOT_SUPPORTED，伪代码如下：

  public void mainTest(String name) {
       A(a1);
       childTest(name);
          
   }
  @Transactional(propagation = Propagation.NOT_SUPPORTED)
  public void childTest(String name) {
       B(b1);  
      throw new RuntimeException();  
   }
复制代码

NOT_SUPPORTED 都是以非事务的方式执行，childTest 不存在事务，b1 添加成功。而 mainTest 也是没有事务，a1 也添加成功。

示例12：childTest 添加事务，设置传播属性为 NOT_SUPPORTED，mainTest 添加默认传播属性 REQUIRED，伪代码如下：

  @Transactional(propagation = Propagation.REQUIRED)
  public void mainTest(String name) {
       A(a1);
       childTest(name);
          
   }
  @Transactional(propagation = Propagation.NOT_SUPPORTED)
  public void childTest(String name) {
       B(b1);  
      throw new RuntimeException();  
    }
复制代码

其中 childTest 都是以非事务的方式执行，b1 添加成功。而 mainTest 存在事务，报错后回滚，a1 添加失败。

NEVER

   /**
	 * Execute non-transactionally, throw an exception if a transaction exists.
	 * Analogous to EJB transaction attribute of the same name.
	 */
复制代码

不使用事务，如果存在事务，就抛出异常。

NEVER 的方法不使用事务，调用 NEVER 方法如果有事务，就抛出异常。

示例13：childTest 添加 NEVER 传播属性，伪代码如下：

  public void mainTest(String name) {
       A(a1);
       childTest(name);
          
   }
  @Transactional(propagation = Propagation.NEVER)
  public void childTest(String name) {
       B(b1);  
      throw new RuntimeException();  
      B2(b2);
   }
复制代码

NEVER 不使用事务，mainTest 也不使用事务，所以 a1 和 b1 都添加成功，b2添加失败。

示例14： mainTest 添加 REQUIRED 传播属性，childTest 传播属性设置为 NEVER，伪代码如下：

  @Transactional(propagation = Propagation.REQUIRED)
  public void mainTest(String name) {
       A(a1);
       childTest(name);
          
   }
  @Transactional(propagation = Propagation.NEVER)
  public void childTest(String name) {
       B(b1);  
      throw new RuntimeException();  
   }
复制代码

mainTest 存在事务，导致 childTest 报错，b1添加失败，childTest 抛错到 mainTest，a1 添加失败。

NESTED

/**
	 * Execute within a nested transaction if a current transaction exists,
	 * behave like PROPAGATION_REQUIRED else. There is no analogous feature in EJB.
	 * <p>Note: Actual creation of a nested transaction will only work on specific
	 */
复制代码

如果当前事务存在，就运行一个嵌套事务。如果不存在事务，就和 REQUIRED 一样新建一个事务。

示例15: childTest 设置 NESTED 传播属性，伪代码如下：

  public void mainTest(String name) {
       A(a1);
       childTest(name);
          
   }
  @Transactional(propagation = Propagation.NESTED)
  public void childTest(String name) {
       B(b1);  
      throw new RuntimeException();  
   }
复制代码

在 childTest 设置 NESTED 传播属性，相当于新建一个事务，所以 b1 添加失败， mainTest 没有事务，a1 添加成功。

示例16：设置 mainTest 传播属性为 REQUIRED，新建一个事务，并在方法最后抛出异常。 childTest 设置属性为 NESTED，伪代码如下：

  @Transactional(propagation = Propagation.REQUIRED)
  public void mainTest(String name) {
       A(a1);
       childTest(name);
       throw new RuntimeException();     
   }
  @Transactional(propagation = Propagation.NESTED)
  public void childTest(String name) {
       B(b1);         
      B2(b2);
   }
复制代码

childTest 是一个嵌套的事务，当主事务的抛出异常时，嵌套事务也受影响，即 a1、b1 和 b2 都添加失败。和示例10不同的是，示例10不会影响 childTest 事务。

  • NESTED 和 REQUIRED_NEW 的区别：
    • REQUIRED_NEW 是开启一个新的事务，和调用的事务无关。调用方回滚，不会影响到 REQUIRED_NEW 事务。
    • NESTED 是一个嵌套事务，是调用方的一个子事务，如果调用方事务回滚，NESTED 也会回滚。

示例17：和示例16一样，在 mainTest 设置传播属性为 REQUIRED，childTest 设置传播属性为 NESTED，不同的是，在 mainTest 捕获 childTest 抛出的异常，伪代码如下：

  @Transactional(propagation = Propagation.REQUIRED)
  public void mainTest(String name) {
       A(a1);
      try {
           childTest(name);
       } catch (RuntimeException e) {
           e.printStackTrace();
       } 
   }
  @Transactional(propagation = Propagation.NESTED)
  public void childTest(String name) {
      B(b1);         
      B2(b2);
      throw new RuntimeException(); 
   }
复制代码

childTest 是一个子事务，报错回滚，b1 和 b2 都添加失败。而 mainTest 捕获了异常，不受异常影响，a1 添加成功。

示例18：将示例2改造一下，mainTest 捕获 childTest 抛出的异常，伪代码如下：

  @Transactional(propagation = Propagation.REQUIRED)
  public void mainTest(String name) {
       A(a1);
      try {
           childTest(name);
       } catch (RuntimeException e) {
           e.printStackTrace();
       } 
   }
  @Transactional(propagation = Propagation.REQUIRED)
  public void childTest(String name) {
      B(b1);         
      B2(b2);
      throw new RuntimeException(); 
   }
复制代码

mainTest 和 childTest 两个方法都处于同一个事务，如果有一个方法报错回滚，并且被捕获。整个事务如果还有数据添加就会抛出 Transaction rolled back because it has been marked as rollback-only 异常，同一个事务，不能出现有的回滚了，有的不回滚，要么一起回滚，要不一起执行成功。所以全部数据都添加失败。

  • 对比示例17和示例18，NESTED 和 REQUIRED 的区别：
    • REQUIRED 传播属性表明调用方和被调用方都是使用同一个事务，被调用方出现异常，无论异常是否被捕获，因为属于同一个事务，只要发生异常，事务都会回滚。
    • NESTED 被调用方出现异常，只要异常被捕获，只有被调用方事务回滚，调用方事务不受影响。

总结

传播属性总结
REQUIRED默认属性，所有的事务都处于同一个事务下，出现异常，不管是否捕获所有事务回滚
SUPPORTS如果不存事务，就以非事务的方式运行，存在事务就加入该事务
MANDATORY强制调用方添加事务，如果不存在事务就报错，存在事务就加入该事务
REQUIRES_NEW无论调用方是否存在事务，都会创建新的事务，并且调用方异常不会影响 REQUIRES_NEW事务
NOT_SUPPORTED无论是否调用方是否存在事务，都是以非事务的方式执行，出现异常也会回滚
NEVER不用事务，存在事务就报错，和 MANDATORY 相反
NESTED嵌套事务，新建一个子事务，事务执行相互独立，如果调用方出现异常，直接回滚

测试源码

原文链接：https://juejin.cn/post/7054340368124346399

Java架构师小森
关注
18个示例详解 Spring 事务传播机制(附测试源码)
qq_42700121的博客
01-18 517
什么是事务传播机制 事务的传播机制，顾名思义就是多个事务方法之间调用，事务如何在这些方法之间传播。 举个例子，方法 A 是一个事务的方法，方法 A 执行的时候调用了方法 B,此时方法 B 有无事务以及是否需要事务都会对方法 A 和方法 B 产生不同的影响，而这个影响是由两个方法的事务传播机制决定的。 传播属性 Propagation 枚举 Spring 对事务的传播机制在 Propagation 枚举中定义了7个分类： REQUIRED 默认 SUPPORTS 支持 MANDATORY 强制
spring 事务传播行为实例分析
码农的世界你不懂
02-28 4万+
欢迎转载和指正，转载时请说明来源
Spring中事务传播机制
最新发布
qq_44286009的博客
08-25 990
Spring事务传播机制是指在一个事务方法调用另一个事务方法时，Spring如何管理这些方法之间的事务边界。Spring在接口中定义了七种事务传播行为，以满足不同的业务需求。
Spring的事务传播机制实例
柒七的博客
02-06 402
1，Propagation.REQUIRED 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。详细解释在代码下方。 看下代码 员工service @Service public class EmployeeServiceImpl implements EmployeeService { @Autowired EmployeeMapper employeeMapper; @Autowired DepartmentService dep
Spring事务管理（详解+实例）
Trigl的博客
03-25 8万+
写这篇博客之前我首先读了《Spring in action》，之后在网上看了很多关于Spring事务管理的文章，具体参考文章如下： 1、将相应的接口依赖图理清出 2、将每个类的具体配置弄明白 3、将具体的配置给出来 4、给出具体的例子（一个声明式的一个编程式的）
Spring事务传播行为详解（示例版）
baodao1410的博客
07-17 129
内容来自: https://segmentfault.com/a/1190000013341344?utm_source=tag-newest Spring中七种事务传播行为 事务传播行为类型 说明 PROPAGATION_REQUIRED 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。 PROPAGATION_SUPPO...
8个示例详解 Spring 事务传播机制(附测试源码)
qq_64513388的博客
01-18 474
什么是事务传播机制 事务的传播机制，顾名思义就是多个事务方法之间调用，事务如何在这些方法之间传播。 举个例子，方法 A 是一个事务的方法，方法 A 执行的时候调用了方法 B,此时方法 B 有无事务以及是否需要事务都会对方法 A 和方法 B 产生不同的影响，而这个影响是由两个方法的事务传播机制决定的。 传播属性 Propagation 枚举 Spring 对事务的传播机制在Propagation枚举中定义了7个分类： REQUIRED 默认 SUPPORTS 支持 MANDATORY 强制 ..
Spring事务传播机制--包含用例解释
qq_45646289的博客
05-20 5201
Spring事务传播机制 一、何为Spring传播机制： Spring事务的传播机制就是，事务如何在方法的调用如何传播。 二、使用传播机制的时候的关键点： 使用声明式的事务时，调用方法和被调用方法不能在同一个类。比如同在一个service方法中，这样是不会生效的。Spring的事务分为编程式和声明式的注解，我们一般使用声明方式的注解，利用@Transactional注解标记需要使用事务的类，Spring会利用AOP为我们在方法执行前启动事务，接受后提交和关闭事务。而AOP是基于动态代理的实现，生成代理对
spring事务Propagation及其实现原理详解
08-28
在Spring框架中，事务Propagation（事务传播）是一种机制，用于控制事务的行为和传播方式。事务Propagation是Spring的事务管理机制中的一部分，用于定义事务的执行和传播规则。 Spring的事务Propagation机制可以...
详解Spring的核心机制依赖注入
10-19
本文详细介绍了Spring框架的核心机制之一：依赖注入（Dependency Injection，简称DI）。依赖注入是Spring框架最重要的设计理念之一，它是一种用于实现控制反转（Inversion of Control，简称IoC）的技术，旨在减少...
Spring事务和MySQL事务详解面试
热门推荐
用文字记录下每一个瞬间的感动和每一次思考的火花
09-10 23万+
文章目录数据库事务事务是什么事务的四大特性MySQL事务隔离级别查看MySQL当前事务隔离级别MySQL默认操作模式为自动提交模式JDBC处理事务Spring事务Spring的事务传播PROPAGATION_REQUIREDPROPAGATION_SUPPORTSPROPAGATION_MANDATORYPROPAGATION_REQUIRES_NEWPROPAGATION_NOT_SUPPORTEDPROPAGATION_NEVERPROPAGATION_NESTEDSpring事务的隔离级别Spring
spring事务传播机制实例讲解
qq_16436555的博客
01-30 277
1.在xml 文件配置 bean id="TransactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor"> property name="transactionManager"> ref bean="tra
java spring 事务传播_举例讲解spring事务传播行为
weixin_42501850的博客
02-16 137
假如有两个方法A和B，A调用B,这两个方法上都加了事物，究竟使用哪个事物？Public void A(){B();}这就是spring事物传播行为要解决的问题。在spring中有七种事务传播行为简单介绍一下这七种方式(如果不懂不用纠结，后面详细介绍)常用：REQUIRED:如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中，一般的选择(默认值)REQUIRES_NEW: 新...
Spring事务传播特性实例解析
u012706314的专栏
11-05 158
背景介绍        目前系统正在进行代码重构前期预研工作，目标采用spring控制事务以减少开发代码量，提高开发效率。同时避免开发人员编码控制事务所带来的链接没有释放，事务没有提交，出现异常事务没有回滚的Bug。 为保证系统能正确使用Spring控制事务，必须很好的理解其传播特性。在沟通中发现，好多人知道这个概念但是对于事务的实际传播行为往往模棱两可。 基于上述原因，本文采用Demo实...
Spring事务7种传播机制（代码示例）
谢文峰的博客
12-30 1232
Spring事务7种传播机制（代码示例） 文章目录Spring事务7种传播机制（代码示例）前言1.项目环境2.相关资料2.1 Spring 源码2.2 官网地址3.示例代码3.1 无事务示例3.1.1 正常示例3.1.2 异常示例3.2 REQUIRED（默认）3.2.1 代码示例3.2.2 结果分析3.3 REQUIRES_NEW3.3.1 代码示例3.3.2 结果分析3.4 SUPPORTS3.4.1 代码示例3.4.2 结果分析3.5 MANDATORY3.5.1 代码示例3.5.2 结果分析3.6
java事务传播机制事例_（02）验证Spring的事务及其7种传播机制真实案例
weixin_39812142的博客
02-25 309
原文：说起Spring的事务，仿佛是很熟悉的老朋友了，然鹅。。。现实却很残酷。。。起初我以 Spring、Mybatis、druid、Mysql尝试，发现其中一个问题，无论数据源的defaultAutoCommit设置为true或者false，事务总会自动提交。确定配置无误后，发现网上有一种说法是把数据库的autocommit设置为OFF，即关闭数据库的自动提交，且不说这样是否可以，这种方法本身就...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值