搜尋套件、儲存庫與 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!

所屬分類

原始碼儲存庫

使用此套件的專案

暫無相關資料。