深入分析Spring事务和底层原理

1 知识回顾

1.1 事务特性

MySQL事务特性

1.2 隔离级别

MySQL隔离级别

1.3 脏读、幻读、不可重复读

MySQL脏读、幻读、不可重复读

2 Spring使用事务的两种方式

2.1 编程式事务

使用TransactionalTemplate

@Autowired
private UserDAO userDAO;

@Autowired
private TransactionTemplate transactionTemplate;

@Override
public void insertUser(User user) {
    transactionTemplate.execute(new TransactionCallback<Object>() {
        //异常不需要处理,否则不回滚
        @Override
        public Object doInTransaction(TransactionStatus status) {
            userDAO.insertUser(user);
            return status;
        }
    });
}

2.3 声明式事务

使用@Transactional注解

@Transactional(rollbackFor = Exception.class)
@Override
public int updateUserById(User user) throws Exception {
    int res = userDAO.updateUserById(user);
    return res;
}

2.4 事务的传播机制

配置：@Transactional(propagation = Propagation.xxx)

public enum Propagation {

   /**
    * 支持当前事务，如果不存在则创建一个新的事务（Spring默认的事务传播机制）.
    */
   REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),

   /**
    * 支持当前事务，如果不存在则以非事务方式执行.
    */
   SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),

   /**
    * 支持当前事务，如果不存在则抛出异常.
    */
   MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),

   /**
    * 创建一个新事务，如果存在当前事务，则挂起当前事务.
    */
   REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),

   /**
    * 以非事务方式执行，如果存在当前事务，则挂起当前事务  
    */
   NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),

   /**
    * 以非事务方式执行，如果存在事务则抛出异常  .
    */
   NEVER(TransactionDefinition.PROPAGATION_NEVER),

   /**
    * 如果存在当前事务，则在嵌套事务中执行  ,否则，行为像{@code REQUIRED}.
    */
   NESTED(TransactionDefinition.PROPAGATION_NESTED);
    
   ...
}

• REQUIRED：默认的传播机制，能满足绝大部分业务需求，如果外层有事务，则当前事务加入到外层事务，一块提交，一块回滚。如果外层没有事务，新建一个事务执行。
• REQUES_NEW：该事务传播机制是每次都会新开启一个事务，同时把外层事务挂起，当当前事务执行完毕，恢复上层事务的执行。如果外层没有事务，执行当前新开启的事务即可。
• SUPPORT：如果外层有事务，则加入外层事务，如果外层没有事务，则直接使用非事务方式执行。完全依赖外层的事务。
• NOT_SUPPORT：该传播机制不支持事务，如果外层存在事务则挂起，执行完当前代码，则恢复外层事务，无论是否异常都不会回滚当前的代码。
• NEVER：该传播机制不支持外层事务，即如果外层有事务就抛出异常。
• MANDATORY：与NEVER相反，如果外层没有事务，则抛出异常。
• NESTED：该传播机制的特点是可以保存状态保存点，当前事务回滚到某一个点，从而避免所有的嵌套事务都回滚，即各自回滚各自的，如果子事务没有把异常吃掉，基本还是会引起全部回滚的。

2.5 事务的隔离级别

配置：@Transactional(isolation = Isolation.xxx)

2.6 Spring事务回滚（声明式为例）

配置：@Transactional(rollbackFor = Exception.class)

含义：当出现rollbackFor 指定的异常类或者其派生类时才会触发事务回滚机制

2.6.1 Java异常类继承体系（部分）

Spring框架的事务管理默认是只在发生不受控异常（RuntimeException和Error）时才进行事务回滚。

2.6.1 事务回滚实验

（1）使用默认配置，抛出ClassNotFound异常查看是否回滚

@Transactional
@Override
public int updateUserById(User user) throws Exception {
    int res = userDAO.updateUserById(user);
    throw new ClassNotFoundException();
}

测试：

@Test
void contextLoads() {
    System.out.println("before update "+userService.selectUserById(1));
    try {
        userService.updateUserById(new User(1L, "aaa", "aaa"));
    } catch (Exception e) {
        System.err.println("---------捕获异常咯---------");
        System.out.println("after update "+userService.selectUserById(1));
    }
}

结果：

（2）配置成Excepction.class，抛出ClassNotFound异常查看是否回滚

@Transactional(rollbackFor = Exception.class)
@Override
public int updateUserById(User user) throws Exception {
    int res = userDAO.updateUserById(user);
    throw new ClassNotFoundException();
}

测试：

@Test
void contextLoads() {
    System.out.println("before update "+userService.selectUserById(1));
    try {
        userService.updateUserById(new User(1L, "bbb", "bbb"));
    } catch (Exception e) {
        System.err.println("---------捕获异常咯---------");
        System.out.println("after update "+userService.selectUserById(1));
    }
}

结果：

（3）使用默认配置，抛出NullPointException异常查看是否回滚

@Transactional
@Override
public int updateUserById(User user) throws Exception {
    int res = userDAO.updateUserById(user);
    throw new NullPointerException();
}

测试：

@Test
void contextLoads() {
    System.out.println("before update "+userService.selectUserById(1));
    try {
        userService.updateUserById(new User(1L, "ccc", "ccc"));
    } catch (Exception e) {
        System.err.println("---------捕获异常咯---------");
        System.out.println("after update "+userService.selectUserById(1));
    }
}

结果：

3 底层原理

3.1 概述

Spring事务属于AOP范畴，是通过代理对象对数据库的操作来进行事务处理，并且Spring事务的底层也是需要数据库的支持。

下面让我们debug下：

由此可见，声明事务之后，IOC初始化时会利用cglib进行AOP动态代理，将userDAO转变为代理对象对事务进行操作

点进入看下，并没有直接调用UserDAO的相关方法，而是进入了CglibAopProxy类进行对被调用对象的代理


继续向下debug直到出现异常

出现事务的相关信息，该步骤叫做事务清理

protected void cleanupTransactionInfo(@Nullable TransactionInfo txInfo) {
   if (txInfo != null) {
      // 恢复之前的状态
      txInfo.restoreThreadLocalStatus();
   }
}

3.2 事务流程

由此，我们可以总结出Spring事务的执行流程