发布于 由admin

C++中的Marshaling/Unmarshaling机制：实现复杂数据结构在跨进程/网络间的传输

C++中的Marshaling/Unmarshaling机制：实现复杂数据结构在跨进程/网络间的传输

大家好，今天我们来深入探讨C++中Marshaling/Unmarshaling机制。在分布式系统、网络编程以及跨进程通信中，我们经常需要在不同的进程或计算机之间传输数据。然而，内存中的数据表示形式（例如指针、对象布局）在不同环境中可能无效或不兼容。为了解决这个问题，我们需要一种机制将复杂的数据结构转换为可以在网络或进程间安全传输的格式，并在接收端将其还原回原始的数据结构。这就是Marshaling（序列化/编组）和Unmarshaling（反序列化/解组）发挥作用的地方。

1. 什么是Marshaling/Unmarshaling？

  • Marshaling (序列化/编组): 是将内存中的数据结构（例如对象、结构体）转换为一种可以存储或传输的格式的过程。这个过程通常涉及将数据分解为字节流，并可能需要进行格式转换、压缩或加密。

  • Unmarshaling (反序列化/解组): 是Marshaling的逆过程，它将存储或传输的格式的数据重新构建为内存中的数据结构。

简单来说，Marshaling是将数据“打包”以便传输，Unmarshaling是将数据“解包”以便使用。

2. Marshaling/Unmarshaling 的必要性

  • 跨进程通信 (IPC): 不同进程拥有独立的地址空间，不能直接共享内存。Marshaling允许我们将数据转换为字节流，通过管道、消息队列、共享内存等IPC机制传输，并在接收进程中重建数据。

  • 网络传输: 网络传输只能传递字节流。Marshaling将复杂数据结构转换为字节流，使其可以通过TCP/IP协议等进行传输。

  • 持久化存储: 将数据存储到磁盘或数据库时，需要将其转换为一种可以存储的格式。Marshaling可以将数据转换为字节流或特定的数据格式（例如JSON、XML），以便存储和读取。

  • 异构系统互操作: 不同编程语言、操作系统或硬件平台可能具有不同的数据表示方式。Marshaling允许我们在这些异构系统之间安全地交换数据。

3. C++中实现Marshaling/Unmarshaling 的方法

C++本身并没有内置的Marshaling/Unmarshaling机制，我们需要借助第三方库或者自定义实现。

3.1 手动实现

对于简单的数据结构，我们可以手动实现Marshaling和Unmarshaling。这种方法的优点是控制力强、效率高，但缺点是代码量大、容易出错，且不适用于复杂的数据结构。

示例：手动序列化/反序列化一个简单的结构体

#include <iostream>
#include <vector>
#include <cstring> // For memcpy

struct Person {
    int id;
    char name[50];
    int age;
};

// Marshaling (序列化)
std::vector<char> marshal(const Person& person) {
    std::vector<char> buffer;
    size_t size = sizeof(Person);
    buffer.resize(size);
    std::memcpy(buffer.data(), &person, size);
    return buffer;
}

// Unmarshaling (反序列化)
Person unmarshal(const std::vector<char>& buffer) {
    Person person;
    if (buffer.size() != sizeof(Person)) {
        // Error handling: Invalid buffer size
        std::cerr << "Error: Invalid buffer size for unmarshaling Person." << std::endl;
        return person; // Return a default-constructed Person
    }
    std::memcpy(&person, buffer.data(), sizeof(Person));
    return person;
}

int main() {
    Person person1;
    person1.id = 123;
    std::strcpy(person1.name, "Alice");
    person1.age = 30;

    // Marshal the Person object
    std::vector<char> marshaled_data = marshal(person1);

    // Unmarshal the data back into a Person object
    Person person2 = unmarshal(marshaled_data);

    // Verify the data
    std::cout << "Person 2 ID: " << person2.id << std::endl;
    std::cout << "Person 2 Name: " << person2.name << std::endl;
    std::cout << "Person 2 Age: " << person2.age << std::endl;

    return 0;
}

