高性能实体序列化：BSON 与 MessagePack（与 JSON）

Question

最近我发现MessagePack，一个替代二进制序列化格式为 Google 的 协议缓冲区 和 JSON 也优于两者。

还有 MongoDB 用于存储数据的 BSON 序列化格式。

有人可以详细说明 BSON 与 MessagePack 的差异和缺点/优点吗？

---

只是为了完成高性能二进制序列化格式的列表：还有 Gobs 将成为 Google Protocol Buffers 的继承者。然而，与所有其他提到的格式相比，这些格式与语言无关，并且依赖于 Go 的内置反射 至少还有除 Go 之外的其他语言的 Gobs 库。

Answer 1

// 请注意，我是 MessagePack 的作者。这个答案可能有偏见。

格式设计

1. 兼容JSON

   尽管名字如此，但与 MessagePack 相比，BSON 对 JSON 的兼容性并不好。

   BSON 有特殊类型，如“ObjectId”、“Min key”、“UUID”或“MD5”（我认为 MongoDB 需要这些类型）。这些类型与 JSON 不兼容。这意味着当您将对象从 BSON 转换为 JSON 时，某些类型信息可能会丢失，但当然只有当这些特殊类型位于 BSON 源中时才会丢失。在单个服务中同时使用 JSON 和 BSON 可能是一个缺点。

   MessagePack 旨在透明地从/到 JSON 进行转换。

2. MessagePack 比 BSON 小

   MessagePack 的格式比 BSON 更简洁。因此，MessagePack 可以序列化小于 BSON 的对象。

   例如，一个简单的映射 {"a":1, "b":2} 使用 MessagePack 序列化为 7 个字节，而 BSON 使用 19 个字节。

3. BSON支持就地更新

   使用 BSON，您可以修改部分存储的对象，而无需重新序列化整个对象。假设映射 {"a":1, "b":2} 存储在文件中，并且您想要将 "a" 的值从 1 更新到 2000。

   对于 MessagePack，1 仅使用 1 个字节，但 2000 使用 3 个字节。所以“b”必须向后移动2个字节，而“b”不被修改。

   对于 BSON，1 和 2000 都使用 5 个字节。由于这种冗长，您不必移动“b”。

4. MessagePack有RPC

   MessagePack、Protocol Buffers、Thrift 和 Avro 支持 RPC。但 BSON 没有。

这些差异意味着 MessagePack 最初是为网络通信而设计的，而 BSON 是为存储而设计的。

实现和 API 设计

1. MessagePack 具有类型检查 API（Java、C++ 和 D）

   MessagePack 支持静态类型。

   与 JSON 或 BSON 一起使用的动态类型对于 Ruby、Python 或 JavaScript 等动态语言非常有用。但对于静态语言来说就麻烦了。您必须编写无聊的类型检查代码。

   MessagePack 提供类型检查 API。它将动态类型对象转换为静态类型对象。下面是一个简单的示例 (C++)：

    #include <msgpack.hpp>

    class myclass {
    private:
        std::string str;
        std::vector<int> vec;
    public:
        // This macro enables this class to be serialized/deserialized
        MSGPACK_DEFINE(str, vec);
    };

    int main(void) {
        // serialize
        myclass m1 = ...;

        msgpack::sbuffer buffer;
        msgpack::pack(&buffer, m1);

        // deserialize
        msgpack::unpacked result;
        msgpack::unpack(&result, buffer.data(), buffer.size());

        // you get dynamically-typed object
        msgpack::object obj = result.get();

        // convert it to statically-typed object
        myclass m2 = obj.as<myclass>();
    }

2. MessagePack 有 IDL

   与类型检查API有关，MessagePack支持IDL。 （规范可从：http://wiki.msgpack.org/display/MSGPACK /Design+of+IDL)

   Protocol Buffers 和 Thrift 需要 IDL（不支持动态类型）并提供更成熟的 IDL 实现。

3. MessagePack 具有流 API（Ruby、Python、Java、C++...）

   MessagePack 支持流式反序列化器。此功能对于网络通信很有用。下面是一个示例 (Ruby)：

    require 'msgpack'

    # write objects to stdout
    $stdout.write [1,2,3].to_msgpack
    $stdout.write [1,2,3].to_msgpack

    # read objects from stdin using streaming deserializer
    unpacker = MessagePack::Unpacker.new($stdin)
    # use iterator
    unpacker.each {|obj|
      p obj
    }

Answer 2

我认为非常重要的一点是，这取决于您的客户端/服务器环境。

如果您在不进行检查的情况下多次传递字节，例如使用消息队列系统或将日志条目流式传输到磁盘，那么您可能更喜欢使用二进制编码来强调紧凑的大小。否则就是不同环境下的具体问题。

某些环境可以非常快速地与 msgpack/protobuf 进行序列化和反序列化，而其他环境则不然。一般来说，语言/环境越低级，二进制序列化的效果就越好。在高级语言（node.js、.Net、JVM）中，您经常会发现 JSON 序列化实际上更快。那么问题就变成了你的网络开销或多或少比你的内存/CPU 受到限制？

关于 msgpack、bson 和 protocol buffers...msgpack 是该组中最小的字节，protocol buffers 大致相同。 BSON 定义了比其他两种更广泛的本机类型，并且可能更适合您的对象模型，但这使其更加冗长。协议缓冲区的优点是被设计为流式传输......这使其成为二进制传输/存储格式的更自然的格式。

就我个人而言，我倾向于 JSON 直接提供的透明度，除非明确需要减少流量。通过使用 gzip 压缩数据的 HTTP，网络开销的差异在格式之间就不再是问题了。

Answer 3

