devbox
人工智能uu
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringBoot（五）SpringBoot事务_springboot 开启事务

作者：人工智能uu | 2024-08-18 01:18:54

赞

踩

springboot 开启事务

    在实际开发项目时，程序并不是总会按照正常的流程去执行，有时候线上可能出现一些无法预知的问题，任何一步操作都有可能发生异常，异常则会导致后续的操作无法完成。此时由于业务逻辑并未正确的完成，所以在之前操作过数据库的动作并不可靠，需要在这种情况下进行数据的回滚，SpringBoot提供了对这种数据回滚操作场景的支持，也就是事务。

 如果你是新手，且没看过我之前的一系列SpringBoot文章，建议至少看一下这一篇：

SpringBoot（四）SpringBoot搭建简单服务端_springboot做成服务_heart荼毒的博客-CSDN博客​​​​​​​

    如果你想从头到尾系统地学习，欢迎关注我的专栏，持续更新：

https://blog.csdn.net/qq_21154101/category_12359403.html

目录

一、什么是事务

二、快速开启事务

三、用户登录场景模拟使用事务    

1、创建ActionDao

2、创建ActionRepository

3、action_info表设计

4、创建实现事务的Service类 

5、实现登录接口

 四、测试事务是否生效

1、正常测试

 2、在事务方法中打开异常代码注释

3、在第一个方法中打开异常注释

4、在第二个方法打开异常注释

5、反向测试

五、事务的坑

六、事务的原理 

一、什么是事务

    事务，就是一组操作数据库的动作集合。如果一组处理步骤由于其中的一步或多步执行失败，则事务必须回滚到最初的系统状态，也就是一步都不执行。

    举例来讲，在某些业务场景下，如果一个请求，需要同时写入多张表的数据。为了避免数据不一致的情况，我们一般都会用到事务。

    事务的最大特点就是原子性。整个事务是不可分割的最小工作单位，一个事务中的所有操作要么全部执行成功，要么全部都不执行。其中任何一条语句执行失败，都会导致事务回滚。

二、快速开启事务

    那么，如何在SpringBoot项目中开启事务呢？SpringBoot提供了多种开启事务的方式，我们在本篇中使用 @Transactional 注解的方式。至于基于xml配置的方式，我想说的是，这都2032年了，别再去使用一坨一坨的配置了。

    在这里顺嘴一提，如果java是你的日常工作语言，那么注解你一定要习惯去使用。因为不仅是java后端开发，Android开发也大量使用注解。 

三、用户登录场景模拟使用事务    

    上篇博客，我们实现了用户注册的场景，相信基本的步骤大家都掌握了，接下来的示例我不详细去解释了。本篇我们通过用户登录的场景，来模拟事务的使用。

场景比较简单，如下：

（1）用户登录后，我需要往user_info表更新该用户的登录时间。

（2）同时，用户登录是一种主动的行为，我需要往action_info表添加用户登录的打点。

    我的要求如下：

（1）如果更新user_info用户表出现了异常，那么就算是登录失败了，则不能继续执行用户登录的打点。

（2）更新user_info用户表成功执行，但是记录用户登录打点的action_info表执行出现了异常没有成功写入，那么需要回滚user_info表的操作。

1、创建ActionDao

    上面说到了，需要记录用户的登录行为。在这里因为是demo，我的数据库和字段设计没那么严密，只设计了简单的几个字段。

  1. @Entity
  2. @Table(name = "action_info")
  3. public class ActionDao {
  4.     @Id
  5.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  6.     private Integer actionId;
  7.     @Column(name = "user_name")
  8.     private String userName;
  9.     @Column(name = "action_type")
  10.     private String actionType;
  11.     @Column(name = "action_time")
  12.     private String actionTime;
  13.     @Column(name = "action_ext")
  14.     private String actionExt;
  15.  
  16.     public Integer getActionId() {
  17.         return actionId;
  18.     }
  19.  
  20.     public void setActionId(Integer actionId) {
  21.         this.actionId = actionId;
  22.     }
  23.  
  24.     public String getUserName() {
  25.         return userName;
  26.     }
  27.  
  28.     public void setUserName(String userName) {
  29.         this.userName = userName;
  30.     }
  31.  
  32.     public String getActionType() {
  33.         return actionType;
  34.     }
  35.  
  36.     public void setActionType(String actionType) {
  37.         this.actionType = actionType;
  38.     }
  39.  
  40.     public String getActionTime() {
  41.         return actionTime;
  42.     }
  43.  
  44.     public void setActionTime(String actionTime) {
  45.         this.actionTime = actionTime;
  46.     }
  47.  
  48.     public String getActionExt() {
  49.         return actionExt;
  50.     }
  51.  
  52.     public void setActionExt(String actionExt) {
  53.         this.actionExt = actionExt;
  54.     }
  55. }