在这个例子中，我们使用 memcpy 将 Person 结构体的数据复制到 std::vector<char> 缓冲区中进行序列化，并从缓冲区中复制回 Person 结构体进行反序列化。

优点:

  • 直接控制序列化过程，可以进行优化。
  • 不依赖于外部库，减少了依赖性。

缺点:

  • 需要手动处理每个字段，对于复杂结构体非常繁琐。
  • 容易出错，例如缓冲区溢出、类型不匹配等。
  • 没有版本控制，如果结构体定义发生变化，序列化的数据可能无法反序列化。
  • 缺乏灵活性，难以处理不同平台上的数据表示差异。

3.2 使用第三方库

为了简化Marshaling/Unmarshaling 的过程，我们可以使用一些流行的C++序列化库，例如：

  • Boost.Serialization: 一个功能强大、广泛使用的序列化库，支持各种数据类型和序列化格式。
  • Google Protocol Buffers: 一种高效、跨语言的序列化协议，特别适用于网络通信和数据存储。
  • JSON (JavaScript Object Notation) 库: 许多C++ JSON库 (例如RapidJSON, nlohmann_json) 可以用来序列化和反序列化数据为JSON格式，方便与其他语言和系统集成。

3.2.1 Boost.Serialization

Boost.Serialization提供了一种通用的序列化框架，允许我们将C++对象保存到存档（archive）中，并从存档中恢复对象。它支持多种存档类型，例如文本存档、二进制存档和XML存档。

示例：使用Boost.Serialization序列化/反序列化一个类

#include <iostream>
#include <fstream>
#include <string>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/string.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>

class Person {
public:
    Person() {} // Required for serialization
    Person(int id, const std::string& name, int age) : id_(id), name_(name), age_(age) {}

    int id() const { return id_; }
    std::string name() const { return name_; }
    int age() const { return age_; }

private:
    int id_;
    std::string name_;
    int age_;

    // Required for serialization
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version) {
        ar & id_;
        ar & name_;
        ar & age_;
    }
};

int main() {
    Person person1(123, "Alice", 30);

    // Serialize the Person object to a file
    {
        std::ofstream ofs("person.txt");
        boost::archive::text_oarchive oa(ofs);
        oa << person1;
    }

    // Deserialize the Person object from the file
    Person person2;
    {
        std::ifstream ifs("person.txt");
        boost::archive::text_iarchive ia(ifs);
        ia >> person2;
    }

    // Verify the data
    std::cout << "Person 2 ID: " << person2.id() << std::endl;
    std::cout << "Person 2 Name: " << person2.name() << std::endl;
    std::cout << "Person 2 Age: " << person2.age() << std::endl;

    return 0;
}

在这个例子中，我们定义了一个 Person 类，并使用 BOOST_SERIALIZATION_SPLIT_MEMBER 宏定义了 serialize 函数，该函数负责将类的成员变量序列化到存档中。 我们使用 boost::archive::text_oarchive 和 boost::archive::text_iarchive 类分别将对象序列化到文本文件和从文本文件反序列化对象。

优点:

  • 易于使用，只需要在类中添加 serialize 函数即可。
  • 支持多种存档类型，例如文本存档、二进制存档和XML存档。
  • 支持版本控制，可以处理类定义的变化。
  • 功能强大，支持各种数据类型和复杂的对象关系。

缺点:

  • 性能可能不如手动实现或Protocol Buffers。
  • 库的体积较大，可能会增加程序的依赖性。
  • 编译时间可能较长。

3.2.2 Google Protocol Buffers

Google Protocol Buffers (protobuf) 是一种语言无关、平台无关、可扩展的序列化数据格式。它由Google开发，被广泛用于网络通信、数据存储等领域。Protobuf使用一种IDL (Interface Definition Language) 来定义数据结构，然后使用protobuf编译器生成各种语言的代码，用于序列化和反序列化数据。

