Spring事务Transactional详解

最新推荐文章于 2024-09-14 14:26:13 发布

啦啦啦咯咯咯

最新推荐文章于 2024-09-14 14:26:13 发布

阅读量2.6k

点赞数 3

分类专栏： SpringBoot 文章标签： spring

本文链接：https://blog.csdn.net/qq_41583016/article/details/112538681

版权

SpringBoot 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

事务的传播级别

使用Demo：
在这里插入图片描述
测试：
controller层：

 @ResponseBody
    @GetMapping("/save")
    @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.REPEATABLE_READ)
    public void save() {
        System.out.println(employeeService.saveEmployee());
        System.out.println(employeeService.saveEmployee2());
    }

servoce层：

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.REPEATABLE_READ)
    public int saveEmployee(){
        Employee employee = new Employee();
        employee.setName("1");
        employee.setAge("1");
        int save = employeeDao.save(employee);
        System.out.println(employee.getId());
        return save;
    }

    @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.REPEATABLE_READ)
    public int saveEmployee2(){
        Employee employee = new Employee();
        employee.setName("2");
        employee.setAge("2");
        int save = employeeDao.save(employee);
        System.out.println(employee.getId());
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();//手动抛出异常
        return save;
    }

REQUIRED传播级别，两条记录都插入失败，如果servoce层两个注解注释掉，也是插入失败。

    @Transactional(propagation = Propagation.SUPPORTS, isolation = Isolation.REPEATABLE_READ)
    public int saveEmployee(){

SUPPORTS传播级别，两条记录都插入失败，如果controller层去掉注解，第一条记录插入成功（因为以非事务方式运行）。第二条记录插入失败。

    @Transactional(propagation = Propagation.MANDATORY, isolation = Isolation.REPEATABLE_READ)
    public int saveEmployee(){

MANDATORY传播级别，两条记录都插入失败，如果controller层去掉注解，会抛出异常No existing transaction found for transaction marked with propagation ‘mandatory’ （因为saveEmployee()方法不存在事务）

@Transactional(propagation = Propagation.REQUIRES_NEW, isolation = Isolation.REPEATABLE_READ)
    public int saveEmployee(){

REQUIRES_NEW传播级别，第一条记录插入成功（因为新建了一个事务，虽然存在REQUIRED事务，但是会将当前事务挂起），第二条记录插入失败。

@Transactional(propagation = Propagation.NOT_SUPPORTED, isolation = Isolation.REPEATABLE_READ)
    public int saveEmployee(){

NOT_SUPPORTED传播级别，第一条记录插入成功（因为非事务方式运行，虽然存在REQUIRED事务，但是会将当前事务挂起），第二条记录插入失败。

@Transactional(propagation = Propagation.NEVER  , isolation = Isolation.REPEATABLE_READ)
    public int saveEmployee(){

NEVER 传播级别
两条记录都插入失败。（因为存在controller事务）抛出异常Existing transaction found for transaction marked with propagation ‘never’。
如果把controller中transaction注释掉，第一条记录插入成功（因为没事务），第二条记录插入失败。

我们知道 Spring 事务的原理是 AOP，进行了切面增强，那么失效的根本原因是这个 AOP 不起作用了

1. 事务失效的几种原因

1.1 没有被 Spring 管理

1.2 数据源没有配置事务管理器

1.3 异常被吃了

@Service
public class UserService{
    @Transactional
    public void updateUser(User user) {
        try {
            System.out.println("--------");
            //do something
        } catch {
          //do something
        }
    }
}

1.4 异常类型错误

这个问题在第二问讲过了，因为默认回滚的是：RuntimeException。如果是其他异常想要回滚，需要在 @Transactional注解上加 rollbackFor 属性。

1.5 数据库引擎不支持事务

毕竟 Spring 事务用的是数据库的事务，如果数据库不支持事务，那 Spring 事务肯定是无法生效滴。

1.6 方法不是 public 的

@Transactional 注解的方法都是被外部其他类调用才有效，那么如果方法修饰符是 private 的，这个方法能被外部其他类调到么？
既然调不到，事务生效有意义吗？想通这套逻辑就行了。记住：@Transactional 注解只能应用到 public 方法上。如果你在protected、private 或者 package-visible 的方法上使用 @Transactional 注解，它也不会报错，但是这个被注解的方法将不会加入事务之行。

1.7 同一类中，非事务类，调用事务类，事务会失效

@Service
public class UserService{
   public void update(User user) {
        updateUser(user);
    }

    @Transactional
    public void updateUser(User user) {
        System.out.println("--------");
        //do something
    }
}

此时是无效的。因此上面的代码等同于：

@Service
public class UserService{
   public void update(User user) {
        this.updateUser(user);
    }

    @Transactional
    public void updateUser(User user) {
        System.out.println("--------");
        //do something
    }
}

二种解决方法：
1，非事务类 设置事务类

2．事务类进行代理调用。
 此时，这个 this 对象不是代理类，而是 UserService 对象本身。 解决方法很简单，让那个 this 变成 UserService 的代理类即可。

2. Spring 什么情况下进行事务回滚

首先我们要明白， Spring 事务回滚机制是这样的：当所拦截的方法有指定异常抛出，事务才会自动进行回滚！
因此，如果你默默的吞掉异常，像下面这样：

@Service
public class UserService{
    @Transactional
    public void updateUser(User user) {
        try {
            System.out.println("------");
            //do something
        } catch {
          //do something
        }
    }
}

那切面捕捉不到异常，肯定是不会回滚的。

还有就是，默认配置下，事务只会对 Error 与 RuntimeException 及其子类这些异常做出回滚。一般的 Exception
这些 Checked 异常不会发生回滚。如果一般的 Exception 想回滚，要做出如下配置：

@Transactional(rollbackFor = Exception.class)

但是在实际开发中，我们会遇到这么一种情况：就是并没有异常发生，但是由于事务结果未满足具体业务需求，所以我们需要手动回滚事务。于是乎方法也很简单：
• 自己在代码里抛出一个自定义异常（常用）；
• 通过编程用代码回滚（不常用）。

TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

3. Spring 事务隔离和数据库事务隔离是不是一个概念

OK，是一回事！我们先明确一点，数据库一般有四种隔离级别，分别为：
• Read Uncommitted：未提交读；
• Read Committed：提交读、不可重复读；
• Repeatable Read：可重复读；
• Serializable：可串行化。
而Spring 只是在此基础上抽象出一种隔离级别 default，表示以数据库默认配置的为主。例如，MySQL 默认的事务隔离级别为
Repeatable Read，而 Oracle 默认隔离级别为Read Committed。

于是乎，有一个经典问题是这么问的：

我数据库的配置隔离级别是Read Commited,而Spring配置的隔离级别是Repeatable
Read，请问这时隔离级别是以哪一个为准？

答案是以 Spring 配置的为准。JDBC 有一个接口是这样的：

意思就是，如果 Spring 定义的隔离级别和数据库的不一样，则以Spring 定义的为准。另外，如果 Spring 设置的隔离级别数据库不支持，设置的效果取决于数据库。

4. Spring 事务控制放在 Service 层，在 Service 方法中一个方法调用 Service 中的另一个方法，默认开启几个事务

此题考查的是 Spring 的事务传播行为。我们都知道，默认的传播行为是 PROPAGATION_REQUIRED。
如果外层有事务，则当前事务加入到外层事务，一起提交并一起回滚；如果外层没有事务，新建一个事务执行。也就是说，默认情况下只有一个事务。

5. 怎么保证 Spring 事务内的连接唯一性

这道题很多种问法，例如 Spring 是如何保证事务获取的是同一个 Connection?
OK，开始我们的讲解。其实答案只有一句话，因为那个 Connection 在事务开始时封装在了 ThreadLocal 里，后面事务执行过程中，都是从 ThreadLocal中取的。肯定能保证唯一，因为都是在一个线程中执行。
在这里插入图片描述