事务详解整理

qq_37119719

已于 2023-03-08 12:40:52 修改

阅读量226

点赞数

文章标签： spring 数据库 java

于 2021-10-20 15:27:44 首次发布

本文链接：https://blog.csdn.net/qq_37119719/article/details/120867106

版权

事务详解整理

一、搞懂事务需要了解的基本概念

1.1常用的事务类型

事务管理是应用系统开发中必不可少的一部分。Spring 为事务管理提供了丰富的功能支持。Spring 事务管理分为编程式和声明式的两种方式。编程式事务指的是通过编码方式实现事务；声明式事务基于 AOP,将具体业务逻辑与事务处理解耦。声明式事务管理使业务代码逻辑不受污染, 因此在实际使用中声明式事务用的比较多。声明式事务有两种方式，一种是在配置文件（xml）中做相关的事务规则声明，另一种是基于 @Transactional 注解的方式。本文将着重介绍基于 @Transactional 注解的事务管理。

1.2事务的特性

1. 原子性（Atomicity）
　　原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚，这和前面两篇博客介绍事务的功能是一样的概念，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响。

2.一致性（Consistency）
　　一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。

拿转账来说，假设用户A和用户B两者的钱加起来一共是5000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还得是5000，这就是事务的一致性。

3.隔离性（Isolation）
　　隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。

即要达到这么一种效果：对于任意两个并发的事务T1和T2，在事务T1看来，T2要么在T1开始之前就已经结束，要么在T1结束之后才开始，这样每个事务都感觉不到有其他事务在并发地执行。

关于事务的隔离性数据库提供了多种隔离级别，稍后会介绍到。

4.持久性（Durability）
　　持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。

例如我们在使用JDBC操作数据库时，在提交事务方法后，提示用户事务操作完成，当我们程序执行完成直到看到提示后，就可以认定事务以及正确提交，即使这时候数据库出现了问题，也必须要将我们的事务完全执行完成，否则就会造成我们看到提示事务处理完毕，但是数据库因为故障而没有执行事务的重大错误。

以上介绍完事务的四大特性(简称ACID)，现在重点来说明下事务的隔离性，当多个线程都开启事务操作数据库中的数据时，数据库系统要能进行隔离操作，以保证各个线程获取数据的准确性，在介绍数据库提供的各种隔离级别之前，我们先看看如果不考虑事务的隔离性，会发生的几种问题：

1.3事务发生的问题

1.脏读
　　脏读是指在一个事务处理过程里读取了另一个未提交的事务中的数据。

当一个事务正在多次修改某个数据，而在这个事务中这多次的修改都还未提交，这时一个并发的事务来访问该数据，就会造成两个事务得到的数据不一致。例如：用户A向用户B转账100元，对应SQL命令如下

update account set money=money+100 where name=’B’;  (此时A通知B)

update account set money=money - 100 where name=’A’;

当只执行第一条SQL时，A通知B查看账户，B发现确实钱已到账（此时即发生了脏读），而之后无论第二条SQL是否执行，只要该事务不提交，则所有操作都将回滚，那么当B以后再次查看账户时就会发现钱其实并没有转。

2.虚读(幻读)
　　幻读是事务非独立执行时发生的一种现象。例如事务T1对一个表中所有的行的某个数据项做了从“1”修改为“2”的操作，这时事务T2又对这个表中插入了一行数据项，而这个数据项的数值还是为“1”并且提交给数据库。而操作事务T1的用户如果再查看刚刚修改的数据，会发现还有一行没有修改，其实这行是从事务T2中添加的，就好像产生幻觉一样，这就是发生了幻读。

3.不可重复读
　　不可重复读是指在对于数据库中的某个数据，一个事务范围内多次查询却返回了不同的数据值，这是由于在查询间隔，被另一个事务修改并提交了。

例如事务T1在读取某一数据，而事务T2立马修改了这个数据并且提交事务给数据库，事务T1再次读取该数据就得到了不同的结果，发送了不可重复读。

