Flutter快速同步客户端插件fast_sync_client的使用

Flutter快速同步客户端插件fast_sync_client的使用

快速同步简介

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

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

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

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

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

• LastWriterWins
• TimestampOrdering
• PredefinedRules

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

客户端安装

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（数据访问对象），在初始化 FastSync 包时，我们使用 Hive DAO 作为示例。
3. 使用 setSyncableObject 方法配置要同步的对象类型，并为该类型设置同步区域字符串。
4. 初始化该类型的 DataSource 和 Repository。
5. 为配置的对象类型配置冲突处理器。
6. 配置 httpManager，使用它可以与服务器交互，在这里你需要实现 push 和 pull 函数。

示例代码：

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());
}

客户端同步对象

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

客户端同步对象数据源

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

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

客户端同步对象仓库

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管理器

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');
  }
}

同步管理器

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;
  }
}