Spring 事务和事务传播机制

一. Spring 声明式事务

声明式事务的实现很简单,只需要在需要的方法上添加 @Transantioinal 注解就可以实现了,无需手动开启事务和提交事务,进入方法时自动开启事务,方法执行完后会自动提交事务,如果中途发生了没有处理的异常会自动回滚事务.

@RestController
@Transactional
public class UserController {
    @Autowired
    private UserService userService;
    @RequestMapping("/add")
    public int add(){
        UserInfo userInfo=new UserInfo();
        userInfo.setUsername("张三");
        userInfo.setPassword("123");
        System.out.println("插入成功");
        int result=userService.add(userInfo);
        //出现异常会自动回滚,数据库中不会出现对应的数据
        int a=10/0;
        return result;
    }
}

Transactional 作用范围:

• 修饰方法时：需要注意只能应用到 public 方法上，否则不生效。
• 修饰类时：表明该注解对该类中所有的 public 方法都生效

@Transactional 参数说明

参数	作用
value	当配置了多个事务管理器时，可以使用该属性指定选择哪个事务管理器
transactionalManager	当配置了多个事务管理器时，可以使用该属性指定选择哪个事务管理器
propagation	事务的传播行为，默认值为 Propagation.REQUIRED
isolation	事务的隔离级别，默认值为 Isolation.DEFAULT
timeout	事务的超时时间，默认值为 -1，如果超过该时间限制，但事务还没有完成，则自动回滚事务
readOnly	指定事务是否为只读事务，默认值为false,为了忽略那些不需要事务的方法，比如读取数据，可以设置 read-only 为 true
roolbackFor	用于指定能够触发事务回滚的异常类型，可以指定多个异常类型
rollbackForClassName	用于指定能够触发事务回滚的异常类型，可以指定多个异常类型
noRollbackFor	抛出指定的异常类型不回滚事务，也可以指定多个异常类型
noRollbackForClassName	抛出指定的异常类型不回滚事务，也可以指定多个异常类型

 二. 事务的隔离级别

2.1 事务特性回顾

事务由 4 大特性（ACID)，原子性，持久性，一致性，和隔离性：

• 原子性（Atomicity)：一个事务中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚到事务开始前的状态，就像这个事务从来没有执行过一样。
• 一致性(Consistency)：在事务开始之前和事务结束之后，数据库的完整性没有被破坏，这表示写入的资料必须完全符合所有的预设规则，这包含资料的精确度，串联性以及后续数据库可以自发性地完成预定的工作
• 持久性(Isolation)：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失
• 隔离性(Durability)：数据库允许多个并发事务同时对其数据进行读写和修改能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。事务隔离分为不同的级别，包括读未提交（Read uncommitted)、读已提交（Read committed)、可重复读（repeatable read) 和串行化（Serializable)。

2.2 MySQL 事务隔离级别

1.  READ UNCOMMITTED ：读未提交，也叫未提交读，该隔离级别的事务可以看到其他事务中未提交的数据。该隔离级别因为可以读取到其他事务中未提交的数据，而未提交的数据可能会发生回滚，因此我们把该级别读取到的数据称之为脏数据，把这个问题称之为脏读。
2. READ COMMITTED：读已提交，该隔离级别的事务能读取到已提交事务的数据，因此它不会有脏读问题。但由于事务的执行中可以读取到其他事务提交的结果，所以在不同时间的相同 SQL 查询中，可能会得到不同的结果，这种现象叫做不可重复读。
3. REPEATABLE READ：可重复读，是 MySQL 的默认隔离级别，它能确保同一事务多次查询的结果一致。但也会有新的问题，比如此级别的事务正在执行时，另一个事务成功的插入了某条数据，但因为它每次查询的结果都是一样的，所以在事务中查询不到这条信息，但自己就是插入不进去，这就叫做幻读
4. SERIALIZABLE：序列化，事务最高隔离级别，它会强制事务排序，使之不会发生冲突，从而解决了脏读、不可重复读和幻读的问题，但因为执行效率低，所以真正使用的场景并不多。

在数据库中通过以下 SQL 查询全局事务隔离级别和当前连接事务隔离级别

select @@global.tx_isolation,@@tx_isolation;

2.3 Spring 事务隔离级别有5 种

1. Isolation.DEFAULT：以连接的数据库的事务隔离级别为主。
2. Isolation.READ_UNCOMMITTED：读未提交，可以读到未提交的事务，存在脏读。
3. Isolation.READ_COMMITTED：读已提交，只能读到已经提交的事务，解决了脏读，存在不可重复读。
4. Isolation.REPEATABLE_READ：可重复读，解决了不可重复读，但存在幻读（MySQL 默认级别）
5. Isolation.SERIALIZABLE：串行化，可以解决所有并发问题，但性能太低。

当 Spring 和 MySQL 中的事务隔离级别不一致时，以Spring中的设置为准。

2.4 try-catch Excepion不回滚

