Spring事务介绍

Spring中对事务有两种支持方式，分别是编程式事务与声明式事务：

一、编程式事务

  可通过TransactionManager、TransactionTemplate两大内置事务管理对象来完成：

// Spring内置事务管理器对象
@Autowired
private PlatformTransactionManager transactionManager;

/**
 * 通过编程式事务来控制数据库交互:
 * 更新菜品价格 -> 自定义transactionManager来控制事务
 */
public int updateDishPrice(Map<String, Object> paramMap) {
    // 1. 首先定义默认的事务属性与隔离级别
    DefaultTransactionDefinition transactionDefinition = new DefaultTransactionDefinition();
    transactionDefinition.setIsolationLevel(TransactionDefinition.ISOLATION_DEFAULT);
    // 2. 获取TransactionStatus
    TransactionStatus status = transactionManager.getTransaction(transactionDefinition);
    int result = 0;
    try {
        result = dishMapper.updateDish(paramMap);
        // int i = 1 / 0; 模拟报错请求
        // 提交事务
        transactionManager.commit(status);
    } catch (DataAccessException e) {
        LogUtil.error("DishServices.updateDishPrice", e.getMessage());
        // 回滚事务
        transactionManager.rollback(status);
    }
    return result;
}

// Spring内置事务模板对象
@Autowired
private TransactionTemplate transactionTemplate;

/**
 * 通过编程式事务来控制数据库交互:
 * 更新菜品代码 -> 自定义transactionTemplate来控制事务
 */
public int updateDishCode(Map<String, Object> paramMap) {
    // 设置事务隔离级别
    transactionTemplate.setIsolationLevel(TransactionDefinition.ISOLATION_DEFAULT);
    return transactionTemplate.execute(status -> {
        int result = 0;
        try {
           result = dishMapper.updateDish(paramMap);
           // int i = 1 / 0; // 模拟报错请求
        } catch (DataAccessException e) {
           LogUtil.error("MySpringBoot.updateDishCode", e.getMessage());
           status.setRollbackOnly();
        }
        return result;
    });
}

二、声明式事务（常用）

  声明式事务，通过在方法上加@Transactional注解实现，可以在注解中定义一些事务参数例如事务传播行为PROPAGATION、事务超时时间TIMEOUT、事务隔离级别ISOLATION、事务回滚条件ROLLBACKFOR：

@Transactional(timeout = 30, isolation = Isolation.DEFAULT, rollbackFor = DataAccessException.class)
public int updateDishStatus(Map<String, Object> paramMap) {
    int result = dishMapper.updateDish(paramMap);
    // int i = 1 / 0; // 模拟报错请求
    return result;
}

PROPAGATION
PROPAGATION_REQUIRED	这是事务的默认传播行为, 表示如果当前存在事务则加入该事务, 如果当前没有事务则创建一个新的事务.A->B, A如果有事务则B加入该事务(A影响B), 如果A没有则B会自己创建一个事务(B不影响A)
PROPAGATION_REQUIRES_NEW	无论如何都创建一个新的事务, 如果当前存在事务则把当前事务挂起, 且开启的事务与外部事务相互独立, 互不干扰. A->B, A不影响B, 他们是两个独立的事务; B不影响A
PROPAGATION_NESTED	如果当前存在事务就在当前事务中执行, 否则执行PROPAGATION_REQUIRED逻辑 A->B, A影响B, B不影响A
PROPAGATION_SUPPORTS	如果当前存在事务, 则加入该事务; 如果当前没有事务, 则以非事务的方式继续运行
PROPAGATION_NOT_SUPPORTED	以非事务的方式运行, 如果当前存在事务的话则把当前事务挂起
PROPAGATION_MANDATORY	如果当前存在事务, 则加入该事务; 如果当前没有事务, 则抛出异常
PROPAGATION_NEVER	以非事务方式运行, 如果当前存在事务, 则抛出异常

三、事务实战详解

3.1）事务的回滚机制

// 准备一个接口，一个service
@Transactional(propagation = Propagation.REQUIRED)
public int insertDishDefault() {
    Map<String, Object> paramMap = new HashMap<>();
    ...
    int result = dishMapper.insertDishDefault(paramMap);
	 throw new RuntimeException();
}

  查看数据库可以发现，期望的数据并没有被插入，但是切面日志表的数据是插入成功的，并且在进入该事务方法（insertDishDefault）前的其他方法操作也是成功执行的，所以事务的回滚不会影响到在它作用范围之外的sqlSession。

  仔细查看数据库中的数据变化，对比有事务控制与无事务控制的方法，会先发无事务的方法对DB的操作都是实时的（可以打断点查看），但是有事务的方法则是要等到事务提交才会影响DB，这和数据库里面的事务是一样的，Spring的底层也是用了AOP代理来完成事务控制的。

3.2）事务的传播

  Propagation属性默认是REQUIRED，事务的传播机制涉及到多种不同的情况，同时也是面试中的高频考点，下面列举几个常见的场景（下述场景均只讨论默认的事务传播机制）：

