一、为什么需要事务(简单回顾)

我们知道事务的简单定义是将⼀组操作封装成⼀个不可分割的执⾏单元（封装到⼀起），要么全部成功，要么全部失败(通过回滚)

举个例子：⽐如转账分为两个操作，第⼀步操作：A 账户 -100 元，第⼆步操作：B 账户 +100 元

如果没有事务，第⼀步执⾏成功了，第⼆步执⾏失败了，那么 A 账户的 100 元就平⽩⽆故消失了。⽽如果使⽤事务就可以解决这个问题，让这⼀组操作要么⼀起成功，要么⼀起失败

二、MySQL 中的事务使⽤

事务在 MySQL 有 3 个重要的操作：开启事务、提交事务、回滚事务，它们对应的操作命令如下：

--开启事务
start transaction;

-- 业务执⾏

-- 提交事务
commit;
-- 或回滚事务
rollback;

三、Spring 中事务的实现

3.1 Spring 编程式事务(手动事务)

Spring ⼿动操作事务(编程式事务)和上⾯ MySQL 操作事务类似，它也是有 3 个重要操作步骤：
开启事务（获取事务），提交事务或回滚事务。

具体如何在 spring 中实现呢？SpringBoot 内置了两个对象，DataSourceTransactionManager ⽤来获取事务（开启事务）、提交或回滚事务的，⽽ TransactionDefinition 是事务的属性，在获取事务的时候需要将TransactionDefinition 传递进去从⽽获得⼀个事务 TransactionStatus，实现用户添加，代码如下：

1. 实现 mapper 接口

@Mapper
public interface UserInfoMapper {
    int add(UserInfo userInfo);
}

2. xml 文件实现

