手写一个 RPC 远程调用(C++)

最新推荐文章于 2024-07-25 12:39:48 发布
最新推荐文章于 2024-07-25 12:39:48 发布
阅读量3.7k 收藏 19
点赞数 5
分类专栏： 网络编程 Linux 文章标签： rpc c++ 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WilliamCode/article/details/123131347
版权

手写一个 RPC 远程调用(C++)

版权声明

个人作品，禁止转载

参考资料

  • Build Remote Procedure Calls (RPC) - from scratch in C(https://www.udemy.com/course/linuxrpc/)
  • Linux manual page(https://man7.org/linux/man-pages/)
  • Cpp reference(https://en.cppreference.com/w/)

代码下载

https://github.com/541380000/write_rpc_from_scratch.git
或者从网盘下载
链接：https://pan.baidu.com/s/1BjTK3aH_T80umXsF9Yzqmg?pwd=5mof
提取码：5mof

推荐进阶工具

  • protobuf(对象序列化工具，按字节序列化)
  • msgpack(对象序列化工具，类似 json，但更加精简)
  • Boost 的序列化库

Overview

  • 这是一个学习型项目，旨在学习 RPC 如何运行
  • 这是一个 C++项目，只是用 C++标准库，不使用第三方库
  • 各个步骤纯手写，代码无法用于商业项目
  • 本项目不考虑机器大小端

预备知识

  • 基础的 c/c++知识
  • 基础的 socket 编程
  • 基础的 debug 能力

RPC 的步骤

  • RPC 客户端，序列化 RPC 头和 RPC 参数
  • RPC 客户端，将 RPC 头和参数打包成数据包，通过网络（等其他通信手段）发送
  • RPC 服务器，反序列化 RPC 头和 RPC 参数
  • RPC 服务器，执行远程调用
  • RPC 服务器，将 RPC 头和返回值打包成数据包，发送给客户端
  • RPC 客户端，反序列化 RPC 头和返回值，得到 RPC 结果

序列化和反序列化

基础数据类型:SerBuffer

结构体定义
SerBuffer是数据序列化和反序列化的缓冲区
```
using byte=char;
struct SerBuffer{
    vector<byte> buffer;
};
```
方法
创建新的 SerBuffer，预留若干字节的空间
unique_ptr<SerBuffer> creatSerBuffer(const uint32_t buffer_size=DEFAULT_INIT_SERIALIZE_BUFFER_SIZE){
    auto ptr = make_unique<SerBuffer>();
    ptr->buffer.reserve(buffer_size);
    return move(ptr);
}
将 nBytes 的数据复制到 buffer 中
void serializeData(const unique_ptr<SerBuffer>& buffer, const byte* data, const uint32_t nBytes){
    copy(data, data+nBytes, back_inserter(buffer->buffer));
}
跳过 n 字节，nBytes 为负则从缓冲区删除数据，为正则追加 nBytes 个 0
void serializeBufferSkip(const unique_ptr<SerBuffer>& buffer, int32_t nBytes){
    if (nBytes < 0)
        while(nBytes < 0) buffer->buffer.pop_back(), nBytes ++;
    else if (nBytes > 0)
        while(nBytes > 0) buffer->buffer.emplace_back('0'), nBytes --;
}
清空缓冲区
void resetSerBuffer(const unique_ptr<SerBuffer>& buffer){
    buffer->buffer.clear();
}
填充一个空指针，空指针用 0xFFFFFFFF 表示
void fillNull(const unique_ptr<SerBuffer>& buffer){
    uint32_t sentinel = 0xFFFFFFFF;
    serializeData(buffer, (byte*)&sentinel, 4);
}
将 RPC 头序列化到 buffer 中(RPC 头定义见下文)
void serializeRPCHeader(const unique_ptr<SerBuffer>& buffer, const RPCHeader* const header){
    serializeData(buffer, (char*)header, sizeof(header));
}

简单对象(反)序列化

简单对象定义为：只包含基础数据类型的结构体（不包含指针和其他结构体）

对象定义
using byte=char;
struct SimplePerson{
    byte name[30];
    uint32_t age;
    uint32_t weight;
};
序列化方法
  • 将数据拷贝到内存中，不考虑内存对齐。
  • 对于 SimplePerson，内存中应该包含：30 字节的 name，4 字节的 age，4 字节的 weight，共 38 字节
  • 如果传入参数为 NULL，则填充空指针，表示为 0xFFFFFFFF，否则填充数据
void serialize_simple_person(const SimplePerson* const obj, const unique_ptr<SerBuffer>& buffer){
    if(!obj){
        fillNull(buffer);
        return ;
    }
    serializeData(buffer, obj->name, sizeof(obj->name));
    serializeData(buffer, (char*)&obj->age, sizeof(obj->age));
    serializeData(buffer, (char*)&obj->weight, sizeof(obj->weight));
}
反序列化方法
  • 相反的过程，将数据提取出来即可
  • offset 为：从 buffer 的第几个字节开始，反序列化出来一个对象

unique_ptr<SimplePerson> deserialize_simple_person(const unique_ptr<SerBuffer>& buffer, uint32_t offset = 0){
    if (*(uint32_t*)buffer->buffer.data() == 0xFFFFFFFF)
        return {nullptr};

    auto ptr = make_unique<SimplePerson>();
    auto& person = *ptr;
    copy(buffer->buffer.begin() + offset, buffer->buffer.begin() + sizeof(person) + offset, person.name);
    offset += sizeof(person.name);

    person.age = *(decltype(person.age)*)(buffer->buffer.data() + offset);
    offset += sizeof(person.age);

    person.weight = *(decltype(person.weight)*)(buffer->buffer.data() + offset);
    offset += sizeof(person.weight);

    return move(ptr);
}
测试
void testSimplePerson(){
    SimplePerson p{"1234", 1, 1};
    auto buf = make_unique<SerBuffer>();
    printf("-------------------> SimplePerson\n");
    serialize_simple_person(&p, buf);
    printf("Full size of person after serialize: %zu, expected is %d\n", buf->buffer.size(), 30+4+4);
    cout << "Before  serialize: " << p << "\nAfter deserialize: " << *deserialize_simple_person(buf) << endl << endl;
}

嵌套对象(反)序列化

简单对象定义为：只包含基础数据类型和其他结构体的结构体（不包含指针）

对象定义
struct Occupation{
    char title[30];
    uint32_t id;
}
struct NestedPerson{
    char name[30];
    Occupation occupation;
    uint32_t age;
    uint32_t weight;
}
Occupation 的(反)序列化方法（简单对象序列化）
void serialize_simple_occupation(const Occupation* const obj, const unique_ptr<SerBuffer>& buffer){
    serializeData(buffer, obj->title, sizeof(obj->title));
    serializeData(buffer, (char*)&obj->id, sizeof(obj->id));
}

unique_ptr<Occupation> deserialize_simple_occupation(const unique_ptr<SerBuffer>& buffer, uint32_t offset = 0){
    auto ptr = make_unique<Occupation>();
    auto& occupation = *ptr;
    copy(buffer->buffer.begin() + offset, buffer->buffer.begin() + offset + sizeof(occupation.title), occupation.title);
    offset += sizeof(occupation.title);

    occupation.id = *(decltype(occupation.id)*)(buffer->buffer.data() + offset);

    return move(ptr);
}
序列化与反序列化方法
  • 如果遇到嵌套结构体，则调用嵌套结构体的序列化方法，将内层结构体序列化到 buffer 中
void serialize_nested_person(const NestedPerson* const obj, const unique_ptr<SerBuffer>& buffer){
    if (!obj){
        fillNull(buffer);
        return ;
    }
    serializeData(buffer, obj->name, sizeof(obj->name));
    serialize_simple_occupation(&obj->occupation, buffer);
    serializeData(buffer, (char*)&obj->age, sizeof(obj->age));
    serializeData(buffer, (char*)&obj->weight, sizeof(obj->weight));
}

unique_ptr<NestedPerson> deserialize_nested_person(const unique_ptr<SerBuffer>& buffer, uint32_t offset = 0){
    if (*(uint32_t*)buffer->buffer.data() == 0xFFFFFFFF)
        return {nullptr};

    auto ptr = make_unique<NestedPerson>();
    auto& person = *ptr;
    copy(buffer->buffer.begin() + offset, buffer->buffer.begin() + sizeof(person) + offset, person.name);
    offset += sizeof(person.name);

    person.occupation = *deserialize_simple_occupation(buffer, offset);
    offset += sizeof(person.occupation.title) + sizeof(person.occupation.id);

    person.age = *(decltype(person.age)*)(buffer->buffer.data() + offset);
    offset += sizeof(person.age);

    person.weight = *(decltype(person.weight)*)(buffer->buffer.data() + offset);
    offset += sizeof(person.weight);

    return move(ptr);
}
测试
void testNestedPerson(){
    NestedPerson p{"1234", {"doctor", 294}, 1, 1};
    auto buf = make_unique<SerBuffer>();
    printf("-------------------> NestedPerson\n");
    serialize_nested_person(&p, buf);
    printf("Full size of nested person after serialize: %zu, expected is %d\n", buf->buffer.size(), 30+4+4+30+4);
    cout << "Before  serialize: " << p << "\nAfter deserialize: " << *deserialize_nested_person(buf) << endl << endl;
}

含有指针的结构体的(反)序列化

结构体定义
struct PointerPerson{
    char name[30];
    Occupation* occupation;
    uint32_t age;
    uint32_t weight;
}
序列化与反序列化方法

如果有指针

  • 指针为空，则填充 0xFFFFFFFF(如你所见，这会导致问题)
  • 指针不为空，调用内层对象的序列化方法，将内层对象序列化到 buffer 中
void serialize_pointer_person(const PointerPerson* const obj, const unique_ptr<SerBuffer>& buffer){
    if (!obj){
        fillNull(buffer);
        return ;
    }
    serializeData(buffer, obj->name, sizeof(obj->name));
    serialize_simple_occupation(obj->occupation, buffer);
    serializeData(buffer, (char*)&obj->age, sizeof(obj->age));
    serializeData(buffer, (char*)&obj->weight, sizeof(obj->weight));
}

unique_ptr<PointerPerson> deserialize_pointer_person(const unique_ptr<SerBuffer>& buffer, uint32_t offset = 0){
    if (*(uint32_t*)buffer->buffer.data() == 0xFFFFFFFF)
        return {nullptr};

    auto ptr = make_unique<PointerPerson>();
    auto& person = *ptr;
    copy(buffer->buffer.begin() + offset, buffer->buffer.begin() + sizeof(person) + offset, person.name);
    offset += sizeof(person.name);

    person.occupation = deserialize_simple_occupation(buffer, offset).release();
    offset += sizeof(person.occupation->title) + sizeof(person.occupation->id);

    person.age = *(decltype(person.age)*)(buffer->buffer.data() + offset);
    offset += sizeof(person.age);

    person.weight = *(decltype(person.weight)*)(buffer->buffer.data() + offset);
    offset += sizeof(person.weight);

    return move(ptr);
}
测试
void testPointerPerson(){
    Occupation occ{"doctor", 294};
    PointerPerson p{"1234", &occ, 1, 1};
    auto buf = make_unique<SerBuffer>();
    printf("-------------------> PointerPerson\n");
    serialize_pointer_person(&p, buf);
    printf("Full size of pointer person after serialize: %zu, expected is %d\n", buf->buffer.size(), 30+4+4+30+4);
    cout << "Before  serialize: " << p << "\nAfter deserialize: " << *deserialize_pointer_person(buf) << endl << endl;
}

还有其他很多数据结构需要序列化，但是不应该这样手动实现

RPC 头

RPC 头应该包含如下信息

  • 远程调用 id，这里用 uint32_t 表示
  • payload 大小，即参数大小，用 uint32_t 表示
    定义为：
struct RPCHeader{
    uint32_t id;    // id of procedure
    uint32_t size;  // size of payload(argument)
};

RPC 服务器实现

下方的 id 为 1 的 RPC，实现如下功能：接受两个 SimplePerson 对象，给他们办结婚证
，返回值的 name 字段为 name1 -Merry- name2，age 最大值，weight 取最小值

// socket相关代码省略
// 从socket_fd读取指定字节的数据，存入buffer
int read_n_bytes(int connfd, char* buffer, int n_bytes){
    int tmp = 0;
    int cnt = 0;
    while (cnt < n_bytes) {
        if ((tmp = read(connfd, buffer + cnt, n_bytes - cnt)) == -1) {cout << "failed reading" << endl;return -1;}
        cnt += tmp;
    }
    return 0;
}
void handle_rpc(int connfd)
{

    char buff[BUFFER_SIZE];
    RPCHeader header{};
    for (;;) {
        bzero(buff, BUFFER_SIZE);
        // 读取RPC头
        if (read_n_bytes(connfd, buff, sizeof(RPCHeader))){
            printf("Error reading nbytes header\n");
            exit(-1);
        }

        memcpy(&header, buff, sizeof(RPCHeader));
        printf("Get header: id: %d\t\tpayload: %d\n", header.id, header.size);

        // 根据RPC头中指示的payload大小，读取参数
        bzero(buff, BUFFER_SIZE);
        if (read_n_bytes(connfd, buff, header.size)) {
            printf("Error reading nbytes payload\n");
            exit(-1);
        }

        auto buffer = make_unique<SerBuffer>();
        buffer->buffer.assign(buff, buff + header.size);
        cout << "Get header: " << header << endl;

        // 根据不同的远程调用id，执行远程调用
        switch (header.id) {
            // get merry of two person
            case 1:{
                // 解析两个参数
                auto p1 = deserialize_simple_person(buffer);
                auto p2 = deserialize_simple_person(buffer, header.size / 2);

                // 产生新的对象
                auto res = string(p1->name) + string(" -Merry- ") + string(p2->name);
                auto resp_buf = make_unique<SerBuffer>();
                SimplePerson p{};
                memcpy(p.name, res.c_str(), res.length());
                p.age = max(p1->age, p2->age);
                p.weight = min(p1->weight, p2->weight);
                // 产生RPC头，id为1的RPC请求，其返回的id为100+1=101
                RPCHeader resp_header{100+header.id, sizeof(p.weight) + sizeof(p.name) + sizeof(p.age)};
                // 序列化返回值并发送
                serializeRPCHeader(resp_buf, &resp_header);
                serialize_simple_person(&p, resp_buf);
                // send it back
                if (send(connfd, resp_buf->buffer.data(), resp_buf->buffer.size(), 0) == -1){
                    return ;
                }
                break;
            }
            case 2:{
                // .... do something
            }
            default:{
                printf("Invalid rpc id: %d\n", header.id);
                break;
            }
        }
    }
}

RPC 客户端实现

如下代码将调用 id 为 1 的 RPC，并接收结果

// socket相关代码省略
void func(int sockfd)
{
    char buff[BUFFER_SIZE];
    int n;
    bzero(buff, sizeof(buff));
    /**
     * to run rpc, we will follow the steps:
     * 1. serialize RPC header to a buffer
     * 2. serialize RPC argument to a buffer
     * 3. send RPC package through socket
     * 4. receive the response
     * 5. deserialize RPC package
     */
    // 1. serialize RPC header to a buffer
    RPCHeader rpcHeader{};
    rpcHeader.id = 1;
    // TODO: size will be assigned after argument serialize

    // 2. serialize RPC argument to a buffer
    SimplePerson p1{"Tony", 23, 160};
    SimplePerson p2{"Jenny", 21, 100};


    auto argumentBuffer = make_unique<SerBuffer>();
    serialize_simple_person(&p1, argumentBuffer);
    serialize_simple_person(&p2, argumentBuffer);
    rpcHeader.size = argumentBuffer->buffer.size();

    // combine 1 & 2
    auto buffer = make_unique<SerBuffer>();
    serializeRPCHeader(buffer, &rpcHeader);
    copy(argumentBuffer->buffer.begin(), argumentBuffer->buffer.end(), back_inserter(buffer->buffer));

    cout << "send request -> p1: " << p1 << "\t\tp2: " << p2 << endl;
    // cout << "buf sent: " << buffer->buffer.size() << endl;
    send(sockfd, buffer->buffer.data(), buffer->buffer.size(), 0);

    rpcHeader = {};
    read_n_bytes(sockfd, (char*)&rpcHeader, sizeof(rpcHeader));
    // printf("From Server : %s", buff);
    read_n_bytes(sockfd, buff, rpcHeader.size);
    resetSerBuffer(argumentBuffer);
    copy(buff, buff+rpcHeader.size, back_inserter(argumentBuffer->buffer));
    auto resp = deserialize_simple_person(argumentBuffer, 0);

    cout << "Get response -> " << *resp << endl;
}
WilliamCode
关注
  • 5
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
一文讲解 基于C++手写Rpc项目
hch977的博客
06-07 2590
一文讲解C++ rpc的实现, 基于muduo与protobuf
RPC讲解与完整版C++代码示例
Warren++的博客
05-14 948
RPC讲解与完整版C++代码示例
手写rpc远程过程调用框架
xiaoyou137的博客
02-26 486
这是一个模仿grpc,基于TCP协议和protobuf编解码的RPC框架，支持多种数据类型的序列化和反序列化，使用muduo网络库实现高并发处理,使用zookeeper作为服务配置中心。同时，采用了函数特征的模板类和protobuf框架自动生成代码等技术，使得代码实现简洁高效。
如何手写一个RPC？，2024年最新先收藏了
2301_79099473的博客
04-19 886
现代RPC系统，如JSON-RPC：一个无状态、轻量级的远程过程调用（RPC）协议，以JSON（JavaScript Object Notation）作为数据格式，可以使用各种传输协议。ProxyFactory，动态代理模式，主要在调用的过程当中屏蔽网络通讯相关的一些细节，使得我们开发人员在使用过程中不再关注网络细节。通过方法参数列表，可以得到参数类型列表，然后再通过方法名，就可以得到具体的方法；单体架构初始开发简单，所有的功能都在一个项目中，容易理解整个应用的业务，而且部署也比较简单，就一个服务。
【手写一个RPC框架】序章 simpleRPC-01
锥栗的博客
12-18 1019
序章 RPC（RemoteProcedureCall）—远程过程调用，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。 在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。 在本模块中，我们试图实现client通过指定id，通过RPC框架，从server拿到id对应的User对象信息。 本项目实现参考自MyRPCFromZero 环境 JDK.
手写一个简单的rpc框架
qq_48336929的博客
10-05 191
手写一个简单的rpc框架 自己手写的一个小RPC框架，只是为了巩固自己所学的知识。 几个概念 RPC: Remote Procedure Call即远程过程调用，是分布式系统常用的一种通信方法，从跨进程到跨物理机已经有十几年的历史了。 Procedure: 一段可执行的代码，自我可理解为java中的方法而已。 跨进程的交互方式： RESTful、WebService、HTTP、基于DB做数据交换，基于MQ数据交换及RPC 几个模块 my-rpc my-rpc-common:公共模块（工具类） my-rpc
手写一个简单的RPC
qq_45100361的博客
02-03 154
公共类 public class User implements Serializable { private static final long serialversionUID = 1L; private Integer id; private String name; public User(Integer id, String name) { this.id = id; this.name = name; } p
RPC原理及实现—阿里带你从无到有手写一个RPC框架
m0_55849656的博客
06-11 450
RPC原理及实现—阿里带你从无到有手写一个RPC框架
2024年最全【Java】远程调用、线程池手写一个简单服务器_远程终端线程池(1)，C C++高级开发岗必问知识点
2401_84976285的博客
05-15 325
RPC 框架需要解决的一个问题是：像调用本地接口一样调用远程的接口。​举个例子，你突然想吃外面的 () 炸鸡了，但你（）又不会做。**流程 **：服务端建立 **socket **监听端口 【服务端创建 socket 监听端口 --> 如果有服务来就开启一个线程去响应服务】 【客户端 调用接口 --> 向服务端建立 socket --》 服务端通过反射和代理实现调用内容通过 socket 返回】上图是服务器上面发送** 一个** 请求的模式。但实际情况是的访问情况，服务端被客户端访问。
手写一个RPC远程调用（基于netty、反射和代理）
01-20
基于这个原因，我今天就花费了半天的时间通过查资料做了一个远程调用rpc。 首先呢，我们的这个项目是基于netty、动态代理、反射等知识实现的，如果童鞋们对这块内容还有不熟的地方，建议去先了解一下这些知识，再来...
Java使用传统socket手写的远程RPC框架调用框架
11-10
RPC的本质是通过网络协议在两个进程之间传递参数和返回结果，它隐藏了网络通信的细节，让开发者可以像调用本地方法一样调用远程服务。在Java中，Socket是实现网络通信的基础，它提供了双向的数据通道，可以用来建立...
手写rpc rpc简单源码 rpc源码学习 rpc过程了解 rpc通信原理
09-20
它为开发者提供了一种透明调用远程服务的方式，使得分布式系统开发更为便捷。下面将详细解释RPC的核心概念、工作原理以及手写RPC的基本流程。 一、RPC核心概念 1. **客户端（Client）**：发起RPC调用的一方，它...
C++编程实现的手写数字识别
05-07
总的来说，C++实现手写数字识别是一个涉及多领域知识的综合项目，需要理解和运用图像处理、机器学习以及编程技巧。通过这个项目，不仅可以提升编程技能，还能深入理解图像识别背后的原理和技术。在实践中，你将不断...
百度手写板代码JavaScript远程调用的实现(鼠标输入法)
01-19
百度在线手写板 #sx{color:#00C;text-decoration:underline;cursor:pointer;} [Ctrl+A 全选 注:如需引入外部Js需刷新才能执行]
netty应用-手写RPC
program哲学
07-25 1318
本文详细介绍如何基于netty实现一个RPC框架，包含了RPC框架网络通信部分的各个模块的实现说明，如序列化、超时处理、动态代理、日志封装、粘包拆包等
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1242
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++ primer plus 第16章string 类和标准模板库, 关联容器
最新发布
zhyjhacker的博客
07-25 702
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 290
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
简单手写一个rpc框架
03-10
手写一个RPC框架需要实现以下几个步骤： 1. 定义协议：定义客户端和服务端之间通信的协议，包括数据格式、编码方式、传输协议等。 2. 生成代码：根据协议生成客户端和服务端的代码，包括序列化和反序列化的代码、...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值