不可重复读和脏读的区别是，脏读是某一事务读取了另一个事务未提交的脏数据，而不可重复读则是读取了前一事务提交的数据。

在某些情况下，不可重复读并不是问题，比如我们多次查询某个数据当然以最后查询得到的结果为主。但在另一些情况下就有可能发生问题，例如对于同一个数据A和B依次查询就可能不同，A和B就可能打起来了……

幻读和不可重复读都是读取了另一条已经提交的事务（这点就脏读不同），所不同的是不可重复读查询的都是同一个数据项，而幻读针对的是一批数据整体（比如数据的个数）。

1.4 MySQL数据库为我们提供的四种隔离级别：

① SERIALIZABLE(串行化)：可避免脏读、不可重复读、幻读的发生。

② REPEATABLE-READ (可重复读)：可避免脏读、不可重复读的发生。

③ READ-COMMITTED (读已提交)：可避免脏读的发生（Mysql默认级别）。

④ READ-UNCOMMITTED (读未提交)：最低级别，任何情况都无法保证。

以上四种隔离级别最高的是Serializable级别，最低的是Read uncommitted级别，当然级别越高，执行效率就越低。像Serializable这样的级别，就是以锁表的方式(类似于Java多线程中的锁)使得其他的线程只能在锁外等待，所以平时选用何种隔离级别应该根据实际情况。在MySQL数据库中默认的隔离级别为Repeatable read (可重复读)。

在MySQL数据库中，支持上面四种隔离级别，默认的为Repeatable read (可重复读)；而在Oracle数据库中，只支持Serializable (串行化)级别和Read committed (读已提交)这两种级别，其中默认的为Read committed级别

在MySQL数据库中查看当前事务的隔离级别：

查看mysql当前连接的事务（mysql8之后名称变更了）
-- mysql8版本
select @@transaction_isolation
-- 较低版本
select @@tx_isolation;

查询结果
mysql> select @@transaction_isolation;
+-------------------------+
| @@transaction_isolation |
+-------------------------+
| REPEATABLE-READ         |
+-------------------------+
1 row in set (0.00 sec)

mysql事物隔离级别值, (文档)

READ-UNCOMMITTED
READ-COMMITTED
REPEATABLE-READ
SERIALIZABLE

在MySQL数据库中设置事务的隔离级别：

set  [glogal | session]  transaction isolation level 隔离级别名称;
set transaction_isolation=’隔离级别名称;’

具体测试可看该文章 mysq事物隔离级别测试

二、spring中使用事务

1 .1原理

1）接口实现类或接口实现方法上，而不是接口类中。
2）访问权限：public 的方法才起作用。@Transactional 注解应该只被应用到 public 方法上，这是由 Spring AOP 的本质决定的。
系统设计：将标签放置在需要进行事务管理的方法上，而不是放在所有接口实现类上：只读的接口就不需要事务管理，由于配置了@Transactional就需要AOP拦截及事务的处理，可能影响系统性能。

@Transactional 实质是使用了 JDBC 的事务来进行事务控制的
@Transactional 基于 Spring 的动态代理的机制

@Transactional 实现原理：
 
1) 事务开始时，通过AOP机制，生成一个代理connection对象，
   并将其放入 DataSource 实例的某个与 DataSourceTransactionManager 相关的某处容器中。
   在接下来的整个事务中，客户代码都应该使用该 connection 连接数据库，
   执行所有数据库命令。
   [不使用该 connection 连接数据库执行的数据库命令，在本事务回滚的时候得不到回滚]
  （物理连接 connection 逻辑上新建一个会话session；
   DataSource 与 TransactionManager 配置相同的数据源）
 
2) 事务结束时，回滚在第1步骤中得到的代理 connection 对象上执行的数据库命令，
   然后关闭该代理 connection 对象。
  （事务结束后，回滚操作不会对已执行完毕的SQL操作命令起作用）