示例：使用Protocol Buffers序列化/反序列化一个消息

首先，我们需要定义一个 .proto 文件来描述数据结构：

syntax = "proto3";

package example;

message Person {
  int32 id = 1;
  string name = 2;
  int32 age = 3;
}

然后，使用protobuf编译器 protoc 生成C++代码：

protoc --cpp_out=. person.proto

这将生成 person.pb.h 和 person.pb.cc 文件。

接下来，我们可以在C++代码中使用生成的代码来序列化和反序列化数据：

#include <iostream>
#include <fstream>
#include <string>
#include "person.pb.h"

int main() {
    example::Person person1;
    person1.set_id(123);
    person1.set_name("Alice");
    person1.set_age(30);

    // Serialize the Person object to a file
    {
        std::fstream output("person.data", std::ios::out | std::ios::trunc | std::ios::binary);
        if (!person1.SerializeToOstream(&output)) {
            std::cerr << "Failed to write person." << std::endl;
            return -1;
        }
    }

    // Deserialize the Person object from the file
    example::Person person2;
    {
        std::fstream input("person.data", std::ios::in | std::ios::binary);
        if (!person2.ParseFromIstream(&input)) {
            std::cerr << "Failed to parse person." << std::endl;
            return -1;
        }
    }

    // Verify the data
    std::cout << "Person 2 ID: " << person2.id() << std::endl;
    std::cout << "Person 2 Name: " << person2.name() << std::endl;
    std::cout << "Person 2 Age: " << person2.age() << std::endl;

    return 0;
}

在这个例子中，我们首先使用protobuf编译器生成了C++代码。 然后，我们使用生成的 example::Person 类来创建、序列化和反序列化 Person 对象。SerializeToOstream 和 ParseFromIstream 函数用于将对象序列化到输出流和从输入流反序列化对象。

优点:

  • 性能高，序列化和反序列化速度快。
  • 语言无关，支持多种编程语言。
  • 可扩展，可以方便地添加新的字段。
  • 体积小，序列化后的数据量较小。
  • 支持版本控制，可以处理消息定义的变化。

缺点:

  • 需要使用protobuf编译器生成代码。
  • 需要学习protobuf的IDL语法。

3.2.3 JSON 库 (RapidJSON, nlohmann_json)

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，易于阅读和编写，也易于机器解析和生成。许多C++ JSON库可以用来序列化和反序列化数据为JSON格式，方便与其他语言和系统集成。 常用的库包括RapidJSON和nlohmann_json。

示例：使用nlohmann_json序列化/反序列化一个类

#include <iostream>
#include <fstream>
#include <string>
#include <nlohmann/json.hpp> // 引入nlohmann_json库

using json = nlohmann::json;

class Person {
public:
    Person() {} // Required for serialization
    Person(int id, const std::string& name, int age) : id_(id), name_(name), age_(age) {}

    int id() const { return id_; }
    std::string name() const { return name_; }
    int age() const { return age_; }

private:
    int id_;
    std::string name_;
    int age_;

    friend json & operator<<(json &j, const Person &p) {
        j = json{{"id", p.id_}, {"name", p.name_}, {"age", p.age_}};
        return j;
    }

    friend const json & operator>>(const json &j, Person &p) {
        p.id_ = j.at("id").get<int>();
        p.name_ = j.at("name").get<std::string>();
        p.age_ = j.at("age").get<int>();
        return j;
    }
};

