SpringBoot大事务问题的常用优化方案

From: https://www.jb51.net/program/320280l7c.htm

大事务是指运行时间比较长,操作的数据比较多的事务123,大事务的产生原因包括操作的数据比较多、大量的锁竞争、事务中有其他非数据库的耗时操作等,本文给大家总结了SpringBoot大事务问题的常用优化方案,需要的朋友可以参考下

 

+

目录

1.前言

在分享解决办法之前，先看看系统中如果出现大事务可能会引发哪些问题

从上图可以看出，如果系统中出现大事务的问题，那么情况不容乐观。

因此，在实际项目开发中，我们应该尽量避免大事务的情况。

2.什么是大事务

大事务是指运行时间比较长，操作的数据比较多的事务123。例如，执行超过5秒、10秒、1分钟等。大事务的产生原因包括操作的数据比较多、大量的锁竞争、事务中有其他非数据库的耗时操作等。

3.解决办法

3.1.少用@Transactional注解

在实际项目中，开启事务功能是非常常见的做法。在业务方法上加上@Transactional注解，可以方便地开启事务功能，这种做法被称为声明式事务。

1 2 3 4

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

为什么说要少用@Transactional注解？

• 我们知道@Transactional注解是通过spring的aop起作用的，但是如果使用不当，事务功能可能会失效。
• @Transactional注解一般加在某个业务方法上，会导致整个业务方法都在同一个事务中，粒度太粗，不好控制事务范围，是出现大事务问题的最常见的原因。

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

1 2 3 4 5 6 7 8 9 10 11

@Autowired private TransactionTemplate transactionTemplate;   ...   public void save(final User user) {       transactionTemplate.execute((status) => {          doSameThing...          return true;       }) }

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

查询(select)方法一般情况下是不需要事务的，所以应该放到事务外！

1 2 3 4 5 6 7

@Transactional(rollbackFor=Exception.class)    public void save(User user) {          query1();          query2();          add1();          update2();    }

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

可以用这个TransactionTemplate来解决！

1 2 3 4 5 6 7 8 9 10 11 12 13 14

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

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

1 2 3 4 5 6 7 8 9 10 11

public void save(User user) {          query1();          query2();          doSave();     }          @Transactional(rollbackFor=Exception.class)     public void doSave(User user) {        add1();        update2();     }

在一个Service内部，事务方法之间的嵌套调用，普通方法和事务方法之间的嵌套调用，都不会开启新的事务。是因为声明式事务来实现事务控制，当我们通过this调用普通方法时，是通过原始对象而不是代理对象调用的方法，导致事务

不过这边事务是失效的，因为直接方法调用使用的还是原始对象，所以事务不会生效。

那该怎么解决呢？

1.新加Service方法

这个方法非常简单，只需要新加Service方法，把@Transactional注解加到新Service方法上，把需要事务执行的代码移到新方法中。具体代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

@Servcie   publicclass ServiceA {      @Autowired      prvate ServiceB serviceB;          public void save(User user) {            query1();            query2();            serviceB.doSave(user);      }    }         @Servcie    publicclass ServiceB {            @Transactional(rollbackFor=Exception.class)       public void doSave(User user) {          add1();          update2();       }         }

2.在该Service类中注入自己

在该Service类中注入自己也是一种选择，如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

@Servcie   publicclass ServiceA {      @Autowired      prvate ServiceA serviceA;          public void save(User user) {            query1();            query2();            serviceA.doSave(user);      }             @Transactional(rollbackFor=Exception.class)      public void doSave(User user) {          add1();          update2();       }    }

spring ioc内部的三级缓存保证了它，不会出现循环依赖问题。

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

通过在该Service类中使用AOPProxy获取代理对象，实现相同的功能。如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

@Servcie   publicclass ServiceA {          public void save(User user) {            query1();            query2();            ((ServiceA)AopContext.currentProxy()).doSave(user);      }             @Transactional(rollbackFor=Exception.class)      public void doSave(User user) {          add1();          update2();       }    }

3.3.事务中避免远程调用

网络不稳定，远程调其他系统响应时间可能比较长，这就是大事务！

当然，发MQ消息，或者连接redis、mongodb保存数据等也属于远程调用哦！

1 2 3 4 5

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

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

1 2 3 4 5 6 7 8 9 10 11 12

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

不过这就需要建立：重试+补偿机制，达到数据最终一致性了。

3.4.事务中避免一次性处理太多数据

如果一个事务中需要处理的数据太多，也会造成大事务问题。

你可能会一次批量更新1000条数据，这样会导致大量数据锁等待，特别在高并发的系统中问题尤为明显! 那怎么解决呢？

用分页处理，1000条数据，分20页，一次只处理50条数据，这样可以大大减少大事务的出现。

3.5.非事务执行

在使用事务之前，我们都应该思考一下，是不是所有的数据库操作都需要在事务中执行？

1 2 3 4 5 6 7 8 9 10 11 12 13

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

上面的例子中，其实addLog增加操作日志方法 和 updateCount更新统计数量方法，是可以不在事务中执行的，因为操作日志和统计数量这种业务允许少量数据不一致的情况。

1 2 3 4 5 6 7 8 9 10 11 12 13

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

当然大事务中要鉴别出哪些方法可以非事务执行，其实没那么容易，需要对整个业务梳理一遍，才能找出最合理的答案。

3.6.异步处理

我们都知道，方法同步执行需要等待方法返回，如果一个事务中同步执行的方法太多了，势必会造成等待时间过长，出现大事务问题。

看看下面这个列子：

1 2 3 4 5 6 7 8 9 10 11 12

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

order方法用于下单，delivery方法用于发货，是不是下单后就一定要马上发货呢？

答案是否定的。

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

1 2 3 4 5 6 7 8 9 10 11 12

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

4.总结

以上就是SpringBoot大事务问题的常用优化方案的详细内容，更多关于SpringBoot大事务优化的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

• Springboot并发调优之大事务和长连接
• SpringBoot 多线程事务回滚的实现
• SpringBoot @Transactional事务不生效排查方式
• SpringBoot中进行事务回滚的方法
• SpringBoot事务注解超详细讲解