当我们使用try-catch 处理异常后，发现事务不会回滚：

    @RequestMapping("/add")
    @Transactional(propagation = Propagation.REQUIRED,isolation=Isolation.REPEATABLE_READ)
    public int add(){
        UserInfo userInfo=new UserInfo();
        userInfo.setUsername("张三");
        userInfo.setPassword("123");
        System.out.println("插入成功");
        int result=userService.add(userInfo);
        try {
            int a=10/0;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
}

解决方案：

1. 直接向上抛出异常：

try {
    int a=10/0;
} catch (Exception e) {
    throw e;
}

2. 手动回滚事务 

try {
    int a=10/0;
} catch (Exception e) {
    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}

2.5 @Transactional 工作原理

@Transactional 是基于 AOP 实现的，AOP 又是使用动态代理实现的。如果目标对象实现了接口，默认情况下会采用 JDK 的动态代理，如果目标对象没有实现接口接口，会使用 CGLIB 动态代理。@Transactional 在开始执行业务之前，通过代理先开启事务，在执行成功之后再提交事务。如遇到异常，则回滚事务。

三. 事务的传播机制

事务的隔离级别解决的是多个事务同时调用数据库的问题,而事务的传播机制是规定多个事务在相互调用时,事务的执行行为。

Spring 事务传播机制包含以下 7 中：

1. Propagation.REQUIRED：默认的事务传播级别，它表示当前如果存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
2. Propagation.SUPPORTS：如果当前存在事务，则加入该事务，如果当前没有事务，则以非事务的方式继续运行。
3. Propagation.MANDATORY：如果当前存在事务，则加入该事务，如果当前没有事务，则抛出异常。
4. Propagation.REQUIRES_NEW：表示创建一个新的事务，如果当前存在事务，则把当前事务挂起。也就是说不管外部方法是否开启事务，Propagation.REQUIRES_NEW 修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。
5. Propagation.NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
6. Propagation.NEVER：以非事务的方式运行，如果当前存在事务，则抛出异常。
7. Propagation.NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则取值等价于 PROPAGATION_REQUIRED。

对于 Propagatino.NESTED需要注意以下几点。

1. 当嵌套异常是直接抛出的，没有使用try-catch捕获时，整个事务都会回滚：

@RestController
//@Transactional
public class UserController {
    @Autowired
    private UserService userService;
    @RequestMapping("/add")
    @Transactional(propagation = Propagation.REQUIRED,isolation=Isolation.REPEATABLE_READ)
    public int add(){
        UserInfo userInfo=new UserInfo();
        userInfo.setUsername("王五");
        userInfo.setPassword("123");
        System.out.println("插入成功");
        int result=userService.add(userInfo);
        userService.insert(userInfo);
//        try {
//            int a=10/0;
//        } catch (Exception e) {
//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//        }
        return result;
    }
}


@Service
public class UserService {
    @Autowired
    UserMapper userMapper;
    @Transactional(propagation = Propagation.NESTED)
    public int add(UserInfo userInfo){
        int result=userMapper.add(userInfo);
        return result;
    }

    @Transactional(propagation = Propagation.NESTED)
    public int insert(UserInfo userInfo){
        int result=userMapper.add(userInfo);
        int n=10/0;
        return result;
    }
}


@Mapper
public interface UserMapper {
    @Insert("insert into userinfo(username,password) values(#{username},#{password})")
    int add(UserInfo userInfo);
}

当我们运行时，本应该有一条插入数据的，但因为 insert 中抛出的异常在 controller 层感受到了，致使整个事务都发生了回滚。如果不想整个事务发生回滚，可以在 insert 中发生异常的地方使用try-catch 进行捕获处理，这样在 controller 层就感受不到异常了。

2. 当嵌套事务中继续嵌套事务时，其中一个嵌套事务出现异常，整个嵌套事务都会发生回滚。

@RestController
//@Transactional
public class UserController {
    @Autowired
    private UserService userService;
    @RequestMapping("/add")
    @Transactional(propagation = Propagation.REQUIRED,isolation=Isolation.REPEATABLE_READ)
    public int add(){
        UserInfo userInfo=new UserInfo();
        userInfo.setUsername("王五");
        userInfo.setPassword("123");
        System.out.println("插入成功");
        int result=userService.add(userInfo);
//        try {
//            int a=10/0;
//        } catch (Exception e) {
//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//        }
        return result;
    }
}

@Service
public class UserService {
    @Autowired
    UserMapper userMapper;
    @Transactional(propagation = Propagation.NESTED)
    public int add(UserInfo userInfo){
        int result=userMapper.add(userInfo);
        insert(userInfo);
        return result;
    }

    @Transactional(propagation = Propagation.NESTED)
    public int insert(UserInfo userInfo){
        int result=userMapper.add(userInfo);
        int n=10/0;
        return result;
    }
}

@Mapper
public interface UserMapper {
    @Insert("insert into userinfo(username,password) values(#{username},#{password})")
    int add(UserInfo userInfo);
}