深入掌握 Protobuf 与 RPC 的高效结合：实现C++工程中的高效通信

TravisBytes2024-10-02 23:46

目录

在现代分布式系统中，高效的通信至关重要，而Protobuf（Protocol Buffers）不仅能提供数据序列化的高效性，还常被用于与RPC（远程过程调用）框架结合，优化客户端与服务器之间的通信效率。本文将详细解析如何在C++工程中使用Protobuf，并结合RPC框架，构建高性能的分布式系统通信机制。

一、Protobuf与RPC框架的通信流程概述

为了便于理解，以下结合Protobuf和RPC的通信流程进行详细解析：

  1. 定义IDL（接口定义语言）文件 ：通过Protobuf的.proto文件，定义服务接口和消息格式，这是所有客户端与服务器通信的基础。

  2. 编译IDL文件 ：使用Protobuf编译器（protoc），生成客户端与服务器的代码骨架。这一步使得开发者无需关心底层通信细节，大幅减少编码工作量。

  3. 客户端调用服务：客户端通过调用生成的骨架代码发起请求，Protobuf负责将消息进行序列化，并通过RPC框架的协议栈传输至服务器。

  4. 服务器处理请求：服务器接收客户端请求，反序列化数据，执行相应的业务逻辑，并将结果序列化为响应数据返回给客户端。

  5. 客户端接收响应：客户端接收到服务器的响应后，反序列化数据并继续处理后续业务逻辑。

二、Protobuf与RPC在C++中的实际应用

2.1 定义 .proto 文件

首先，我们需要通过Protobuf定义服务接口和消息结构。例如，下面的.proto文件定义了一个简单的用户服务接口，包括获取用户信息的服务：

protobuf 复制代码 
syntax = "proto3";

package example;

message User {
    int32 id = 1;
    string name = 2;
    string email = 3;
}

message GetUserRequest {
    int32 id = 1;
}

message GetUserResponse {
    User user = 1;
}

service UserService {
    rpc GetUser (GetUserRequest) returns (GetUserResponse);
}
2.2 编译 .proto 文件生成C++代码

使用protoc编译器生成C++代码：

bash 复制代码 
protoc --cpp_out=. --grpc_out=. --plugin=protoc-gen-grpc=`which grpc_cpp_plugin` user_service.proto

编译后生成的文件包含以下两部分：

  • 消息类 ：user_service.pb.h 和 user_service.pb.cc
  • 服务接口及骨架代码 ：user_service.grpc.pb.h 和 user_service.grpc.pb.cc
2.3 实现服务器端逻辑

服务器端需要实现生成的服务接口，并通过RPC服务器处理客户端的请求。下面是基于gRPC的C++服务器实现：

cpp 复制代码 
#include <iostream>
#include <memory>
#include <string>
#include <grpcpp/grpcpp.h>
#include "user_service.grpc.pb.h"

using grpc::Server;
using grpc::ServerBuilder;
using grpc::ServerContext;
using grpc::Status;
using example::UserService;
using example::GetUserRequest;
using example::GetUserResponse;
using example::User;

class UserServiceImpl final : public UserService::Service {
public:
    Status GetUser(ServerContext* context, const GetUserRequest* request,
                  GetUserResponse* reply) override {
        // 模拟数据库操作
        User* user = reply->mutable_user();
        user->set_id(request->id());
        user->set_name("Alice");
        user->set_email("alice@example.com");
        return Status::OK;
    }
};

void RunServer() {
    std::string server_address("0.0.0.0:50051");
    UserServiceImpl service;

    ServerBuilder builder;
    builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
    builder.RegisterService(&service);

    std::unique_ptr<Server> server(builder.BuildAndStart());
    std::cout << "Server listening on " << server_address << std::endl;
    server->Wait();
}

int main() {
    RunServer();
    return 0;
}
2.4 实现客户端逻辑

客户端通过调用生成的代码与服务器进行通信。以下是gRPC客户端的实现代码：

cpp 复制代码 
#include <iostream>
#include <memory>
#include <grpcpp/grpcpp.h>
#include "user_service.grpc.pb.h"

using grpc::Channel;
using grpc::ClientContext;
using grpc::Status;
using example::UserService;
using example::GetUserRequest;
using example::GetUserResponse;

