springboot事务管理

已于 2023-04-06 19:04:17 修改
阅读量1k 收藏 1
点赞数 1
文章标签： spring boot spring java
于 2023-04-06 18:53:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chyo098/article/details/129996203
版权

目录

事务管理概述

如何使用@Transactional注解

事务管理的传播行为

事务隔离级别

事务的嵌套

手动提交事务

手动回滚事务

注解方式嵌套事务

事务管理的异常处理

在@Transactional注解中指定回滚策略

使用try-catch

自定义异常处理器

创建自定义异常类

编写自定义异常处理器类

在@Transactional注解中指定自定义异常处理器

事务管理概述

在关系型数据库中，事务是指一组相关的操作，这些操作被看作单个逻辑单元并且要么全部执行成功，要么全部回滚。事务管理就是保证所有操作都能够原子性地进行，即要么全部成功，要么全部失败。

在Spring Boot中，我们可以使用@Transactional注解来启用事务管理。当使用@Transactional注解时，Spring会将方法包装在一个事务中，并在方法执行期间自动处理事务提交或回滚。

如何使用@Transactional注解

在Spring Boot中使用@Transactional注解非常简单。只需将@Transactional注解添加到要进行事务管理的方法上即可。例如：

@Service
public class MyService {

    @Autowired
    private SomeRepository someRepository;

    @Transactional
    public void doSomething() {
        // 执行一些业务逻辑
        someRepository.save(entity1);
        someRepository.save(entity2);
        // 如果任何一个保存操作失败，则整个事务都会回滚。
    }
}

在上面的示例中，当方法doSomething()被调用时，Spring将自动为该方法创建一个事务。如果该方法执行过程中有任何异常抛出，那么整个事务都将被回滚，所有已经执行的保存操作也会被回滚。

事务管理的传播行为

Spring Boot中的@Transactional注解有一个非常强大的特性，即可以控制事务的传播行为。传播行为定义了事务如何在嵌套的方法调用中进行传递。

  • REQUIRED：默认值。如果当前没有事务，则创建一个新事务。如果当前已经有事务，则加入该事务。
  • SUPPORTS：如果当前有事务，则加入该事务；否则以非事务方式执行。
  • MANDATORY：如果当前有事务，则加入该事务；否则抛出异常。
  • REQUIRES_NEW：创建一个新事务，如果当前已经有事务，则将当前事务挂起。
  • NOT_SUPPORTED：以非事务方式执行操作，如果当前有事务，则将当前事务挂起。
  • NEVER：以非事务方式执行操作，如果当前有事务，则抛出异常。
  • NESTED：如果当前有事务，则在嵌套事务内执行；否则像REQUIRED一样执行。

事务隔离级别

除了传播行为之外，事务还有一个重要的概念，即隔离级别。隔离级别定义了多个并发事务之间应该如何相互隔离。Spring Boot支持以下五种隔离级别：

  • DEFAULT：使用数据库的默认隔离级别
  • READ_UNCOMMITTED：最低的隔离级别，允许读取未提交的数据
  • READ_COMMITTED：允许读取已提交的数据
  • REPEATABLE_READ：在同一事务中多次读取相同的数据会产生一致的结果
  • SERIALIZABLE：最高的隔离级别，所有并发事务按顺序逐个执行

可以使用@Transactional注解的isolation属性指定要使用的隔离级别。例如：

@Service
public class MyService {

    @Transactional(isolation = Isolation.READ_COMMITTED)
    public void doSomething() {
        // 执行业务逻辑
    }
}

事务的嵌套

当一个方法内部调用另一个被@Transactional注解标记的方法时，会发生事务的嵌套。如果在内部方法中启动了新事务，则新事务将成为当前事务的子事务。

在子事务完成后，可以选择回滚该子事务或将其提交到父事务中。如果父事务成功提交，则所有子事务都将一起提交；如果父事务失败回滚，则所有子事务也将一起回滚。

下面是一个示例代码：

@Service
public class MyService {

    @Autowired
    private SomeRepository someRepository;

    // 外层事务
    @Transactional
    public void doSomething() {
        someRepository.save(entity1);
        try {
            // 内层事务
            doSomeOtherThing();
        } catch (Exception e) {
            // 内层事务抛出异常，外层事务回滚
        }
    }

    // 内层事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void doSomeOtherThing() {
        someRepository.save(entity2);
        // 如果这里抛出异常，则整个内嵌事务会被回滚
    }
}

