事务失效场景

1. 抛出检查异常导致事务不能回滚

  • 代码：

image.png

  • 原因：

Spring 默认只会回滚非检查异常（RuntimeException/error）

  • 解决：

配置 rollbackFor 属性 （@Transactional(rollbackFor = Exception.class)）
image.png

2. 业务方法内自己 try-catch 异常导致事务不能回滚

  • 代码：

image.png

  • 原因：

事务通知只有捉到了目标抛出的异常，才能进行后续的回滚处理，如果目标自己处理掉异常，事务通知无法知悉

  • 解决方案：
    • 解法1：异常原样抛出
      • 在 catch 块添加throw new RuntimeException(e);
    • 解法2：手动设置 TransactionStatus.setRollbackOnly()
      • 在 catch 块添加TransactionInterceptor.currentTransactionStatus().setRollbackOnly();

image.png

3. aop切面顺序导致事务不能正确回滚

  • 代码： ```java @Service public class Service3 {

    @Autowired private AccountMapper accountMapper;

    @Transactional(rollbackFor = Exception.class) public void transfer(int from, int to, int amount) throws FileNotFoundException {

    1.   int fromBalance = accountMapper.findBalanceBy(from);
    2.   if (fromBalance - amount >= 0) {
    3.       accountMapper.update(from, -1 * amount);
    4.       new FileInputStream("aaa");
    5.       accountMapper.update(to, amount);
    6.   }

    } }

@Aspect public class MyAspect { @Around(“execution(* transfer(..))”) public Object around(ProceedingJoinPoint pjp) throws Throwable { LoggerUtils.get().debug(“log:{}”, pjp.getTarget()); try { return pjp.proceed(); } catch (Throwable e) { e.printStackTrace(); return null; } } }


- 原因：

事务切面优先级最低，但如果自定义的切面优先级和他一样，则还是自定义切面在内层，这时若自定义切面没有正确抛出异常；

- 解法：
   - 解法1、2：同情况2 中的解法:1、2 
   - 解法3：调整切面顺序，在 MyAspect 上添加 **@Order(Ordered.LOWEST_PRECEDENCE - 1) **（不推荐） 

---


<a name="zxk1y"></a>
### 4. 非 public 方法导致事务失效

- 代码：

![image.png](https://cdn.nlark.com/yuque/0/2022/png/109239/1641125981784-1d673a03-3ff2-49ef-991b-59d4a7444495.png#clientId=u3be5a9b1-b2ac-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=211&id=xGLDr&margin=%5Bobject%20Object%5D&name=image.png&originHeight=422&originWidth=1498&originalType=binary&ratio=1&rotation=0&showTitle=false&size=113600&status=done&style=none&taskId=u5f6e88ae-6c15-4401-b2e3-499d3db1023&title=&width=749)

- 原因：

Spring 为方法创建代理、添加事务通知、前提条件都是该方法是 public 的 

- 解法： 
   - 解法1：改为 public 方法 
   - 解法2：添加 bean 配置如下（不推荐） 
```java
@Bean
public TransactionAttributeSource transactionAttributeSource() {
    return new AnnotationTransactionAttributeSource(false);
}

5. 父子容器导致的事务失效


package day04.tx.app.service;

// ...

  @Service  
  public class Service5 {
    @Autowired
    private AccountMapper accountMapper;

    @Transactional(rollbackFor = Exception.class)
    public void transfer(int from, int to, int amount) throws FileNotFoundException {
        int fromBalance = accountMapper.findBalanceBy(from);
        if (fromBalance - amount >= 0) {
            accountMapper.update(from, -1 * amount);
            accountMapper.update(to, amount);
        }
    }
}

控制器类

package day04.tx.app.controller;

// ...
@Controller  
public class AccountController {
  @Autowired
  public Service5 service;

  public void transfer(int from, int to, int amount) throws FileNotFoundException {
      service.transfer(from, to, amount);
  }
}

App 配置类

@Configuration  
@ComponentScan("day04.tx.app.service")
@EnableTransactionManagement
// ...
public class AppConfig {
// ... 有事务相关配置
}

Web 配置类

@Configuration  
@ComponentScan("day04.tx.app")
// ...
public class WebConfig {
// ... 无事务配置
}

现在配置了父子容器，WebConfig 对应子容器，AppConfig 对应父容器，发现事务依然失效

  • 原因：子容器扫描范围过大，把未加事务配置的 service 扫描进来（SpringBoot 没有这个问题，因为它只有一个容器）
  • 解法1：各扫描各的，不要图简便
  • 解法2：不要用父子容器，所有 bean 放在同一容器

6. 调用本类方法导致传播行为失效

@Service  
public class Service6 {
  @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
  public void foo() throws FileNotFoundException {
      LoggerUtils.get().debug("foo");
      bar();
  }

  @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
  public void bar() throws FileNotFoundException {
      LoggerUtils.get().debug("bar");
  }
}
  • 原因：本类方法调用不经过代理，因此无法增强
  • 解法1：依赖注入自己（代理）来调用
  • 解法2：通过 AopContext 拿到代理对象，来调用
  • 解法3：通过 CTW，LTW 实现功能增强

解法1

@Service  
public class Service6 {
  @Autowired
  private Service6 proxy; // 本质上是一种循环依赖

  @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
  public void foo() throws FileNotFoundException {
      LoggerUtils.get().debug("foo");
    System.out.println(proxy.getClass());
    proxy.bar();
  }

  @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
  public void bar() throws FileNotFoundException {
      LoggerUtils.get().debug("bar");
  }
}

解法2，还需要在 AppConfig 上添加@EnableAspectJAutoProxy(exposeProxy = true)

