Flutter无依赖实现Stateful组件实例化通知方案咨询

需求：在独立对象中监听Stateful组件的实例化/生命周期启动事件，目前通过自定义EventBus实现，希望替换为Flutter框架内置方案（零依赖、无第三方包）。试过StreamController但不符合场景，也考虑过通过Key获取实例的思路，现有实现代码如下：

现有实现代码 #

Foo组件 #

class Foo extends StatefulWidget {
  const Foo({super.key});

  @override
  State<FooState> createState() => _FooState();
}

class _FooState extends State<Foo> {
  @override
  void initState() {
    super.initState();
    EventBus().dispatch("MOUNTED", this);
  }
}

Bar组件 #

class Bar extends StatefulWidget {
  const Bar({super.key});

  @override
  State<BarState> createState() => _BarState();
}

class _BarState extends State<Bar> {
  @override
  void initState() {
    super.initState();
    EventBus().dispatch("MOUNTED", this);
  }
}

待移除的EventBus实现 #

class EventBus {
  static final EventBus _instance = EventBus._internal();

  factory EventBus() {
    return _instance;
  }

  EventBus._internal();

  final Map<String, List<void Function(dynamic sender)>> _listeners = {};

  void subscribe(String event, void Function(dynamic sender) callback) {
    if (_listeners[event] == null) {
      _listeners[event] = [];
    }
    _listeners[event]!.add(callback);
  }

  void unsubscribe(String event, void Function(dynamic sender) callback) {
    _listeners[event]?.remove(callback);
  }

  void dispatch(String event, dynamic sender) {
    if (_listeners[event] != null) {
      for (var callback in _listeners[event]!) {
        callback(sender);
      }
    }
  }
}

独立监听对象Isolated #

class Isolated {
  void startup() {
    EventBus().subscribe("MOUNTED", OnMount);
    // 发散思考：或许可以从框架中获取Keys
  }

  void OnMount(dynamic sender) { // 当Foo或Bar实例化时
    // 可在此判断sender是`Foo`还是`Bar`
  }
}

框架内置替代方案 #

方案1：优化版全局StreamController #

如果之前用StreamController不符合场景，大概率是没做好单例和订阅管理。下面用Flutter内置的StreamController实现完全等价于EventBus的功能，零依赖：

// 全局广播StreamController，替代EventBus
final componentLifecycleStream = StreamController<ComponentMountEvent>.broadcast();

// 封装事件类，明确传递数据类型
class ComponentMountEvent {
  final State sender;
  ComponentMountEvent(this.sender);
}

// 修改Foo/Bar的initState，发送事件
class _FooState extends State<Foo> {
  @override
  void initState() {
    super.initState();
    componentLifecycleStream.add(ComponentMountEvent(this));
  }

  @override
  void dispose() {
    // 可选：需要监听销毁时，在此发送销毁事件
    super.dispose();
  }
}

// 修改Isolated订阅Stream
class Isolated {
  StreamSubscription? _subscription;

  void startup() {
    _subscription = componentLifecycleStream.listen((event) {
      OnMount(event.sender);
    });
  }

  void OnMount(dynamic sender) {
    if (sender is _FooState) {
      // 处理Foo挂载逻辑
    } else if (sender is _BarState) {
      // 处理Bar挂载逻辑
    }
  }

  // 务必在不需要监听时取消订阅，避免内存泄漏
  void shutdown() {
    _subscription?.cancel();
  }
}

方案2：通过GlobalKey追踪组件实例 #

利用Flutter的GlobalKey可以直接获取组件State实例的特性，实现监听：

// 全局维护组件对应的GlobalKey
final Map<Type, GlobalKey> componentKeys = {
  Foo: GlobalKey<_FooState>(),
  Bar: GlobalKey<_BarState>(),
};

// 修改Foo组件的构造，绑定GlobalKey
class Foo extends StatefulWidget {
  const Foo({super.key = const GlobalKey<_FooState>()});

  @override
  State<FooState> createState() => _FooState();
}

// Isolated中通过WidgetsBinding检查组件是否挂载
class Isolated {
  void startup() {
    // 监听第一帧绘制完成，此时组件已挂载
    WidgetsBinding.instance.addPostFrameCallback((_) {
      checkComponentMounted();
    });
    // 可选：监听路由变化，实时检查组件状态
    WidgetsBinding.instance.addObserver(RouteObserver());
  }

  void checkComponentMounted() {
    final fooKey = componentKeys[Foo] as GlobalKey<_FooState>?;
    if (fooKey?.currentState != null) {
      OnMount(fooKey!.currentState!);
    }

    final barKey = componentKeys[Bar] as GlobalKey<_BarState>?;
    if (barKey?.currentState != null) {
      OnMount(barKey!.currentState!);
    }
  }

  void OnMount(dynamic sender) {
    // 处理组件挂载逻辑
  }
}

方案3：使用InheritedWidget传递回调 #

如果Isolated和Widget树存在关联，可以用Flutter内置的InheritedWidget将回调注入到组件树中，让组件在initState时主动调用：

// 定义InheritedWidget，传递挂载回调
class LifecycleListener extends InheritedWidget {
  final void Function(State) onComponentMount;

  const LifecycleListener({
    super.key,
    required this.onComponentMount,
    required super.child,
  });

  static LifecycleListener? of(BuildContext context) {
    return context.dependOnInheritedWidgetOfExactType<LifecycleListener>();
  }

  @override
  bool updateShouldNotify(LifecycleListener oldWidget) {
    return oldWidget.onComponentMount != onComponentMount;
  }
}

// 修改Foo的initState，调用回调
class _FooState extends State<Foo> {
  @override
  void initState() {
    super.initState();
    final listener = LifecycleListener.of(context);
    listener?.onComponentMount(this);
  }
}

// Isolated作为回调提供者，将回调注入Widget树
class Isolated {
  void startup(BuildContext context) {
    // 示例：通过路由注入LifecycleListener
    Navigator.of(context).push(MaterialPageRoute(
      builder: (context) => LifecycleListener(
        onComponentMount: OnMount,
        child: const Foo(), // 包含Foo/Bar的页面
      ),
    ));
  }

  void OnMount(dynamic sender) {
    // 处理组件挂载逻辑
  }
}

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