Spring事务的底层原理

已于 2024-10-03 18:49:32 修改
阅读量1k 收藏 23
点赞数 9
分类专栏： JAVA开发+基础+面试题 JAVA开发+JAVA框架-Spring JAVA开发+关系型数据库-MySQL 文章标签： spring java 数据库 面试题 八股文
于 2024-10-03 18:49:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74007708/article/details/142694523
版权

事物的特性

        事务其实是一个并发控制单位，是用户定义的一个操作序列，这些操作要么全部完成，要不全部不完成，是一个不可分割的工作单位。事务有 ACID 四个特性，即：

  1. Atomicity（原子性）：事务中的所有操作，或者全部完成，或者全部不完成，不会结束在中间某个环节。
  2. 一致性（Consistency）：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。
  3. 事务隔离（Isolation）：多个事务之间是独立的，不相互影响的。
  4. 持久性（Durability）：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。

而我们说的 Spring 事务，其实是事务在 Spring 中的实现。

明白了什么是事务之后，我们来聊聊：为什么要有 Spring 事务？

为了解释清楚这个问题，我们举个简单的例子：银行里树哥要给小黑转 1000 块钱，这时候会有两个必要的操作：

  1. 将树哥的账户余额减少 1000 元。
  2. 将小黑的账户余额增加 1000 元。

这两个操作，要么一起都完成，要么都不完成。如果其中某个成功，另外一个失败，那么就会出现严重的问题。而我们要保证这个操作的原子性，就必须通过 Spring 事务来完成，这就是 Spring 事务存在的原因。

如果你深入了解过 MySQL 事务，那么你应该知道：MySQL 默认情况下，对于所有的单条语句都作为一个单独的事务来执行。我们要使用 MySQL 事务的时候，可以通过手动提交事务来控制事务范围。Spring 事务的本质，其实就是通过 Spring AOP 切面技术，在合适的地方开启事务，接着在合适的地方提交事务或回滚事务，从而实现了业务编程层面的事务操作。

        Spring 事务支持两种使用方式，分别是：声明式事务（注解方式）、编程式事务（代码方式）。一般来说，我们使用声明式事务比较多，这里我们就演示声明式事务的使用方法。

项目准备

        为了较好地进行讲解，我们需要搭建一个具备数据库 CURD 功能的项目，并创建 tablea 和 tableb 两张表。

        首先，创建 tablea 和 tableb 两张表，两张表都只有 id 和 name 两列，建表语句如下图所示。

