Linux 深入理解网络编程：应用层自定义协议、序列化、TCP 粘包与 Socket 封装

报文 = 报头 + 有效载荷

"有效载荷的长度"\r\n"有效载荷"\r\n

"len"\r\n"_x _op _y"\r\n -> len: 有效载荷的长度，约定\r\n是分隔符，不参与统计

2.3.1 编码操作：

我们自己利用自定义协议将报文封装起来，方便解码判断是否是一个完整的报文。

编码后的报文：有效载荷的长度 + 分隔符 + 有效载荷 + 分隔符

const std::string SEP = "\r\n"; // 我们把 tcp 中读到的报文，可能读到半个，也可能读到 1 个半个，TCP 粘报问题 // 解决 TCP 的粘报问题
std::string Encode(const std::string &json_str) {
    int json_str_len = json_str.size();
    std::string proto_str = std::to_string(json_str_len);
    proto_str += SEP;
    proto_str += json_str;
    proto_str += SEP;
    return proto_str;
}

2.3.2 解码操作

根据我们自己定义的协议，分离报头，分隔符后，看是否是一个完整的报头。

如果输入流还有内容，我们只需要从输入流中提取出一个完整的请求，剩余留着下一次处理！

std::string Decode(std::string &inbuffer) {
    auto pos = inbuffer.find(SEP);
    if (pos == std::string::npos) return std::string();
    std::string len_str = inbuffer.substr(0, pos);
    if (len_str.empty()) return std::string();
    int packlen = std::stoi(len_str);
    int total = packlen + len_str.size() + 2 * SEP.size();
    if (inbuffer.size() < total) return std::string();
    std::string package = inbuffer.substr(pos + SEP.size(), packlen);
    inbuffer.erase(0, total);
    return package;
}

2.4.如何使用 Json 进行序列化和反序列化

下面主要是主要代码

2.4.1 序列化

bool Serialize(std::string *out) {
    // 转换成为字符串
    Json::Value root;
    root["result"] = _result;
    root["code"] = _code;
    Json::FastWriter writer;
    // Json::StyledWriter writer;
    *out = writer.write(root);
    return true;
}

2.4.2 反序列化

bool Deserialize(const std::string &in) {
    Json::Value root;
    Json::Reader reader;
    bool res = reader.parse(in, root);
    if (!res) return false;
    _result = root["result"].asInt();
    _code = root["code"].asInt();
    return true;
}

3.封装 socket 类

3.1.封装思想

将 socket 系列操作分类封装，设计为基类，派生出 Tcp 和 Udp 两种具体的 Socket！基类都需要进行创建 socket 文件、进行绑定、进入 listen、获取链接、申请链接…由于两种类的操作方式不一致，所以基类只需要进行一个声明就可以，具体实现在派生类中完成！

以后直接调用相应接口即可，非常优雅！TcpSocket 继承 Socket 类，成员变量 sockfd。

3.2.基本框架

通过这些操作的组合，可以进行建立监听链接，建立客户端连接等操作，十分方便！这种设计模式是模版方法设计模式！！！

3.3.代码实现