在上面的示例中，doSomething()方法使用REQUIRED事务传播行为启用了一个外层事务，然后调用了doSomeOtherThing()方法，doSomeOtherThing()方法使用REQUIRES_NEW事务传播行为启用了一个内层事务。

如果在doSomething()方法中发生异常，则整个外层事务将被回滚，包括所有的子事务。如果在doSomeOtherThing()方法中发生异常，则只会回滚内层事务，而外层事务不受影响。

需要注意的是，在使用嵌套事务时，仅有@Transactional注解标记的方法才会产生事务。如果内部方法没有被@Transactional注解标记，则不会启动新的事务，事务的传播行为也就失去了意义。

手动提交事务

下面是一个示例代码：

@Service
public class MyService {

    @Autowired
    private SomeRepository someRepository;

    @Autowired
    private PlatformTransactionManager transactionManager;

    // 外层事务
    public void doSomething() {
        TransactionTemplate template = new TransactionTemplate(transactionManager);
        template.execute(new TransactionCallbackWithoutResult() {
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                someRepository.save(entity1);
                try {
                    // 内层事务
                    doSomeOtherThing();
                    // 如果内层事务成功，则手动提交外层事务
                    status.flush();
                } catch (Exception e) {
                    // 内层事务抛出异常，外层事务回滚
                    status.setRollbackOnly();
                }
            }
        });
    }

    // 内层事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void doSomeOtherThing() {
        someRepository.save(entity2);
        // 如果这里抛出异常，则整个内嵌事务会被回滚
    }
}

在上面的示例中，doSomething()方法使用TransactionTemplate对象手动执行事务操作，对于内层事务，再次使用@Transactional注解进行管理。如果内层事务成功，则手动提交外层事务；如果内层事务失败，则手动回滚外层事务。

手动回滚事务

下面是一个手动回滚事务的示例代码：

@Service
public class MyService {

    @Autowired
    private SomeRepository someRepository;

    @Autowired
    private PlatformTransactionManager transactionManager;

    // 外层事务
    public void doSomething() {
        TransactionTemplate template = new TransactionTemplate(transactionManager);
        template.execute(new TransactionCallbackWithoutResult() {
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                someRepository.save(entity1);
                try {
                    // 内层事务
                    doSomeOtherThing();
                    // 如果内层事务成功，则手动提交外层事务
                    status.flush();
                } catch (Exception e) {
                    // 内层事务抛出异常，手动回滚所有事务
                    status.setRollbackOnly();
                    throw e;
                }
            }
        });
    }

    // 内层事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void doSomeOtherThing() {
        someRepository.save(entity2);
        // 如果这里抛出异常，则整个内嵌事务会被回滚
    }
}

在上面的示例中，如果发生了任何异常，则手动回滚所有事务。在回滚时，需要将事务状态设置为rollback-only，以便Spring自动回滚所有连接的事务。

需要注意的是，手动提交和回滚事务通常不是必要的，只有在特殊情况下才使用。在大多数情况下，应该让Spring自动管理事务，以便实现更好的性能和可维护性。

注解方式嵌套事务

@Service
public class MyService {

    @Autowired
    private SomeRepository someRepository;

    // 外层事务
    @Transactional
    public void doSomething() {
        someRepository.save(entity1);
        try {
            // 内层事务
            doSomeOtherThing();
        } catch (Exception e) {
            // 内层事务抛出异常，外层事务回滚
        }
    }

    // 内层事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void doSomeOtherThing() {
        someRepository.save(entity2);
        // 如果这里抛出异常，则整个内嵌事务会被回滚
    }
}

在上面的示例中，doSomething()方法使用@Transactional注解标记外层事务，然后调用了doSomeOtherThing()方法，doSomeOtherThing()方法使用REQUIRES_NEW事务传播行为启用了一个内层事务。

如果在doSomething()方法中发生异常，则整个外层事务将被回滚，包括所有的子事务。如果在doSomeOtherThing()方法中发生异常，则只会回滚内层事务，而外层事务不受影响。

事务管理的异常处理

在@Transactional注解中指定回滚策略

可以在@Transactional注解中使用rollbackFor属性指定需要回滚的异常类型。例如，如果希望在发生任何RuntimeException时回滚事务，则可以添加以下代码：

@Transactional(rollbackFor = RuntimeException.class)

使用try-catch