2、创建ActionRepository

    只自定义一个方法，findByUserName，也就是通过用户名查到Dao对象：    

  1. @Repository
  2. public interface ActionRepository extends JpaRepository<ActionDao,Integer> {
  3.  
  4.     public ActionDao findByUserName(String userName);
  5. }

3、action_info表设计

    很简单，就跟ActionDao里面的字段一一对应即可，不过多介绍，上图： 

4、创建实现事务的Service类 

    特别需要注意的是，这个类的实现有以下特点：

（1）新起的一个类。

（2）提供了一个开启事务（@Transactional）的public方法updateData。

（3）在这个支持事务的方法里有两个串行的数据库操作的方法。

（4）三个方法的最后我手动抛了一个异常，临时注释掉，打开的话模拟实际的登录异常。

  1. @Service
  2. public class LoginService {
  3.  
  4.     @Transactional
  5.     public void updateData(UserRepository userRepository, ActionRepository actionRepository, UserDao userDao, String name) {
  6.         updateUser(userRepository, userDao);
  7.         addAction(actionRepository, name);
  8.         // throw new RuntimeException("更新用户SQL执行异常");
  9.     }
  10.  
  11.     /**
  12.      * 更新用户信息
  13.      *
  14.      * @param userDao UserDao
  15.      */
  16.     public void updateUser(UserRepository userRepository, UserDao userDao) {
  17.         Timestamp timestamp = new Timestamp(new java.util.Date().getTime());
  18.         userDao.setUserLastLoginTime(timestamp + "");
  19.         userRepository.save(userDao);
  20.         // throw new RuntimeException("更新用户登录时间SQL执行异常");
  21.     }
  22.  
  23.     /**
  24.      * 添加用户行为
  25.      *
  26.      * @param name 用户名
  27.      */
  28.     private void addAction(ActionRepository actionRepository, String name) {
  29.         ActionDao actionDao = new ActionDao();
  30.         actionDao.setUserName(name);
  31.         Timestamp timestamp = new Timestamp(new java.util.Date().getTime());
  32.         actionDao.setActionTime(timestamp + "");
  33.         actionDao.setActionType("login");
  34.         actionRepository.save(actionDao);
  35.         // throw new RuntimeException("添加用户行为SQL执行异常");
  36.     }
  37. }

5、实现登录接口

    通过@RestController注解，实现一个登录接口。我直接把我的代码全部贴上，注意里面的TextIUtils是我自己写的工具类，就是比较两个字符串是否一致，你也可以str1.equals(str2)，但是需要注意str1判空：

  1. @RestController
  2. public class LoginController {
  3.     @Autowired
  4.     private UserRepository userRepository;
  5.     @Autowired
  6.     private ActionRepository actionRepository;
  7.     @Autowired
  8.     private LoginService loginService;
  9.  
  10.     @GetMapping("login")
  11.     public LoginResult login(String name, String password) {
  12.         int code = 0;
  13.         String status = "未知状态";
  14.         String msg = "未知信息";
  15.         LoginResult loginResult = new LoginResult();
  16.  
  17.         UserDao userDao = userRepository.findByUserName(name);
  18.         if (userDao == null) {
  19.             status = "fail";
  20.             msg = "用户名不存在";
  21.         } else {
  22.             String localPassword = userDao.getUserPassword();
  23.             if (TextUtils.equals(password, localPassword)) {
  24.                 try {
  25.                     loginService.updateData(userRepository, actionRepository, userDao, name);
  26.                     status = "success";
  27.                     msg = "登录成功";
  28.                 } catch (Exception e) {
  29.                     status = "fail";
  30.                     msg = e.getMessage();
  31.                 }
  32.             } else {
  33.                 status = "fail";
  34.                 msg = "密码错误";
  35.             }
  36.         }
  37.  
  38.         loginResult.setCode(code);
  39.         loginResult.setStatus(status);
  40.         loginResult.setMsg(msg);
  41.         return loginResult;
  42.     }
  43. }

 四、测试事务是否生效

     接下来，我们通过上面的代码来测试下，程序正常执行和分别在三个地方发生异常时，事务能否回滚来规避数据的不一致性。

