导言

你以为你加了事务注解就能生效吗？

代码片段

@Service
public class ScoreService {
  @Autowired
  private ScoreMapper scoreMapper;
  public void testTransactional(Score scoreOne,Score scoreTwo,Score scoreThree) {
    // DO SOMETHING
    updateScores(scoreOne,scoreTwo,scoreThree);
    // DO SOMETHING
  }
  @Transactional
  public void updateScores(Score scoreOne,Score scoreTwo,Score scoreThree){
    updateScoreOne(scoreOne);
    updateScoreTwo(scoreTwo);
    updateScoreThree(scoreThree);
  }
  private void updateScoreOne(Score one) {
    updateScore(one);
  }
  private void updateScoreTwo(Score two) {
    updateScore(two);
  }
  private void updateScoreThree(Score three) {
    updateScore(three);
  }
  private void updateScore(Score score) {
    if (score.getScore() == -1) {
      throw new RuntimeException();
    }
    scoreMapper.updateById(score);
  }
  @Transactional
  public void testTransactionalTwo(Score scoreOne,Score scoreTwo,Score scoreThree) {
    updateScores(scoreOne,scoreTwo,scoreThree);
  }
}

在工作的时候，用的是spring boot + mybatis，见到类似上面的代码

就是在做一些操作之后，把保存方法都放到同一个类里面的方法里面，然后加个事务注解。要么全部成功要么全部失败。这么做是为了把事务做小。

其实一开始见到这种写法的时候，是感觉有点怪的。但是又说不出哪里怪。

最近sonar新出的规则又扫出了这种bug，一开始还不以为然。

直到在做codeReview的时候，看到自己之前写的异步调用
是使用Spring框架的@Async实现的

刚开始用，遇到一个很神奇的事情
就是调用方法跟异步方法放在同一个类里面，异步方法变成同步了。

后来查阅资料才知道
Spring @Async是通过切面来完成的，如果是同个类，走的是本地方法，不会通过切面。

然后突然间就想到了这个问题了。查了资料，果然Spring 的 @Transactional也是通过切面来做的，那么上面的写法就有问题了。

测试代码
当score.score == -1 的时候，抛出一个错误，测试回滚

public class CommonTest {
  @Autowired
  private ScoreService scoreService;
  @Autowired
  private ScoreMapper scoreMapper;
  @Test
  public void testSave(){
    Score score1 = new Score();
    Score score2 = new Score();
    Score score3 = new Score();
    score1.setId(1L);
    score2.setId(2L);
    score3.setId(3L);
    score1.setScore(11L);
    score2.setScore(-1L);
    score3.setScore(33L);

    List<Score> befores = scoreMapper.selectBatchIds(Lists.newArrayList(1,2,3));
    befores.forEach(System.out::println);
    try {
      scoreService.testTransactional(score1,score2,score3);
    } catch (Exception e) {
      System.out.println("出现了一个错误");
    }
    List<Score> afters = scoreMapper.selectBatchIds(Lists.newArrayList(1,2,3));
    afters.forEach(System.out::println);
  }

  @Test
  public void testSaveTwo(){
    Score score1 = new Score();
    Score score2 = new Score();
    Score score3 = new Score();
    score1.setId(1L);
    score2.setId(2L);
    score3.setId(3L);
    score1.setScore(11L);
    score2.setScore(-1L);
    score3.setScore(33L);

    List<Score> befores = scoreMapper.selectBatchIds(Lists.newArrayList(1,2,3));
    befores.forEach(System.out::println);
    try {
      scoreService.testTransactionalTwo(score1,score2,score3);
    } catch (Exception e) {
      System.out.println("出现了一个错误");
    }
    List<Score> afters = scoreMapper.selectBatchIds(Lists.newArrayList(1,2,3));
    afters.forEach(System.out::println);
  }
}

执行

testSave()执行结果 testSaveTwo()执行结果

可以看出，
当执行testSave的时候，scoreOne成功保存了，所以说，事务没有回滚。也可以说Spring没有代理这个事务。
当执行testSaveTwo的时候，saveScoreOne已经执行了，当要保存saveScoreTwo的时候抛出了异常，整个事务回滚了。

代码

https://gitee.com/allen_learn_test/transaction-test.git

后续还会整理一些Spring事务，感觉自己还是学的不是特别精。

结语

换了工作之后一直用的是mybatis，还是很差异，为什么之前是没遇到这种问题的。

之前用的是jpa。

用一个更新操作要写@Modifing，外面一定要加上@Transactional注解，不然的话，不用等奇葩的异常出现，自己自测的时候，就直接报错了