1.2声明式事务的管理实现本质：

事务的两种开启方式：
显示开启 start transaction | begin，通过 commit | rollback 结束事务
关闭数据库中自动提交 autocommit set autocommit = 0；MySQL 默认开启自动提交；通过手动提交或执行回滚操作来结束事务Spring 关闭数据库中自动提交：在方法执行前关闭自动提交，方法执行完毕后再开启自动提交

问题：

关闭自动提交后，若事务一直未完成，即未手动执行 commit 或 rollback 时如何处理已经执行过的SQL操作？

C3P0 默认的策略是回滚任何未提交的事务
C3P0 是一个开源的JDBC连接池，它实现了数据源和 JNDI 绑定，支持 JDBC3 规范和 JDBC2 的标准扩展。目前使用它的开源项目有 Hibernate，Spring等
JNDI(Java Naming and Directory Interface,Java命名和目录接口)是SUN公司提供的一种标准的Java命名系统接口，JNDI提供统一的客户端API，通过不同的访问提供者接口JNDI服务供应接口(SPI)的实现，由管理者将JNDI API映射为特定的命名服务和目录系统，使得Java应用程序可以和这些命名服务和目录服务之间进行交互

1.3 注解的属性列表

属性	类型	描述
value	string	可选的限定描述符，指定使用的事务管理器
propagation	enum: Propagation	可选的事务传播行为设置
isolation	enum: Isolation	可选的事务隔离级别设置
readOnly	boolean	读写或只读事务，默认读写
timeout	int (单位是：秒)	事务超时时间设置
rollbackFor	Class[]，Class对象数组，必须继承自Throwable	导致事务回滚的异常类数组
rollbackForClassName	String[]，类名数组，必须继承自Throwable	导致事务回滚的异常类名字数组
noRollbackFor	Class[]，Class对象数组，必须继承自Throwable	不会导致事务回滚的异常类数组
noRollbackForClassName	String[]，类名数组，必须继承自Throwable	不会导致事务回滚的异常类名字数组

value: 主要用来指定不同的事务管理器；主要用来满足在同一个系统中，存在不同的事务管理器。比如在Spring中，声明了两种事务管理器txManager1, txManager2.然后，用户可以根据这个参数来根据需要指定特定的txManager.

适用场景：在一个系统中，需要访问多个数据源或者多个数据库，则必然会配置多个事务管理器的

REQUIRED_NEW和NESTED两种不同的传播机制的区别

REQUIRED_NEW：内部的事务独立运行，在各自的作用域中，可以独立的回滚或者提交；而外部的事务将不受内部事务的回滚状态影响

ESTED的事务，基于单一的事务来管理，提供了多个保存点。这种多个保存点的机制允许内部事务的变更触发外部事务的回滚。而外部事务在混滚之后，仍能继续进行事务处理，即使部分操作已经被混滚。由于这个设置基于JDBC的保存点，所以只能工作在JDBC的机制

rollbackFor 让受检查异常回滚；即让本来不应该回滚的进行回滚操作

**noRollbackFor ** 忽略非检查异常；即让本来应该回滚的不进行回滚操作

Isolation 指定事务的隔离级别

是指若干个并发的事务之间的隔离程度

在注解中如何指定隔离级别

1. @Transactional(isolation = Isolation.READ_UNCOMMITTED)：读取未提交数据(会出现脏读,
 不可重复读) 基本不使用
2. @Transactional(isolation = Isolation.READ_COMMITTED)：读取已提交数据(会出现不可重复读和幻读)
3. @Transactional(isolation = Isolation.REPEATABLE_READ)：可重复读(会出现幻读)
4. @Transactional(isolation = Isolation.SERIALIZABLE)：串行化

propagation 指定事务的传播行为

1. TransactionDefinition.PROPAGATION_REQUIRED：
   如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是默认值。
 