int main() {
    Person person1(123, "Alice", 30);

    // Serialize the Person object to a JSON string
    json j;
    j << person1;  // Use the overloaded << operator
    std::string json_string = j.dump();

    std::cout << "JSON String: " << json_string << std::endl;

    // Deserialize the JSON string back into a Person object
    Person person2;
    json j2 = json::parse(json_string);
    j2 >> person2; // Use the overloaded >> operator

    // Verify the data
    std::cout << "Person 2 ID: " << person2.id() << std::endl;
    std::cout << "Person 2 Name: " << person2.name() << std::endl;
    std::cout << "Person 2 Age: " << person2.age() << std::endl;

    // Serialize the object to file
    {
        std::ofstream ofs("person.json");
        ofs << j.dump(4); // pretty print with indentation of 4 spaces
    }

    // Deserialize from the file
    Person person3;
    {
        std::ifstream ifs("person.json");
        json j3;
        ifs >> j3;
        j3 >> person3;
    }

    // Verify the data
    std::cout << "Person 3 ID: " << person3.id() << std::endl;
    std::cout << "Person 3 Name: " << person3.name() << std::endl;
    std::cout << "Person 3 Age: " << person3.age() << std::endl;
    return 0;
}

在这个例子中，我们使用了 nlohmann_json 库来序列化和反序列化 Person 对象。 我们重载了 << 和 >> 运算符，以便将 Person 对象转换为JSON对象，并将JSON对象转换为 Person 对象。

优点:

  • 易于使用，代码简洁。
  • JSON格式易于阅读和编写。
  • 与其他语言和系统集成方便。
  • 许多C++ JSON库具有高性能。

缺点:

  • JSON格式的数据量通常比二进制格式的数据量大。
  • 缺乏版本控制。
  • 需要引入第三方库。

4. 选择合适的Marshaling/Unmarshaling 方法

选择合适的Marshaling/Unmarshaling 方法取决于具体的应用场景和需求。 需要考虑的因素包括：

  • 性能: 如果性能是关键因素，可以考虑手动实现或使用Protocol Buffers。
  • 复杂性: 对于简单的数据结构，手动实现可能更合适。 对于复杂的数据结构，使用序列化库可以简化开发。
  • 可移植性: 如果需要在不同的编程语言或平台之间交换数据，可以考虑使用Protocol Buffers或JSON。
  • 可读性: 如果需要人工阅读或编辑序列化后的数据，可以使用JSON或XML。
  • 版本控制: 如果需要处理数据结构的变化，可以选择支持版本控制的序列化库，例如Boost.Serialization或Protocol Buffers。
  • 依赖性: 需要考虑引入第三方库对程序的影响。

以下是一个简单的表格，总结了不同方法的特点：

方法 优点 缺点 适用场景
手动实现 控制力强、效率高 代码量大、容易出错、不适用于复杂数据结构、缺乏版本控制、缺乏灵活性 简单的数据结构、对性能要求极高、不依赖第三方库
Boost.Serialization 易于使用、支持多种存档类型、支持版本控制、功能强大 性能可能不如手动实现或Protocol Buffers、库的体积较大、编译时间可能较长 复杂的数据结构、需要版本控制、对性能要求不高
Protocol Buffers 性能高、语言无关、可扩展、体积小、支持版本控制 需要使用protobuf编译器生成代码、需要学习protobuf的IDL语法 网络通信、数据存储、对性能要求高、需要在不同的编程语言或平台之间交换数据
JSON 库 易于使用、代码简洁、JSON格式易于阅读和编写、与其他语言和系统集成方便、许多C++ JSON库具有高性能 JSON格式的数据量通常比二进制格式的数据量大、缺乏版本控制、需要引入第三方库 Web API、配置文件、需要在不同的编程语言或平台之间交换数据、需要人工阅读或编辑序列化后的数据

5. Marshaling/Unmarshaling 的一些注意事项

  • 数据对齐: 确保在不同的平台上数据对齐方式一致，否则可能会导致反序列化错误。
  • 字节序: 在不同的计算机体系结构中，字节序（Byte Order）可能不同（大端或小端）。 在Marshaling/Unmarshaling过程中，需要进行字节序转换。
  • 指针: 不能直接序列化指针，因为指针在不同的进程或计算机中可能无效。 需要将指针指向的数据也序列化。
  • 循环引用: 如果对象之间存在循环引用，需要特殊处理，否则可能会导致无限递归。
  • 安全性: 在Marshaling/Unmarshaling过程中，需要注意安全性，防止恶意数据攻击。 例如，可以对序列化后的数据进行签名或加密。
  • 版本兼容性: 当数据结构发生变化时，需要考虑版本兼容性，确保旧版本的数据可以被新版本的代码正确反序列化。

