Flutter中Riverpod两个StateProvider如何通信（不使用构造器传Ref）

方案一：直接监听目标Provider的状态变化 #

通过在SomeClass_Two的StateNotifierProvider创建逻辑中，监听SomeClass_ONE的状态变更，触发methodTwo。这种方式无需修改StateNotifier的构造器，完全符合团队规范。

代码示例 #

// SomeClass_ONE的定义
class SomeClassOne extends StateNotifier<int> {
  SomeClassOne() : super(0);

  void methodOne() {
    // 执行业务逻辑并更新状态
    state += 1;
  }
}

final someClassOneProvider = StateNotifierProvider<SomeClassOne, int>((ref) {
  return SomeClassOne();
});

// SomeClass_Two的定义
class SomeClassTwo extends StateNotifier<String> {
  SomeClassTwo() : super("初始状态");

  void methodTwo() {
    // 更新自身状态的逻辑
    state = "已响应methodOne: ${DateTime.now().toLocal()}";
  }
}

final someClassTwoProvider = StateNotifierProvider<SomeClassTwo, String>((ref) {
  final twoNotifier = SomeClassTwo();
  
  // 监听SomeClassOne的状态变化
  ref.listen<int>(someClassOneProvider, (prevState, currState) {
    // 可根据需要判断状态变化是否由methodOne触发
    if (currState != prevState) {
      twoNotifier.methodTwo();
    }
  });
  
  return twoNotifier;
});

适用场景 #

• 两个Provider的状态关联紧密，仅需在SomeClass_ONE状态变更时触发SomeClass_Two的逻辑。
• 不需要区分状态变更的触发源（如果需要区分，可在SomeClass_ONE的状态中增加标识字段）。

方案二：通过事件总线解耦通信 #

引入一个全局事件总线，SomeClass_ONE在methodOne执行后发送事件，SomeClass_Two在其Provider创建逻辑中监听事件并执行methodTwo。这种方式解耦性更强，适合跨多个组件/Provider的通信场景。

代码示例 #

// 定义事件总线
class MethodOneEventBus {
  final _controller = StreamController<void>.broadcast();

  // 发送事件
  void trigger() => _controller.add(null);
  
  // 监听事件流
  Stream<void> get stream => _controller.stream;

  void dispose() => _controller.close();
}

// 提供事件总线的Provider
final methodOneEventBusProvider = Provider<MethodOneEventBus>((ref) {
  final bus = MethodOneEventBus();
  ref.onDispose(bus.dispose);
  return bus;
});

// SomeClass_ONE的定义
class SomeClassOne extends StateNotifier<int> {
  SomeClassOne() : super(0);
  Ref? _ref;

  // 初始化时由Provider注入Ref（非构造器传入）
  void setRef(Ref ref) => _ref = ref;

  void methodOne() {
    state += 1;
    // 发送事件通知
    _ref?.read(methodOneEventBusProvider).trigger();
  }
}

final someClassOneProvider = StateNotifierProvider<SomeClassOne, int>((ref) {
  final oneNotifier = SomeClassOne();
  oneNotifier.setRef(ref);
  return oneNotifier;
});

// SomeClass_Two的定义
class SomeClassTwo extends StateNotifier<String> {
  SomeClassTwo() : super("初始状态");

  void methodTwo() {
    state = "已响应methodOne事件: ${DateTime.now().toLocal()}";
  }
}

final someClassTwoProvider = StateNotifierProvider<SomeClassTwo, String>((ref) {
  final twoNotifier = SomeClassTwo();
  
  // 监听事件总线
  ref.listen<MethodOneEventBus>(methodOneEventBusProvider, (_, bus) {
    bus.stream.listen((_) {
      twoNotifier.methodTwo();
    });
  });
  
  return twoNotifier;
});

适用场景 #

• 需要跨多个Provider或组件响应methodOne的执行。
• 希望避免两个Provider之间直接依赖，保持低耦合。

补充：区分methodOne触发的状态变更 #

如果需要仅在methodOne执行时触发methodTwo（而非SomeClass_ONE的其他方法），可以给SomeClass_ONE的状态增加标识字段：

class OneState {
  final int count;
  final bool isFromMethodOne;

  OneState({required this.count, this.isFromMethodOne = false});
}

class SomeClassOne extends StateNotifier<OneState> {
  SomeClassOne() : super(OneState(count: 0));

  void methodOne() {
    state = OneState(count: state.count + 1, isFromMethodOne: true);
  }

  void otherMethod() {
    state = OneState(count: state.count + 1, isFromMethodOne: false);
  }
}

// 在SomeClass_Two的Provider中监听时判断
ref.listen<OneState>(someClassOneProvider, (_, currState) {
  if (currState.isFromMethodOne) {
    twoNotifier.methodTwo();
  }
});

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