2. TransactionDefinition.PROPAGATION_REQUIRES_NEW：
   创建一个新的事务，如果当前存在事务，则把当前事务挂起。
 
3. TransactionDefinition.PROPAGATION_SUPPORTS：
   如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
 
4. TransactionDefinition.PROPAGATION_NOT_SUPPORTED：
   以非事务方式运行，如果当前存在事务，则把当前事务挂起。
 
5. TransactionDefinition.PROPAGATION_NEVER：
   以非事务方式运行，如果当前存在事务，则抛出异常。
 
6. TransactionDefinition.PROPAGATION_MANDATORY：
   如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
 
7. TransactionDefinition.PROPAGATION_NESTED：
   如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；
   如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。

1.4 @Transactional不生效场景

1.一个有@Transactional的方法被没有@Transactional方法调用时，会导致Transactional作用失效。也是最容易出现的情况。

那为啥会出现这种情况？其实这还是由于使用Spring AOP代理造成的，因为只有当事务方法被当前类以外的代码调用时，才会由Spring生成的代理对象来管理。

2.对非public方法进行事务注解。@Transactional 将会失效。

原因：是应为在Spring AOP代理时，事务拦截器在目标方法前后进行拦截，DynamicAdvisedInterceptor的intercept 方法会获取Transactional注解的事务配置信息，

因为在Spring AOP 代理时，如上图所示 TransactionInterceptor （事务拦截器）在目标方法执行前后进行拦截，DynamicAdvisedInterceptor（CglibAopProxy 的内部类）的 intercept 方法或 JdkDynamicAopProxy 的 invoke 方法会间接调用 AbstractFallbackTransactionAttributeSource的 computeTransactionAttribute 方法会间接调用 AbstractFallbackTransactionAttributeSource的 computeTransactionAttribute 方法，这个方法会获取Transactional 注解的事务配置信息。他会首先校验事务方法的修饰符是不是public，不是 public则不会获取@Transactional 的属性配置信息。

3.Transactional 事务配置属性中的propagation 属性配置的问题。

当propagation属性配置为：

(1)TransactionDefinition.PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。

(2)TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。

(3)TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常

4.还存在一种情况：

在一个类中A方法被事务注释，B方法也被事务注释。

@Transactional
public void A(){
　　try{
　　this.B();
　　}catch(Exception e){
　　　　logger.error();
　　}
}

但在执行B方法是报错，但是异常被A catch 住，此时事务也会失效。

1.5 @Transactional与try…catch

1.如果在事务方法中开发人员自己用try-catch处理了异常，那么spring aop就捕获不到异常信息，从而会导致spring不能对事务方法正确的进行管理，不能及时回滚错误信息。

