当前位置： 代码网 > it编程>编程语言>Java > 深入理解SpringBoot事务传播机制

深入理解SpringBoot事务传播机制

2024年12月23日 • Java •我要评论
在 spring boot 开发中，事务是一个至关重要的概念，尤其是在涉及多层业务逻辑或者多个数据库操作时。spring 提供了强大的事务管理功能，使得开发者可以方便地控制事务的行为。事务传播机制作为

在 spring boot 开发中，事务是一个至关重要的概念，尤其是在涉及多层业务逻辑或者多个数据库操作时。spring 提供了强大的事务管理功能，使得开发者可以方便地控制事务的行为。事务传播机制作为 spring 事务管理的一部分，是 spring 事务管理中一个非常重要的概念。

本文将介绍 spring boot 中事务传播机制的原理及其常用配置，以帮助开发者更好地理解事务传播的工作方式。

一、什么是事务传播机制？

事务传播机制定义了在多个方法中调用事务时，事务的行为是如何传播的。换句话说，它决定了一个事务方法在被另一个方法调用时应该如何处理事务的开启、提交、回滚等操作。

事务传播机制通过 @transactional 注解的 propagation 属性来配置，它有多个传播行为，开发者可以根据具体的需求来选择合适的传播方式。常见的传播行为包括：

  • required
  • requires_new
  • supports
  • mandatory
  • not_supported
  • never
  • nested

二、spring 事务传播机制的传播行为

1. required（默认传播行为）

传播行为： 如果当前没有事务，则创建一个新的事务；如果当前已经存在事务，则加入到现有事务中。

应用场景： 这是最常用的传播行为，通常在业务方法调用中使用，确保调用方法的一致性。

@transactional(propagation = propagation.required)
public void methoda() {
    // 业务逻辑
}

@transactional(propagation = propagation.required)
public void methodb() {
    // 业务逻辑
}
  • 如果 methoda() 没有事务，它会新建一个事务；
  • 如果 methoda() 已经在一个事务中，那么 methodb() 会加入到这个事务中。

2. requires_new

传播行为： 总是新建一个事务。如果当前有事务存在，则将当前事务挂起，等新事务提交或回滚后再恢复当前事务。

应用场景： 当我们希望某个方法独立于当前事务进行处理，通常用于一些不希望受到外部事务影响的操作，例如日志记录、通知等。

@transactional(propagation = propagation.requires_new)
public void methodc() {
    // 业务逻辑
}
  • 无论 methodc() 调用时是否有事务，它都会开启一个新的事务；
  • 如果 methodc() 调用时已经有事务存在，它会将当前事务挂起，开启一个新的事务；
  • 当 methodc() 的事务结束后，原本挂起的事务会恢复继续执行。

3. supports

传播行为： 如果当前有事务，则加入到现有事务中；如果当前没有事务，则以非事务方式执行。

应用场景： 当方法支持事务，但不强制要求事务存在时，可以使用 supports。例如，一些方法可能不需要事务，但如果存在事务，它们会加入其中。

@transactional(propagation = propagation.supports)
public void methodd() {
    // 业务逻辑
}
  • 如果 methodd() 调用时已有事务，它将加入该事务；
  • 如果没有事务，methodd() 以非事务方式执行。

4. mandatory

传播行为： 如果当前有事务，则加入到现有事务中；如果没有事务，则抛出异常。

应用场景： 如果方法依赖事务执行，但又不希望自行创建事务，则可以使用 mandatory。如果没有现有事务，将抛出 transactionrequiredexception 异常。

@transactional(propagation = propagation.mandatory)
public void methode() {
    // 业务逻辑
}
  • 如果当前没有事务，methode() 会抛出异常；
  • 如果当前有事务，methode() 会加入到该事务中。

5. not_supported

传播行为： 如果当前有事务，则将当前事务挂起，并以非事务方式执行方法。

应用场景： 当某个方法不希望参与事务操作时，可以使用 not_supported，例如一些查询操作，它们无需事务支持。

@transactional(propagation = propagation.not_supported)
public void methodf() {
    // 业务逻辑
}
  • 如果当前有事务，methodf() 会挂起当前事务，执行时不支持事务；
  • 如果没有事务，methodf() 以非事务方式执行。

6. never

传播行为： 如果当前有事务，则抛出异常；如果没有事务，则以非事务方式执行。

应用场景： 当一个方法不允许在事务中运行时使用。例如，一些特定的检查方法，它们要求事务完全不存在。

@transactional(propagation = propagation.never)
public void methodg() {
    // 业务逻辑
}
  • 如果当前有事务，methodg() 会抛出 illegaltransactionstateexception 异常；
  • 如果没有事务，methodg() 以非事务方式执行。

