手写序列化与反序列化：StructSerializer 与协议设计实战

#include <string>     // std::string
#include <iostream>   // std::cout 调试；编译目标是链接时用到
 
// 板块常量：整个 Protocol 命名空间共用的"协议约定"
namespace Protocol
{
    // 分隔单个字段用的分隔符（后面 Request/Response 的字段拆解会用到）
    const std::string ProtSep = " ";
    // 分隔"长度数字/正文"、标记"一条消息结束"用的换行
    const std::string LineBreakSep = "\r\n";
 
    // 编码：把一段正文 message 包成一个完整的、自带边界的"包" package
    // 约定为 "长度\r\n正文\r\n"
    std::string Encode(const std::string &message)
    {
        // 1) 先把正文长度转成十进制字符串，比如 5 变成 "5"
        std::string len = std::to_string(message.size());
        // 2) 按约定拼装：长度 + \r\n + 正文 + \r\n
        std::string package = len + LineBreakSep + message + LineBreakSep;
        return package;   // 这就是一个可以在网络上发的"完整包"
    }
}

    // 解码：从缓冲区 package 里尝试剥出"恰好一条"完整消息到 message
    // 返回值 true 表示成功剥出一条；false 表示字节还不够形成完整一条
    bool Decode(std::string &package, std::string *message)
    {
        // 步骤一：找第一个 \r\n，它前面的那个数字就是"这条消息的长度"
        auto pos = package.find(LineBreakSep);
        if (pos == std::string::npos)
            return false;   // 连 \r\n 都没找到：说明长度数字都还没到齐，属于"半包"，先等数据
 
        // 取到长度数字对应的字符串，比如 "5"
        std::string lens = package.substr(0, pos);
 
        // 把长度字符串转成真正的数字。注意：这里可能抛异常（后面健壮性一节会讲）
        int messagelen = std::stoi(lens);
 
        // 计算这一条完整消息总共占多少字节：
        //   = 长度数字的字节数(lens.size())
        //   + 第一个 \r\n(LineBreakSep.size())
        //   + 真正的正文(messagelen)
        //   + 收尾的 \r\n(LineBreakSep.size())
        int total = lens.size() + messagelen + 2 * LineBreakSep.size();
 
        // 步骤二：判断缓冲区里字节够不够 total。
        // 如果 package.size() < total，说明正文还有一部分没到，也是"半包"，
        // 此时绝不能被砍掉，返回 false，等后续数据拼上来。
        if (package.size() < total)
            return false;
 
        // 到这里，可以确定：缓冲区里至少有一个完整消息了。
        // 正文位置从 pos + \r\n 之后开始，长度为 messagelen。
        *message = package.substr(pos + LineBreakSep.size(), messagelen);
 
        // 把已经消费掉的这条完整消息（共 total 字节）从缓冲区前部删掉，
        // 剩下的（可能是另一条消息，或下一条消息的半包）留在 package 里给下次用。
        package.erase(0, total);
 
        return true;   // 成功剥出一条
    }
}

    class Request
    {
    public:
        Request() : _data_x(0), _data_y(0), _oper(0) {}   // 默认构造：清零
        Request(int x, int y, char op)
            : _data_x(x), _data_y(y), _oper(op) {}        // 带参构造
        int  GetX()    { return _data_x; }                // 取第一个操作数
        int  GetY()    { return _data_y; }                // 取第二个操作数
        char GetOper() { return _oper; }                  // 取运算符
 
    private:
        int  _data_x;   // 第一个操作数
        int  _data_y;   // 第二个操作数
        char _oper;     // 运算符 + - * / %
    };

        // 序列化：把自己的字段拼成一个字符串，例如 "3 + 5"
        bool Serialize(std::string *out)
        {
            // 用 to_string 把数字变成字符串，用 ProtSep(空格) 分隔各字段
            *out  = std::to_string(_data_x) + ProtSep   // "3"
                 + _oper                 + ProtSep   // "+"
                 + std::to_string(_data_y);           // "5"
            // 拼出来就是 "3 + 5"
            return true;
        }

        // 反序列化：把形如 "x op y" 的字符串解析回自己的三个字段
        bool Deserialize(std::string &in)   // 入参：形如 "3 + 5"
        {
            // 1) 找第一个空格，它的左边就是第一个操作数
            auto left = in.find(ProtSep);                 // 定位到 "3" 之后的空格
            if (left == std::string::npos)
                return false;                             // 连空格都没有：格式非法
 
            // 2) 找最后一个空格，它的右边就是第二个操作数
            auto right = in.rfind(ProtSep);               // 定位到 "+" 之后的空格
            if (right == std::string::npos)
                return false;                             // 理论不会出现，防御性检查
 
            // 3) 从左边截取第一个操作数，从右边截取第二个操作数
            _data_x = std::stoi(in.substr(0, left));          // "3"
            _data_y = std::stoi(in.substr(right + ProtSep.size())); // "5"
            // 注意：right + ProtSep.size() 是"跳到最后一个空格之后"的位置
            // 也就是第二个操作数的起点
 
            // 4) 中间夹着的就是运算符，长度必须是 1
            std::string oper = in.substr(left + ProtSep.size(),     // 从第一个空格之后起
                                         right - (left + ProtSep.size())); // 到最后一个空格前
            if (oper.size() != 1)
                return false;                             // 运算符不是单字符：格式非法
            _oper = oper[0];                              // 取出那个字符
            return true;
        }
    };

    class Response
    {
    public:
        Response() : _result(0), _code(0) {}      // 默认构造
        Response(int result, int code) : _result(result), _code(code) {}
        void SetResult(int res) { _result = res; }  // 设置运算结果
        void SetCode(int code)  { _code = code; }   // 设置状态码
        int  GetResult() { return _result; }        // 取结果
        int  GetCode()   { return _code; }          // 取状态码
 
        // 序列化：拼成 "_result _code"，例如 "8 0"
        bool Serialize(std::string *out)
        {
            *out = std::to_string(_result) + ProtSep + std::to_string(_code);
            return true;
        }
 
        // 反序列化：用第一个空格切开前后两段
        bool Deserialize(std::string &in)   // 入参：形如 "8 0"
        {
            auto pos = in.find(ProtSep);               // 找空格
            if (pos == std::string::npos)
                return false;                         // 格式非法
            _result = std::stoi(in.substr(0, pos));          // "8"
            _code   = std::stoi(in.substr(pos + ProtSep.size())); // "0"
            return true;
        }
    private:
        int _result; // 运算结果
        int _code;   // 运算状态（0 表示成功，非 0 表示出错码）
    };

