• 数据库的事务

    一、什么是事务？

    事务是逻辑上的一组数据库操作，要么都执行，要么都不执行。

    转账业务：必须同时成功或失败 

    二、事务的特性

    ① 原子性：事务是最小的执行单位，不允许分割。事务的原子性确保动作要么全部完成，要么完全不起作用；例如转账的这两个关键操作（将张三的余额减少200元，将李四的余额增加200元）要么全部完成，要么全部失败。

    ② 一致性： 确保从一个正确的状态转换到另外一个正确的状态，这就是一致性。例如转账业务中，将张三的余额减少200元，中间发生断电情况，李四的余额没有增加200元，这个就是不正确的状态，违反一致性。又比如表更新事务，一部分数据更新了，但一部分数据没有更新，这也是违反一致性的；

    ③ 隔离性：并发访问数据库时，一个用户的事务不被其他事务所干扰，各并发事务之间数据库是独立的；

    ④ 持久性：一个事务被提交之后，对数据库中数据的改变是持久的，即使数据库发生故障也不应该对其有任何影响。
     

    三、事务间的相互影响

    脏读，丢失更新，不可重复读，幻读 是因为事务之间的相互影响造成的

    脏读：事务2读取到了事务1未提交的数据。例如：事务1修改数据库数据a，修改成a+1，但是事务1还未提交。此时事务2，查询此数据，查到的是a+1。此时事务1，做了回滚操作。数据库数据还是a，但是事务2查询到的是a+1。

    不可重复读：事务1对数据a做查询，未结束时，事务2修改数据库数据a，修改（update）成a+1，事务1（未结束的事务）再次对数据a查询。查询到数据为a+1。两次查询结果不一致。

    幻读：事务1根据某条件（name=小王）查询，查询到数据a。在事务1未结束时，事务2增添（insert）了数据b，其中b对应的name是小王（符合事务1的查询条件）。此时事务1再次根据此条件（name=小王）查询，查询到了数据a和数据b。两次查询结果不一致。

    不可重复读和幻读的主要区分是update操作和insert操作

    四、事务的隔离级别以及原理

    读未提交（Read uncommitted）：可能会出现脏读，重复读，幻读；

    读已提交（Read committed）：可能会出现重复读，幻读（mysql默认的隔离级别）；

    重复读（Repeatable read）：可能会出现幻读。带来了更多的性能损失；

    串读（Serializable ）：不会引发事务之间的相互影响，但是事务串行执行资源消耗巨大。

    原理：

    不同的隔离级别是通过加锁来实现的。

    共享锁(S锁):假设事务T1对数据A加上共享锁，那么事务T2可以读数据A，不能修改数据A。
    排他锁(X锁):假设事务T1对数据A加上排他锁，那么事务T2不能读数据A，不能修改数据A。

    读未提交（Read uncommitted）：

    • 事务对当前数据读取时不加锁
    • 事务对数据更新时添加行级共享锁，直到事务结束释放锁

    读已提交（Read committed）：

    • 事务对当前读取的数据加行级共享锁（不被其他事务修改），读完之后立即释放此共享锁；
    • 事务对数据更新瞬间会添加行级排它锁，直到事务结束释放锁

    重复读（Repeatable read）：

    • 事务在读取的数据的瞬间加行级共享锁（不被其他事务修改），直到事务结束释放锁；
    • 事务对数据更新瞬间会添加行级排它锁，直到事务结束释放锁

    串读（Serializable ）：

    • 事务在读取的数据的瞬间加表级排他锁，直到事务结束释放锁；
    • 串读的本质是串行化，只能做一种操作，其他别的操作会被阻止，所以也会很大程度影响效率。

    五、事务的传播机制

    REQUIRED

    如果当前方法有事务则加入事务，没有则创建一个事务。

    NOT_SUPPORTED

    不支持事务，如果当前有事务则挂起事务运行。

    REQUIREDS_NEW

    新建一个事务并在这个事务中运行，如果当前存在事务就把当前事务挂起。新建的事务的提交与回滚一挂起事务没有联系，不会影响挂起事务的操作。

    MANDATORY

    强制当前方法使用事务运行，如果当前没有事务则抛出异常。

    NEVER

    当前方法不能存在事务，即非事务状态运行，如果存在事务则抛出异常。

    SUPPORTS

    支持当前事务，如果当前没事务也支持非事务状态运行。

    NESTED

    如果当前存在事务，则在嵌套事务内执行。嵌套事务的提交与回滚与父事务没有任务关系，反之，当父事务提交嵌套事务也一起提交，父事务回滚会也回滚嵌套事务的。

    如果当前没有事务，则新建一个事务运行，这时候则与PROPAGATION_REQUIRED场景一致。

    六、@Transactional 注解控制事务有哪些不生效的场景

    1、数据库引擎不支持事务

    这里以 MySQL 为例，其 MyISAM 引擎是不支持事务操作的，InnoDB 才是支持事务的引擎，一般要支持事务都会使用 InnoDB。

    从 MySQL 5.5.5 开始的默认存储引擎是：InnoDB，之前默认的都是：MyISAM，所以这点要值得注意，底层引擎不支持事务再怎么搞都是白搭。

    2、没有被 Spring 管理 

    如下面例子所示：

    1. // @Service
    2.  
    3. public class OrderServiceImpl implements OrderService {
    4.  
    5.  
    6.     @Transactional
    7.  
    8.     public void updateOrder(Order order) {
    9.  
    10.         // update order
    11.  
    12.     }
    13.  
    14.  
    15. }

    如果此时把 @Service 注解注释掉，这个类就不会被加载成一个 Bean，那这个类就不会被 Spring 管理了，事务自然就失效了。

    3、方法不是 public 的

    以下来自 Spring 官方文档：

    When using proxies, you should apply the @Transactional annotation only to methods with public visibility. If you do annotate protected, private or package-visible methods with the @Transactional annotation, no error is raised, but the annotated method does not exhibit the configured transactional settings. Consider the use of AspectJ (see below) if you need to annotate non-public methods.

    大概意思就是 @Transactional 只能用于 public 的方法上，否则事务不会失效，如果要用在非 public 方法上，可以开启 AspectJ 代理模式。

    4、自身调用问题

    来看两个示例：

    1. @Service
    2.  
    3. public class OrderServiceImpl implements OrderService {
    4.  
    5.  
    6.     public void update(Order order) {
    7.  
    8.         updateOrder(order);
    9.  
    10.     }
    11.  
    12.  
    13.     @Transactional
    14.  
    15.     public void updateOrder(Order order) {
    16.  
    17.         // update order
    18.  
    19.     }
    20.  
    21.  
    22. }

    update方法上面没有加 @Transactional 注解，调用有 @Transactional 注解的 updateOrder 方法，updateOrder 方法上的事务管用吗？不管用

    再来看下面这个例子：

    1. @Service
    2.  
    3. public class OrderServiceImpl implements OrderService {
    4.  
    5.  
    6.     @Transactional
    7.  
    8.     public void update(Order order) {
    9.  
    10.         updateOrder(order);
    11.  
    12.     }
    13.  
    14.  
    15.     @Transactional(propagation = Propagation.REQUIRES_NEW)
    16.  
    17.     public void updateOrder(Order order) {
    18.  
    19.         // update order
    20.  
    21.     }
    22.  
    23.  
    24. }

    这次在 update 方法上加了 @Transactional，updateOrder 加了 REQUIRES_NEW 新开启一个事务，那么新开的事务管用么？不管用！

    因为它们发生了自身调用，就调该类自己的方法，而没有经过 Spring 的代理类，默认只有在外部调用事务才会生效。

    这个的解决方案之一就是在的类中注入自己，用注入的对象再调用另外一个方法，这个不太优雅，另外一个可行的方案可以参考《Spring 如何在一事务失效的事务个事务中开启另一个事务？》这篇文章。

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

    1. @Bean
    2.  
    3. public PlatformTransactionManager transactionManager(DataSource dataSource) {
    4.  
    5.     return new DataSourceTransactionManager(dataSource);
    6.  
    7. }

    如上面所示，当前数据源若没有配置事务管理器，那也是白搭！

    6、不支持事务

    来看下面这个例子：

    1. @Service
    2.  
    3. public class OrderServiceImpl implements OrderService {
    4.  
    5.  
    6.     @Transactional
    7.  
    8.     public void update(Order order) {
    9.  
    10.         updateOrder(order);
    11.  
    12.     }
    13.  
    14.  
    15.     @Transactional(propagation = Propagation.NOT_SUPPORTED)
    16.  
    17.     public void updateOrder(Order order) {
    18.  
    19.         // update order
    20.  
    21.     }
    22.  
    23.  
    24. }

     Propagation.NOT_SUPPORTED： 表示不以事务运行，当前若存在事务则挂起

    都主动不支持以事务方式运行了，那事务生效也是白搭！

    7、异常被吃了

    这个也是出现比较多的场景：

    1. // @Service
    2.  
    3. public class OrderServiceImpl implements OrderService {
    4.  
    5.  
    6.     @Transactional
    7.  
    8.     public void updateOrder(Order order) {
    9.  
    10.         try {
    11.  
    12.             // update order
    13.  
    14.         } catch {
    15.  
    16.  
    17.         }
    18.  
    19.     }
    20.  
    21.  
    22. }

     把异常吃了，然后又不抛出来，事务怎么回滚吧！

    8、异常类型错误

    上面的例子再抛出一个异常：

    1. // @Service
    2.  
    3. public class OrderServiceImpl implements OrderService {
    4.  
    5.  
    6.     @Transactional
    7.  
    8.     public void updateOrder(Order order) {
    9.  
    10.         try {
    11.  
    12.             // update order
    13.  
    14.         } catch {
    15.  
    16.             throw new Exception("更新错误");
    17.  
    18.         }
    19.  
    20.     }
    21.  
    22.  
    23. }

    这样事务也是不生效的，因为默认回滚的是：RuntimeException，如果你想触发其他异常的回滚，需要在注解上配置一下，如：

    @Transactional(rollbackFor = Exception.class)

    这个配置仅限于 Throwable 异常类及其子类。

  • 相关阅读:
    计算机毕业设计Java会展中心招商服务平台(源码+系统+mysql数据库+lw文档)
    SSM学习——IoC与DI（1）
    《排序和数据结构学习笔记》看完直呼，太全了！
    AD22使用笔记+积累库
    5+非肿瘤+WGCNA+PPI+实验，简单WGCNA分析思路，干湿结合
    Java面试题
    十五、商城 - 品牌管理-AngularJS（3）
    伟大的micropython smartconfig 配网它来了！！！
    レレ / 蕾蕾
    tensorflow的简单使用
  • 原文地址：https://blog.csdn.net/m0_53077601/article/details/126852569