<insert id="add">
       insert into userinfo(username,password) values (#{username},#{password})
</insert>

3. service 代码实现

@Service
public class UserService {
    @Resource
    private UserInfoMapper userInfoMapper;
    
    public int add(UserInfo userInfo){
        return userInfoMapper.add(userInfo);
    }
}

4. controller 中的代码实现(编程式业务实现)

@RestController
public class UserController {
    @Resource
    private UserService userService;

    @Resource
    private LogService logService;

    //通过注入的方式，而不是 new 对象
    @Resource
    //事务管理器，负责管理事务的行为，比如开始，提交，回滚等操作
    private DataSourceTransactionManager transactionManager;
    @Resource
    //是对事务属性的相关定义，比如设置事务的隔离传播机制，超时时间等
    private TransactionDefinition transactionDefinition;

    // 在此方法中使用编程式的事务
    @RequestMapping("/add")
    public int add(UserInfo userInfo) {
        // 非空效验【验证用户名和密码不为空】
        if (userInfo == null || !StringUtils.hasLength(userInfo.getUsername())
                || !StringUtils.hasLength(userInfo.getPassword())) {
            return 0;
        }
        // 开启事务（获取事务）
        TransactionStatus transactionStatus =
                transactionManager.getTransaction(transactionDefinition);
                
        //执行业务代码        
        int result = userService.add(userInfo);
        System.out.println("受影响的行数：" + result);
        
        //transactionManager.commit(transactionStatus);   // 提交事务
        //transactionManager.rollback(transactionStatus); // 回滚事务
        return result;
    }
}    

4.1 获取到事务后，我们先验证提交事务后的效果 ！ 通过 url 访问，再观察数据库的结果，如下

执行之前的数据表

通过 url 访问，得到受影响的行数为1

再次查看数据表

由此可见，数据添加成功 ！！

4.2 再来验证事务回滚的效果 ！！将事务提交的代码注释掉，添加事务回滚代码。紧接上面的数据表来验证

通过 url 访问，得到受影响的行数为1

查看数据表

我们发现，开起事务回滚后，数据表中并没有我们添加的那组数组，由此可见事务回滚成功了

扩展知识点：

如果我仅仅只是开启了事务，而不进行提交事务或回滚事务，这时我的操作也会达到回滚的效果。因为当你没有使用 commit 提交事务时，系统会认为没有提交事务，业务操作会自动回滚，因此数据不会持久化，这是一种保护机制，避免误提交！！

---

3.2 Spring 声明式事务(自动事务)

声明式事务的实现很简单，只需要在需要的⽅法上添加 @Transactional 注解就可以实现了，⽆需⼿动开启事务和提交事务，进⼊⽅法时⾃动开启事务，⽅法执⾏完会⾃动提交事务，如果中途发⽣了没有处理的异常会⾃动回滚事务，具体实现代码如下：

    //注意：修饰方法时，该注解只能加到 Public修饰的方法上。修饰类时：表明该注解对该类中所有的 public ⽅法都⽣效
    @Transactional
    @RequestMapping("/add1")
    public int add1(UserInfo userInfo) {
        // 非空效验【验证用户名和密码不为空】
        if (userInfo == null || !StringUtils.hasLength(userInfo.getUsername())
                || !StringUtils.hasLength(userInfo.getPassword())) {
            return 0;
        }
        int result = userService.add(userInfo);
        System.out.println("受影响的行数：" + result);
        //int num = 10/0;
        return result;
    }

对比编程式事务，我们并没有繁琐的步骤，只添加了一个 @Transaction 注解，下面我们看效果

添加事务之前的数据表

添加事务之后的数据表

显而易见，我们添加数据成功了 ！！

---

当我们的方法中出现了一个异常，我们再次验证事务是否会自动回滚呢？ 将上面代码中的
int num = 10/0 异常解开注释

再次查看数据表

我们发现表中并没有我们添加的数据 ！！ 由此可见事务发生了回滚，添加操作失败了

---

3.2.1 @Transactional 作⽤范围

@Transactional 可以⽤来修饰⽅法或类：

1. 修饰⽅法时：需要注意只能应⽤到 public ⽅法上，否则不⽣效
2. 修饰类时：表明该注解对该类中所有的 public ⽅法都⽣效

---

3.2.2 @Transactional 参数说明

3.2.3 @Transactional 不进行事务回滚的情况

前面我们知道，当方法中存在异常时，我们的 @Transaction 会自动进行事务回滚 ！但是当我们把这个异常捕获后即进行try…catch 处理，回滚事务就会失效，如下：

TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    @Transactional
    @RequestMapping("/add2")
    public int add2(UserInfo userInfo) {
        // 非空效验【验证用户名和密码不为空】
        if (userInfo == null || !StringUtils.hasLength(userInfo.getUsername())
                || !StringUtils.hasLength(userInfo.getPassword())) {
            return 0;
        }
        int result = userService.add(userInfo);
        System.out.println("受影响的行数：" + result);
        try {
            int num = 10 / 0;
        } catch (Exception e) {
            // throw e;
            // TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
        return result;
    }

解决方案：

1. 将异常重新抛出去 throw e; (不推荐)
2. 手动回滚事务 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

---

3.2.4 @Transactional ⼯作原理

1.@Transactional 是基于 AOP 实现的，AOP ⼜是使⽤动态代理实现的。若⽬标对象实现了接⼝，默认情况下会采⽤ JDK 的动态代理，若继承了目标对象,会使⽤ CGLIB 动态代理。

2.@Transactional 在开始执⾏业务之前，通过代理先开启事务，在执⾏成功之后再提交事务。如果中途遇到的异常，则回滚事务。

3.@Transactional 实现思路预览：

4.@Transactional 具体执⾏细节如下图所示：

---

四、Spring事务隔离级别

4.1 事务特性回顾：

事务有4 ⼤特性（ACID），原⼦性、持久性、⼀致性和隔离性，具体概念如下：

1. 原⼦性：⼀个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执⾏过程中发⽣错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执⾏过⼀样
2. ⼀致性：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写⼊的资料必须完全符合所有的预设规则，这包含资料的精确度、串联性以及后续数据库可以⾃发性地完成预定的⼯作
3. 持久性：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失
4. 隔离性：数据库允许多个并发事务同时对其数据进⾏读写和修改的能⼒，隔离性可以防⽌多个事务并发执⾏时由于交叉执⾏⽽导致数据的不⼀致。事务隔离分为不同级别，包括读未提交（Read uncommitted）、读提交（read committed）、可重复读（repeatable read）和串⾏化（Serializable）

⽽这 4 种特性中，只有隔离性（隔离级别）是可以设置的，那为什么要设置事务的隔离级别？

设置事务的隔离级别是⽤来保障多个并发事务执⾏更可控，更符合操作者预期的，为了防⽌其他的事务影响当前事务执⾏的⼀种策略

4.2 回顾MySQL 事务隔离级别：

1. READ UNCOMMITTED：读未提交，也叫未提交读，该隔离级别的事务可以看到其他事务中未提交的数据。该隔离级别因为可以读取到其他事务中未提交的数据，⽽未提交的数据可能会发⽣回滚，因此我们把该级别读取到的数据称之为脏数据，把这个问题称之为脏读
2. READ COMMITTED：读已提交，也叫提交读，该隔离级别的事务能读取到已经提交事务的数据，因此它不会有脏读问题。但由于在事务的执⾏中可以读取到其他事务提交的结果，所以在不同时间的相同 SQL 查询中，可能会得到不同的结果，这种现象叫做不可重复读
3. REPEATABLE READ：可重复读，是 MySQL 的默认事务隔离级别，它能确保同⼀事务多次查询的结果⼀致。但也会有新的问题，⽐如此级别的事务正在执⾏时，另⼀个事务成功的插⼊了某条数据，但因为它每次查询的结果都是⼀样的，所以会导致查询不到这条数据，⾃⼰重复插⼊时⼜失败（因为唯⼀约束的原因）。明明在事务中查询不到这条信息，但⾃⼰就是插⼊不进去，这就叫幻读（Phantom Read）
4. SERIALIZABLE：序列化，事务最⾼隔离级别，它会强制事务排序，使之不会发⽣冲突，从⽽解决了脏读、不可重复读和幻读问题，但因为执⾏效率低，所以真正使⽤的场景并不多

● 脏读：⼀个事务读取到了另⼀个事务修改的数据之后，后⼀个事务⼜进⾏了回滚操作，从⽽导致第⼀个事务读取的数据是错误的。
● 不可重复读：⼀个事务两次查询得到的结果不同，因为在两次查询中间，有另⼀个事务把数据修改了(侧重点为 修改)。
● 幻读：⼀个事务两次查询中得到的结果集不同，因为在两次查询中另⼀个事务有新增了⼀部分数据(侧重点为 添加和删除)

---

在数据库中如何查询全局事务隔离级别和当前连接的事务隔离级别 ！！

select @@global.tx_isolation,@@tx_isolation;

以上 SQL 的执⾏结果如下：

---

4.3 Spring 事务隔离级别：

相⽐于 MySQL 的事务隔离级别，Spring 的事务隔离级别只是多了⼀个 Isolation.DEFAULT（以所连接数据库的全局事务隔离级别为主）

4.4 Spring 中设置事务隔离级别：

Spring 中事务隔离级别可以通过 @Transactional 中的 isolation 属性进⾏设置，具体操作如下图所示：

---