关于事务你了解多少？

小菜yh

于 2024-09-08 23:05:45 发布

阅读量1k

点赞数 26

文章标签： java 数据库开发语言 spring boot mysql intellij idea

本文链接：https://blog.csdn.net/m0_53369973/article/details/142034973

版权

事务处理

事务是一组操作的执行单元，针对数据库操作，事务管理的是一组SQL指令，事务内的操作要不全部成功，要不全部失败。比如执行过程中，如果有一条SQL语句没有执行成功，那么这一组操作都将全部回滚

一、事务特性（ACID）：

Atomic(原子性):要么都成功，要么都失败

Consistent(一致性):数据不应该被破坏

Isolate(隔离性):用户间操作不相混淆

Durable(持久性):永久保存

二、介绍

1）编程式事务

编程式的事务，可以实现细粒度的事务控制，比如可以控制事务何时开始，何时结束等，但是spring中一般不提倡使用。Spring提供两种方式的编程式事务管理，分别是使用TransactionTemplate和直接使用PlatformTransactionManager。

2）声明式事务

在Spring中使用AOP思想，对目标方法动态织入事务处理操作，根据目标方法执行情况，提交或者回滚。在Spring中，只需要在配置文件中进行一系列配置（或者通过@Transactional注解），即可将相关方法纳入到事务管理中，这种做法降低了代码的耦合度，灵活方便。

3) 事务的传播特性

多个事务方法相互调用时，事务如何在这些方法间传播

传播特性	意义
REQUIRED	常用默认配置。业务方法运行时会开启事务。如果方法运行时，已经处在一个事务中，进行事务的合并
NOT_SUPPORTED	声明方法不需要事务。如果方法没有关联到一个事务，容器不会为它开启事务。如果方法在一个事务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便会恢复执行
REQUIRES_NEW	不管是否存在事务，业务方法总会开启一个新的事务。如果方法已经运行在一个事务中，则原有事务会被挂起，新的事务会被创建，直到方法执行结束，新事务才算结束，原先的事务才会恢复执行
MANDATORY	业务方法只能在一个已经存在的事务中执行。如果业务方法在没有事务的环境下调用，容器就会抛出例外。
SUPPORTS	如果业务方法在某个事务范围内被调用，则方法成为该事务的一部分。如果业务方法在事务范围外被调用，则方法在没有事务的环境下执行
Never	指定业务方法绝对不能在事务范围内执行。如果业务方法在某个事务中执行，容器会抛出异常，只有业务方法没有关联到任何事务，才能正常执行
NESTED	如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按REQUIRED属性执行.它使用了一个单独的事务，这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager事务管理器起效

4)事务的隔离级别

用来限定事务内外的哪些改变是可见的，哪些是不可见的。低级别的隔离级一般支持更高的并发处理，并拥有更低的系统开销。

隔离级别	含义
DEFAULT	使用后端数据库默认的隔离级别(spring中的的选择项)
READ_UNCOMMITED	允许你读取还未提交的改变了的数据。可能导致脏、幻、不可重复读
READ_COMMITTED	允许在并发事务已经提交后读取。可防止脏读，但幻读和不可重复读仍可发生
REPEATABLE_READ	对相同字段的多次读取是一致的，除非数据被事务本身改变。可防止脏、不可重复读，但幻读仍可能发生。
SERIALIZABLE	完全服从ACID的隔离级别，确保不发生脏、幻、不可重复读。这在所有的隔离级别中是最慢的，它是典型的通过完全锁定在事务中涉及的数据表来完成的。

什么是脏数据，脏读，不可重复读，幻觉读？

1）脏读: 指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。因为这个数据是还没有提交的数据，那么另外一个事务读到的这个数据是脏数据，依据脏数据所做的操作可能是不正确的。

2）不可重复读: 指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，那么第一个事务两次读到的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读。

3）幻觉读: 指当事务不是独立执行时发生的一种现象，例如第一个事务对一个表中的数据进行了修改，而且这种修改涉及到表中的全部数据行。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。

mysql默认的事务处理级别是’REPEATABLE-READ’,也就是可重复读

查看当前会话隔离级别

5.7版本:select @@tx_isolation;

8版本: select @@transaction_isolation

查看系统当前隔离级别

5.7版本:select @@global.tx_isolation;

8版本: select @@global.transaction_isolation;

三、事务的注解方式

在需要启用事务的类中使用@Transactional注解，该注解既可以修饰方法，也可以修饰类

注意：dao层使用mybatis实现

1) 类中注解使用

//rollbackFor=Exception.class
//rollbackFor 表示哪些异常回滚
//noRollbackFor 表示某些异常下不回滚
//声明事务的注解
@Transactional(readOnly=false,//是否只读，如果只有查询，设置为true，效率高
               propagation=Propagation.REQUIRED, //事务的传播特性
               isolation=Isolation.DEFAULT, //事务的隔离特性
               timeout=3,//事务的超时时间，单位秒，默认-1
               noRollbackFor=ArithmeticException.class 

              )
public void addPerson(String name){}

2）事务传播特性测试

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class EmployeeServiceImpl implements EmployeeService {

    @Autowired
    private EmployeeDao employeeDao;

    @Autowired
    private DogService dogService;

    // 将自身进行注入
    @Autowired
    private EmployeeService employeeService;

    /**
     * A 表示addEmployee(), B表示addDog()
     * A REQUIRED  B REQUIRED  A方法中调用B方法, 事务合并，A发生异常，A和B中数据都会回滚
     * A REQUIRED  B REQUIRE_NEW  A方法中调用B方法,B中启用新的事务，A如果发生异常，A方法回滚，B方法正常执行
     * A 没有事务   B REQUIRED A方法中调用B, 如果B发生异常 B中数据回滚，A不会回滚
     * A REQUIRED  B 没有事务 A方法中调用B，如果A或B发生异常 所有数据回滚
     * A REQUIRED  B SUPPORTS（支持事务） A方法中调用B, B与处于事务之中，发生异常，所有数据回滚
     * A 无事务    B SUPPORTS A方法中调用B, B中不会启用事务，发生异常，不会回滚
     * A REQUIRED  B NOT_SUPPORT A方法中调用B, A中异常，A回滚，B不回滚（B不支持事务）
     * A 无事务    B NOT_SUPPORT A方法中调用B, A中异常，数据不回滚
     * <p>
     * 如果启用事务的方法中，捕获异常并且处理异常，数据不会回滚
     */
    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void addEmployee() {
        try {
            Employee employee = new Employee();
            employee.setName("hhhhhhhhhhhhhh");
            employee.setAge(20);
            employeeDao.insert(employee);

            dogService.addDog();

            int a = 10 / 0;
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

    // 不使用事务
    @Override
    public void addEmployee2() {
        Employee employee = new Employee();
        employee.setName("hhhhhhhhhhhhhh");
        employee.setAge(20);
        employeeDao.insert(employee);

        // deleteEmp()发生异常，没有回滚
        // 在方法中，通过this调用自身的方法(启用事务)，事务不会生效
        // this.deleteEmp();

        // 需要通过代理对象才会生效
        employeeService.deleteEmp();

    }
    
    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void deleteEmp() {
        employeeDao.deleteById(51);
        int a = 10 / 0;
    }

    // spring中事务针对RuntimeException,为了防止非运行时异常数据不回滚，一般指定rollbackFor
    // 建议
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void addEmployee3() {
        Employee employee = new Employee();
        employee.setName("hhhhhhhhhhhhhh");
        employee.setAge(20);
        employeeDao.insert(employee);
    }

    
}