在Spring Boot中，可以使用try-catch块来处理业务逻辑中可能出现的异常。当抛出异常时，可以手动回滚事务以确保数据的一致性。例如，以下代码演示了如何在发生异常时回滚事务：

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    @Transactional
    public void save(User user) {
        try {
            // 保存用户信息
            userRepository.save(user);
        } catch (Exception e) {
            // 回滚事务
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            throw e;
        }
    }
}

自定义异常处理器

在Spring Boot的事务管理中，可以使用自定义异常处理器来处理特定类型的异常。自定义异常处理器是实现org.springframework.transaction.interceptor.TransactionAspectSupport.TransactionExceptionHandler接口的类。在该接口中，只有一个方法handleException()，用于处理发生的异常。

下面是在Spring Boot中使用自定义异常处理器进行事务管理的步骤：

创建自定义异常类

首先，需要创建一个自定义异常类来处理特定类型的异常。例如，以下代码演示了如何创建一个UserNotFoundException异常类：

public class UserNotFoundException extends RuntimeException {
     public UserNotFoundException(String message) { 
        super(message); 
    } 
}

  1. 编写自定义异常处理器类

接下来，需要编写一个实现TransactionExceptionHandler接口的类来处理自定义异常。在该类中，需要实现handleException()方法，用于根据异常类型执行相应的回滚或提交操作。例如，以下代码演示了如何创建一个自定义异常处理器：

@Component 
public class CustomTransactionExceptionHandler implements TransactionExceptionHandler {                 
 @Override 
 public void handleException(Throwable ex) throws Throwable { 
     if (ex instanceof UserNotFoundException) { 
     // 如果抛出的异常是UserNotFoundException，则回滚事务     
    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
     throw ex; 
    } else {
      // 对其他异常进行默认的处理 
      TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); 
     throw new RuntimeException(ex); 
   } 
 } 
}

在这个例子中，我们判断了抛出的异常是否是UserNotFoundException，如果是，则回滚事务并重新抛出此异常。否则，我们将使用默认的处理方式（即回滚事务并重新抛出RuntimeException）。

  1. 在@Transactional注解中指定自定义异常处理器

最后，在使用@Transactional注解时，需要在该注解中指定自定义异常处理器。例如，以下代码演示了如何在UserService类中使用自定义异常处理器：

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    @Transactional(rollbackFor = RuntimeException.class, exceptionHandler = CustomTransactionExceptionHandler.class)
    public void save(User user) {
        // 保存用户信息
        userRepository.save(user);
    
        if (user.getId() == null) {
            throw new UserNotFoundException("User not found!");
        }
    }
}

在这个例子中，我们在@Transactional注解中指定了自定义异常处理器CustomTransactionExceptionHandler.class。当抛出UserNotFoundException异常时，将会执行自定义异常处理器中指定的操作。

通过以上步骤，可以在Spring Boot应用程序中使用自定义异常处理器来进行事务管理，并针对特定类型的异常进行相应的处理。

