【在Linux世界中追寻伟大的One Piece】手写序列化与反序列化

目录

[1 -> 序列化与反序列化概念](#1 -> 序列化与反序列化概念)

[2 -> 序列化与反序列化作用和应用场景](#2 -> 序列化与反序列化作用和应用场景)

[3 -> 手写序列化与反序列化](#3 -> 手写序列化与反序列化)

---

1 -> 序列化与反序列化概念

序列化是指将对象的状态信息转换为可以存储或传输的形式的过程，通常涉及将数据结构或对象转换成字节流或字符串格式。反序列化则是序列化的逆过程，即将序列化后的数据转换回原始的数据结构或对象。

2 -> 序列化与反序列化作用和应用场景

序列化和反序列化在软件开发中发挥着重要作用，尤其是在数据持久化、网络通信、分布式系统、远程方法调用(RMI)、Web服务、消息队列、移动应用、云服务和微服务架构等领域。它们使得数据可以在不同的系统、不同时刻之间进行有效的存储和传输。

3 -> 手写序列化与反序列化

#pragma once

#include <iostream>
#include <memory>
#include <jsoncpp/json/json.h>

// #define SelfDefine 1

namespace Protocol
{
	// 问题
	// 1. 结构化数据的序列和反序列化
	// 2. 还要解决用户区分报文边界 --- 数据包粘报问题
	// 讲法
	// 1. 自定义协议
	// 2. 成熟方案序列和反序列化
	// 总结：
	// "protocol_code\r\nlen\r\nx op y\r\n" : \r\n 不属于报文的一部分，约定
	const std::string ProtSep = " ";
	const std::string LineBreakSep = "\r\n";

	// "len\r\nx op y\r\n" : \r\n 不属于报文的一部分，约定
	std::string Encode(const std::string& message)
	{
		std::string len = std::to_string(message.size());
		std::string package = len + LineBreakSep + message +
			LineBreakSep;
		return package;
	}

	// "len\r\nx op y\r\n" : \r\n 不属于报文的一部分，约定
	// 我无法保证 package 就是一个独立的完整的报文
	// "l
	// "len
	// "len\r\n
	// "len\r\nx
	// "len\r\nx op
	// "len\r\nx op y
	// "len\r\nx op y\r\n"
	// "len\r\nx op y\r\n""len
	// "len\r\nx op y\r\n""len\n
	// "len\r\nx op
	// "len\r\nx op y\r\n""len\nx op y\r\n"
	// "len\r\nresult code\r\n""len\nresult code\r\n"
	bool Decode(std::string & package, std::string * message)
	{
		// 除了解包，我还想判断报文的完整性, 能否正确处理具有"边界"的报文
		auto pos = package.find(LineBreakSep);
		if (pos == std::string::npos)
			return false;

		std::string lens = package.substr(0, pos);
		int messagelen = std::stoi(lens);
		int total = lens.size() + messagelen + 2 *
			LineBreakSep.size();

		if (package.size() < total)
			return false;

		// 至少 package 内部一定有一个完整的报文了！
		*message = package.substr(pos + LineBreakSep.size(),
			messagelen);
		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)
		{
		}

		void Debug()
		{
			std::cout << "_data_x: " << _data_x << std::endl;
			std::cout << "_data_y: " << _data_y << std::endl;
			std::cout << "_oper: " << _oper << std::endl;
		}

		void Inc()
		{
			_data_x++;
			_data_y++;
		}

		// 结构化数据->字符串
		bool Serialize(std::string* out)
		{

#ifdef SelfDefine // 条件编译
			* out = std::to_string(_data_x) + ProtSep + _oper +
				ProtSep + std::to_string(_data_y);
			return true;
#else
			Json::Value root;
			root["datax"] = _data_x;
			root["datay"] = _data_y;
			root["oper"] = _oper;
			Json::FastWriter writer;
			*out = writer.write(root);
			return true;
#endif
		}

		bool Deserialize(std::string& in) // "x op y" [)
		{
#ifdef SelfDefine
			auto left = in.find(ProtSep);
			if (left == std::string::npos)
				return false;

			auto right = in.rfind(ProtSep);
			if (right == std::string::npos)
				return false;

			_data_x = std::stoi(in.substr(0, left));
			_data_y = std::stoi(in.substr(right +
				ProtSep.size()));
			std::string oper = in.substr(left + ProtSep.size(),
				right - (left + ProtSep.size()));
			if (oper.size() != 1)
				return false;

			_oper = oper[0];
			return true;
#else

			Json::Value root;
			Json::Reader reader;
			bool res = reader.parse(in, root);
			if (res)
			{
				_data_x = root["datax"].asInt();
				_data_y = root["datay"].asInt();
				_oper = root["oper"].asInt();
			}

			return res;
#endif
		}
		int GetX() 
		{ 
			return _data_x; 
		}

		int GetY() 
		{ 
			return _data_y; 
		}

		char GetOper() 
		{ 
			return _oper;
		}

	private:
		// _data_x _oper _data_y
		// 报文的自描述字段
		// "len\r\nx op y\r\n" : \r\n 不属于报文的一部分，约定
		// 很多工作都是在做字符串处理！
		int _data_x; // 第一个参数
		int _data_y; // 第二个参数
		char _oper; // + - * / %
	};

	class Response
	{
	public:
		Response() : _result(0), _code(0)
		{
		}

		Response(int result, int code) : _result(result),
			_code(code)
		{
		}

		bool Serialize(std::string* out)
		{
#ifdef SelfDefine
			* out = std::to_string(_result) + ProtSep +
				std::to_string(_code);
			return true;
#else
			Json::Value root;
			root["result"] = _result;
			root["code"] = _code;
			Json::FastWriter writer;
			*out = writer.write(root);
			return true;
#endif
		}

		bool Deserialize(std::string& in) // "_result _code" [)
		{
#ifdef SelfDefine
			auto pos = in.find(ProtSep);
			if (pos == std::string::npos)
				return false;
			_result = std::stoi(in.substr(0, pos));
			_code = std::stoi(in.substr(pos + ProtSep.size()));
			return true;
#else
			Json::Value root;
			Json::Reader reader;
			bool res = reader.parse(in, root);
			if (res)
			{
				_result = root["result"].asInt();
				_code = root["code"].asInt();
			}

			return res;
#endif
		}

		void SetResult(int res) 
		{ 
			_result = res; 
		}

		void SetCode(int code) 
		{ 
			_code = code; 
		}

		int GetResult() 
		{ 
			return _result; 
		}

		int GetCode() 
		{ 
			return _code;
		}

	private:
		// "len\r\n_result _code\r\n"
		int _result; // 运算结果
		int _code; // 运算状态
	};

	// 简单的工厂模式，建造类设计模式
	class Factory
	{

	public:
		std::shared_ptr<Request> BuildRequest()
		{
			std::shared_ptr<Request> req =
				std::make_shared<Request>();
			return req;
		}

		std::shared_ptr<Request> BuildRequest(int x, int y, char
			op)
		{
			std::shared_ptr<Request> req =
				std::make_shared<Request>(x, y, op);
			return req;
		}

		std::shared_ptr<Response> BuildResponse()
		{
			std::shared_ptr<Response> resp =
				std::make_shared<Response>();
			return resp;
		}

		std::shared_ptr<Response> BuildResponse(int result, int
			code)
		{
			std::shared_ptr<Response> req =
				std::make_shared<Response>(result, code);
			return req;
		}
	};
}

---

感谢各位大佬支持！！！

互三啦！！！