Flutter Clean Architecture中分层与ChangeNotifier的合规性咨询

我正在Flutter应用中实现Clean Architecture，将其划分为domain、data、presentation三层：

• domain层：包含用例、实体和仓库接口
• data层：包含仓库实现、API接口及实现（数据源）
• presentation层：包含UI和Bloc

依赖流向为：Bloc → 用例 → 仓库 → 数据源

我遇到两种需要跨页面监听状态变更的场景：

1. 列表页跳转至注册页后返回，需动态刷新列表
2. 认证场景中，UserRepository存储已认证用户，希望用户认证状态变更时UI能动态更新

为此我将UserRepository实现为ChangeNotifier，在currentUser变更时通知监听器，并在UseCase中添加仓库的getter供Bloc订阅。但我担心该方案违反Clean Architecture原则，特此咨询：

• 此实现是否合规？
• 在Clean Architecture框架内处理此类场景的替代方案有哪些？

相关代码示例 #

class UserRepository extends ChangeNotifier implements IUserRepository {
  const UserRepository({
    required IUserApi userApi,
  }) : _userApi = userApi;

  final IUserApi _userApi;

  User? currentUser;

  Future<User> logIn(String token) async {
    try {
      final user = await _userApi.logIn(token);
      currentUser = user;
      
      notifyListeners();

      return user;
    } catch(e) {
      currentUser = null;
      notifyListeners();
      rethrow;
    }
  }
}

class GetUserUseCases {
  GetUserUseCases({
    required IUserRepository userRepository,
  }) : _user = userRepository;

  final IUserRepository _user;

  IUserRepository get userRepository => _user;

  Future<User> execute(String token) => _user.logIn(token);
}

class AuthBloc extends Bloc<AuthEvent, AuthState> {
  AuthBloc({
    required GetUserUseCases getUserUseCases,
  })  : _getUserUseCases = getUserUseCases,
        super(AuthStateInitial()) {
          on<AuthEventLoggedIn>(_onLogIn);
          on<AuthEventLoggedOut>(_onLogOut);
          // 其他事件订阅... 

          // 监听仓库变化，实时更新状态
          _getUserUseCases.userRepository.addListener(() {
            final repository = _getUserUseCases.userRepository as UserRepository;
            if (repository.currentUser != null) {
              add(AuthEventLoggedIn(repository.currentUser!));
            } else {
              add(const AuthEventLoggedOut());
            }
          });
        }

  final GetUserUseCases _getUserUseCases;

  // 事件处理方法...
  void _onLogIn(AuthEventLoggedIn event, Emitter<AuthState> emit) {
    emit(AuthStateLoggedIn(user: event.user));
  }

  void _onLogOut(AuthEventLoggedOut event, Emitter<AuthState> emit) {
    emit(const AuthStateLoggedOut());
  }
}

当前实现的合规性分析 #

你的方案确实存在违反Clean Architecture原则的问题：

1. domain层依赖泄露：UseCase中暴露仓库实例给Bloc，打破了"外层依赖内层，内层不感知外层"的分层规则，UseCase的职责应该仅为封装业务逻辑，而非作为仓库的传递通道。
2. 仓库职责越界：ChangeNotifier属于Flutter UI层组件，将data层的仓库实现为ChangeNotifier，相当于让内层依赖外层的具体实现，违反了依赖倒置原则——所有依赖应指向抽象而非具体类。
3. 状态流转不清晰：仓库直接通知Bloc变更状态，跳过了UseCase的业务逻辑校验，可能导致状态更新不符合业务规则。

Clean Architecture框架内的替代方案 #

方案1：让仓库返回流(Stream)而非使用ChangeNotifier

修改domain层的仓库接口，添加返回用户状态流的方法，data层实现该接口时使用StreamController管理状态：

domain层 - IUserRepository

abstract class IUserRepository {
  Future<User> logIn(String token);
  Stream<User?> watchCurrentUser(); // 添加状态监听流
}

data层 - UserRepository实现

class UserRepository implements IUserRepository {
  UserRepository({required IUserApi userApi}) : _userApi = userApi;

  final IUserApi _userApi;
  final _userController = BehaviorSubject<User?>(); // 保存最新状态的流

  @override
  Stream<User?> watchCurrentUser() => _userController.stream;

  @override
  Future<User> logIn(String token) async {
    try {
      final user = await _userApi.logIn(token);
      _userController.add(user);
      return user;
    } catch (e) {
      _userController.add(null);
      rethrow;
    }
  }

  // 释放资源避免内存泄漏
  void dispose() => _userController.close();
}

UseCase层：封装流的获取，不暴露仓库实例

class GetUserUseCases {
  GetUserUseCases({required IUserRepository userRepository}) : _userRepository = userRepository;

  final IUserRepository _userRepository;

  Future<User> logIn(String token) => _userRepository.logIn(token);
  Stream<User?> watchCurrentUser() => _userRepository.watchCurrentUser();
}

Bloc层：通过UseCase订阅流

class AuthBloc extends Bloc<AuthEvent, AuthState> {
  AuthBloc({required GetUserUseCases getUserUseCases}) 
    : _getUserUseCases = getUserUseCases,
      super(AuthStateInitial()) {
    on<AuthEventLoggedIn>(_onLogIn);
    on<AuthEventLoggedOut>(_onLogOut);

    // 订阅用户状态流
    _userSubscription = _getUserUseCases.watchCurrentUser().listen((user) {
      if (user != null) {
        add(AuthEventLoggedIn(user));
      } else {
        add(const AuthEventLoggedOut());
      }
    });
  }

  final GetUserUseCases _getUserUseCases;
  late StreamSubscription<User?> _userSubscription;

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

  // 事件处理方法...
}

方案2：使用Event Bus处理跨页面状态通知

对于跨页面的状态变更，可以通过Event Bus发送事件：

• 在domain层定义事件类（如UserAuthenticatedEvent、UserLoggedOutEvent）
• data层的仓库在状态变更时发送对应事件
• presentation层的Bloc订阅这些事件，更新自身状态

这种方式适合简单的跨页面状态通知，避免直接依赖问题。

方案3：Bloc间状态共享（列表页刷新场景）

对于列表页跳转注册页返回刷新的场景：

• 列表页Bloc初始化时订阅用户注册成功事件（通过Event Bus或全局Bloc）
• 注册页完成注册后发送事件，列表页Bloc收到事件后触发重新获取数据的用例

也可以使用RepositoryProvider配合Stream，让列表页Bloc直接监听数据源变化。

核心原则总结 #

无论选择哪种方案，都要遵守Clean Architecture的核心规则：

• 依赖倒置：所有依赖都指向抽象（domain层的接口）
• 分层清晰：内层（domain）不依赖外层（data/presentation），外层仅依赖内层抽象
• 单一职责：仓库只负责数据获取和存储，状态通知通过抽象的流或事件实现，不绑定具体UI层组件

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