Flutter中的RxJava，链式执行代码块ChainExecutor

其实flutter中已提供了链式调用的实现方式，我只是为了业务需求，再次进行了封装与定制

我们先看看flutter中原生是如何实现链式调用的：

Future((){
    //做一些事情
    return "返回一些值";
}).then((value){
    //Future中返回的值。
    print(value);//输出：返回一些值
    //做一些事情
    return "再返回一些值";
}).then((value){
    //输入上一个处理返回过来的值
    print(value);//输出：再返回一些值
});

上面的这一实现，也非常简洁方便。我们由于业务需要，自己封装了ChainExecutor来实现链式调用，运用了单例模式，可以终端链，有返回值，废话不多说，直接上代码：

import 'dart:ui';

///链式执行代码块
///方法调用用顺序[onOpen]||[onClose]||[add]->[execute]->如需要手动停止则调用[stop]
///[onOpen]||[onClose]||[add]必须在[execute]之前调用
///[add]可多次调用添加任务，遵循先进先出的原则
///调用[execute]时会回调[onOpen]
///无论是自动停止或者手动停止，都会调用[onClose]
class ChainExecutor {
  ///是否开启了执行线程
  bool _isOpen = false;

  ///执行队列
  final List<Chain> _queueChain = [];

  VoidCallback? _closeCallBack;
  VoidCallback? _openCallBack;

  Chain? _tempChain;
  dynamic _tempData;

  ChainExecutor._internal();

  factory ChainExecutor() => _instance;
  static final ChainExecutor _instance = ChainExecutor._internal();

  ///开启执行线程
  onOpen(VoidCallback openCallBack) {
    _openCallBack = openCallBack;
  }

  ///所有任务执行完成关闭执行线程
  onClose(VoidCallback closeCallBack) {
    _closeCallBack = closeCallBack;
  }

  ///添加需要执行的任务到执行线程
  add(Chain chain) {
    _queueChain.add(chain);
  }

  ///开始执行
  execute() {
    _isOpen = true;
    _openCallBack?.call();
    _executor().then((value) {
      if (value) {
        _closeCallBack?.call();
      }
    });
  }

  ///主动停止
  ///终止执行
  ///界面退出时需要调用该方法，否者会内存溢出
  stop() {
    _isOpen = false;
  }

  Future<bool> _executor() async {
    return Future(() async {
      while (_isOpen) {
        if (_isOpen) {
          if (_queueChain.isNotEmpty &&
              (_tempChain == null || _tempChain!.isFinished())) {
            _tempChain = _queueChain.removeAt(0);
            if (!_tempChain!.isFinished()) {
              _tempChain!.execute(_tempData);
              _tempData = _tempChain!.data;
            }
          }
        }
        //退出条件
        if ((!_isOpen) ||
            (_isOpen &&
                _queueChain.isEmpty &&
                (_tempChain == null || _tempChain!.isFinished()))) {
          break;
        }
        await Future.delayed(const Duration(milliseconds: 50));
      }
      return true;
    });
  }
}

///执行一些代码，不管是异步还是同步，执行完成后调用[Chain]的[finish]方法才会执行下一个[Chain]
///可以往下一个Chain传递参数调用[Chain]中的[sendData]
///或者可以接收上一个Chain传递过来的参数调用[Chain]中的[receiveData]
class Chain {
  dynamic data;

  final dynamic Function(Chain chain,dynamic data) callback;

  Chain(this.callback);

  ///任务是否执行完毕
  ///创建[Chain]相当于就开启了一个无限循环的任务一直等待该任务执行完毕
  ///用户需要在任务完成时主动调用[finish]结束任务
  bool _finished = false;

  ///用户任务实际执行的方法
  execute(dynamic data) {
    this.data=callback.call(this,data);
  }

  ///用户主动结束任务执行
  finish() {
    _finished = true;
  }

  isFinished() {
    return _finished;
  }
}

/// 测试类
class Test {
  test() {
    ChainExecutor._instance
      ..onOpen(() {
        ///执行前做什么事情
      })
      ..onClose(() {
        ///执行完毕做什么事情
      })
      ..add(Chain((chain,data) {
        ///do some thing
        ///执行一些代码，不管是异步还是同步，执行完成后调用[Chain]的[finish]方法才会执行下一个[Chain]
        ///可以往下一个Chain传递参数调用[Chain]中的[sendData]
        ///或者可以接收上一个Chain传递过来的参数调用[Chain]中的[receiveData]
      }))
      ..add(Chain((chain,data) {
        ///do some thing
      }))
      ..execute();
  }
}

代码中的注释非常多，用得着的可以直接复制粘贴便可使用，使用方法也很简单：

执行结果：