简介： 大事务问题

大事务引发的问题

从上图可以看出如果系统中出现大事务时，问题还不小，所以我们在实际项目开发中应该尽量避免大事务的情况。如果我们已有系统中存在大事务问题，该如何解决呢？

解决办法

少用 @Transactional 注解

部分代码如下：

@Transactional(rollbackFor=Exception.class)
   public void save(User user) {
         doSameThing()...
   }

然而，我要说的第一条是：少用 @Transactional 注解。

为什么？

1. 我们知道 @Transactional 注解是通过 spring 的 aop 起作用的，但是如果使用不当，事务功能可能会失效。如果恰巧你经验不足，这种问题不太好排查。至于事务哪些情况下会失效
2. @Transactional 注解一般加在某个业务方法上，会导致整个业务方法都在同一个事务中，粒度太粗，不好控制事务范围，是出现大事务问题的最常见的原因。

可以使用编程式事务，在 spring 项目中使用 TransactionTemplate 类的对象，手动执行事务。（推荐）

部分代码如下：

@Autowired
   private TransactionTemplate transactionTemplate;
   
   ...
       
   public void save(final User user) {
       transactionTemplate.execute(new TransactionCallback(){
  @Override
  public Boolean doInTransaction(TransactionStatus status) {
     doSameThing()...
   return Boolean.TRUE;
    }
    });  
  }

从上面的代码中可以看出，使用 TransactionTemplate 的编程式事务功能自己灵活控制事务的范围，是避免大事务问题的首选办法。

将查询 (select) 方法放到事务外

如果出现大事务，可以将查询 (select) 方法放到事务外，也是比较常用的做法，因为一般情况下这类方法是不需要事务的。

比如出现如下代码 (不推荐使用)

@Transactional(rollbackFor=Exception.class)
   public void save(User user) {
         queryData1();
         queryData2();
         insertA(user);
         updateB(user);
   }

可以将 queryData1 和 queryData2 两个查询方法放在事务外执行，将真正需要事务执行的代码才放到事务中，比如：addData1 和 updateData2 方法，这样就能有效的减少事务的粒度。

改写如下 (推荐使用)：

@Autowired
   private TransactionTemplate transactionTemplate;
   
   ...
   
   public void save(final User user) {
         queryData1();
         queryData2();
      transactionTemplate.execute(new TransactionCallback(){
  @Override
  public Boolean doInTransaction(TransactionStatus status) {
       addData1();
            updateData2();
   return Boolean.TRUE;
    }
    }); 
   }

但是如果你实在还是想用 @Transactional 注解，该怎么拆分呢？

这个写法是否有问题？

public void save(User user) {
         queryData1();
         queryData2();
         doSave();
    }
   
    @Transactional(rollbackFor=Exception.class)
    public void doSave(User user) {
         insertA(user);
         updateB(user);
    }

这个例子是非常经典的错误，这种直接方法调用的做法事务不会生效，给正在坑中的朋友提个醒。因为 @Transactional 注解的声明式事务是通过 spring aop 起作用的，而 spring aop 需要生成代理对象，直接方法调用使用的还是原始对象，所以事务不会生效。

有没有办法解决这个问题呢？

1. 新加一个 Service 方法

@Service
  public class ServiceA {
     @Autowired
     prvate ServiceB serviceB;
  
     public void save(User user) {
           queryData1();
           queryData2();
           serviceB.doSave(user);
     }
   }
   
   @Service
   public class ServiceB {
   
      @Transactional(rollbackFor=Exception.class)
      public void doSave(User user) {
         insertA(user);
         updateB(user);
      }
   
   }

2. 在该 Service 类中注入自己

可以使用这样 (可以使用)：

@Service
  public class ServiceA {
     @Autowired
     prvate ServiceA serviceA;
  
     public void save(User user) {
           queryData1();
           queryData2();
           serviceA.doSave(user);
     }
     
     @Transactional(rollbackFor=Exception.class)
     public void doSave(User user) {
         insertA(user);
         updateB(user);
      }
   }

3. 在该 Service 类中使用 AopContext.currentProxy () 获取代理对象

还可以通过在该 Service 类中使用 AOPProxy 获取代理对象，实现相同的功能。具体代码如下 (可以使用)：

@Servcie
  public class ServiceA {
  
     public void save(User user) {
           queryData1();
           queryData2();
           ((ServiceA)AopContext.currentProxy()).doSave(user);
     }
     
     @Transactional(rollbackFor=Exception.class)
     public void doSave(User user) {
         insertA(user);
         updateB(user);
      }
   }

事务中避免远程调用

如果远程调用的代码放在某个事物中，这个事物就可能是大事务。当然，远程调用不仅仅是指调用接口，还有包括：发 MQ 消息，或者连接 redis、mongodb 保存数据等

(不推荐使用)：

@Transactional(rollbackFor=Exception.class)
   public void save(User user) {
         callRemoteApi();
         addData1();
   }

远程调用的代码可能耗时较长，切记一定要放在事务之外。(推荐使用)：

@Autowired
   private TransactionTemplate transactionTemplate;
   
   ...
   
   public void save(final User user) {
         callRemoteApi();
         transactionTemplate.execute((status) => {
            addData1();
            return Boolean.TRUE;
         })
   }

异步处理

(不推荐使用)：

@Autowired
   private TransactionTemplate transactionTemplate;
   
   ...
   
   public void save(final User user) {
         transactionTemplate.execute((status) => {
            order();
            delivery();
            return Boolean.TRUE;
         })
   }

答案是否定的。

这里发货功能其实可以走 mq 异步处理逻辑。

(推荐使用)：

@Autowired
   private TransactionTemplate transactionTemplate;
   
   ...
   
   public void save(final User user) {
         transactionTemplate.execute((status) => {
            order();
            return Boolean.TRUE;
         })
         sendMq();
   }

总结

本人结合自己实际的工作经验分享了处理大事务的 6 种办法：

1. 少用 @Transactional 注解，减少事务的粒度，推荐使用 TransactionTemplate
2. 将查询 (select) 方法放到事务外
3. 事务中避免远程调用
4. 事务中避免一次性处理太多数据
5. 非事务执行
6. 异步处理