#pragma once
#include <iostream>
#include <string>
#include <functional>
#include <sys/types.h>
/* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <cstring>
#include <pthread.h>
#include <sys/types.h>
#include <memory>
#include "InetAddr.hpp"
#include "Log.hpp"

// 模版方法模式
namespace socket_ns {
class Socket;
const static int gbacklog = 8;
using socket_sptr = std::shared_ptr<Socket>;
enum { SOCKET_ERROR = 1, BIND_ERROR, LISTEN_ERROR, USAGE_ERROR };

// std::unique_ptr<Socket> listensock = std::make_unique<TcpSocket>();
// listensock->BuildListenSocket();
// std::unique_ptr<Socket> clientsock = std::make_unique<TcpSocket>();
// clientsock->BuildClientSocket();
// clientsock->send();
// clientsock->Recv();

class Socket {
public:
    virtual void CreateSocketOrDie() = 0;
    virtual void BindSocketOrDie(InetAddr &addr) = 0;
    virtual void ListenSocketOrDie() = 0;
    virtual socket_sptr Accepter(InetAddr *addr) = 0;
    virtual bool Connecter(InetAddr &addr) = 0;
    virtual void SetSocketAddrReuse() = 0;
    virtual int SockFd() = 0;
    virtual int Recv(std::string *out) = 0;
    virtual int Send(const std::string &in) = 0;
    virtual void Close() = 0;
    // virtual void Recv() = 0;
    // virtual void Send() = 0;
    // virtual void other() = 0;

public:
    void BuildListenSocket(InetAddr &addr) {
        CreateSocketOrDie();
        SetSocketAddrReuse();
        BindSocketOrDie(addr);
        ListenSocketOrDie();
    }

    bool BuildClientSocket(InetAddr &addr) {
        CreateSocketOrDie();
        return Connecter(addr);
    }
    // void BuildUdpSocket()
    // {
    //     CreateSocketOrDie();
    //     BindSocketOrDie();
    // }
};

class TcpSocket : public Socket {
public:
    TcpSocket(int fd = -1) : _sockfd(fd) { }

    void CreateSocketOrDie() override {
        // 1. 创建流式套接字
        _sockfd = ::socket(AF_INET, SOCK_STREAM, 0);
        if (_sockfd < 0) {
            LOG(FATAL, "socket error");
            exit(SOCKET_ERROR);
        }
        LOG(DEBUG, "socket create success, sockfd is : %d\n", _sockfd);
    }

    void BindSocketOrDie(InetAddr &addr) override {
        // 2. bind
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(addr.Port());
        local.sin_addr.s_addr = inet_addr(addr.Ip().c_str());
        int n = ::bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
        if (n < 0) {
            LOG(FATAL, "bind error\n");
            exit(BIND_ERROR);
        }
        LOG(DEBUG, "bind success, sockfd is : %d\n", _sockfd);
    }

    void ListenSocketOrDie() override {
        int n = ::listen(_sockfd, gbacklog);
        if (n < 0) {
            LOG(FATAL, "listen error\n");
            exit(LISTEN_ERROR);
        }
        LOG(DEBUG, "listen success, sockfd is : %d\n", _sockfd);
    }

    socket_sptr Accepter(InetAddr *addr) override {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int sockfd = ::accept(_sockfd, (struct sockaddr *)&peer, &len);
        if (sockfd < 0) {
            LOG(WARNING, "accept error\n");
            return nullptr;
        }
        *addr = peer;
        socket_sptr sock = std::make_shared<TcpSocket>(sockfd);
        return sock;
    }

    virtual bool Connecter(InetAddr &addr) {
        // tcp client 要 bind，不要显示的 bind.
        struct sockaddr_in server;
        // 构建目标主机的 socket 信息
        memset(&server, 0, sizeof(server));
        server.sin_family = AF_INET;
        server.sin_port = htons(addr.Port());
        server.sin_addr.s_addr = inet_addr(addr.Ip().c_str());
        int n = connect(_sockfd, (struct sockaddr *)&server, sizeof(server));
        if (n < 0) {
            std::cerr << "connect error" << std::endl;
            return false;
        }
        return true;
    }

    void SetSocketAddrReuse() override {
        int opt = 1;
        ::setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));
    }

    int Recv(std::string *out) override {
        char inbuffer[4096];
        ssize_t n = ::recv(_sockfd, inbuffer, sizeof(inbuffer) - 1, 0);
        if (n > 0) {
            inbuffer[n] = 0;
            *out = inbuffer;
        }
        return n;
    }

    int Send(const std::string &in) override {
        int n = ::send(_sockfd, in.c_str(), in.size(), 0);
        return n;
    }

    int SockFd() override {
        return _sockfd;
    }

    void Close() override {
        if (_sockfd > -1) ::close(_sockfd);
    }

private:
    int _sockfd;
};

// class SocketFactor
// {
// public:
//     void Build
// }
} // namespace socket_ns