#include <arpa/inet.h>   // 提供 htonl / ntohl
#include <cstdio>
 
int main()
{
    // 发送方：以主机(小端)视角构造这个整数
    int value = 0x01020304;
    // 转成网络字节序（大端）后再发到网络
    int net_value = htonl(value);
    std::printf("主机序 0x%08X -> 网络序 0x%08X\n", value, net_value);
 
    // 接收方：收到网络序字节后，转回主机序使用
    int recv = ntohl(net_value);
    std::printf("还原回主机的值 = 0x%08X\n", recv);
    return 0;
}

struct A {
    char c;     // 1 字节
    int  i;     // 4 字节
};

    bool Decode(std::string &package, std::string *message)
    {
        // 防御一：出参为空指针，直接失败
        if (message == nullptr)
            return false;
 
        // 防御二：约定单条报文最大长度，防止恶意超大长度字段拖垮我们
        const size_t MaxMessageLength = 1 * 1024 * 1024;   // 1MB
 
        // 防御三：找不到 \r\n，说明长度数字都没到齐，半包，等待
        auto pos = package.find(LineBreakSep);
        if (pos == std::string::npos)
            return false;
 
        std::string lens = package.substr(0, pos);   // 长度数字文本
 
        // 防御三：解析长度数字，失败或非法一律返回 false（绝不信任网络数据）
        long messagelen = 0;
        try {
            messagelen = std::stol(lens);            // 可能抛异常，必须接住
        } catch (const std::exception & /*e*/) {
            return false;                            // 长度字段非法：当垃圾报文丢弃
        }
 
        // 防御四：长度不能为负、不能超过上限
        if (messagelen < 0 || (size_t)messagelen > MaxMessageLength)
            return false;
 
        // 计算这条完整消息总共多少字节（两个 \r\n 一个都不能少）
        size_t total = lens.size()
                     + LineBreakSep.size()          // 长度数字后的 \r\n
                     + (size_t)messagelen           // 正文字节数
                     + LineBreakSep.size();         // 正文后的 \r\n
 
        // 防御五：缓冲区字节不够，半包，等待更多数据
        if (package.size() < total)
            return false;
 
        // 剥出一条完整消息
        *message = package.substr(pos + LineBreakSep.size(), (size_t)messagelen);
        package.erase(0, total);                    // 消费掉这条
        return true;
    }