class UserServiceClient {
public:
    UserServiceClient(std::shared_ptr<Channel> channel)
        : stub_(UserService::NewStub(channel)) {}

    GetUserResponse GetUser(int id) {
        GetUserRequest request;
        request.set_id(id);

        GetUserResponse response;
        ClientContext context;

        Status status = stub_->GetUser(&context, request, &response);
        if (!status.ok()) {
            std::cerr << "RPC failed: " << status.error_message() << std::endl;
        }
        return response;
    }

private:
    std::unique_ptr<UserService::Stub> stub_;
};

int main() {
    UserServiceClient client(grpc::CreateChannel("localhost:50051", grpc::InsecureChannelCredentials()));
    int user_id = 1;
    GetUserResponse response = client.GetUser(user_id);
    std::cout << "User ID: " << response.user().id() << std::endl;
    std::cout << "Name: " << response.user().name() << std::endl;
    std::cout << "Email: " << response.user().email() << std::endl;
    return 0;
}
2.5 使用CMake构建工程

使用CMake构建Protobuf和gRPC项目，确保将生成的代码自动编译到项目中：

cmake 复制代码 
cmake_minimum_required(VERSION 3.14)
project(ProtobufRPCExample)

find_package(Protobuf REQUIRED)
find_package(gRPC REQUIRED)

set(CMAKE_CXX_STANDARD 14)

protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS user_service.proto)
grpc_generate_cpp(GRPC_SRCS GRPC_HDRS user_service.proto)

add_executable(server server.cpp ${PROTO_SRCS} ${PROTO_HDRS} ${GRPC_SRCS} ${GRPC_HDRS})
target_link_libraries(server PRIVATE protobuf::libprotobuf gRPC::grpc++)

add_executable(client client.cpp ${PROTO_SRCS} ${PROTO_HDRS} ${GRPC_SRCS} ${GRPC_HDRS})
target_link_libraries(client PRIVATE protobuf::libprotobuf gRPC::grpc++)
2.6 编译与运行

  1. 安装依赖

    确保已安装Protobuf和gRPC库。可以参考以下步骤进行安装：

    bash 复制代码 
    # 安装gRPC及其依赖
git clone -b v1.53.0 https://github.com/grpc/grpc
cd grpc
git submodule update --init
mkdir -p build
cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make -j4
sudo make install
sudo ldconfig

  2. 编译项目

    在项目根目录下创建构建目录并编译：

    bash 复制代码 
    mkdir build
cd build
cmake ..
make

  3. 运行服务器

    在一个终端中启动服务器：

    bash 复制代码 
    ./server

    输出：

    Server listening on 0.0.0.0:50051

  4. 运行客户端

    在另一个终端中运行客户端：

    bash 复制代码 
    ./client

    输出：

    User ID: 1
Name: Alice
Email: alice@example.com
2.7 关键组件解析

以下是各组件在上述实现中的作用：

  1. client（客户端）：

    • 客户端代码位于 client.cpp，通过 UserServiceClient 类发起RPC请求。
    • serialize（序列化） ：Protobuf自动处理消息的序列化，将 GetUserRequest 转换为字节流。
    • deserialize（反序列化） ：接收 GetUserResponse 字节流并转换为 User 对象。

  2. server（服务器）：

    • 服务器代码位于 server.cpp，通过 UserServiceImpl 类实现服务逻辑。
    • serialize/deserialize：Protobuf自动处理接收的请求数据反序列化和响应数据序列化。

  3. protocol stack（协议栈）：

    • 在本示例中，gRPC基于HTTP/2协议栈处理网络通信细节，负责数据的传输和连接管理。

  4. idl（接口定义语言）：

    • user_service.proto 文件定义了服务接口和消息结构，作为IDL文件。

  5. compiler（编译器）：

    • protoc 编译器与gRPC插件一起，将.proto文件编译生成C++代码，生成消息类和服务骨架代码。

  6. skeleton（骨架代码）：

    • 生成的 user_service.grpc.pb.h 和 user_service.grpc.pb.cc 文件包含服务接口的骨架代码。
    • 服务器实现类 UserServiceImpl 继承自生成的骨架类，完成业务逻辑。
    • 客户端通过生成的 UserService::Stub 类进行远程调用，隐藏了底层的通信细节。
