Flutter快速同步Hive数据库插件fast_sync_hive_dao的使用

Flutter快速同步Hive数据库插件fast_sync_hive_dao的使用

Fast Sync

FastSync 是一个强大的简化数据同步包，旨在通过将多个 API 集成到一个统一的接口中来简化从服务器端到客户端应用程序的数据同步。

受 Git 版本控制方法的启发，FastSync 提供了一组功能，为高效的数据同步提供了稳健的解决方案：

• pull()
• push()
• sync()
• hardReset()

FastSync 通过智能处理由于远程更改同时发生而可能产生的冲突，超越了传统的同步工具。我们的高级冲突检测机制在对象级别识别冲突，使用户能够提供自定义的解决函数。

FastSync 支持三种不同的冲突解决策略以适应各种用例：

• LastWriterWins
• TimestampOrdering
• PredefinedRules

注意：当您指定为预定义规则时，每当检测到冲突时，您需要提供一个自定义函数来解决冲突。

快速同步核心

• 服务器安装
• 服务器设置
• 服务器可同步对象
• 服务器可同步对象数据源
• 服务器可同步存储库
• 服务器推送和拉取

服务器安装

"dependencies": {
    ...
    "fast-sync-core": "*.*.*",
    "fast-sync-mongoose-dao": "*.*.*",
    ...
  }

服务器设置

1. 在您的服务器入口点初始化 FastSync 包。
2. 配置您的 DAO（数据访问对象），在此示例中我们使用 mongoose dao。
3. 使用 setSyncalbeObject 方法配置要同步的对象类型。
4. 配置已配置对象类型的冲突处理器。

async function configureFastSync() {
  let fastSync: FastSync = FastSync.getInstance(
    new MongooseSyncConfiguration()
  );
  let conflictsHandler: IConflictsHandler = new ConflictsHandler(
    ConflictsResolutionStrategyEnum.PredefinedRules,
    conflictsResolutionFunction
  );
  let repo = new ItemRepository();
  await fastSync.setSyncalbeObject(Item.name, repo, conflictsHandler);
}

1. 在主函数运行后调用 configureFastSync()。

app.listen(port, async () => {
  try {
    await configureFastSync();
    console.log("Configuration completed successfully");
  } catch (error) {
    console.error("Error configuring Fast Sync:", error);
  }
});

服务器可同步对象

1. 需要 fast-sync-mongoose-dao 包。
2. 您需要从 fast-sync-core 中扩展 SyncableObject 并使用 plugMetadataSchema 插入类型元数据模式。

import { SyncableObject } from "fast-sync-core";
import { SyncableSchemaItemBuilder } from "fast-sync-mongoose-dao";
import * as mongoose from "mongoose";

export class Item extends SyncableObject {
  public name: string;
  public description: string;
  public id: string;
  constructor() {
    super();
  }
}

export const ItemSchema = SyncableSchemaItemBuilder.plugMetadataSchema(
  new mongoose.Schema({
    name: {
      type: mongoose.Schema.Types.String,
    },
    description: {
      type: mongoose.Schema.Types.String,
    },
  })
);

服务器可同步对象数据源

1. 对于每个 SyncableObject，您应该有一个 DataSource，不用担心每件事都为你设置好了，只需创建类。
2. 注意：如果需要进一步的方法，可以在那里创建并使用它们。

import { SyncalbeObjectDataSource } from "fast-sync-mongoose-dao";
import { Item, ItemSchema } from "./item";

export class ItemDataSource extends SyncalbeObjectDataSource<Item> {
  constructor() {
    super(ItemSchema, Item.name);
  }
}

服务器可同步存储库

1. 要与对象交互，您只能使用存储库，您可以使用数据源，但那样会破坏包。
2. 注意：您不需要在存储库中创建新方法，因为所有操作都在那里定义。在某些罕见的情况下，我们可以创建一些新方法。

import { SyncalbeRepository } from "fast-sync-core";
import { Item } from "./item";
import { ItemDataSource } from "./item_datasource";