1、正常测试

    首先，直接运行上述程序，不产生任何异常。如下是我之前的博客中注册成功的用户，我还是使用这个用户的用户名密码来模拟登录：http://localhost:8080/login?name=zj&password=123456

    可以看到，登录成功：

 我们看下user_info和action_info两个表是否都更新，时间刚好跟我的测试时间一致：

 

 2、在事务方法中打开异常代码注释

    如下所示，直接把支持事务的方法打开抛出异常代码的注释，手动抛一个异常：

  1.     @Transactional
  2.     public void updateData(UserRepository userRepository, ActionRepository actionRepository, UserDao userDao, String name) {
  3.         updateUser(userRepository, userDao);
  4.         addAction(actionRepository, name);
  5.         throw new RuntimeException("更新用户SQL执行异常");
  6.     }

    模拟调用登录接口后，登录失败：

     看下数据库两个表格是否回滚了，在这里不截图了，跟上面的截图一致，没有任何更新，事务回滚成功。

3、在第一个方法中打开异常注释

    也就是，在这样的场景下：

  1.     /**
  2.      * 更新用户信息
  3.      *
  4.      * @param userDao UserDao
  5.      */
  6.     public void updateUser(UserRepository userRepository, UserDao userDao) {
  7.         Timestamp timestamp = new Timestamp(new java.util.Date().getTime());
  8.         userDao.setUserLastLoginTime(timestamp + "");
  9.         userRepository.save(userDao);
  10.         throw new RuntimeException("更新用户登录时间SQL执行异常");
  11.     }

    可以看到，登录失败：

     查看数据库的两张表，确实也没有更新，事务回滚成功。

4、在第二个方法打开异常注释

    模拟第一个数据操作已经完成，第二个数据操作出现了异常：

  1.     /**
  2.      * 添加用户行为
  3.      *
  4.      * @param name 用户名
  5.      */
  6.     private void addAction(ActionRepository actionRepository, String name) {
  7.         ActionDao actionDao = new ActionDao();
  8.         actionDao.setUserName(name);
  9.         Timestamp timestamp = new Timestamp(new java.util.Date().getTime());
  10.         actionDao.setActionTime(timestamp + "");
  11.         actionDao.setActionType("login");
  12.         actionRepository.save(actionDao);
  13.         throw new RuntimeException("添加用户行为SQL执行异常");
  14.     }

    毫无疑问，登录失败：

    

    同样的，数据库的两张表没有任何更新。 

5、反向测试

    那么，我们把支持事务的方法的注解去掉会发生什么事情呢？去掉注解，再次运行程序，模拟登录行为：

  1.     //@Transactional
  2.     public void updateData(UserRepository userRepository, ActionRepository actionRepository, UserDao userDao, String name) {
  3.         updateUser(userRepository, userDao);
  4.         addAction(actionRepository, name);
  5.         // throw new RuntimeException("更新用户SQL执行异常");
  6.     }

    毫无疑问，现象还是跟上面一致，登录失败： 

    但是，我们看下数据库呢。可以看到，数据库也变了：

    这就前后不一致了，程序发生异常了，告诉用户的其实是登录失败了这没问题，但是数据库更新了用户的登录时间，并且增加了用户登录的打点。但实际上，用户本次登录确实失败了。

    通过这几个例子可以看出，事务确实很好地帮我们避免了数据不一致的情况或数据库跟前端表现不一致的情况。

五、事务的坑

    事务的使用，其实是有很多坑的。在一开始使用事务的时候，我就说明了我处理事务的类的特点，其实那也是使用事务的几个基本的规范。在这里，我直接引用知乎一个大佬总结的事务使用的坑，我就不一一给大家详解了。

 图片出处：聊聊Spring事务失效的12种场景，太坑人了 - 知乎

六、事务的原理 

    简单说下事务的原理。如果你对java常用的设计模式有过了解，那么通过其特点，其实可以想到，在这里使用了拦截器模式。

拦截器模式：每个任务都对应一个拦截器，共同组成了一个拦截器链，每个拦截器都是拦截器链的一环。下一个拦截器是否执行，取决于上一个拦截器执行的结果。

    在这里只说其实现原理，不去深扒源码看其实现，感兴趣的同学自己去查阅。添加事务注解的方法，其内部的每一个方法都是一个拦截器，多个方法共同组成了拦截器链。当上一个任务执行成功时，下一个任务才会执行。反之，如果上一个任务执行失败了，那么会回滚该方法的执行，并且下一个方法不再执行。以此类推，只有拦截器链的每一个拦截器均执行成功了，那么才算执行成功。

    最后，简单的总结下。本篇介绍了SpringBoot事务是什么以及事务的特点，并且通过注解的方式实现了事务的demo，通过模拟登录场景下更新两张数据表，测试了事务是否是符合预期的。最后呢，也简单的对事务的原理进行了介绍。如果有任何问题，欢迎留言或私聊交流。

 最后，分享一款免费看热门电影和电视剧的app，仅限Android：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/人工智能uu/article/detail/995247
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号