7. nested

传播行为： 如果当前没有事务，则新建一个事务；如果当前已有事务，则在当前事务中嵌套一个事务。嵌套事务可以独立提交或回滚。

应用场景： 如果你希望事务能够嵌套，并且在嵌套事务回滚时不会影响外部事务的提交，可以使用 nested。

@transactional(propagation = propagation.nested)
public void methodh() {
    // 业务逻辑
}
  • 如果 methodh() 内部抛出异常并回滚，则不会影响外部事务；
  • 如果 methodh() 成功提交，外部事务也会提交。

三、事务传播机制原理分析

1. 事务的传播原理

spring 的事务传播机制实际上是通过 aop（面向切面编程）来实现的。spring 在运行时会生成一个代理对象（通常是 jdk 动态代理或 cglib 代理），在事务方法执行时，代理会负责判断事务的传播行为并根据行为决定是否开启新的事务或加入到现有事务中。

  • 事务开始：当方法执行时，代理会检查是否已有事务存在。如果没有，则会根据传播行为决定是否需要创建新的事务。
  • 事务嵌套：对于 requires_new 或 nested 传播行为，spring 会创建新的事务，这些事务与外部事务相互独立。
  • 事务回滚：如果方法发生异常且指定了回滚规则，则代理会回滚事务。
  • 事务提交：当方法执行成功，spring 会提交事务。

2. 事务传播机制的执行顺序

假设方法 a 调用方法 b，方法 b 使用 requires_new 传播行为：

  • 方法 a 开始执行时，判断是否有事务，如果没有事务，则开启事务。
  • 方法 a 调用方法 b，方法 b 会暂停方法 a 的事务，并开启自己的事务。
  • 方法 b 执行完成后，提交自己的事务，并恢复方法 a 的事务。

这就是事务传播机制在嵌套调用中的行为。

在 spring 中，事务传播机制的实现依赖于 aop（面向切面编程），而 aop 只会应用于通过 spring 管理的 bean。如果我们直接调用同一个类中的方法（即同一个实例的方法），则事务传播机制可能会失效，因为 spring 的代理对象并未被应用到这些内部方法调用中。以下是关于事务传播机制的一些代码示例，并且会展示事务传播机制失效的场景。

四、代码测试示例

1. required 传播行为示例

@service
public class userservice {