我我的龙呢
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
详解Springboot事务管理
08-28
本篇文章主要介绍了详解Springboot事务管理，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringBoot开启事务
yu的博客
03-23 1028
不同的是Spring中我们要配置事务管理器，而Spring Boot 为我们提供了默认的事务管理器，当我们使用了 spring-boot-starter-jdbc 的启动器时，框架会自动注入 DataSourceTransactionManager 管理器。@Transactional默认回滚的是RuntimeException的异常，如果抛出的不是RuntimeException的异常，数据库是不会回滚的。在serviceImpl的方法上加注解：@Transactional。导入jdbc的启动器。
事务及SpringBoot中的事务开启
m0_70770402的博客
02-28 1616
1.什么是事务？1.什么是事务？事务是指在数据库管理系统中执行的一系列操作的逻辑单元。事务可以由一个或多个数据库操作（例如插入、更新、删除等）组成，这些操作被视为一个不可分割的工作单元。在事务中，要么所有的操作都成功执行，要么所有的操作都不执行，不会出现部分操作成功而部分操作失败的情况。传播行为（Propagation）：指定事务的传播行为，即定义了事务方法调用之间的关系。隔离级别（Isolation Level）：指定事务的隔离级别，即定义了事务之间的可见性和并发控制的程度。
Spring Boot 事务的使用
热门推荐
小单的博客专栏
01-27 18万+
Spring Boot 使用事务非常简单，首先使用注解 @EnableTransactionManagement 开启事务支持后，然后在访问数据库的Service方法上添加注解 @Transactional 便可。关于事务管理器，不管是JPA还是JDBC等都实现自接口 PlatformTransactionManager 如果你添加的是 spring-boot-starter-jdbc 依赖，框架会
如何开启SpringBoot的事务
qq_46130027的博客
07-22 3868
如果项目中使用了多个数据源或需要使用特定的事务管理器配置，那么@EnableTransactionManagement注解就很有用。我们可以通过这个注解来配置自定义的事务管理器，并与数据源进行关联。
SpringBoot的事务管理
yaoyuanbo的博客
05-07 1267
Springboot内部提供的事务管理器是根据autoconfigure来进行决定的。 比如当使用jpa的时候，也就是pom中加入了spring-boot-starter-data-jpa这个starter之后(之前我们分析过springboot的自动化配置原理)。 Springboot会构造一个JpaTransactionManager这个事务管理器。 而当我们使用spring-boot-...
SpringBoot-Mybatis处理事务
08-15
SpringBoot+Mybatis简单的处理事务回滚
Spring Boot中的事务管理
weixin_34311757的博客
05-27 135
什么是事务？ 我们在开发企业应用时，对于业务人员的一个操作实际是对数据读写的多步操作的结合。由于数据操作在顺序执行的过程中，任何一步操作都有可能发生异常，异常会导致后续操作无法完成，此时由于业务逻辑并未正确的完成，之前成功操作数据的并不可靠，需要在这种情况下进行回退。 事务的作用就是为了保证用户的每一个操作都是可靠的，事务中的每一步操...
SpringBoot中的事务管理
chouweigu1923的博客
08-20 118
事务概念 ###在使用事务之前，我们要理解下事务概念： 什么是事务呢？事务是并发控制的单位，是用户定义的一个操作序列。有四个特性： 原子性(Atomicity)： 事务是数据库的逻辑工作单位，事务中包括的诸操作要么全做，要么全不做。 一致性(Consistency)： 事务执行的结果必...
springboot班级事务管理.zip
08-17
采用java技术构建的一个管理系统。整个开发过程首先对系统进行需求分析，得出系统的主要功能。接着对系统进行总体设计和详细设计。总体设计主要包括系统功能设计、系统总体结构设计、系统数据结构设计和系统安全设计...
详解SpringBoot的事务管理
08-30
Springboot内部提供的事务管理器是根据autoconfigure来进行决定的。接下来通过本文给大家介绍SpringBoot的事务管理相关知识，感兴趣的朋友一起学习吧
springboot班级事务管理毕业设计.zip
08-20
采用java技术构建的一个管理系统。整个开发过程首先对系统进行需求分析，得出系统的主要功能。接着对系统进行总体设计和详细设计。总体设计主要包括系统功能设计、系统总体结构设计、系统数据结构设计和系统安全设计...
Java-springboot班级事务管理计算机毕业设计程序.zip
06-30
采用java技术构建的一个管理系统。整个开发过程首先对系统进行需求分析，得出系统的主要功能。接着对系统进行总体设计和详细设计。总体设计主要包括系统功能设计、系统总体结构设计、系统数据结构设计和系统安全设计...
如何使用Spring Boot导出数据到Excel表格
最新发布
weixin_54574094的博客
04-30 265
本文介绍了如何使用Spring Boot和Apache POI库将数据导出到Excel表格的方法。通过一个简单的示例，你可以了解到实现这一功能的基本步骤和方法。在实际项目中，你可以根据需求对代码进行扩展和定制，以满足更复杂的导出需求。希望本文对你有所帮助，如果有任何疑问或建议，请随时留言。
如何在Spring Boot中配置数据库密码加密
weixin_43816998的博客
04-28 193
Spring Boot中配置数据库密码加密
快速构建Spring boot项目
Fxdll的博客
04-22 648
2、运行4、开发环境热部署查看目前已有的依赖。
Spring boot 应用引入 Spring cloud alibaba nacos
ttyy1112的专栏
04-30 579
通过这些步骤，您的Spring Boot应用就可以成功引入Spring Cloud Alibaba的依赖，并且使用Nacos作为服务发现和配置中心。要在Spring Boot应用中引入Spring Cloud Alibaba的依赖以及Nacos的依赖，您可以按照以下步骤在。通过上述步骤，你可以使用OpenFeign轻松地调用远程服务。如果使用tomcat方式启动应用，应用无法自动注册到nacos，可参考。运行你的应用程序，它将会自动注册到Nacos注册中心。注解，以启用Nacos服务注册功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值