Flutter数据序列化插件easy_serialization的使用

描述

这个包帮助你系统地处理序列化问题，尤其在序列化列表和抽象类型时提供了很大的帮助。

使用

第一步：定义你的类型

/// 代表来自Flutter SDK的[Offset]类型。
class Offset {
  final double dx, dy;
  const Offset(this.dx, this.dy);
}

enum ShapeFillType {
  solid,
  outlined,
}

abstract class Shape with SerializableMixin {
  Offset offset = const Offset(0, 0);
  ShapeFillType fill = ShapeFillType.solid;
  Shape();

  double area();

  /// 如果这些对象是原语，则直接传递；否则使用[Prop]进行序列化。
  @override
  MarkupObj toMarkupObj() => {
    "offset": Prop.valueToMarkup(offset),
    "fill": Prop.valueToMarkup(fill),
  };

  /// 如果这些对象是原语，则直接传递；否则使用[Prop]进行序列化。
  Shape.fromMarkup(MarkupObj markup)
      : offset = Prop.valueFromMarkup(markup["offset"]),
        fill = Prop.valueFromMarkup(markup["fill"]);
}

class Circle extends Shape {
  double radius;
  Circle(this.radius);

  @override
  double area() => 3.14 * radius * radius;

  @override
  MarkupObj toMarkupObj() => {
    ...super.toMarkupObj(),
    "radius": radius,
  };

  Circle.fromMarkup(MarkupObj markup)
      : radius = markup["radius"],
        super.fromMarkup(markup);
}

class Rectangle extends Shape {
  double height, width;
  Rectangle(this.height, this.width);

  @override
  double area() => height * width;

  @override
  MarkupObj toMarkupObj() => {
    ...super.toMarkupObj(),
    "height": height,
    "width": width,
  };

  Rectangle.fromMarkup(MarkupObj markup)
      : height = markup["height"],
        width = markup["width"],
        super.fromMarkup(markup);
}

class Square extends Rectangle {
  Square(double sideLen) : super(sideLen, sideLen);

  Square.fromMarkup(MarkupObj markup) : super.fromMarkup(markup);
}

第二步：注册这些类型

final customSerializableObjects = [
  /// 如何配置一个不是你的类型（来自不同的库），或者只是你不想使用[SerializableMixin]的类型。
  SerializationConfig<Offset>(
    toMarkupObj: (obj) => {"dx": obj.dx, "dy": obj.dy},
    fromMarkupObj: (markup) => Offset(markup["dx"], markup["dy"]),
  ),

  /// 如何配置枚举类型。
  ShapeFillType.values.config,

  /// 如何配置你的类型。

  /// [SerializationConfig.abstract]用于创建一个该抽象类型的列表。
  SerializationConfig.abstract<Shape>(),
  SerializationConfig.serializable<Circle>(Circle.fromMarkup),
  SerializationConfig.serializable<Rectangle>(Rectangle.fromMarkup),
  SerializationConfig.serializable<Square>(Square.fromMarkup),
];

void main() async {
  // 在每个新的隔离区或服务中，你必须首先配置此列表。
  Prop.registerSerializationConfigs(customSerializableObjects);

  final circle = Circle(5.0)
    ..fill = ShapeFillType.solid
    ..offset = Offset(20, 20);

  final rect = Rectangle(10, 10)
    ..fill = ShapeFillType.outlined
    ..offset = Offset(10, 10);

  final square = Square(75);

  final list = <List<Shape>>[
    [circle],
    [rect, square],
    []
  ];

  /// [Prop.valueToMarkup] 和 [Prop.valueFromMarkup] 将静态地推断类型，
  /// 但最好显式地传递类型，特别是对于[List]。

  /// 注意这里你必须提供一个空列表实例。
  ///
  /// 这个标记可以发送到任何隔离区，或者如果你想将其解析为JSON字符串，请使用json.encode和json.decode。
  final msg = Prop.valueToMarkup<List<List<Shape>>>(list, emptyList: []);

  Isolate.spawn(isolateMain, msg);

  // 仅为了展示第二个隔离区中的打印结果。
  await Future.delayed(const Duration(seconds: 2));
}

然后你可以直接在隔离区之间发送和接收标记，

或者如果你想将其作为JSON字符串发送，可以使用json.encode和json.decode。 以下是第二个隔离区：

/// 这可以是任何服务的入口点，例如[flutter_background_service]包，
/// 或者像[overlay_window]包这样的覆盖服务，
///
/// 或者甚至是一个客户端-服务器应用
/// （但在这种情况下，两者都必须一起编译在一起[在未来更新中这将变得更加清晰]）。
void isolateMain(MarkupObj msg) {
  // 在每个新的隔离区或服务中，你必须首先配置此列表。
  Prop.registerSerializationConfigs(customSerializableObjects);

  /// 注意这里你必须提供一个空列表实例。
  /// 注意这里任何内部空列表都会被忽略。
  final ml = Prop.valueFromMarkup<List<List<Shape>>>(
    msg,
    emptyList: [],
  );

  print(ml); // 发送的精确列表。
  print(ml[0][0].offset.dx); // 20

  print(ml.runtimeType); // List<List<Shape>>
  print(ml[0].runtimeType); // List<Circle>
  print(ml[1].runtimeType); // List<Rectangle>
}

工具

1. TypeProvider<OBJ> 混入类

TypeProvider<OBJ> 混入类允许你在任何时间动态地存储和使用泛型类型 [OBJ]。

class MyList<E> with TypeProvider<E> {
  final List<E> list;
  const MyList(this.list);
}

void main() {
  final myList = const MyList<int>([5, 6]);
  final dynamicList = myList as MyList;

  dynamicList.provType(() => print(dynamicList.runtimeType)); // MyList<int>
}

2. TypeHash<OBJ> 类

TypeHash<OBJ> 类允许你获取每个已注册类型的唯一ID（某些情况下你必须注册所有类型）。

class Configration<E> with TypeHash<E> {
  final E obj;
  Configration(this.obj) {
    ensureCalcTypeID();
  }
}

void main() {
  final config = Configration<int>(7);
  print(config.typeID.hashCodes); // [List<int>]
}

3. withoutEmpties 方法

withoutEmpties 方法可以从提供的列表中移除任何空列表。

final list = [1, "A", [], [5, [6], []], [[[]]]];
print(list.withoutEmpties()); // [1, A, [5, [6]]]

4. withSpecificTypes 方法

withSpecificTypes 方法会将列表及其子列表转换为其最具体的已注册类型（某些情况下你必须注册所有类型）。

final list1 = <dynamic>[[1, 2], [1.1, 2.2]];
print(list1.runtimeType); // List<dynamic>
final list2 = list1.withSpecificTypes();
print(list2.runtimeType); // List<List<num>>
print(list2[0].runtimeType); // List<int>
print(list2[1].runtimeType); // List<double>