#include <jsoncpp/json/json.h>   // Jsoncpp 的 Json::Value 及相关读写器
#include <string>                // std::string
#include <memory>                // std::unique_ptr
#include <sstream>               // std::ostringstream / std::istringstream
 
// Request 的 Json 版序列化：把三个字段装进一个 Json 对象
bool RequestToJson(int x, int y, char op, std::string *out)
{
    Json::Value root;                 // 一个万能容器，能放键值对
    root["datax"] = x;                // 存成有名字的字段
    root["datay"] = y;
    root["oper"]  = op;               // 注意：char 会被当作整数存（见下）
 
    // 用 StreamWriterBuilder 生成紧凑的 Json 文本（新版本库推荐用法）
    Json::StreamWriterBuilder writer;
    std::unique_ptr<Json::StreamWriter> jw(writer.newStreamWriter());
    std::ostringstream oss;           // 需要一个字符串缓冲当输出流
    jw->write(root, &oss);            // 写出 Json 文本
    *out = oss.str();                 // 形如: {"datax":3,"datay":5,"oper":43}
    return true;
}
 
// Request 的 Json 版反序列化：从 Json 文本还原字段
bool JsonToRequest(const std::string &in, int *x, int *y, char *op)
{
    Json::Value root;
    Json::CharReaderBuilder reader;   // 新版本库推荐的 Json 读取方式
    std::string errs;
    std::istringstream iss(in);       // 把字符串包成输入流
    bool ok = Json::parseFromStream(reader, iss, &root, &errs);
    if (!ok)
        return false;                 // Json 文本非法
    *x = root["datax"].asInt();       // 取回字段
    *y = root["datay"].asInt();
    *op = (char)root["oper"].asInt(); // char 在 Json 里以整数存取，再转回字符
    return true;
}

#include <memory>     // std::shared_ptr / std::make_shared
 
    class Factory
    {
    public:
        // 造一个"默认空"的 Request
        std::shared_ptr<Request> BuildRequest()
        {
            return std::make_shared<Request>();     // 用默认构造
        }
        // 造一个"带参"的 Request
        std::shared_ptr<Request> BuildRequest(int x, int y, char op)
        {
            return std::make_shared<Request>(x, y, op);  // 用带参构造
        }
        // 造默认的 Response
        std::shared_ptr<Response> BuildResponse()
        {
            return std::make_shared<Response>();    // 用默认构造
        }
        // 造带结果的 Response
        std::shared_ptr<Response> BuildResponse(int result, int code)
        {
            return std::make_shared<Response>(result, code); // 用带参构造
        }
    };

// main.cpp —— 手写序列化与反序列化：完整可运行演示
// 编译：g++ -std=c++17 main.cpp -o a.out && ./a.out
#include <string>     // std::string
#include <memory>     // std::shared_ptr / make_shared
#include <iostream>   // std::cout / std::endl
#include <exception>  // std::exception（stoi 抛异常捕获用）
 
namespace Protocol
{
    // 协议的硬约定：字段间用空格，报文帧用 \r\n 做"头标/尾标"
    const std::string ProtSep = " ";
    const std::string LineBreakSep = "\r\n";
 
    // 编码：把一段正文 message 包成自带长度的网包 "len\r\n正文\r\n"
    std::string Encode(const std::string &message)
    {
        std::string len = std::to_string(message.size()); // 正文长度->文本
        return len + LineBreakSep + message + LineBreakSep;
    }
 
