如何实现Bloc间正确通信？Bloc(A)数据共享至Bloc(B)咨询

你的当前静态类方案虽然能实现数据共享，但存在几个明显缺陷：缺乏状态变更通知、易引发内存泄漏、单元测试难以Mock，不符合Bloc的响应式设计原则。下面是几种更合理的实现方式：

1. 共享Repository（推荐） #

将参与者数据的存储、获取逻辑抽离到共享Repository中，Bloc(A)和Bloc(B)都依赖这个Repository，保证数据来源单一且一致性。

示例代码：

// 共享的参与者Repository
class ParticipantRepository {
  List<Participant>? _participants;
  final _streamController = StreamController<List<Participant>>.broadcast();

  // 暴露数据变更流，供Bloc监听
  Stream<List<Participant>> get participantsStream => _streamController.stream;

  // Bloc(A)调用此方法存储数据
  void saveParticipants(List<Participant> participants) {
    _participants = participants;
    _streamController.add(participants);
  }

  // Bloc(B)调用此方法获取当前数据
  List<Participant>? getCurrentParticipants() => _participants;

  // 销毁资源
  void dispose() => _streamController.close();
}

Bloc(A)中使用：

// 通过依赖注入获取Repository实例
final participantRepo = getIt<ParticipantRepository>();

// 成功获取数据后保存并推送变更
if (dataState is DataSuccess) {
  List<Participant> participants = List<Participant>.from(j.map((e) => Participant.fromJson(e)));
  participantRepo.saveParticipants(participants);
  emit(ParticipantsLoaded(participants: participants));
}

Bloc(B)中监听并使用数据：

class ActionBloc extends Bloc<ActionEvent, ActionState> {
  final ParticipantRepository _participantRepo;
  late StreamSubscription _subscription;

  ActionBloc(this._participantRepo) : super(ActionInitial()) {
    // 监听参与者数据变更
    _subscription = _participantRepo.participantsStream.listen((participants) {
      add(UseParticipants(participants));
    });

    on<UseParticipants>((event, emit) async {
      // 使用参与者数据执行API操作
      final result = await yourApiService.doAction(event.participants);
      emit(ActionSuccess(result));
    });
  }

  @override
  Future<void> close() {
    _subscription.cancel();
    _participantRepo.dispose();
    return super.close();
  }
}

2. Bloc间状态监听 #

如果不想引入Repository，可以让Bloc(B)直接监听Bloc(A)的状态变化，依赖注入时确保Bloc(A)是单例实例。

示例代码：

class ActionBloc extends Bloc<ActionEvent, ActionState> {
  final GetParticipantsBloc _participantsBloc;
  late StreamSubscription _blocSubscription;

  ActionBloc(this._participantsBloc) : super(ActionInitial()) {
    // 监听Bloc(A)的状态变更
    _blocSubscription = _participantsBloc.stream.listen((state) {
      if (state is ParticipantsLoaded) {
        add(UseParticipants(state.participants));
      }
    });

    on<UseParticipants>((event, emit) async {
      // 执行API操作逻辑
      await apiCall(event.participants);
      emit(ActionCompleted());
    });
  }

  @override
  Future<void> close() {
    _blocSubscription.cancel();
    return super.close();
  }
}

3. 持久化全局状态（如HydratedBloc） #

如果数据需要跨页面持久化，可以使用hydrated_bloc将Bloc(A)的状态保存到本地，Bloc(B)直接读取该持久化状态。

示例代码（Bloc(A)配置Hydrated）：

class GetParticipantsBloc extends HydratedBloc<GetParticipantsEvent, GetParticipantsState> {
  GetParticipantsBloc() : super(Loading()) {
    on<LoadParticipants>(_onLoadParticipants);
  }

  void _onLoadParticipants(LoadParticipants event, Emitter<GetParticipantsState> emit) async {
    // 原有API调用逻辑...
    if (dataState is DataSuccess) {
      List<Participant> participants = List<Participant>.from(j.map((e) => Participant.fromJson(e)));
      emit(ParticipantsLoaded(participants: participants));
    }
  }

  // 从本地读取状态
  @override
  GetParticipantsState? fromJson(Map<String, dynamic> json) {
    if (json['participants'] != null) {
      final participants = List<Participant>.from(json['participants'].map((e) => Participant.fromJson(e)));
      return ParticipantsLoaded(participants: participants);
    }
    return Loading();
  }

  // 将状态保存到本地
  @override
  Map<String, dynamic>? toJson(GetParticipantsState state) {
    if (state is ParticipantsLoaded) {
      return {
        'participants': state.participants.map((e) => e.toJson()).toList(),
      };
    }
    return null;
  }
}

Bloc(B)中读取状态：

class ActionBloc extends Bloc<ActionEvent, ActionState> {
  final GetParticipantsBloc _participantsBloc;

  ActionBloc(this._participantsBloc) : super(ActionInitial()) {
    on<ExecuteAction>((event, emit) async {
      final currentState = _participantsBloc.state;
      if (currentState is ParticipantsLoaded) {
        await apiOperation(currentState.participants);
        emit(ActionSuccess());
      } else {
        emit(ActionFailure('参与者数据未加载'));
      }
    });
  }
}

总结 #

• 优先选择共享Repository，符合单一职责原则，易于测试和维护
• Bloc间直接通信适合简单场景，但需注意生命周期管理
• 持久化需求优先使用hydrated_bloc

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