    @transactional(propagation = propagation.required)
    public void methoda() {
        system.out.println("methoda: 开始事务");
        // 模拟数据库操作
        try {
            thread.sleep(1000);  // 模拟耗时操作
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
        system.out.println("methoda: 完成事务");
    }

    @transactional(propagation = propagation.required)
    public void methodb() {
        system.out.println("methodb: 开始事务");
        // 模拟数据库操作
        try {
            thread.sleep(1000);  // 模拟耗时操作
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
        system.out.println("methodb: 完成事务");
    }

    public void testrequiredpropagation() {
        methoda();  // 这会触发事务的传播机制
        methodb();  // 也会加入到当前事务中
    }
}

预期输出：

methoda: 开始事务
methoda: 完成事务
methodb: 开始事务
methodb: 完成事务

2. requires_new 传播行为示例

@service
public class userservice {

    @transactional(propagation = propagation.requires_new)
    public void methodc() {
        system.out.println("methodc: 开始新事务");
        // 模拟数据库操作
        try {
            thread.sleep(1000);  // 模拟耗时操作
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
        system.out.println("methodc: 完成新事务");
    }

    public void testrequiresnewpropagation() {
        methodc();  // 新事务会独立执行
    }
}

预期输出：

methodc: 开始新事务
methodc: 完成新事务

3. supports 传播行为示例

@service
public class userservice {

    @transactional(propagation = propagation.supports)
    public void methodd() {
        system.out.println("methodd: 支持事务（如果有）");
        // 模拟数据库操作
        try {
            thread.sleep(1000);  // 模拟耗时操作
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
        system.out.println("methodd: 完成");
    }

    public void testsupportspropagation() {
        methodd();  // 如果存在事务，方法会加入到当前事务中
    }
}

预期输出：

如果没有事务：

methodd: 支持事务（如果有）
methodd: 完成

如果有事务：

methodd: 支持事务（如果有）
methodd: 完成

4. mandatory 传播行为示例

@service
public class userservice {

    @transactional(propagation = propagation.mandatory)
    public void methode() {
        system.out.println("methode: 必须加入事务");
        // 模拟数据库操作
        try {
            thread.sleep(1000);  // 模拟耗时操作
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
        system.out.println("methode: 完成事务");
    }

    public void testmandatorypropagation() {
        methode();  // 调用时必须有事务存在，否则会抛出异常
    }
}

预期输出：

  • 如果没有事务，抛出 transactionrequiredexception 异常；
  • 如果有事务，方法会加入现有事务。

5. not_supported 传播行为示例

@service
public class userservice {

    @transactional(propagation = propagation.not_supported)
    public void methodf() {
        system.out.println("methodf: 当前事务被挂起");
        // 模拟数据库操作
        try {
            thread.sleep(1000);  // 模拟耗时操作
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
        system.out.println("methodf: 完成");
    }

    public void testnotsupportedpropagation() {
        methodf();  // 如果有事务，会被挂起，执行非事务操作
    }
}

预期输出：

如果方法在事务中调用，则事务会被挂起，并执行非事务操作：

methodf: 当前事务被挂起
methodf: 完成

6. nested 传播行为示例

@service
public class userservice {

    @transactional(propagation = propagation.nested)
    public void methodg() {
        system.out.println("methodg: 开始嵌套事务");
        // 模拟数据库操作
        try {
            thread.sleep(1000);  // 模拟耗时操作
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
        system.out.println("methodg: 完成嵌套事务");
    }

    public void testnestedpropagation() {
        methodg();  // 方法会启动一个嵌套事务
    }
}

预期输出：

methodg: 开始嵌套事务
methodg: 完成嵌套事务

五、事务传播机制失效的场景

场景 1：同一个类中的方法直接调用

如果我们在一个类的实例中直接调用另一个被 @transactional 注解的方法，事务传播机制可能会失效，因为事务代理是基于 spring aop 的，而 aop 仅对外部方法调用起作用。

示例：事务失效

@service
public class userservice {

    @transactional(propagation = propagation.required)
    public void methoda() {
        system.out.println("methoda: 开始事务");
        // 模拟数据库操作
        try {
            thread.sleep(1000);  // 模拟耗时操作
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
        system.out.println("methoda: 完成事务");
    }

    public void methodb() {
        system.out.println("methodb: 事务不生效（直接调用）");
        methoda();  // 直接调用 methoda()，事务不会传播
    }
}

问题：

methodb() 会直接调用 methoda()，但是因为事务注解依赖 aop 代理，而 methodb() 没有通过 spring 代理调用 methoda()，因此事务不会生效。

预期输出：

methodb: 事务不生效（直接调用）
methoda: 开始事务
methoda: 完成事务

事务应该在 methoda() 中生效，但因为是直接调用，所以没有生效。

解决方案

为了让事务传播机制生效，方法应该通过 spring 容器中的代理对象进行调用，可以通过 @autowired 注入当前类实例并调用其方法，或者通过使用外部类实例来间接调用。

@service
public class userservice {

    @autowired
    private userservice self;  // 注入当前类的代理实例

    @transactional(propagation = propagation.required)
    public void methoda() {
        system.out.println("methoda: 开始事务");
        // 模拟数据库操作
        try {
            thread.sleep(1000);  // 模拟耗时操作
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
        system.out.println("methoda: 完成事务");
    }

    public void methodb() {
        system.out.println("methodb: 事务会生效（通过代理调用）");
        self.methoda();  // 通过代理调用 methoda()
    }
}

六、总结

spring boot 的事务传播机制为开发者提供了灵活的事务管理方式，确保在复杂的业务逻辑中能够精准地控制事务的行为。通过合理选择事务传播行为，我们可以在多层业务逻辑中实现事务的一致性和隔离性。

  • required：大多数情况下使用此传播行为，保证事务一致性。
  • requires_new：当需要独立事务时使用。
  • supports 和 not_supported：当方法支持或不支持事务时使用。
  • mandatory 和 never：严格控制事务的参与。
  • nested：支持嵌套事务，可以独立提交和回滚。

到此这篇关于深入理解springboot事务传播机制的文章就介绍到这了,更多相关springboot事务传播内容请搜索代码网以前的文章或继续浏览下面的相关文章希望 

赞 (0)

相关文章:

版权声明：本文内容由互联网用户贡献，该文观点仅代表作者本人。本站仅提供信息存储服务，不拥有所有权，不承担相关法律责任。 如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 2386932994@qq.com 举报，一经查实将立刻删除。

发表评论

验证码：
最近更新的文章
推荐阅读
大家感兴趣的文章
Copyright © 2017-2025  代码网 保留所有权利. 粤ICP备2024248653号
站长QQ:2386932994 | 联系邮箱：2386932994@qq.com