嗯，正如作者所说，MessagePack 最初是为网络通信而设计的，而 BSON 是为存储而设计的。

MessagePack 比较紧凑，而 BSON 比较冗长。
MessagePack 旨在节省空间，而 BSON 则专为 CURD（节省时间）而设计。

最重要的是，MessagePack的类型系统（前缀）遵循Huffman编码，这里我画了一个MessagePack的Huffman树（点击链接看图）：

Answer 4

尚未提及的一个关键区别是 BSON 包含整个文档和进一步嵌套的子文档的大小信息（以字节为单位）。

document    ::=     int32 e_list

这对于尺寸和性能都很重要的受限环境（例如嵌入式）有两个主要好处。

1. 您可以立即检查要解析的数据是否代表完整的文档，或者您是否需要在某个时刻请求更多数据（无论是来自某些连接还是存储）。由于这很可能是异步操作，因此您可能在解析之前已经发送了新请求。
2. 您的数据可能包含包含与您无关的信息的整个子文档。 BSON 允许您通过使用子文档的大小信息来跳过它，从而轻松地遍历到子文档之后的下一个对象。另一方面，msgpack 包含所谓映射内的元素数量（类似于 BSON 的子文档）。虽然这无疑是有用的信息，但它对解析器没有帮助。您仍然必须解析地图内的每个对象，而不能跳过它。根据数据的结构，这可能会对性能产生巨大影响。

Answer 5

我做了快速基准测试来比较 MessagePack 与 BSON 的编码和解码速度。至少如果您有大型二进制数组，BSON 会更快：

BSON writer: 2296 ms (243487 bytes)
BSON reader: 435 ms
MESSAGEPACK writer: 5472 ms (243510 bytes)
MESSAGEPACK reader: 1364 ms

Using C# Newtonsoft.Json and MessagePack by neuecc：

    public class TestData
    {
        public byte[] buffer;
        public bool foobar;
        public int x, y, w, h;
    }

    static void Main(string[] args)
    {
        try
        {
            int loop = 10000;

            var buffer = new TestData();
            TestData data2;
            byte[] data = null;
            int val = 0, val2 = 0, val3 = 0;

            buffer.buffer = new byte[243432];

            var sw = new Stopwatch();

            sw.Start();
            for (int i = 0; i < loop; i++)
            {
                data = SerializeBson(buffer);
                val2 = data.Length;
            }

            var rc1 = sw.ElapsedMilliseconds;

            sw.Restart();
            for (int i = 0; i < loop; i++)
            {
                data2 = DeserializeBson(data);
                val += data2.buffer[0];
            }
            var rc2 = sw.ElapsedMilliseconds;

            sw.Restart();
            for (int i = 0; i < loop; i++)
            {
                data = SerializeMP(buffer);
                val3 = data.Length;
                val += data[0];
            }

            var rc3 = sw.ElapsedMilliseconds;

            sw.Restart();
            for (int i = 0; i < loop; i++)
            {
                data2 = DeserializeMP(data);
                val += data2.buffer[0];
            }
            var rc4 = sw.ElapsedMilliseconds;

            Console.WriteLine("Results:", val);
            Console.WriteLine("BSON writer: {0} ms ({1} bytes)", rc1, val2);
            Console.WriteLine("BSON reader: {0} ms", rc2);
            Console.WriteLine("MESSAGEPACK writer: {0} ms ({1} bytes)", rc3, val3);
            Console.WriteLine("MESSAGEPACK reader: {0} ms", rc4);
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
        }

        Console.ReadLine();
    }

    static private byte[] SerializeBson(TestData data)
    {
        var ms = new MemoryStream();

        using (var writer = new Newtonsoft.Json.Bson.BsonWriter(ms))
        {
            var s = new Newtonsoft.Json.JsonSerializer();
            s.Serialize(writer, data);
            return ms.ToArray();
        }
    }

    static private TestData DeserializeBson(byte[] data)
    {
        var ms = new MemoryStream(data);

        using (var reader = new Newtonsoft.Json.Bson.BsonReader(ms))
        {
            var s = new Newtonsoft.Json.JsonSerializer();
            return s.Deserialize<TestData>(reader);
        }
    }

    static private byte[] SerializeMP(TestData data)
    {
        return MessagePackSerializer.Typeless.Serialize(data);
    }

    static private TestData DeserializeMP(byte[] data)
    {
        return (TestData)MessagePackSerializer.Typeless.Deserialize(data);
    }

Answer 6

快速测试表明，缩小的 JSON 的反序列化速度比二进制 MessagePack 更快。在测试中，Article.json 是 550kb 的缩小 JSON，Article.mpack 是其 420kb MP 版本。当然可能是一个实施问题。

MessagePack：

//test_mp.js
var msg = require('msgpack');
var fs = require('fs');

var article = fs.readFileSync('Article.mpack');

for (var i = 0; i < 10000; i++) {
    msg.unpack(article);    
}

JSON：

// test_json.js
var msg = require('msgpack');
var fs = require('fs');

var article = fs.readFileSync('Article.json', 'utf-8');

for (var i = 0; i < 10000; i++) {
    JSON.parse(article);
}

所以时间是：

Anarki:Downloads oleksii$ time node test_mp.js 

real    2m45.042s
user    2m44.662s
sys     0m2.034s

Anarki:Downloads oleksii$ time node test_json.js 

real    2m15.497s
user    2m15.458s
sys     0m0.824s

所以节省了空间，但速度更快？编号。

测试版本：

Anarki:Downloads oleksii$ node --version
v0.8.12
Anarki:Downloads oleksii$ npm list msgpack
/Users/oleksii
└── [email protected]