    // 解码：从缓冲区 package 尝试剥出恰好一条完整消息
    bool Decode(std::string &package, std::string *message)
    {
        if (message == nullptr) return false;             // 出参空指针防御
        const size_t MaxLen = 1 * 1024 * 1024;            // 单条最大 1MB，防超级长度
        auto pos = package.find(LineBreakSep);            // 找长度数字结尾
        if (pos == std::string::npos) return false;       // 半包：长度都没到齐
        std::string lens = package.substr(0, pos);        // 长度数字文本
        long n = 0;
        try { n = std::stol(lens); }                       // 解析长度，可能抛异常
        catch (const std::exception &) { return false; }  // 非法长度：当垃圾丢
        if (n < 0 || (size_t)n > MaxLen) return false;    // 负长度 / 超上限：非法
        size_t total = lens.size() + LineBreakSep.size()  // 头标
                     + (size_t)n + LineBreakSep.size();   // 正文 + 尾标
        if (package.size() < total) return false;         // 半包：正文没到齐
        *message = package.substr(pos + LineBreakSep.size(), (size_t)n); // 取正文
        package.erase(0, total);                          // 消费掉这条完整消息
        return true;
    }
 
    class Request
    {
    public:
        Request() : _data_x(0), _data_y(0), _oper(0) {}
        Request(int x, int y, char op) : _data_x(x), _data_y(y), _oper(op) {}
        int  GetX()    { return _data_x; }
        int  GetY()    { return _data_y; }
        char GetOper() { return _oper; }
        // 序列化：拼成 "x op y"
        bool Serialize(std::string *out)
        {
            *out = std::to_string(_data_x) + ProtSep
                 + _oper + ProtSep
                 + std::to_string(_data_y);
            return true;
        }
        // 反序列化：解析 "x op y"，用 find/rfind 夹出运算符
        bool Deserialize(std::string &in)
        {
            auto left  = in.find(ProtSep);              // 第一个空格
            if (left == std::string::npos) return false;
            auto right = in.rfind(ProtSep);             // 最后一个空格
            if (right == std::string::npos) return false;
            try {
                _data_x = std::stoi(in.substr(0, left));
                _data_y = std::stoi(in.substr(right + ProtSep.size()));
            } catch (const std::exception &) { return false; }
            std::string oper = in.substr(left + ProtSep.size(),
                                         right - (left + ProtSep.size()));
            if (oper.size() != 1) return false;          // 运算符必须单字符
            _oper = oper[0];
            return true;
        }
        void Debug()
        {
            // 打出来验证解析是否正确
            std::cout << "  x=" << _data_x << " y=" << _data_y
                      << " op=" << _oper << std::endl;
        }
    private:
        int  _data_x;  // 操作数1
        int  _data_y;  // 操作数2
        char _oper;    // 运算符 + - * / %
    };
 
    class Response
    {
    public:
        Response() : _result(0), _code(0) {}
        Response(int result, int code) : _result(result), _code(code) {}
        void SetResult(int r) { _result = r; }
        void SetCode(int c)   { _code = c; }
        int  GetResult() { return _result; }
        int  GetCode()   { return _code; }
        // 序列化：拼成 "result code"
        bool Serialize(std::string *out)
        {
            *out = std::to_string(_result) + ProtSep + std::to_string(_code);
            return true;
        }
        // 反序列化：用第一个空格切开
        bool Deserialize(std::string &in)
        {
            auto pos = in.find(ProtSep);
            if (pos == std::string::npos) return false;
            try {
                _result = std::stoi(in.substr(0, pos));
                _code   = std::stoi(in.substr(pos + ProtSep.size()));
            } catch (const std::exception &) { return false; }
            return true;
        }
        void Debug()
        {
            std::cout << "  result=" << _result << " code=" << _code << std::endl;
        }
    private:
        int _result;  // 运算结果
        int _code;    // 状态码，0=成功
    };
 
    class Factory
    {
    public:
        // 创建空/带参的 Request
        std::shared_ptr<Request> BuildRequest() { return std::make_shared<Request>(); }
        std::shared_ptr<Request> BuildRequest(int x, int y, char op)
        { return std::make_shared<Request>(x, y, op); }
        // 创建空/带参的 Response
        std::shared_ptr<Response> BuildResponse() { return std::make_shared<Response>(); }
        std::shared_ptr<Response> BuildResponse(int result, int code)
        { return std::make_shared<Response>(result, code); }
    };
}
 