@Override
    @Transactional(rollbackFor = Exception.class)
    public int doSaveUser() throws Exception {
        int result = 0;
        UserEntity u = new UserEntity();
        u.setUserSex("男");
        u.setUserName("AAA");
        try {
            result = userMapper.insertUser(u);
            int i = 1 / 0;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
———————————————— 该章节为引用章节，可以参考原文
版权声明：本文为CSDN博主「三分魔系」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/C_AJing/article/details/106054265

控制台报错：在这里插入图片描述
数据库：
可以看到程序虽然报错了，但是事务并没有回滚，这就是由于我们自己处理了异常信息。
可是，只要是我们自己处理了异常，事务就一定不会回滚吗？答案是不一定的，下面用两段代码对比一下：

代码一：

public class User2ServiceImpl implements User2Service {
    @Autowired
    private UserService userService;
    @Autowired
    private UserMapper userMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int doSaveUser() throws Exception {
        int result = 0;
        UserEntity u = new UserEntity();
        u.setUserSex("男");
        u.setUserName("小A");
        userMapper.insertUser(u);
        try {
            u.setUserName("小B");
            result = userService.insertUser(u); //此时调用的方法没有加事务
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
}

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public int insertUser(UserEntity user) throws Exception {
        int i = 1 / 0;
        return userMapper.insertUser(user);
    }

}

异常信息：
在这里插入图片描述
数据库：

可以看到由于我们自己处理了保存小B时抛出的异常，事务方法没有受到影响，依然正常的保存了小A，并没有回滚事务。

代码二：

@Service
public class User2ServiceImpl implements User2Service {
    @Autowired
    private UserService userService;
    @Autowired
    private UserMapper userMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int doSaveUser() throws Exception {
        int result = 0;
        UserEntity u = new UserEntity();
        u.setUserSex("男");
        u.setUserName("小C");
        userMapper.insertUser(u);
        try {
            u.setUserName("小D");
            result = userService.insertUser(u); //此时调用的方法加上事务
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
}

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public int insertUser(UserEntity user) throws Exception {
        int i = 1 / 0;
        return userMapper.insertUser(user);
    }

}

异常信息：在这里插入图片描述
此时数据库里面一条记录也没有，也就是是说doSaveUser()方法也进行了事务回滚，我们已经用try-catch处理了异常了，为什么还会事务回滚呢？

我们此时把insertUser方法稍微修改一下：

@Override
   @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
    public int insertUser(UserEntity user) throws Exception {
        int i = 1 / 0;
        return userMapper.insertUser(user);
    }

此时数据库多了一条记录：
在这里插入图片描述
这里，我把spring事务传播机制从REQUIRED改成了REQUIRES_NEW，doSaveUser()方法就没有进行事务回滚了，到这里你应该能猜到了，spring事务传播机制默认是REQUIRED，也就是说支持当前事务，如果当前没有事务，则新建事务，如果当前存在事务，则加入当前事务，合并成一个事务，当insertUser方法有事务且事务传播机制为REQUIRED时，会和doSaveUser()方法的事务合并成一个事务，此时insertUser方法发生异常，spring捕获异常后，事务将会被设置全局rollback，而最外层的事务方法执行commit操作，这时由于事务状态为rollback，spring认为不应该commit提交该事务，就会回滚该事务，这就是为什么doSaveUser()方法的事务也被回滚了。

1.6注意事项

1.@Transactional 使用位置类上方方法上方
Spring 建议不要在接口或者接口方法上使用该注解，因为这只有在使用基于接口的代理时它才会生效
当作用于类上时，该类的所有 public 方法将都具有该类型的事务属性，同时，我们也可以在方法级别使用该标注来覆盖类级别的定义。

2.方法的访问权限为 public
@Transactional 注解应该只被应用到 public 方法上，这是由 Spring AOP 的本质决定的。在 protected、private 或者默认可见性的方法上使用 @Transactional 注解，这将被忽略，也不会抛出任何异常

默认情况下，只有来自外部的方法调用才会被AOP代理捕获，也就是，类内部方法调用本类内部的其他方法并不会引起事务行为，即使被调用方法使用@Transactional注解进行修饰

例如一：同一个类中方法，A方法未使用此标签，B使用了，C未使用，A 调用 B , B 调用 C ；则外部调用A之后，B的事务是不会起作用的

例如二：若是有上层（按照 Controller层、Service层、DAO层的顺序）由Action 调用Service 直接调用，发生异常会发生回滚；若间接调用，Action 调用 Service 中的 A 方法，A无 @Transactional 注解，B有，A调用B，B的注解无效

事务方法的嵌套调用会产生事务传播

spring 的事务管理是线程安全的

父类的声明的@Transactional会对子类的所有方法进行事务增强；子类覆盖重写父类方式可覆盖其@Transactional中的声明配置

类名上方使用@Transactional，类中方法可通过属性配置覆盖类上的@Transactional配置；比如：类上配置全局是可读写，可在某个方法上改为只读

undolog 记录修改前的数据，用于事务回滚，redolog记录修改后的数据，用于事务提交