Flutter核心功能扩展插件spread_core的使用

Flutter核心功能扩展插件spread_core的使用

spread_core库简化了Dart应用程序的状态管理。通过实体（entities）、订阅者（subscribers）和状态发射器（state emitters），开发者可以轻松地存储、观察和操作状态，而无需编写大量的样板代码。

概述

spread_core库提供了在Dart应用程序中管理状态的简化方法。通过使用实体（entities）、订阅者（subscribers）和状态发射器（state emitters），开发者能够更方便地存储、观察和操作状态。

特性

• 状态管理：使用标识符、类型或实体存储状态数据。类似于具有可观察事件的键值映射。
• 观察者：订阅特定的状态变化并作出相应反应。
• 状态发射器：一种混合（mixin）方式，根据类型、名称或实体发出状态变化。
• 用例：通过UseCase类抽象业务逻辑或领域逻辑。
• 实体：将UI更改订阅到一个由类型和ID识别的具体对象实例。

开始使用

安装

在你的pubspec.yaml文件中添加以下依赖：

dependencies:
   spread_core: ^0.0.6

然后运行：

pub get

基本使用

定义一个状态实体：

import 'package:spread_core/spread_core.dart';

class User implements Entity {
  final String id;
  final String name;

  User({required this.id, required this.name});

  [@override](/user/override)
  String get entityId => id;
}

定义一个类型化的实体：

import 'user.dart';

abstract class UsersState {}

class LoadingUsers extends UsersState {}

class LoadedUsersSuccess extends UsersState {
  final List<User> users;

  LoadedUsersSuccess({required this.users});
}

class LoadedUsersFail extends UsersState {
  final Object? error;
  final StackTrace? stackTrace;

  LoadedUsersFail({required this.error, required this.stackTrace});
}

发射状态

使用StateEmitter混合：

import 'package:spread_core/spread_core.dart';

class UserManager with StateEmitter {

  void updateUser(User user) {
    emitEntity<User>(user); // 发射用户状态更新
  }
}

观察状态

扩展自SpreadObserver：

import 'package:spread_core/spread_core.dart';

class UserObserver extends SpreadObserver {

  [@override](/user/override)
  void onState(User user) {
    print('User updated: ${user.name}'); // 打印用户更新信息
  }
}

示例代码

以下是一个完整的示例代码，展示了如何使用spread_core库进行状态管理。

import 'dart:math';

import 'package:spread_core/spread_core.dart';

void main() async {
  await initServices(); // 初始化服务
  await initObservers(); // 初始化观察者
  LoadUsersUseCase().execute(); // 执行加载用户用例
}

Future initServices() async {
  Services()
      .init(userService: () => UserServiceImpl(repository: PostsApiPort()));
}

Future initObservers() async {
  UsersObserver().selfRegister(); // 注册用户观察者
}

// 我们的端口：

abstract class PostsPort {
  Future<List<User>> findAllUsers();
}

class PostsApiPort implements PostsPort {
  Random random = Random();

  [@override](/user/override)
  Future<List<User>> findAllUsers() async {
    final id = random.nextInt(1000);
    return Future.delayed(
        const Duration(seconds: 2),
        () => [
              User(id: id, name: "aaaa").generatePosts(),
              User(id: id + 500, name: "bbbb").generatePosts()
            ]);
  }
}

// 我们的服务：

abstract class UserService {
  Future<List<User>> getUsers();
}

class UserServiceImpl implements UserService {
  final PostsPort repository;

  UserServiceImpl({required this.repository});

  [@override](/user/override)
  Future<List<User>> getUsers() async {
    return repository.findAllUsers();
  }
}

class Services {
  static final Services _singleton = Services._internal();
  factory Services() {
    return _singleton;
  }
  Services._internal();
  late final UserService userService;

  void init({
    required UserService Function() userService,
  }) async {
    this.userService = userService.call();
  }
}

// 我们的模型：

class User with StateEmitter implements Entity {
  final int id;
  final String name;
  final List<UserPost> posts = List.empty(growable: true);

  User({required this.id, required this.name});

  dynamic toDynamic() => {'id': id, 'name': name};

  static User fromDynamic(dynamic user) =>
      User(id: user['id'], name: user['name']);

  [@override](/user/override)
  bool operator ==(Object other) {
    if (identical(this, other)) return true;
    return other is User && other.id == id && other.name == name;
  }

  [@override](/user/override)
  int get hashCode => id.hashCode ^ name.hashCode;

  [@override](/user/override)
  String toString() {
    return 'User{id: $id, name: $name}';
  }

  [@override](/user/override)
  String get entityId => id.toString();

  User generatePosts() {
    _generateRandomPosts();
    return this;
  }

  void _generateRandomPosts() async {
    for (int i = 0; i < 100; i++) {
      final post = await _generateRandomPost();
      print('added post');
      posts.add(post);
      emitEntity<User>(this); // 发射用户状态更新
    }
  }

  Future<UserPost> _generateRandomPost() async {
    return Future.delayed(
        const Duration(seconds: 1),
        () => UserPost(content: 'random content'));
  }
}

class UserPost {
  final String content;

  UserPost({required this.content});
}

// 我们的状态：

abstract class UsersState {}

class LoadingUsers extends UsersState {}

class LoadedUsersSuccess extends UsersState {
  final List<User> users;

  LoadedUsersSuccess({required this.users});
}

class LoadedUsersFail extends UsersState {
  final Object? error;
  final StackTrace? stackTrace;

  LoadedUsersFail({required this.error, required this.stackTrace});
}

// 我们的用例：

class LoadUsersUseCase with StateEmitter implements UseCase {
  [@override](/user/override)
  void execute() async {
    final List<User>? usersCached = SpreadState().getNamed<List<User>>("users_cache");
    if (usersCached != null) {
      emit<UsersState>(LoadedUsersSuccess(users: usersCached)); // 发射成功状态
    } else {
      emit<UsersState>(LoadingUsers()); // 发射加载状态
      Services().userService.getUsers().then((users) {
        emitNamed("users_cache", users); // 存储缓存
        emit<UsersState>(LoadedUsersSuccess(users: users)); // 发射成功状态
      }).onError((error, stackTrace) {
        emit<UsersState>(LoadedUsersFail(error: error, stackTrace: stackTrace)); // 发射失败状态
      });
    }
  }
}

// 创建一个状态观察者服务以异步监听和处理状态

class UsersObserver extends SpreadObserver<UsersState> {
  [@override](/user/override)
  onState(UsersState state) {
    print("UsersObserver Observed: ${state.toString()}"); // 打印状态
  }
}