搜索插件、代码仓与 APP 分类

插件详情v0.2.1

messagepack

MessagePack 二进制序列化格式的流式 API 实现 - msgpack。

AndroidiOSWebmacOSWindowsLinux
近 30 天下载
1.1万
喜欢数
40
Pub 分数
150

安装插件

flutter pub add messagepack

插件介绍

基于插件公开信息、社区数据与项目使用情况整理的选型参考。

Dart 和 Flutter 的 MessagePack 二进制序列化格式的流式 API 实现。它可实现高效、紧凑的数据序列化和反序列化,非常适合网络通信和存储。该包支持所有主要平台,包括 Android、iOS、Web、macOS、Windows 和 Linux。专为性能设计,它可增量处理数据,减少内存开销。非常适合需要快速、低带宽数据交换的应用程序。

适合场景

  • 实时数据传输
  • 结构化数据的高效存储
  • 跨平台数据同步
  • 高性能 API
  • 二进制数据交换

主要特点

  • 用于低内存使用的流式 API
  • 紧凑的二进制格式
  • 跨平台支持
  • 快速序列化/反序列化
  • 支持嵌套数据结构

适合对象

  • 网络应用
  • 数据密集型应用
  • 低带宽环境
  • 高吞吐量系统
  • 移动和网页应用

使用建议

  • 需要了解 MessagePack 格式
  • 有限的人类可读性
  • 不适用于调试日志
  • 可能需要模式管理来处理复杂数据
  • 二进制格式在调试时需要仔细处理

原始 README

以下为关联源码仓库的 README 原文快照,最新内容请访问源码仓库。

Streaming API implementation of MessagePack binary serialization format - msgpack.

pub package MIT License

The basics

Packer and Unpacker classes provide Streaming API for serializing and deserializing data.
Unpacker also provide automatic unpacking Map and List by implicitly unpacking internal items.

Streaming API Example - Simple

For the simplest data packaging to bytes packet like this:

-------------------------------------------   
| version | userId | broadcast? | message |
-------------------------------------------
Packer part
import 'package:messagepack/messagepack.dart';
final p = Packer();
p.packInt(1); // packet format version
p.packInt(222); // user id
p.packBool(false); // broadcast message to others
p.packString('hi'); // user message text
final bytes = p.takeBytes(); //Uint8List
yourFunctionSendToServer(bytes); //sends [1, 204, 222, 195, 162, 104, 105]

1 encodes to 1 byte with value 1.
222 encodes to 2 bytes with values [204, 222] because 222 > 127.
true encodes to 1 byte with value 195.
'hi' encodes to 3 bytes with first byte containing str length info and other 2 bytes hold symbols values.

For more information, refer to the msgpack documentation.

Streaming packing process not like the way we usually pack data in json, by specifying keys.
The current example is more like how data is packed in TCP/IP frame structure.

Unpacker part
final List<int> rawBytes = yourFunctionReceiveFromServer(); // receive List<int> bytes from server
final u = Unpacker.fromList(rawBytes);
final version = u.unpackInt();
final userId = u.unpackInt();
final broadcast = u.unpackBool();
final message = u.unpackString();

// check values in test
expect(version, equals(1));
expect(userId, equals(222));
expect(broadcast, equals(true));
expect(message, equals('hi'));

Streaming packing and automatic/implicit unpacking example - complex

final p = Packer()
  ..packListLength(10)              //pack 10 different types items to list
  ..packInt(99)
  ..packBool(true)
  ..packString('hi')
  ..packNull()                      // explicitly pack null
  ..packString(null)                // implicitly any type can accept null 
  ..packBinary(<int>[104, 105])     // hi codes
  ..packListLength(2)               // pack 2 elements list ['elem1',3.14]
  ..packString('elem1')             // list[0]
  ..packDouble(3.14)                // list[1]
  ..packString('continue to pack other elements')
  ..packMapLength(1)                // map {'key1':false}
  ..packString('key1')              // map key
  ..packBool(false)                 // map value 
  ..packInt(9223372036854775807);   // next root list item (map ended)

final bytes = p.takeBytes();
final u = Unpacker(bytes);
// Unpack by the same sequential/streaming way 
// or implicitly/automatically
final l = u.unpackList(); //List<Object>
print(l);
// [99, true, hi, null, null, [104, 105], [elem1, 3.14], continue to pack other elements, {key1: false}, 9223372036854775807]

List<Object> items explicitly casted to corresponding types when using.

NOTES

Packing Maps and Lists
  • firstly, pack Map or List header length
  • secondly, manually pack all items - that's all

Only need put length header before packing items

After packing all items no need to stop or finish or end this map / list

final list = ['i1','i2'];
final map = {'k1': 11, 'k2': 22};
final p = Packer();
p.packListLength(list.length);
list.forEach(p.packString);
p.packMapLength(map.length);
map.forEach((key, v) {
  p.packString(key);
  p.packInt(v);
});
final bytes = p.takeBytes();
More examples

More examples can be found in:

  • test/messagepack_test.dart
  • example/example.dart
Don't use Packer after calling .takeBytes()

Internally it cleans up underlying _builder, so further behaviour will be useless.
Call .takeBytes() only once. It returns Uint8List of packed bytes.
After that don't continue to use Packer instance (don't call .packXXX() methods and .takeBytes() anymore).
Instead create new Packer instance.

Motivation for creating this package

No other packages available that give streaming API for processing data

Contributing

If you have advice how to improve library code or making it lighter or blazingly faster - don't hesitate to open an issue or pull request!

所属分类

源码仓库

使用此插件的项目

暂无相关数据。