Spring单体事务机制（传播、隔离、回滚）

一、Spring事务传播机制

Spring事务传播机制，是Spring针对事务嵌套而制定的解决方案。所谓事务嵌套，就是我们有方法A和方法B，方法A和方法B都是事务方法，那么假如我们在方法A中调用了方法B，这就形成了一个事务嵌套。这里默认大家知道，Spring的事务是通过AOP向方法中织入开启事务、提交事务/事务回滚等代码，当我们在事务A中调用了事务B时，因为这里事务A是最外层事务，所以一定会对方法A进行事务代码织入，那么Spring对事务B是否也要进行事务代码织入呢？这就要说到Spring的事务传播机制了。

我们知道，在SpringBoot中使用事务需要两个步骤，第一，在SpringBoot的入口类中使用@EnableTransactionManagement注解，第二，在方法上使用@Transactional注解。如下面的test()，这就是一个事务方法。

@SpringBootApplication
@EnableTransactionManagement
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}
-------------------------------------------
@Transactional
public void test(){
}

下面是@Transantional注解的定义，Spring在@Transactional注解中，定义了propagation属性，用于配置事务的传播行为。

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
    @AliasFor("transactionManager")
    String value() default "";

    @AliasFor("value")
    String transactionManager() default "";

    Propagation propagation() default Propagation.REQUIRED;

    Isolation isolation() default Isolation.DEFAULT;

    int timeout() default -1;

    boolean readOnly() default false;

    Class<? extends Throwable>[] rollbackFor() default {};

    String[] rollbackForClassName() default {};

    Class<? extends Throwable>[] noRollbackFor() default {};

    String[] noRollbackForClassName() default {};
}

事务的传播机制有七种配置方式，分别是

1.REQUIRED：Spring默认的传播行为。如果业务方法执行时已经在一个事务中，则加入当前事务，否则重新开启一个事务。

2.SUPPORTS：当前有事务就支持，没有事务就不支持，和REQUIRED的区别就是SUPPORTS不会在没有事务时启动一个新的事务。

3.MANDATORY：如果业务方法执行时已经在一个事务中，则加入当前事务。否则抛出异常。

4.REQUIRES_NEW：每次都是创建一个新事物，如果当前已经在事务中了，会挂起当前事务。

5.NOT_SUPPORTED：不支持事务，如果执行当前方法的时候已经有事务，那么会将事务挂起，同时当前方法内的数据操作不会受到事务影响。使用场景：主事务和当前方法业务不相关的场景。

6.NEVER：不支持事务，如果被放在一个事务中，则会抛IllegalTransactionStateException异常 。

7.NESTED：如果当前已经在一个事务中了，则嵌套在已有的事务中作为一个子事务。如果当前没在事务中则开启一个事务。

public enum Propagation {
    REQUIRED(0),
    SUPPORTS(1),
    MANDATORY(2),
    REQUIRES_NEW(3),
    NOT_SUPPORTED(4),
    NEVER(5),
    NESTED(6);

    private final int value;

    private Propagation(int value) {
        this.value = value;
    }

    public int value() {
        return this.value;
    }
}

常用的是1.REQUIRED和4.REQUIRES_NEW。

注意：

(1)使用REQUIRES_NEW时，虽然是开启的一个新事务，外层报错不影响内层，但是内层报错会同样让外层事务回滚，如果外层捕获了内层throws的异常，那么外层不会回滚。

(2)NESTED和REQUIRES_NEW的区别在于，NESTED开启一个子事务，子事务的提交和回滚和外层同步，REQUIRES_NEW开启一个新事务，新事物的提交和回滚不受外层影响

二、Spring的事务隔离

@Transactional(isolation=Isolation.REPEATABLE_READ)

使用isolation属性设置Spring的事务隔离级别

public enum Isolation {
    DEFAULT(-1),
    READ_UNCOMMITTED(1),
    READ_COMMITTED(2),
    REPEATABLE_READ(4),
    SERIALIZABLE(8);

    private final int value;

    private Isolation(int value) {
        this.value = value;
    }

    public int value() {
        return this.value;
    }
}

DEFAULT：使用数据库的事务隔离级别

READ_UNCOMMITTED：读未提交。脏读、不可重复读、幻读，都有可能发生。

READ_COMMITED：读已提交。可以使用乐观锁解决不可重复读问题。不可重复读、幻读，都有可能发生。

REPEATABLE_READ：可重复读。避免脏读、不可重复读，幻读有可能发生。

SERIALIZABLE：避免脏读、不可重复读、幻读。
下面说一说什么是脏读、不可重复读、幻读。

1.脏读：假设账户A余额1000元，事务1对账户A进行+2000操作，此时事务1还未提交，但事务2对账户A读取了余额为3000，然后事务1进行了回滚，事务2读取到的是事务1未提交的余额3000，而不是本应该读到的1000。

2.不可重复读：事务1对账户A的余额多次读取，并且进行了修改，但事务2在事务1操作的过程中，对账户A的余额进行了修改，导致事务1后几次读取的账户余额，和前几次不同，所以这里也会造成数据不一致的问题。

3.幻读：事务1读取某些范围的数据，此时事务2将这个范围内的某些数据进行了改变，当事务1再读取这个范围内的数据时，会发现和之前的不一样，犹如产生了幻觉一般。

注：MySQL的InnoDB默认隔离级别为REPEATABLE_READ，MyISAM不支持事务。

三、Spring事务回滚

Spring事务遇到运行时异常，如果不对异常进行处理，那么Spring会对事务进行回滚。当我们遇到非运行时异常时，如果也要对事务进行回滚，可以在catch代码块中throw new RuntimeException();

另外，@Transactional(readOnly = true)，readOnly属性为true的事务也不会回滚。

如果我们不想在catch块中抛异常，可以在catch中使用TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();让当前事务回滚。

也可以@Transactional(rollbackFor = Exception.class)，使用rollbackFor属性设置回滚异常。

PS：学习事务隔离级别的过程让我想到了多线程加锁， 更深入的MySQL实现事务隔离级别的原理有时间再研究。

参考链接：https://www.cnblogs.com/zeng1994/p/8257763.html 浅谈事务回滚