Java大事务处理

Java大事务处理

1.少用@Transactional注解，可以使用编程式事务
2.将查询(select)方法放到事务外，事务失效原因：spring aop需要生成代理对象，直接方法调用使用的还是原始对象，所以事务不会生效。

• 1.新加一个Service方法
• 2.在该Service类中注入自己
• 3.在该Service类中使用AopContext.currentProxy()获取代理对象

3.事务中避免远程调用
4.事务中避免一次性处理太多数据
5.非事务执行
6.异步处理

1.少用@Transactional注解
大家在实际项目开发中，我们在业务方法加上@Transactional注解开启事务功能，这是非常普遍的做法，它被称为声明式事务。

部分代码如下：

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

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

部分代码如下：

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

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

@Configuration
@MapperScan(basePackages = "com.order.mapper.order", sqlSessionFactoryRef = "orderDBSessionFactory")
public class orderDBConfig {

    @Bean(name = "orderDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.scooter.order")
    @Primary
    public DataSource fundsDataSource() {
        return DataSourceBuilder.create().build();
    }


    @Bean(name = "orderDBSessionFactory")
    @Primary
    public SqlSessionFactory sqlSessionFactoryBean(@Qualifier("orderDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/order/*.xml"));
        sqlSessionFactoryBean.setDataSource(dataSource);
        return sqlSessionFactoryBean.getObject();
    }

    @Bean(name = "scooterTransactionManager")
    @Primary
    public DataSourceTransactionManager transactionManager(@Qualifier("orderDataSource") DataSource dataSource) {
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }

    @Bean(name = "scooterTransactionTemplate")
    @Primary
    public TransactionTemplate transactionTemplate(@Qualifier("scooterTransactionManager") DataSourceTransactionManager transactionManager) {
        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
        return transactionTemplate;
    }
}


    @Resource(name = "scooterTransactionTemplate")
    private TransactionTemplate scooterTransactionTemplate;
    
    scooterTransactionTemplate.execute(status -> {
        //声明式编程事务逻辑,比如：提交订单操作等
        return null;
    });

当然，我说少使用@Transactional注解开启事务，并不是说一定不能用它，如果项目中有些业务逻辑比较简单，而且不经常变动，使用@Transactional注解开启事务开启事务也无妨，因为它更简单，开发效率更高，但是千万要小心事务失效的问题。

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

比如出现如下代码：

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

如果使用TransactionTemplate的编程式事务这里就非常好修改。

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

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

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

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

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

@Servcie
  publicclass ServiceA {
     @Autowired
     prvate ServiceB serviceB;
  
     public void save(User user) {
           queryData1();
           queryData2();
           serviceB.doSave(user);
     }
   }
   
   @Servcie
   public class ServiceB {
   
      @Transactional(rollbackFor=Exception.class)
      public void doSave(User user) {
         addData1();
         updateData2();
      }
   }

2.在该Service类中注入自己
如果不想再新加一个Service类，在该Service类中注入自己也是一种选择。具体代码如下：

@Servcie
  publicclass ServiceA {
     @Autowired
     prvate ServiceA serviceA;
  
     public void save(User user) {
           queryData1();
           queryData2();
           serviceA.doSave(user);
     }
     
     @Transactional(rollbackFor=Exception.class)
     public void doSave(User user) {
         addData1();
         updateData2();
      }
   }

可能有些人可能会有这样的疑问：这种做法会不会出现循环依赖问题？
其实spring ioc内部的三级缓存保证了它，不会出现循环依赖问题。 自测可以正常启动项目。

A,B类相互依赖注入，项目也可以正常启动。
使用依赖查找或注入框架：比如Spring框架，它可以管理对象的生命周期，并解决循环依赖问题。
在Spring等依赖注入框架的帮助下，循环依赖可以被正确解决，但在没有使用这些框架的情况下，需要手动管理依赖关系，避免循环依赖的发生。

3.在该Service类中使用AopContext.currentProxy()获取代理对象
上面的方法2确实可以解决问题，但是代码看起来并不直观，还可以通过在该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) {
         addData1();
         updateData2();
      }
   }
   
//自己注入自己  报错了  Cannot find current proxy: Set 'exposeProxy' property on Advised to 'true' to make it available.
NestedComponent ss = (NestedComponent)(AopContext.currentProxy());
System.out.println("nestedComponent-ss=" + ss.toString());   

3.事务中避免远程调用
我们在接口中调用其他系统的接口是不能避免的，由于网络不稳定，这种远程调的响应时间可能比较长，如果远程调用的代码放在某个事物中，这个事物就可能是大事务。当然，远程调用不仅仅是指调用接口，还有包括：发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;
         })
   }

有些朋友可能会问，远程调用的代码不放在事务中如何保证数据一致性呢？ 这就需要建立：重试+补偿机制，达到数据最终一致性了。【关键】

4.事务中避免一次性处理太多数据
如果一个事务中需要处理的数据太多，也会造成大事务问题。比如为了操作方便，你可能会一次批量更新1000条数据，这样会导致大量数据锁等待，特别在高并发的系统中问题尤为明显。
解决办法是分页处理，1000条数据，分50页，一次只处理20条数据，这样可以大大减少大事务的出现。 分页处理

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

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

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

改进后：

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

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

6.异步处理
还有一点也非常重要，是不是事务中的所有方法都需要同步执行？我们都知道，方法同步执行需要等待方法返回，如果一个事务中同步执行的方法太多了，势必会造成等待时间过长，出现大事务问题。
看看下面这个列子：

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

order方法用于下单，delivery方法用于发货，是不是下单后就一定要马上发货呢？
答案是否定的。
这里发货功能其实可以走mq异步处理逻辑。

改进后：

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

总结
1.少用@Transactional注解
2.将查询(select)方法放到事务外

• 1.新加一个Service方法
• 2.在该Service类中注入自己
• 3.在该Service类中使用AopContext.currentProxy()获取代理对象

3.事务中避免远程调用
4.事务中避免一次性处理太多数据
5.非事务执行
6.异步处理