6. 代码示例：跨进程使用共享内存和Protobuf进行通信

以下示例展示了如何使用共享内存和Protocol Buffers在两个进程之间传递 Person 对象。

进程 1 (发送者):

#include <iostream>
#include <fstream>
#include <string>
#include <sys/ipc.h>
#include <sys/shm.h>
#include "person.pb.h"

int main() {
    // Generate a key for shared memory
    key_t key = ftok("shmfile", 65);

    // Get shared memory ID
    int shmid = shmget(key, sizeof(example::Person), 0666 | IPC_CREAT);
    if (shmid < 0) {
        perror("shmget");
        return 1;
    }

    // Attach shared memory
    example::Person* person = (example::Person*)shmat(shmid, NULL, 0);
    if (person == (example::Person*)(-1)) {
        perror("shmat");
        return 1;
    }

    // Create a Person object and populate data
    person->set_id(456);
    person->set_name("Bob");
    person->set_age(40);

    std::cout << "Sent Person: ID=" << person->id() << ", Name=" << person->name() << ", Age=" << person->age() << std::endl;

    // Detach from shared memory (sender doesn't release it)
    shmdt(person);

    return 0;
}

进程 2 (接收者):

#include <iostream>
#include <fstream>
#include <string>
#include <sys/ipc.h>
#include <sys/shm.h>
#include "person.pb.h"

int main() {
    // Generate a key for shared memory
    key_t key = ftok("shmfile", 65);

    // Get shared memory ID
    int shmid = shmget(key, sizeof(example::Person), 0666 | IPC_CREAT);
    if (shmid < 0) {
        perror("shmget");
        return 1;
    }

    // Attach shared memory
    example::Person* person = (example::Person*)shmat(shmid, NULL, 0);
    if (person == (example::Person*)(-1)) {
        perror("shmat");
        return 1;
    }

    // Read the Person object from shared memory
    std::cout << "Received Person: ID=" << person->id() << ", Name=" << person->name() << ", Age=" << person->age() << std::endl;

    // Detach from shared memory
    shmdt(person);

    // Destroy the shared memory segment (only receiver does this)
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

在这个例子中，两个进程都使用 ftok 函数生成相同的键，然后使用 shmget 函数获取共享内存的ID。 然后，两个进程都使用 shmat 函数将共享内存附加到自己的地址空间。 发送者进程创建一个 Person 对象，并将其数据写入共享内存。 接收者进程从共享内存读取 Person 对象的数据。 最后，接收者进程使用 shmdt 函数从共享内存分离，并使用 shmctl 函数销毁共享内存段。

请注意:

  • 需要在两个进程中包含相同的 .proto 文件和生成的 C++ 代码。
  • 需要确保共享内存的大小足够存储 Person 对象。
  • 错误处理至关重要，特别是在处理共享内存时。
  • 这个例子是一个简化的示例，实际应用中需要考虑更多的细节，例如同步和错误处理。

选择合适的工具完成数据传输

今天我们讨论了C++中Marshaling/Unmarshaling的重要性，以及几种常用的实现方法，包括手动实现、Boost.Serialization、Google Protocol Buffers和JSON库。选择哪种方法取决于具体的需求，需要在性能、复杂性、可移植性、可读性、版本控制和依赖性之间进行权衡。希望这次讲解能帮助大家更好地理解和使用Marshaling/Unmarshaling机制，从而构建更健壮、更高效的分布式系统。

更多IT精英技术系列讲座，到智猿学院

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注