Flutter Bloc：如何确保多个Bloc完成API请求初始化？

针对登录后需要初始化多个Bloc并确保全部完成API调用的场景，以下是几种比本地变量检查更简洁的实现方案：

方案一：通过流合并监听所有Bloc状态 #

利用CombineLatestStream（可通过rxdart或dart官方async包实现）将多个Bloc的状态流合并，当所有流都达到目标加载完成状态时，触发后续逻辑。

代码示例（使用rxdart）： #

import 'package:rxdart/rxdart.dart';

void initBlocsAfterLogin() {
  // 触发各Bloc的加载事件
  userBloc.add(FetchUserEvent());
  settingsBloc.add(FetchSettingsEvent());
  notificationsBloc.add(FetchNotificationsEvent());

  // 合并三个Bloc的状态流，判断是否全部加载完成
  CombineLatestStream.combine3(
    userBloc.stream,
    settingsBloc.stream,
    notificationsBloc.stream,
    (UserState userState, SettingsState settingsState, NotificationsState notifyState) => 
      userState is UserLoaded && settingsState is SettingsLoaded && notifyState is NotificationsLoaded,
  ).listen((allLoaded) {
    if (allLoaded) {
      // 所有Bloc数据加载完成，执行后续操作（如跳转主页、隐藏加载弹窗）
      print('所有Bloc初始化完成');
    }
  });
}

若不想引入rxdart，可使用dart官方package:async/async.dart中的CombineLatestStream，用法基本一致。

方案二：封装初始化管理类统一处理 #

创建专门的管理类，负责维护所有需要初始化的Bloc及其完成状态，将状态检查逻辑封装起来，避免在页面中分散处理。

代码示例： #

import 'package:flutter_bloc/flutter_bloc.dart';
import 'dart:async';

class BlocInitManager {
  final List<Bloc> _blocs;
  final List<Type> _targetLoadedStates;
  final Set<int> _completedBlocIndexes = {};
  VoidCallback? _onAllCompleted;

  BlocInitManager(this._blocs, this._targetLoadedStates) {
    assert(_blocs.length == _targetLoadedStates.length, "Bloc数量需与目标状态数量一致");
    _setupBlocListeners();
  }

  void _setupBlocListeners() {
    for (int i = 0; i < _blocs.length; i++) {
      _blocs[i].stream.listen((state) {
        if (state.runtimeType == _targetLoadedStates[i] && !_completedBlocIndexes.contains(i)) {
          _completedBlocIndexes.add(i);
          _checkIfAllCompleted();
        }
      });
    }
  }

  void _checkIfAllCompleted() {
    if (_completedBlocIndexes.length == _blocs.length) {
      _onAllCompleted?.call();
    }
  }

  void setOnAllCompleted(VoidCallback callback) {
    _onAllCompleted = callback;
  }
}

// 使用方式
void initBlocs() {
  final targetBlocs = [userBloc, settingsBloc, notificationsBloc];
  final targetStates = [UserLoaded, SettingsLoaded, NotificationsLoaded];

  final initManager = BlocInitManager(targetBlocs, targetStates);
  initManager.setOnAllCompleted(() {
    // 所有Bloc初始化完成，执行后续逻辑
    print('全部Bloc加载完成');
  });

  // 触发各Bloc的加载事件
  targetBlocs.forEach((bloc) => bloc.add(FetchDataEvent()));
}

后续新增需要初始化的Bloc时，只需添加到targetBlocs和targetStates列表即可，无需修改检查逻辑，复用性强。

方案三：使用MultiBlocListener集中监听 #

通过MultiBlocListener统一管理多个Bloc的状态监听，用计数器统计完成数量，达到总数时触发后续操作。

代码示例： #

import 'package:flutter_bloc/flutter_bloc.dart';

int _completedBlocCount = 0;
final _totalInitBlocs = 3;

void _handleBlocCompleted() {
  _completedBlocCount++;
  if (_completedBlocCount == _totalInitBlocs) {
    // 所有Bloc初始化完成
    print('全部加载完成');
    _completedBlocCount = 0; // 重置计数器，避免重复触发
  }
}

// 在页面的build方法中
@override
Widget build(BuildContext context) {
  return MultiBlocListener(
    listeners: [
      BlocListener<UserBloc, UserState>(
        listener: (context, state) {
          if (state is UserLoaded) _handleBlocCompleted();
        },
      ),
      BlocListener<SettingsBloc, SettingsState>(
        listener: (context, state) {
          if (state is SettingsLoaded) _handleBlocCompleted();
        },
      ),
      BlocListener<NotificationsBloc, NotificationsState>(
        listener: (context, state) {
          if (state is NotificationsLoaded) _handleBlocCompleted();
        },
      ),
    ],
    child: Scaffold(
      body: Center(child: CircularProgressIndicator()), // 加载中UI
    ),
  );
}

// 登录成功后触发加载
userBloc.add(FetchUserEvent());
settingsBloc.add(FetchSettingsEvent());
notificationsBloc.add(FetchNotificationsEvent());

这种方案将监听逻辑集中在一处，比分散的本地变量更整洁，适合简单场景。

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