双异步系列完结撒花，如何解決异步事务问题？

if(end == sheet.getLastRowNum()){
    logger.info("插入最后一批数据，模拟异常");
    int a = 1/0;
}

@Transactional(rollbackFor = Exception.class)
public void readXls(String filePath, String filename) throws Exception{
 try {
  // 省略一些复杂操作...
   
   List<Future<Integer>> futureList = new ArrayList<>();
  for (int time = 0; time < times; time++) {
   Future<Integer> sumFuture = readExcelDataAsyncFutureService.readXlsCacheAsyncMybatis();
            futureList.add(sumFuture);
  }
  
  // 主线程获取Future返回值
        boolean futureFlag = getFutureResult(futureList, excelRow);
        if (futureFlag) {
            logger.info("readXlsCacheAsync---插入数据成功，提交事务");
        } else {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            logger.info("readXlsCacheAsync---插入数据失败，回滚事务");
        }
 } catch (Exception e) {
  TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
  logger.error("readXlsCacheAsync---插入数据异常，回滚事务：", e);
    }
}

@Async("async-executor")//是否开启异步
@Override
public Integer readXlsCacheAsyncMybatis() {
    try {
     // 省略一些复杂操作...
    }catch (Exception e){
        throw new RuntimeException("插入数据库异常", e);
    }
}

public void readXls(String filePath, String filename) throws Exception{
  // 手动开启事务,不自动提交
    TransactionStatus transactionStatus = dataSourceTransactionManager.getTransaction(transactionDefinition);
 try {
  // 省略一些复杂操作...
   
   List<Future<Integer>> futureList = new ArrayList<>();
  for (int time = 0; time < times; time++) {
   Future<Integer> sumFuture = readExcelDataAsyncFutureService.readXlsCacheAsyncMybatis();
            futureList.add(sumFuture);
  }
  
  // 主线程获取Future返回值
        boolean futureFlag = getFutureResult(futureList, excelRow);
        if (futureFlag) {
         dataSourceTransactionManager.commit(transactionStatus); // 提交
            logger.info("readXlsCacheAsync---插入数据成功，提交事务");
        } else {
            dataSourceTransactionManager.rollback(transactionStatus);// 回滚
            logger.info("readXlsCacheAsync---插入数据失败，回滚事务");
        }
 } catch (Exception e) {
  dataSourceTransactionManager.rollback(transactionStatus);// 回滚
  logger.error("readXlsCacheAsync---插入数据异常，回滚事务：", e);
    }
}

@Async("async-executor")//是否开启异步
@Override
public Integer readXlsCacheAsyncMybatis() {
    try {
     // 省略一些复杂操作...
    }catch (Exception e){
        throw new RuntimeException("插入数据库异常", e);
    }
}

/**
 * 数据源事务管理器
 */
private DataSourceTransactionManager dataSourceTransactionManager;

@Autowired
public void setUserService(DataSourceTransactionManager dataSourceTransactionManager) {
 this.dataSourceTransactionManager = dataSourceTransactionManager;
}

@Override
public void readXls(String filePath, String filename) {

 List<TransactionStatus> transactionStatusList = Collections.synchronizedList(new ArrayList<>());
 List<TransactionResource> transactionResourceList = Collections.synchronizedList(new ArrayList<>());

 try {
  List<Future<Integer>> futureList = new ArrayList<>();
        for (int time = 0; time < times; time++) {
   Future<Integer> sumFuture = readAsyncFutureTransactionDBService.readXlsCacheAsyncMybatis(sheet, row, start, end, insertBuilder,transactionStatusList,transactionResourceList);
            futureList.add(sumFuture);
  }
  
  // 主线程获取Future返回值
        boolean futureFlag = getFutureResult(futureList, excelRow);
  if (futureFlag) {
   for (int i = 0; i < transactionStatusList.size(); i++) {
    TransactionStatus transactionStatus = transactionStatusList.get(i);
    dataSourceTransactionManager.commit(transactionStatus); // 提交
   }

   logger.info("readXlsCacheAsync---插入数据成功，提交事务");
  } else {
   for (int i = 0; i < transactionStatusList.size(); i++) {
    TransactionStatus transactionStatus = transactionStatusList.get(i);
    dataSourceTransactionManager.rollback(transactionStatus);// 回滚
   }

   logger.info("readXlsCacheAsync---插入数据失败，事务回滚");
   throw new RuntimeException("readXlsCacheAsync---插入数据异常，异常事务回滚");
  }
 } catch (Exception e) {
  logger.error("readXlsCacheAsync---插入数据异常，事务回滚：", e);

  for (int i = 0; i < transactionStatusList.size(); i++) {
   TransactionStatus transactionStatus = transactionStatusList.get(i);
   dataSourceTransactionManager.rollback(transactionStatus);// 回滚
  }
  //connection.rollback();
  throw new RuntimeException("readXlsCacheAsync---插入数据异常，异常事务回滚");
 }
}