• 有事务Controller层 -> 无事务Services层

  @GetMapping("/insert")
  @Transactional(propagation = Propagation.REQUIRED)
  public int insert() {
      Ticket ticket = new Ticket();
      ticket.setDeparture("黑龙江");
      ticket.setDestination("广州");
      ticketMapper.insert(ticket);
      return dishServices.insertDishDefault(); // 无事务方法：插入数据，让其抛出异常
  }
  

    结果：Ticket与Dish表均插入数据失败。所以不同类中有事务的方法 -> 无事务的方法，后者会自动加入前者的事务，且它们是同一个事务，如果是前者抛异常，后者也会回滚，此处不演示。

• 有事务Services层 -> 无事务Services层

  @Transactional(propagation = Propagation.REQUIRED)
  public int insertDishDefault() {
      Map<String, Object> paramMap = new HashMap<>();
      ...
      testsw(); // testsw() 是同类的无事务方法：插入数据，让其抛出异常
      return result;
  }
  

    结果：Ticket与Dish表均插入数据失败。所以同一个类中有事务的方法 -> 无事务的方法，后者会自动加入前者的事务，且它们是同一个事务，如果是前者抛异常，后者也会回滚，此处不演示。

• 无事务Controller层 -> 有事务Services层

  @GetMapping("/insert")
  public int insert() {
      Ticket ticket = new Ticket();
      ticket.setDeparture("黑龙江");
      ticket.setDestination("广州");
      ticketMapper.insert(ticket);
      return dishServices.insertDishDefault(); // 有事务方法：插入数据，让其抛出异常
  }
  

    结果：Ticket插入成功，Dish插入失败。所以不同类中无事务的方法 -> 有事务的方法，后者不会影响前者，也可以通过数据库看出来，当Controller层代码执行完之后，Tick就已经被实时插入了。如果是前者抛出异常，前者不会回滚，后者需要看无事务方法是否已经执行完毕，如果已经执行完毕则不会回滚（事务方法一旦被执行完毕就会提交）。

• 无事务Services层 -> 有事务Services层（重要）

  // 同一个类中Dish插入无事务的方法调用有事务的方法
  @Transactional(propagation = Propagation.REQUIRED)
  public void testsw() {
      Ticket ticket = new Ticket();
      ticket.setDeparture("黑龙江");
      ticket.setDestination("广州");
      ticketMapper.insert(ticket);
      throw new RuntimeException(); // 同类中无事务调用该有有事务，有事务抛出异常
  }
  

    结果：Ticket与Dish均插入成功，Dish能插入成功因为其没有事务控制，实时就插入了，而Tick能插入成功是因为事务没有生效。如果是前者抛出异常，前者不会回滚，后者需要看无事务方法是否已经执行完毕，如果已经执行完毕则不会回滚（事务方法一旦被执行完毕就会提交）。

为何好端端的事务会失效？

1）Spring的事务注解@Transactional只能放在public方法上才起作用；

2）方法用final或static修饰了，用这两个关键字修饰的方法Spring无法对目标方法进行重写，因此自然也就不存在事务了；

3）如果采用spring+spring mvc，则context:component-scan重复扫描问题可能会引起事务失败；

4）数据库引擎不支持，如使用mysql且引擎是MyISAM，则事务会不起作用，原因是MyISAM不支持事务，可以改成InnoDB引擎；

5）本类中的方法互相调用，不会经过Spring的代理类，所以如果在调用方法前没有事务控制的话，调用后也是没有的（Spring事务是通过AOP代理来实现的）。

3.3）事务超时时间

  timeout属性默认是-1，不超时，在实际生产环境中一般设置为30秒、60秒，注意这个时间是所有事务的执行时间综合。

@Transactional(propagation = Propagation.REQUIRED, timeout = 5)
public int insertDishDefault() {
    Map<String, Object> paramMap = new HashMap<>();
    ...
    try {
        Thread.sleep(6000); //让线程暂停6秒，而事务的回滚时间阈值是5秒
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    int result = dishMapper.insertDishDefault(paramMap); // 插入失败
    return result;
}

3.4）事务隔离级别

  isolation属性默认是-1，表示使用数据库的隔离级别，用一个实验来测试隔离性，如下面代码所示，该查询方法可以查看未提交的事务。

@Transactional(isolation = Isolation.READ_UNCOMMITTED)
public String selectDishDefault(String dishId) {
    Dish dish =  dishMapper.selectDishDefault(dishId);
    if (dish == null) {
        return "没有该用户";
    } else {
        return JsonUtil.objectToJson(dish);
    }
}

  在第一行打上断点，然后执行一个sql插入语句不提交，实际证明该方法可以读取到我们没提交的这个sqlSession中的数据，可以用datagrip来手动提交事务：

3.5）事务回滚条件

  rollbackFor属性默认是空，表示捕获所有异常。指定了异常种类后，只有在出现了指定的异常才会回滚。

@Transactional(propagation = Propagation.REQUIRED, rollbackFor = DataAccessException.class)
public int insertDishDefault() {
    Map<String, Object> paramMap = new HashMap<>();
    ...
    int result = dishMapper.insertDishDefault(paramMap);
    try {
        int i = 1/0; // 会抛出ArithmeticException异常，但不是回滚的异常条件，数据插入成功
    } catch (ArithmeticException e) {
        e.printStackTrace();
    }
    return result;
}