@Service  
public class Service6 {
  @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
  public void foo() throws FileNotFoundException {
      LoggerUtils.get().debug("foo");
      ((Service6) AopContext.currentProxy()).bar();
  }

  @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
  public void bar() throws FileNotFoundException {
      LoggerUtils.get().debug("bar");
  }
 }


7. @Transactional 没有保证原子行为

@Service  
public class Service7 {
  private static final Logger logger = LoggerFactory.getLogger(Service7.class);

  @Autowired
  private AccountMapper accountMapper;

  @Transactional(rollbackFor = Exception.class)
  public void transfer(int from, int to, int amount) {
      int fromBalance = accountMapper.findBalanceBy(from);
      logger.debug("更新前查询余额为: {}", fromBalance);
      if (fromBalance - amount >= 0) {
          accountMapper.update(from, -1 * amount);
          accountMapper.update(to, amount);
      }
  }

  public int findBalance(int accountNo) {
      return accountMapper.findBalanceBy(accountNo);
  }
}

上面的代码实际上是有 bug 的，假设 from 余额为 1000，两个线程都来转账 1000，可能会出现扣减为负数的情况

  • 原因：事务的原子性仅涵盖 insert、update、delete、select … for update 语句，select 方法并不阻塞

image.png

  • 如上图所示，红色线程和蓝色线程的查询都发生在扣减之前，都以为自己有足够的余额做扣减

8. @Transactional 方法导致的 synchronized 失效

针对上面的问题，能否在方法上加 synchronized 锁来解决呢？

@Service  
public class Service7 {
  private static final Logger logger = LoggerFactory.getLogger(Service7.class);

  @Autowired
  private AccountMapper accountMapper;

  @Transactional(rollbackFor = Exception.class)
  public synchronized void transfer(int from, int to, int amount) {
      int fromBalance = accountMapper.findBalanceBy(from);
      logger.debug("更新前查询余额为: {}", fromBalance);
      if (fromBalance - amount >= 0) {
          accountMapper.update(from, -1 * amount);
          accountMapper.update(to, amount);
      }
  }

  public int findBalance(int accountNo) {
      return accountMapper.findBalanceBy(accountNo);
  }
}

答案是不行，原因如下：

  • synchronized 保证的仅是目标方法的原子性，环绕目标方法的还有 commit 等操作，它们并未处于 sync 块内
  • 可以参考下图发现，蓝色线程的查询只要在红色线程提交之前执行，那么依然会查询到有 1000 足够余额来转账

image.png

  • 解法1：synchronized 范围应扩大至代理方法调用
  • 解法2：使用 select … for update 替换 select

常见问题

  1. 情况一：Transactional 在主方法上，异常在主方法上，子方法在异常后面；主/子方法事务有效

子方法无法执行

@Transactional
@Override
public void transfer(Long remitter, Long receiver, Long money){
    dao.updateMoney(remitter, -money);
    int i = 1/0;
    dao.updateMoney(receiver, money);
    operatorService.update(1);
}

@Override
public void update(int id) {
    dao.update(id);
}
  1. 情况二：Transactional 在主方法上，异常在主方法上，子方法在异常前面；主/子方法事务有效

主方法中事务传播，子方法也有事务

@Transactional
@Override
public void transfer(Long remitter, Long receiver, Long money){
    operatorService.update(1);
    dao.updateMoney(remitter, -money);
    int i = 1/0;
    dao.updateMoney(receiver, money);
}

@Override
public void update(int id) {
    dao.update(id);
}
  1. 情况三：Transactional 在子方法上，异常在主方法上，子方法在异常前面；主/子方法事务失效

事务只在子方法上，异常在主方法出现

@Override
public void transfer(Long remitter, Long receiver, Long money){
    operatorService.update(1);
    dao.updateMoney(remitter, -money);
    int i = 1/0;
    dao.updateMoney(receiver, money);
}

@Transactional
@Override
public void update(int id) {
    dao.update(id);
}
  1. 情况四：Transactional 在子方法上，异常在主方法上，子方法在异常后面；主/子方法事务失效

子方法没机会执行

@Override
public void transfer(Long remitter, Long receiver, Long money){
    int i = 1/0;
    operatorService.update(1);
    dao.updateMoney(remitter, -money);
    dao.updateMoney(receiver, money);
}

@Transactional
@Override
public void update(int id) {
    dao.update(id);
}
  1. 情况五：Transactional 在子方法上，异常在子方法上，主方法在异常后面

子方法事务生效

@Override
public void transfer(Long remitter, Long receiver, Long money){
    operatorService.update(1);
    dao.updateMoney(remitter, -money);
    dao.updateMoney(receiver, money);
}

@Transactional
@Override
public void update(int id) {
    dao.update(id);
    int i = 1/0;
}
  1. 情况六：Transactional 在子方法上，异常在子方法上，主方法在异常前面

子方法事务生效，主方法事务失效

@Override
public void transfer(Long remitter, Long receiver, Long money){
    dao.updateMoney(remitter, -money);
    operatorService.update(1);
    dao.updateMoney(receiver, money);
}

@Transactional
@Override
public void update(int id) {
    dao.update(id);
    int i = 1/0;
}
  1. 情况七：Transactional 在主方法上，异常在子方法上

事务传播，主/子方法事务生效

@Transactional
@Override
public void transfer(Long remitter, Long receiver, Long money){
    dao.updateMoney(remitter, -money);
    operatorService.update(1);
    dao.updateMoney(receiver, money);
}


@Override
public void update(int id) {
    dao.update(id);
    int i = 1/0;
}