export class ItemRepository extends SyncalbeRepository<Item> {
  constructor() {
    super(new ItemDataSource(), Item.name);
  }
}

服务器推送和拉取

1. 您只需要定义两个 API，一个是 /push，另一个是 /pull。
2. 我们决定给您控制 API 的能力，并且我们负责背后的逻辑。

@Post("/push")
async pushUserObjects(
  @Req() req,
  @Res() res,
  @Body() input: SyncPayload
) {
  try{
    let syncManager = FastSync.getInstance().getSyncManager()
    await this.syncManager.processPush(input)
    return this.success(res, {"result":"push was done with success"});
  }
  catch(err){
    return this.error(res,err);
  }
}

@Post("/pull")
async pullUserObjects(
  @Req() req,
  @Res() res,
  @Body() metadata: SyncOperationMetadata
) {
  try{
    let result = await this.syncManager.processPull(metadata)
    return this.success(res, result);
  }
  catch(err){
    return this.error(res,err);
  }
}

1. SyncOperationMetadata 和 SyncPayload 是内部处理的对象，不用担心他们会从客户端部分创建。您不需要在这里做任何事情。
2. 如果需要，您可以为 API 添加中间件。

快速同步客户端

• Dart 客户端安装
• 客户端设置
• 客户端可同步对象
• 运行代码生成器
• 客户端可同步对象数据源
• 客户端可同步存储库
• HTTP 管理器
• 同步管理器

Dart 客户端安装

dependencies:
  # 添加 fast_sync_client 到你的依赖项
  fast_sync_client:
  # 添加 fast_sync_hive_dao 到你的依赖项
  fast_sync_hive_dao:

dev_dependencies:
  # 添加生成器到你的 dev_dependencies
  build_runner:

客户端设置

1. 在您的应用主函数中初始化 FastSync 包。
2. 配置您的 DAO（数据访问对象），在此示例中我们使用 Hive dao。
3. 使用 setSyncalbeObject 方法配置要同步的对象类型，并为该类型设置 syncZone 字符串。
4. 初始化该类型的数据源和存储库。
5. 配置已配置对象类型的冲突处理器。
6. 配置 httpManger，使用它可以与您的服务器进行交互，在这里您需要实现 push 和 pull 函数。

注意：您可以稍后设置 syncZone 字符串，但在使用 pull 和 push 函数之前，syncZone 字符串是一个唯一 ID，用于仅同步属于该 ID 的对象。

例如：当您指定 user.Id 作为 syncZone 时，对于该用户的所有该类型对象都将被同步。

当您指定 company.id 作为 syncZone 时，对于属于该公司的所有用户，所有该类型对象都将被同步。

您需要指定 SyncZone，以便该包知道对象将被同步给谁，如果是 user.id，只有该用户可以查看和更改这些对象。

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await initHive();
  FastSync.setSyncConfiguration<HiveSyncConfiguration>(HiveSyncConfiguration());
  FastSync.setTypeSyncZone<Item>(SyncZoneRestrictionEnum.restricted,
      syncZone: "userId");
  FastSync.setHttpManager(HttpManager());
  ItemRepository repository = ItemRepository(dataSource: ItemDataSource());
  FastSync.setSyncableObject<Item>(
      fromJson: Item.fromJson, toJson: Item.intoJson, repository: repository);
  runApp(MyApp());
}

Future<void> initHive() async {
  var dir = await getApplicationDocumentsDirectory();
  Hive.init(dir.path);
  Hive.registerAdapter(ItemAdapter());
}

客户端可同步对象

1. 需要 fast_sync_hive_dao 包。
2. 您需要从 fast_sync_hive_dao 中扩展 SyncableItemModel 并插入类型元数据。

import 'package:fast_sync_hive_dao/fast_sync_hive_dao.dart';
import 'package:hive/hive.dart';
import 'package:json_annotation/json_annotation.dart';
part 'item.g.dart';

@HiveType(typeId: 1, adapterName: "ItemAdapter")
@JsonSerializable(explicitToJson: true)
class Item extends SyncableItemModel {
  @HiveField(1)
  String name;

