Flutter中如何将流事件接入Bloc并实现认证路由跳转？

代码中的核心问题 #

1. UserService内存泄漏风险：构造函数内的_subscription是局部变量，未赋值给类成员，导致无法在销毁时取消订阅。
2. AuthBloc事件处理错误：直接调用mapEventToState而非通过add方法触发事件，且unauthenticated分支错误传递了authenticated事件；未管理订阅的生命周期。
3. GoRouter路由跳转逻辑缺陷：初始状态直接跳转注册页，未等待Firebase认证状态返回；未监听Bloc状态变化，无法自动触发路由重定向。
4. Bloc API使用过时：仍使用已弃用的mapEventToState，新版本Bloc推荐使用on方法绑定事件处理。

修复后的代码实现 #

1. UserService 修复 #

enum AuthEventEnum { authenticated, unauthenticated }

class UserService {
  final StreamController<AuthEventEnum> _controller = StreamController<AuthEventEnum>.broadcast();
  late final StreamSubscription _subscription;

  Stream<AuthEventEnum> get authEvents => _controller.stream;

  UserService() {
    // 正确赋值类成员_subscription
    _subscription = FirebaseAuth.instance.authStateChanges().listen((User? user) {
      if (user == null) {
        _controller.sink.add(AuthEventEnum.unauthenticated);
      } else {
        _controller.sink.add(AuthEventEnum.authenticated);
      }
    });
  }

  // 添加销毁方法，取消订阅并关闭流
  void dispose() {
    _subscription.cancel();
    _controller.close();
  }
}

2. AuthBloc 修复（使用新版Bloc API） #

// 先定义AuthState
abstract class AuthState {}
class AuthInitial extends AuthState {}
class AuthAuthenticatedState extends AuthState {}
class AuthUnauthenticatedState extends AuthState {}

class AuthBloc extends Bloc<AuthEventEnum, AuthState> {
  final UserService _userService;
  late final StreamSubscription _authSubscription;

  AuthBloc(this._userService) : super(AuthInitial()) {
    // 监听UserService的流，向Bloc添加事件
    _authSubscription = _userService.authEvents.listen((event) {
      add(event);
    });

    // 使用on方法绑定事件与状态转换
    on<AuthEventEnum>((event, emit) {
      if (event == AuthEventEnum.authenticated) {
        emit(AuthAuthenticatedState());
      } else if (event == AuthEventEnum.unauthenticated) {
        emit(AuthUnauthenticatedState());
      }
    });
  }

  // 重写close方法，清理订阅
  @override
  Future<void> close() {
    _authSubscription.cancel();
    return super.close();
  }
}

3. AppRouter 修复（支持Bloc状态监听） #

class AppRouter {
  final AuthBloc authBloc;
  late final GoRouter routes;

  AppRouter({required this.authBloc}) {
    routes = GoRouter(
      initialLocation: '/',
      redirect: (context, state) {
        final authState = authBloc.state;
        // 初始状态等待认证结果，不跳转
        if (authState is AuthInitial) {
          return null;
        }
        // 已认证 -> 跳转到应用主页（避免重复跳转）
        if (authState is AuthAuthenticatedState) {
          return state.location == '/app' ? null : '/app';
        }
        // 未认证 -> 跳转到注册页（避免重复跳转）
        if (authState is AuthUnauthenticatedState) {
          return state.location == '/register' ? null : '/register';
        }
        return null;
      },
      // 监听Bloc状态变化，触发重定向
      refreshListenable: GoRouterRefreshStream(authBloc.stream),
      routes: [
        GoRoute(
          path: '/',
          builder: (context, state) => const SplashScreen(), // 可选：添加启动页等待认证
        ),
        GoRoute(
          path: '/login',
          builder: (context, state) => const LoginPage(),
        ),
        GoRoute(
          path: '/register',
          builder: (context, state) => const RegisterPage(),
        ),
        GoRoute(
          path: '/app',
          builder: (context, state) => const AppPage(),
        ),
      ],
    );
  }
}

// 自定义GoRouter的RefreshListenable，监听Bloc流
class GoRouterRefreshStream extends ChangeNotifier {
  GoRouterRefreshStream(Stream<dynamic> stream) {
    _subscription = stream.listen((_) => notifyListeners());
  }

  late final StreamSubscription _subscription;

  @override
  void dispose() {
    _subscription.cancel();
    super.dispose();
  }
}

4. main函数 修复（管理UserService生命周期） #

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp(
    options: DefaultFirebaseOptions.currentPlatform,
  );
  final userService = UserService();
  final authBloc = AuthBloc(userService);

  runApp(
    BlocProvider.value(
      value: authBloc,
      child: MaterialApp.router(
        title: 'flutter demo',
        theme: ThemeData(primarySwatch: Colors.blue),
        routerConfig: AppRouter(authBloc: authBloc).routes,
      ),
    ),
  );
}

Bloc与流的协作原理 #

1. Bloc核心机制：Bloc通过add方法接收事件，通过on方法（或旧版mapEventToState）将事件转换为状态，状态流通过stream对外暴露。
2. 监听外部流触发Bloc事件：在Bloc构造函数中订阅外部流（如Firebase的authStateChanges或自定义流），当流发出数据时调用add方法将数据转为Bloc事件，触发状态转换。
3. 流生命周期管理：必须在Bloc的close方法中取消外部流订阅，自定义流控制器需在销毁时关闭，避免内存泄漏。
4. 路由与Bloc状态联动：通过自定义GoRouterRefreshStream监听Bloc状态流，状态变化时通知GoRouter执行重定向，实现自动路由跳转。

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