2.8 序列化与反序列化的实现

在上述示例中，序列化与反序列化过程由gRPC和Protobuf库自动处理，开发者无需手动编写相关代码。然而，理解这一过程对于优化和调试至关重要。

  • 序列化：

    • 客户端在调用 stub_->GetUser(&context, request, &response) 时，Protobuf将 GetUserRequest 对象序列化为二进制格式，通过gRPC协议栈发送到服务器。

  • 反序列化：

    • 服务器接收到字节流后，Protobuf将其反序列化为 GetUserRequest 对象，并传递给 GetUser 方法进行处理。

  • 响应过程：

    • 服务器将 GetUserResponse 对象序列化后，通过gRPC协议栈发送回客户端，客户端再将其反序列化为 GetUserResponse 对象。

三、关键实现与解析

通过上述代码示例，我们可以看到Protobuf和RPC的高效结合体现在以下几个方面：

  1. 自动化生成代码 ：通过Protobuf定义的IDL文件（.proto），可以自动生成C++类，省去手动编写通信代码的复杂性。

  2. 数据序列化与反序列化：Protobuf通过高效的二进制格式，减少了数据传输的开销，保证了性能和数据传输的一致性。

  3. RPC框架的透明性：开发者不必关心底层通信协议，gRPC框架负责数据的传输和连接管理，使得程序员能够像调用本地函数一样完成远程调用。

四、工程实践中的最佳实践

  1. 代码生成自动化 ：集成Protobuf的代码生成步骤至构建系统，确保.proto文件变更后，自动生成与其匹配的代码。

  2. 性能调优：对于大规模消息传输，可考虑使用Protobuf的流式解析功能，并优化网络带宽。

  3. 版本兼容性：在设计Protobuf消息结构时，尽量避免破坏兼容性，确保后续扩展性。例如，避免删除字段或改变字段编号。

  4. 错误处理机制：在客户端和服务器端实现完备的错误处理机制，确保网络异常和序列化失败时的回退策略。

五、总结

Protobuf与RPC框架的结合为现代分布式系统提供了一种高效的通信方案。在C++工程中，通过合理设计和使用Protobuf进行数据序列化，再借助gRPC完成远程过程调用，可以大幅提升通信效率，并简化系统的开发与维护。

附录：常用Protobuf与gRPC命令

  • 编译Protobuf文件

    bash 复制代码 
    protoc --cpp_out=. user_service.proto

  • 编译gRPC Protobuf文件

    bash 复制代码 
    protoc --grpc_out=. --plugin=protoc-gen-grpc=`which grpc_cpp_plugin` user_service.proto

  • 生成所有代码（包括消息和gRPC服务）

    bash 复制代码 
    protoc --cpp_out=. --grpc_out=. --plugin=protoc-gen-grpc=`which grpc_cpp_plugin` user_service.proto

参考资料

相关推荐
Yang.991 小时前
基于Windows系统用C++做一个点名工具
c++·windows·sql·visual studio code·sqlite3
熬夜学编程的小王1 小时前
【初阶数据结构篇】双向链表的实现（赋源码）
数据结构·c++·链表·双向链表
zz40_1 小时前
C++自己写类 和 运算符重载函数
c++
六月的翅膀1 小时前
C++：实例访问静态成员函数和类访问静态成员函数有什么区别
开发语言·c++
谭震鸿1 小时前
Zookeeper集群搭建Centos环境下
分布式·zookeeper·centos
liujjjiyun2 小时前
小R的随机播放顺序
数据结构·c++·算法
￥ 多多￥2 小时前
c++中mystring运算符重载
开发语言·c++·算法
天若有情6733 小时前
c++框架设计展示---提高开发效率！
java·c++·算法
Root_Smile3 小时前
【C++】类和对象
开发语言·c++
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06RAG 实践- Ollama+RagFlow 部署本地知识库07怎样让音频速度变慢？请跟随以下方法进行操作08Unity中PICO实现 隔空取物 和 接触抓取物体09Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO10【目标跟踪】相机运动补偿