  @HiveField(2)
  String description;

  Item({required this.name, required this.description});

  @override
  factory Item.fromJson(Map<String, dynamic> json) => _$ItemFromJson(json);

  @override
  Map<String, dynamic> toJson() => _$ItemToJson(this);

  static Function get intoJson => _$ItemToJson;
}

运行代码生成器

使用 flutter packages pub run build_runner build 运行生成器。 为了自动运行它，每当文件更改时使用 flutter packages pub run build_runner watch。

客户端可同步对象数据源

1. 对于每个 SyncableObject，您应该有一个 DataSource，不用担心每件事都为你设置好了，只需创建类。
2. 注意：如果需要进一步的方法，可以在那里创建并使用它们。

import 'package:example/item/item.dart';
import 'package:fast_sync_hive_dao/fast_sync_hive_dao.dart';

class ItemDataSource extends SyncalbeObjectDataSource<Item> {
  ItemDataSource();
}

客户端可同步存储库

1. 要与对象交互，您只能使用存储库，您可以使用数据源，但那样会破坏包。
2. 注意：您不需要在存储库中创建新方法，因为所有操作都在那里定义。在某些罕见的情况下，我们可以创建一些新方法。

import 'package:example/item/item.dart';
import 'package:fast_sync_client/fast_sync_client.dart';

class ItemRepository extends SyncalbeRepository<Item> {
  ItemRepository({required super.dataSource});
}

HTTP 管理器

1. HttpManger 是一个抽象类，您只需要实现两个方法：pull 和 push。
2. 您只需要向服务器发出两次 HTTP 请求，不要担心如何创建请求的主体，它们会为您完成。

import 'dart:async';
import 'dart:convert';
import 'package:dio/dio.dart';
import 'package:fast_sync_client/fast_sync_client.dart';

class HttpManager implements IhttpManager {
  final dio = Dio();
  HttpManager();

  @override
  Future<SyncPayload> pull(SyncOperationMetadata metadata) async {
    Response response = await dio.post(
        'https://www.server.com/pull',
        data: json.encode(metadata.toJson()));
    if (response.data["success"] == true) {
      return SyncPayload.fromJson(response.data["data"]);
    }
    return throw Exception('pull failed');
  }

  @override
  Future<bool> push(SyncPayload payload) async {
    Response response = await dio.post(
        'https://www.server.com/push',
        data: json.encode(payload.toJson()));
    if (response.data["success"] == true) {
      return true;
    }
    return throw Exception('push failed');
  }
}

1. SyncOperationMetadata 和 SyncPayload 是内部处理的对象，不用担心他们会从客户端部分创建。您不需要在这里做任何事情。

同步管理器

1. 要推送、拉取、同步、硬重置，只需使用 getSyncManager() 获取同步管理器实例，然后就可以开始使用您的数据了。

import 'package:example/item/item.dart';
import 'package:fast_sync_client/fast_sync_client.dart';
import 'package:flutter/material.dart';

class ItemProvider with ChangeNotifier {
  List<Item> items = [];
  ISyncableRepository<Item> repository = FastSync.getObjectRepository<Item>();
  ISyncManager syncManager = FastSync.getSyncManager();

  Future<List<Item>> loadLocalItems() async {
    List<Item> localItems = await repository.getAll();
    return localItems;
  }

  Future<void> pull() async {
    await syncManager.pull();
  }

  Future<void> sync() async {
    await syncManager.sync();
  }

  Future<void> push() async {
    await syncManager.push();
  }

  Future<void> hardReset() async {
    await syncManager.hardReset();
  }

  Future<void> resetItemRepo() async {
    await repository.hardDelete();
  }

  Future<Item> saveElement(Item item) async {
    item = await repository.add(item);
    return item;
  }

  Future<Item> updateElement(Item item) async {
    item = await repository.update(item);
    return item;
  }

  Future<int> getCount() async {
    int count = await repository.count();
    return count;
  }
}