Dart中终止Promise链式调用的最佳实现方案及回滚逻辑处理

好问题！在Dart里处理这类可取消的异步业务流程，确实有几种比全局布尔变量更优雅的方案，我来给你拆解一下：

1. 原生CancelableOperation + 步骤跟踪（推荐） #

你提到的CancelableOperation其实是原生dart:async提供的非常合适的方案，结合步骤跟踪就能完美实现回滚逻辑。核心思路是：用CancelableOperation包装整个流程，同时跟踪当前执行到的步骤，取消时根据当前步骤反向执行回滚操作。

先定义一个枚举来标记步骤，方便跟踪和回滚：

enum ProcessStep {
  authenticate,
  checkLicence,
  registerDevice,
  createDatabaseOnServer,
  waitForDatabase,
  downloadDatabase,
  notifyDatabaseDownloaded,
}

然后实现流程和取消逻辑：

ProcessStep? _currentStep;
late CancelableOperation<void> _cancelableOperation;

void startProcess(String login, String password) {
  _cancelableOperation = CancelableOperation.fromFuture(
    Future.doWhile(() async {
      switch (_currentStep) {
        case null:
          _currentStep = ProcessStep.authenticate;
          await authenticate(login, password);
          break;
        case ProcessStep.authenticate:
          _currentStep = ProcessStep.checkLicence;
          await checkLicence();
          break;
        case ProcessStep.checkLicence:
          _currentStep = ProcessStep.registerDevice;
          await registerDevice();
          break;
        case ProcessStep.registerDevice:
          _currentStep = ProcessStep.createDatabaseOnServer;
          await createDatabaseOnServer();
          break;
        case ProcessStep.createDatabaseOnServer:
          _currentStep = ProcessStep.waitForDatabase;
          await waitForDatabase();
          break;
        case ProcessStep.waitForDatabase:
          _currentStep = ProcessStep.downloadDatabase;
          await downloadDatabase();
          break;
        case ProcessStep.downloadDatabase:
          _currentStep = ProcessStep.notifyDatabaseDownloaded;
          await notifyDatabaseDownloaded();
          return false; // 结束流程循环
        default:
          return false;
      }
      return true;
    }),
    onCancel: () {
      // 取消时触发回滚
      _rollback(_currentStep);
    },
  );
}

// 触发取消操作
void cancelProcess() {
  _cancelableOperation.cancel();
}

// 根据当前步骤执行反向回滚
void _rollback(ProcessStep? step) {
  switch (step) {
    case ProcessStep.downloadDatabase:
      // 回滚：删除本地下载的数据库文件
      deleteLocalDatabase();
      break;
    case ProcessStep.createDatabaseOnServer:
      // 回滚：调用接口删除服务器上创建的数据库
      deleteDatabaseOnServer();
      break;
    case ProcessStep.registerDevice:
      // 回滚：注销已注册的设备
      unregisterDevice();
      break;
    case ProcessStep.authenticate:
      // 回滚：执行登出操作
      logout();
      break;
    // 其他步骤如果需要回滚可以继续补充
    default:
      break;
  }
}

这个方案的优势：

• 原生API支持，无需引入第三方包
• 取消逻辑和回滚逻辑集中管理，代码更整洁
• onCancel回调会可靠触发，不会遗漏取消操作

2. 使用CancellationToken第三方包 #

如果希望更灵活地在异步步骤中间检查取消状态，可以使用package:cancellation_token这个轻量包。它提供了可传递的取消令牌，每个步骤只需检查令牌是否已取消，就能终止流程并触发回滚。

首先添加依赖：

dependencies:
  cancellation_token: ^2.0.0

然后实现流程：

final CancellationToken _cancellationToken = CancellationToken();
ProcessStep? _currentStep;

// 修改每个步骤函数，接受CancellationToken参数
Future<void> authenticate(String login, String password, CancellationToken token) async {
  token.throwIfCancellationRequested(); // 执行前检查取消
  // 原有认证逻辑...
  await someAsyncAuthCall();
  token.throwIfCancellationRequested(); // 异步操作后再次检查
}

Future<void> runProcess(String login, String password) async {
  try {
    _currentStep = ProcessStep.authenticate;
    await authenticate(login, password, _cancellationToken);
    
    _currentStep = ProcessStep.checkLicence;
    await checkLicence(_cancellationToken);
    
    // 依次执行后续步骤...
  } on CancelledException catch (_) {
    // 捕获取消异常，执行回滚
    _rollback(_currentStep);
  }
}

void cancelProcess() {
  _cancellationToken.cancel();
}

// 回滚逻辑和之前一致
void _rollback(ProcessStep? step) {
  // ...省略回滚代码
}

这个方案的优势：

• 可以在异步操作的任意阶段检查取消，粒度更细
• 令牌传递式的设计，代码侵入性比全局变量小很多
• 异常捕获的方式更符合Dart异步编程习惯

3. Stream封装步骤流 #

如果你的流程步骤较多，也可以用Stream来封装每个步骤的执行，通过取消Stream订阅来终止流程，同时跟踪当前步骤实现回滚：

ProcessStep? _currentStep;
late StreamSubscription<ProcessStep> _processSubscription;

Stream<ProcessStep> _processStream(String login, String password) async* {
  yield ProcessStep.authenticate;
  await authenticate(login, password);
  
  yield ProcessStep.checkLicence;
  await checkLicence();
  
  // 依次执行后续步骤...
}

void startProcess(String login, String password) {
  _processSubscription = _processStream(login, password).listen(
    (step) => _currentStep = step,
    onDone: () {
      // 流程完成后的收尾操作
    },
    onError: (e) {
      // 处理流程中的错误
    },
  );
}

void cancelProcess() {
  _processSubscription.cancel();
  _rollback(_currentStep);
}

这个方案的优势是步骤状态通过Stream事件直观传递，取消操作就是取消订阅，逻辑非常清晰，适合复杂的多步骤流程。

对比你的初始方案 #

你提到的全局布尔变量方案，虽然实现简单，但存在几个明显的问题：

• 全局变量容易引发竞态条件（尤其是涉及Isolate多线程场景时）
• 每个步骤都要插入取消判断，代码侵入性强，维护成本高
• 回滚逻辑容易分散在各个步骤中，难以统一管理

而上面的几种方案都能很好地解决这些问题，让取消和回滚逻辑更结构化、更易于维护。

内容的提问来源于stack exchange，提问作者nicearma