// 模拟一个"简单计算器"：真正处理一次算术请求，返回一条应答
std::string DoCalc(int x, int y, char op, int *code)
{
    int r = 0;
    switch (op) {
        case '+': r = x + y; break;
        case '-': r = x - y; break;
        case '*': r = x * y; break;
        case '/': if (y == 0) { *code = 1; return Protocol::Encode("div by zero"); }
                  r = x / y; break;
        case '%': if (y == 0) { *code = 2; return Protocol::Encode("mod by zero"); }
                  r = x % y; break;
        default : *code = 3; return Protocol::Encode("bad op");
    }
    *code = 0;
    Protocol::Response resp(r, *code);   // 构造应答
    std::string body;
    resp.Serialize(&body);              // 对象->字符串
    return Protocol::Encode(body);      // 再套上"长度+边界"
}
 
int main()
{
    using namespace Protocol;
    Factory factory;   // 用工厂创建对象
 
    // —— 场景演示：粘包 ——
    // 构造两条独立消息，在"发送端"各自 Encode，但接收端把它们一次性塞进同一缓冲区：
    // 这模拟一次 recv 拿到两个包（粘包）。
    auto r1 = factory.BuildRequest(3, 5, '+');
    auto r2 = factory.BuildRequest(12, 4, '/');
    std::string b1, b2;
    r1->Serialize(&b1);
    r2->Serialize(&b2);
 
    std::string wire = Encode(b1) + Encode(b2);   // 两个完整包拼进一个缓冲区 = 粘包
    std::cout << "【粘包】一次拿到两个完整包，字节流如下（已做可读化）：\n"
              << "  " << wire << std::endl
              << "字节总数: " << wire.size() << std::endl;
 
    // 循环剥包：while 内部分裂直到剥不出来（剥完或只剩半包）
    std::string msg;
    while (Decode(wire, &msg)) {
        Request req;                    // 一个空请求对象
        req.Deserialize(msg);           // 解析刚剥出的正文
        std::cout << "  剥出一条 Request：";
        req.Debug();                    // 打印字段
    }
    std::cout << "  剩余未剥字节：" << wire.size() << "（应为0）\n\n";
 
    // —— 场景演示：半包 ——
    // 把一条完整网包硬切成两半，分成两次喂给 Decode，模拟一次 recv 只到一半。
    auto r3 = factory.BuildRequest(9, 3, '*');
    std::string b3;
    r3->Serialize(&b3);
    std::string whole = Encode(b3);          // 完整包
    std::string half1 = whole.substr(0, 6);  // 前半段
    std::string half2 = whole.substr(6);     // 后半段（剩余）
    std::cout << "【半包】把一条包切成两半依次投喂：\n";
 
    std::string buf;
    buf += half1;                            // 只喂前半段
    std::cout << "  喂入前半段后 Decode 状态：";
    std::string out;
    bool got = Decode(buf, &out);
    std::cout << (got ? "剥出（不该出现）" : "没剥出，正确等待半包") << std::endl;
 
    buf += half2;                            // 补齐后半段
    std::cout << "  补齐后半段后 Decode 状态：";
    got = Decode(buf, &out);
    if (got) {
        Request req2;
        req2.Deserialize(out);
        std::cout << "剥出完整 Request：";
        req2.Debug();
        std::cout << "  剩余未剥字节：" << buf.size() << "（应为0）\n";
    } else {
        std::cout << "仍没剥出（异常）" << std::endl;
    }
 
    // —— 场景演示：完整往返 —— 客户端请求 → 服务端计算 → 服务端应答
    std::cout << "\n【完整往返】服务端计算 3+5：" << std::endl;
    int code = 0;
    std::string replyWire = DoCalc(3, 5, '+', &code);  // 服务端算完并编码成网包
    std::string replyBody;
    Decode(replyWire, &replyBody);                     // 剥出结果正文
    Response resp;
    resp.Deserialize(replyBody);                       // 解析结果字段
    std::cout << "  结果包正文: \"" << replyBody << "\"\n";
    resp.Debug();                                      // 打印 result / code
 
    std::cout << "\n全部场景演示完毕。" << std::endl;
    return 0;
}