@Async("async-executor")
@Override
public Future<Integer> readXlsCacheAsyncMybatis(XSSFSheet sheet, 
            XSSFRow row, 
            int start, 
            int end, 
            StringBuilder insertBuilder,
            List<TransactionStatus> transactionStatusList,
  List<ReadAsyncFutureTransactionServiceImpl.TransactionResource> transactionResourceList) throws Exception {
  
 DefaultTransactionDefinition defaultTransactionDefinition = new DefaultTransactionDefinition();
 TransactionStatus transactionStatus = dataSourceTransactionManager.getTransaction(defaultTransactionDefinition);
 // 开启新事务
 transactionStatusList.add(transactionStatus);
 // copy事务资源
 transactionResourceList.add(ReadAsyncFutureTransactionServiceImpl.TransactionResource.copyTransactionResource());

 try {
  // 入库操作
 }catch (Exception e){
  throw new RuntimeException("readXlsCacheAsyncMybatis分批异步读取Excel，通过Mybatis插入数据库异常");
 }
}

/**
 * 保存当前事务资源,用于线程间的事务资源COPY操作
 * <p>
 * `@Builder`注解是Lombok库提供的一个注解,它可以用于自动生成Builder模式的代码,使用@Builder注解可以简化创建对象实例的过程,并且可以使代码更加清晰和易于维护
 */
static class TransactionResource {
    // TransactionSynchronizationManager类内部默认提供了下面六个ThreadLocal属性,分别保存当前线程对应的不同事务资源
    // 保存当前事务关联的资源,默认只会在新建事务的时候保存当前获取到的DataSource和当前事务对应Connection的映射关系
    // 当然这里Connection被包装为了ConnectionHolder
    // 事务结束后默认会移除集合中的DataSource作为key关联的资源记录
    private Map<Object, Object> resources;
    //下面五个属性会在事务结束后被自动清理,无需我们手动清理
    // 事务监听者,在事务执行到某个阶段的过程中,会去回调监听者对应的回调接口(典型观察者模式的应用),默认为空集合
    private Set<TransactionSynchronization> synchronizations;
    // 存放当前事务名字
    private String currentTransactionName;
    // 存放当前事务是否是只读事务
    private Boolean currentTransactionReadOnly;
    // 存放当前事务的隔离级别
    private Integer currentTransactionIsolationLevel;
    // 存放当前事务是否处于激活状态
    private Boolean actualTransactionActive;

    /**
     * 对事务资源进行复制
     *
     * @return TransactionResource
     */
    public static TransactionResource copyTransactionResource() {
        return TransactionResource.builder()
                //返回的是不可变集合
                .resources(TransactionSynchronizationManager.getResourceMap())
                //如果需要注册事务监听者,这里记得修改,我们这里不需要,就采用默认负责,spring事务内部默认也是这个值
                .synchronizations(new LinkedHashSet<>()).currentTransactionName(TransactionSynchronizationManager.getCurrentTransactionName()).currentTransactionReadOnly(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).currentTransactionIsolationLevel(TransactionSynchronizationManager.getCurrentTransactionIsolationLevel()).actualTransactionActive(TransactionSynchronizationManager.isActualTransactionActive()).build();
    }

    /**
     * 使用
     */
    public void autoWiredTransactionResource() {
        resources.forEach(TransactionSynchronizationManager::bindResource);
        //如果需要注册事务监听者,这里记得修改,我们这里不需要,就采用默认负责,spring事务内部默认也是这个值
        TransactionSynchronizationManager.initSynchronization();
        TransactionSynchronizationManager.setActualTransactionActive(actualTransactionActive);
        TransactionSynchronizationManager.setCurrentTransactionName(currentTransactionName);
        TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(currentTransactionIsolationLevel);
        TransactionSynchronizationManager.setCurrentTransactionReadOnly(currentTransactionReadOnly);
    }

    /**
     * 移除
     */
    public void removeTransactionResource() {
        // 事务结束后默认会移除集合中的DataSource作为key关联的资源记录
        // DataSource如果重复移除,unbindResource时会因为不存在此key关联的事务资源而报错
        resources.keySet().forEach(key -> {
            if (!(key instanceof DataSource)) {
                TransactionSynchronizationManager.unbindResource(key);
            }
        });
    }
}