CREATE TABLE `tablea` (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1;
CREATE TABLE `tableb` (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1;

接着，创建一个 SpringBoot 项目，随后加入 MyBatis 及 MySQL 的 POM 依赖。

<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
	<groupId>org.mybatis.spring.boot</groupId>
	<artifactId>mybatis-spring-boot-starter</artifactId>
	<version>2.1.0</version>
</dependency>

最后，我们创建对应的 controller 接口、service 接口、mapper 接口，代码如下所示。

创建 controller 接口：

@SpringBootApplication
@RestController
@RequestMapping("/api")
public class SpringTransactionController {

    @Autowired
    private TransactionServiceA transactionServiceA;

    @RequestMapping("/spring-transaction")
    public String testTransaction() {
        transactionServiceA.methodA();
        return "SUCCESS";
    }
}

创建 TableService 接口。

public interface TableService {
    void insertTableA(TableEntity tableEntity);
    void insertTableB(TableEntity tableEntity);
}

创建 Service 接口实现类 TransactionServiceA 类，在 methodA() 方法中先往 tablea 表格插入一条数据，随后会调用 TransactionServiceB 服务的 methodB() 方法。

@Service
public class TransactionServiceA {

    @Autowired
    private TableService tableService;

    @Autowired
    private TransactionServiceB transactionServiceB;

    public void methodA(){
        System.out.println("methodA");
        tableService.insertTableA(new TableEntity());
        transactionServiceB.methodB();
    }
}

创建 TransactionServiceB 类实现，在 methodB() 方法中往 tableb 表格插入一条数据。

@Service
public class TransactionServiceB {

    @Autowired
    private TableService tableService;

    public void methodB(){
        System.out.println("methodB");
        tableService.insertTableB(new TableEntity());
    }
}

创建 Mapper 接口方法：

@Mapper
public interface TableMapper {
    @Insert("INSERT INTO tablea(id, name) " +
            "VALUES(#{id}, #{name})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    void insertTableA(TableEntity tableEntity);

    @Insert("INSERT INTO tableb(id, name) " +
            "VALUES(#{id}, #{name})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    void insertTableB(TableEntity tableEntity);
}

数据库表对应的 TableEntity：

@Data
public class TableEntity {
    private static final long serialVersionUID = 1L;

    private Long id;

    private String name;

    public TableEntity() {
    }

    public TableEntity(String name) {
        this.name = name;
    }
}

最后，我们在配置文件中配置好数据库地址：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver
# MyBatis 配置
mybatis:
  type-aliases-package: tech.shuyi.javacodechip.spring_transaction.model
  configuration:
    map-underscore-to-camel-case: true

最后，我们运行 SpringBoot 项目。通过浏览器访问地址：localhost:8080/api/spring-transaction，正常的话应该是接口请求成功。

查看数据库表，会看到 tablea 和 tableb 都插入了一条数据。

到这里，我们用于测试 Spring 事务的 Demo 就准备完毕了！

快速入门 @Transaction 

使用声明式事务的方法很简单，其实就是在 Service 层对应方法上配置 @Transaction 注解即可。

假设我们的业务需求是：往 tablea 和 tableb 插入的数据，要么都完成，要么都不完成。

这时候，我们应该怎么操作呢？

首先，我们需要在 TransactionServiceA 类的 methodA() 方法上配置 @Transaction 注解，同时也在 TransactionServiceB 类的 methodB() 方法上配置 @Transaction 注解。修改之后的 TransactionServiceA 和 TransactionServiceB 代码如下所示。

// TransactionServiceA
@Transactional
public void methodA(){
    System.out.println("methodA");
    tableService.insertTableA(new TableEntity());
    transactionServiceB.methodB();
}
// TransactionServiceB
@Transactional
public void methodB(){
    System.out.println("methodB");
    tableService.insertTableB(new TableEntity());
    throw new RuntimeException();
}

可以看到，我们在 methodB() 中模拟了业务异常，我们看看是否 tablea 和 tableb 都没有插入数据。

修改之后重新启动项目，此时我们继续访问地址：localhost:8080/api/spring-transaction，我们会发现执行错误，并且控制台也报错了。

这时候我们查看数据库，会发现 tablea 和 tableb 都没有插入数据。这说明事务起作用了。

事务传播类型

事务传播类型，指的是事务与事务之间的交互策略。例如：在事务方法 A 中调用事务方法 B，当事务方法 B 失败回滚时，事务方法 A 应该如何操作？这就是事务传播类型。Spring 事务中定义了 7 种事务传播类型，分别是：REQUIRED、SUPPORTS、MANDATORY、REQUIRES_NEW、NOT_SUPPORTED、NEVER、NESTED。其中最常用的只有 3 种，即：REQUIRED、REQUIRES_NEW、NESTED。

针对事务传播类型，我们要弄明白的是 4 个点：

  1. 子事务与父事务的关系，是否会启动一个新的事务？
  2. 子事务异常时，父事务是否会回滚？
  3. 父事务异常时，子事务是否会回滚？
  4. 父事务捕捉异常后，父事务是否还会回滚？

REQUIRED

REQUIRED 是 Spring 默认的事务传播类型，该传播类型的特点是：当前方法存在事务时，子方法加入该事务。此时父子方法共用一个事务，无论父子方法哪个发生异常回滚，整个事务都回滚。即使父方法捕捉了异常，也是会回滚。而当前方法不存在事务时，子方法新建一个事务。 为了验证 REQUIRED 事务传播类型的特点，我们来做几个测试。

还是上面 methodA 和 methodB 的例子。当 methodA 不开启事务，methodB 开启事务，这时候 methodB 就是独立的事务，而 methodA 并不在事务之中。因此当 methodB 发生异常回滚时，methodA 中的内容就不会被回滚。用如下的代码就可以验证我们所说的。

public void methodA(){
    System.out.println("methodA");
    tableService.insertTableA(new TableEntity());
    transactionServiceB.methodB();
}

@Transactional
public void methodB(){
    System.out.println("methodB");
    tableService.insertTableB(new TableEntity());
    throw new RuntimeException();
}

最终的结果是：tablea 插入了数据，tableb 没有插入数据，符合了我们的猜想。

当 methodA 开启事务，methodB 也开启事务。按照我们的结论，此时 methodB 会加入 methodA 的事务。此时，我们验证当父子事务分别回滚时，另外一个事务是否会回滚。

我们先验证第一个：当父方法事务回滚时，子方法事务是否会回滚？

@Transactional
public void methodA(){
    tableService.insertTableA(new TableEntity());
    transactionServiceB.methodB();
    throw new RuntimeException();
}

@Transactional
public void methodB(){
    tableService.insertTableB(new TableEntity());
}

结果是：talbea 和 tableb 都没有插入数据，即：父事务回滚时，子事务也回滚了。

我们继续验证第二个：当子方法事务回滚时，父方法事务是否会回滚？

@Transactional
public void methodA(){
    tableService.insertTableA(new TableEntity());
    transactionServiceB.methodB();
}

@Transactional
public void methodB(){
    tableService.insertTableB(new TableEntity());
    throw new RuntimeException();
}

结果是：talbea 和 tableb 都没有插入数据，即：子事务回滚时，父事务也回滚了。

我们继续验证第三个：当字方法事务回滚时，父方法捕捉了异常，父方法事务是否会回滚？

@Transactional
public void methodA() {
    tableService.insertTableA(new TableEntity());
    try {
        transactionServiceB.methodB();
    } catch (Exception e) {
        System.out.println("methodb occur exp.");
    }
}
    
@Transactional
public void methodB() {
    tableService.insertTableB(new TableEntity());
    throw new RuntimeException();
}

结果是：talbea 和 tableb 都没有插入数据，即：子事务回滚时，父事务也回滚了。所以说，这也进一步验证了我们之前所说的：REQUIRED 传播类型，它是父子方法共用同一个事务的。

REQUIRES_NEW

REQUIRES_NEW 也是常用的一个传播类型，该传播类型的特点是：无论当前方法是否存在事务，子方法都新建一个事务。此时父子方法的事务时独立的，它们都不会相互影响。但父方法需要注意子方法抛出的异常，避免因子方法抛出异常，而导致父方法回滚。 为了验证 REQUIRES_NEW 事务传播类型的特点，我们来做几个测试。

首先，我们来验证一下：当父方法事务发生异常时，子方法事务是否会回滚？

@Transactional
public void methodA(){
    tableService.insertTableA(new TableEntity());
    transactionServiceB.methodB();
    throw new RuntimeException();
}
    @Transactional(propagation = Propagation.REQUIRES_NEW)
public void methodB(){
    tableService.insertTableB(new TableEntity());
}

结果是：tablea 没有插入数据，tableb 插入了数据，即：父方法事务回滚了，但子方法事务没回滚。这可以证明父子方法的事务是独立的，不相互影响。

下面，我们来看看：当子方法事务发生异常时，父方法事务是否会回滚？

@Transactional
public void methodA(){
    tableService.insertTableA(new TableEntity());
    transactionServiceB.methodB();
}
    @Transactional(propagation = Propagation.REQUIRES_NEW)
public void methodB(){
    tableService.insertTableB(new TableEntity());
    throw new RuntimeException();
}

结果是：tablea 没有插入了数据，tableb 没有插入数据。

从这个结果来看，貌似是子方法事务回滚，导致父方法事务也回滚了。但我们不是说父子事务都是独立的，不会相互影响么？怎么结果与此相反呢？

其实是因为子方法抛出了异常，而父方法并没有做异常捕捉，此时父方法同时也抛出异常了，于是 Spring 就会将父方法事务也回滚了。如果我们在父方法中捕捉异常，那么父方法的事务就不会回滚了，修改之后的代码如下所示。

@Transactional
public void methodA(){
    tableService.insertTableA(new TableEntity());
    // 捕捉异常
    try {
        transactionServiceB.methodB();
    } catch (Exception e) {
        e.printStackTrace();
    }
}
    @Transactional(propagation = Propagation.REQUIRES_NEW)
public void methodB(){
    tableService.insertTableB(new TableEntity());
    throw new RuntimeException();
}

结果是：tablea 插入了数据，tableb 没有插入数据。这正符合我们刚刚所说的：父子事务是独立的，并不会相互影响。

这其实就是我们上面所说的：父方法需要注意子方法抛出的异常，避免因子方法抛出异常，而导致父方法回滚。因为如果执行过程中发生 RuntimeException 异常和 Error 的话，那么 Spring 事务是会自动回滚的。

NESTED

NESTED 也是常用的一个传播类型，该方法的特性与 REQUIRED 非常相似，其特性是：当前方法存在事务时，子方法加入在嵌套事务执行。当父方法事务回滚时，子方法事务也跟着回滚。当子方法事务发送回滚时，父事务是否回滚取决于是否捕捉了异常。如果捕捉了异常，那么就不回滚，否则回滚。

可以看到 NESTED 与 REQUIRED 的区别在于：父方法与子方法对于共用事务的描述是不一样的，REQUIRED 说的是共用同一个事务，而 NESTED 说的是在嵌套事务执行。这一个区别的具体体现是：在子方法事务发生异常回滚时，父方法有着不同的反应动作。

对于 REQUIRED 来说，无论父子方法哪个发生异常，全都会回滚。而 REQUIRED 则是：父方法发生异常回滚时，子方法事务会回滚。而子方法事务发送回滚时，父事务是否回滚取决于是否捕捉了异常。

为了验证 NESTED 事务传播类型的特点，我们来做几个测试。

首先，我们来验证一下：当父方法事务发生异常时，子方法事务是否会回滚？

@Transactional
public void methodA() {
    tableService.insertTableA(new TableEntity());
    transactionServiceB.methodB();
    throw new RuntimeException();
}
@Transactional(propagation = Propagation.NESTED)
public void methodB() {
    tableService.insertTableB(new TableEntity());
}

结果是：tablea 和 tableb 都没有插入数据，即：父子方法事务都回滚了。这说明父方法发送异常时，子方法事务会回滚。

接着，我们继续验证一下：当子方法事务发生异常时，如果父方法没有捕捉异常，父方法事务是否会回滚？

@Transactional
public void methodA() {
    tableService.insertTableA(new TableEntity());
    transactionServiceB.methodB();
}
@Transactional(propagation = Propagation.NESTED)
public void methodB() {
    tableService.insertTableB(new TableEntity());
    throw new RuntimeException();
}

结果是：tablea 和 tableb 都没有插入数据，即：父子方法事务都回滚了。这说明子方法发送异常回滚时，如果父方法没有捕捉异常，那么父方法事务也会回滚。

最后，我们验证一下：当子方法事务发生异常时，如果父方法捕捉了异常，父方法事务是否会回滚？

@Transactional
public void methodA() {
    tableService.insertTableA(new TableEntity());
    try {
        transactionServiceB.methodB();
    } catch (Exception e) {
        
    }
}
@Transactional(propagation = Propagation.NESTED)
public void methodB() {
    tableService.insertTableB(new TableEntity());
    throw new RuntimeException();
}

结果是：tablea 插入了数据，tableb 没有插入数据，即：父方法事务没有回滚，子方法事务回滚了。这说明子方法发送异常回滚时，如果父方法捕捉了异常，那么父方法事务就不会回滚。

看到这里，相信大家已经对 REQUIRED、REQUIRES_NEW 和 NESTED 这三个传播类型有了深入的理解了。最后，让我们来总结一下：

事务传播类型特性
REQUIRED当前方法存在事务时，子方法加入该事务。此时父子方法共用一个事务，无论父子方法哪个发生异常回滚，整个事务都回滚。即使父方法捕捉了异常，也是会回滚。而当前方法不存在事务时，子方法新建一个事务。
REQUIRES_NEW无论当前方法是否存在事务，子方法都新建一个事务。此时父子方法的事务时独立的，它们都不会相互影响。但父方法需要注意子方法抛出的异常，避免因子方法抛出异常，而导致父方法回滚。
NESTED当前方法存在事务时，子方法加入在嵌套事务执行。当父方法事务回滚时，子方法事务也跟着回滚。当子方法事务发送回滚时，父事务是否回滚取决于是否捕捉了异常。如果捕捉了异常，那么就不回滚，否则回滚。

Spring 事务失效

一、非public修饰的方法

二、类内部访问（spring是通过aop实现的，而aop是通过代理对象实现的增强，当普通方法调用事务方法时，是真实对象调用，无法开启aop执行事务）

三、数据库不支持事务

四、异常类型不匹配（运行时异常）

五、传播属性设置问题

六、捕获异常未抛出

七、Bean没有纳入Spring IOC容器管理

八、事务方法内启动新线程进行异步操作

冰冰很社恐
关注
专栏目录
《Spring》第二十一篇 事务底层源码解析
入坑太深起不来
02-09 371
一.事务的底层执行原理 1. 解析注解@EnableTransactionManagement 2. Bean生命周期的初始化后阶段,校验是否需要进行AOP 3. 示例FruitsService已经成功生成,并注册到IOC容器中,此时执行pay()方法 二. 事务的传播机制
深入理解 Spring 事务：入门、使用、原理
Candyz7的博客
08-22 447
Spring 事务是复杂一致性业务必备的知识点，掌握好 Spring 事务可以让我们写出更好地代码。这篇文章我们将介绍 Spring 事务的诞生背景，从而让我们可以更清晰地了解 Spring 事务存在的意义。接着，我们会介绍如何快速使用 Spring 事务。接着，我们会介绍 Spring 事务的一些特性，从而帮助我们更好地使用 Spring 事务。最后，我们会总结一些 Spring 事务常见的问题，避免大家踩坑。Spring 事务 - 思维导图。
深入理解 Spring 事务原理
xiaolyuh的专栏
02-21 2025
一、事务的基本原理 Spring事务的本质其实就是数据库对事务的支持，没有数据库的事务支持，spring是无法提供事务功能的。对于纯JDBC操作数据库，想要用到事务，可以按照以下步骤进行： 获取连接 Connection con = DriverManager.getConnection()开启事务con.setAutoCommit(true/false);执行CRUD提交事务/回滚事
Spring 底层事务原理深度解析：事务管理器与事务拦截器
最新发布
xycxycooo的博客
09-28 751
Spring 事务管理通过事务管理器和事务拦截器实现了对事务的灵活控制。事务管理器负责管理事务的生命周期，而事务拦截器则通过 AOP 机制在方法调用前后执行事务管理逻辑。本文通过详细的代码示例和解释，展示了 Spring 事务管理的内部机制及其在实际项目中的应用。希望本文能够帮助程序员更好地理解和应用 Spring 事务管理，提升开发效率和代码质量。
Spring之事务理解
weixin_30566149的博客
03-26 160
事务管理是保证数据操作的事务性（即原子性、一致性、隔离性、持久性，即所谓的 ACID）。 Java中的事务类型主要有三种：JDBC事务、JTA(Java Transaction API)事务和容器事务。 1. JDBC事务 JDBC 事务是通过 Connection 接口( java.sql.Connection )控制的。JDBC Connection 接口提供了两种事务模式：自...
Spring之事务底层原理源码解析
沮丧的南瓜
01-03 3842
文章目录一、`@EnableTransactionManagement`工作原理二、Spring事务基本执行原理三、Spring事务详细执行流程四、Spring事务传播机制五、Spring事务传播机制分类案例分析情况1情况2情况3情况4六、Spring事务强制回滚七、TransactionSynchronization 一、@EnableTransactionManagement工作原理 开启Spring事务本质上就是增加了一个Advisor，但我们使用@EnableTransactionManagemen
spring事务的理解
qq_38621978的博客
07-05 467
一、事务的基本原理 Spring事务的本质其实就是数据库对事务的支持，没有数据库的事务支持，spring是无法提供事务功能的。对于纯JDBC操作数据库，想要用到事务，可以按照以下步骤进行： 1.获取连接 Connection con = DriverManager.getConnection() 2.开启事务con.setAutoCommit(true/false); 3.执行CRUD 4.提交事务/回滚事务 con.commit() / con.rollback(); 5.关闭连接 conn.clos
spring的事务理解
lesaqiu的专栏
03-31 1266
搜集了一些网上的介绍，这是我对spring事务的理解： spring是在service中事务管理，是当他调用service中的一个方法的时候 就会开启一个事务，直到你执行完这个方法，才会commit。所以只要其中有一个方法失败都会回滚。 就是说配置到方法上，但管理事务在service中 <aop:pointcut id="interceptorPointCu
spring事务底层原理
04-19
Spring事务的底层原理主要涉及到两个关键概念：事务管理器和数据库连接。 1. 事务管理器：Spring通过事务管理器来管理事务的开始、提交和回滚等操作。事务管理器是一个接口，Spring提供了多种实现类，如JDBC事务...
"spring事务底层原理分析及数据库事务的基本特性
本文将探讨Spring事务的底层原理和实现。 首先，我们需要了解数据库事务的基本特性。事务是一组相关的操作，要么全部执行成功，要么全部回滚。这是为了确保在并发的情况下，数据库操作能正确地执行。事务需要满足...
spring-04 spring事务底层原理分析
沐宇熙IT成长之路
02-26 4394
文章目录1.数据库的事务的基本特性1.1 演示1.1.1 sql准备1.1.2 设置连接参数1.2 数据库默认隔离级别1.3 查看mysql 的默认隔离级别2.spring对事务的支持与使用2.1 spring 事务相关API说明2.1.1 如何使用spring事务2.2.2 接口结构图2.2.3 API使用2.2 声明示事物2.2.1 如何使用2.2.1.1 添加依赖2.2.1.2 xml配置2...
Spring事务@Transactional底层原理
05-25 5513
最近同事发现一个业务状态部分更新的bug，这个bug会导致两张表的数据一致性问题。花了些时间去查问题的原因，现在总结下里面遇到的知识点原理。 问题一：事务没生效 我们先看一段实例代码，来说明下问题： @Service public class PaymentServiceImpl implements PaymentService { public void fetchLatestStatus(String trxId) { //1. do RPC request and g
spring事务理解
muRain
10-26 270
由于以前都是对整个selevlet或者jsp进行事务，所以昨天自然的也以为可在controller类中进行事务： 在handleRequest方法中使用了 [code] jzLogic.updateA(A); jzLogic.inserB(B); [/code] jzLogic已经设置事务规则，对insert、update的方法进行事务，然而测试过后，在handleRequest方法中...
spring 事务的理解
我想静静
08-31 275
1、Spring事务的本质其实就是数据库对事务的支持 2、spring事务的传播属性 PROPAGATION_REQUIRED 支持当前事务、 如果当前没有事务，就新建一个事务。 PROPAGATION_REQUIRES_NEW新建事务，如果当前存在事务，把当前事务挂起。 PROPAGATION_SUPPORTS支持当前事务，如果当前没有事务，就以非事务方式执行。...
Spring 事务的理解
qq_41877948的博客
02-12 217
对Spring 事务的理解 什么是事务？ 事务其实就是一件事，要做就做完，中途出问题了就要恢复成原状态（等于没有做）。 事务的4大特性 原子性：事务必须是一个不可分割的整体。 一致性：执行完数据库操作后，数据不会被破坏。例：如果从A账户转账到B账户，不可能因为A账户扣了钱，而B账户没有价钱。 隔离性：对同一条数据的操作，不同事务之间应该隔离（提交之前，数据变化仅仅在事务内部，与外部隔离）。事务隔...
Spring事务如何理解？
u012556994的博客
07-22 1226
事务：是指一组数据库操作，这组操作对数据库所做的修改， 要么全部成功，提交到数据库生效； 要么全部失败，数据库回滚到这组操作之前的状态。 事务保证了数据库中数据的一致性，防止了脏数据的出现。所以，为了使数据库中的数据保持一致性，开发中往往要用到事务管理。 在JDBC中，用Connection对象进行事务管理：默认情况是事务自动提交，但也可以将自动提交关闭，改为用手动commit提交，roll...
我对spring事务一些简单的理解
下一顿吃什么的博客
06-27 251
啊哈哈哈 第一次写博客，希望广大友友勿喷噢，写该博客是是为了自己平时自己查方便当然也是记录平时开发过程中遇到的坑 以便自己越挫越勇，早点变大神~ *一：什么是事务？ 我理解的就是完成一件事情所定义的一系列操作，这些操作要么都成功，要么都失败。生活中，比如那个老掉牙的例子，““取钱””这个可以叫做一个事务，它大体就包含两个操作，ATM出钱和银行卡里扣钱，这两个操作要么都成功要么都失败。事务概念里面...
Spring事务的理解(个人认为非常好容易理解)
天道酬勤
02-18 477
事务传播行为 什么叫事务传播行为？听起来挺高端的，其实很简单。 即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。 事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

冰冰很社恐

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值