gRPC 同步 Server 与 Client 编写示例

本文介绍了基于 gRPC 框架使用 C++ 编写同步服务端和客户端的方法。内容包括定义 Proto 文件中的四种 RPC 模式（一元、服务端流、客户端流、双向流），展示同步 Server 的实现逻辑及 Client 调用代码，并详细解析了各模式下消息发送与接收的时机。通过示例代码帮助开发者理解 gRPC 同步 API 的阻塞特性及数据流转机制。

猫巷少女发布于 2026/3/290 浏览

一、proto 文件

syntax = "proto3";
package example;

// 定义四种 RPC 模式的服务
service ExampleService {
    // 1. 一元 RPC (Unary)：客户端发一个请求，服务端回一个响应
    rpc UnaryCall (Request) returns (Response);
    // 2. 服务端流式 RPC (Server Streaming)：客户端发一个请求，服务端回多个响应
    rpc ServerStream (Request) returns (stream Response);
    // 3. 客户端流式 RPC (Client Streaming)：客户端发多个请求，服务端回一个响应
    rpc ClientStream (stream Request) returns (Response);
    // 4. 双向流式 RPC (Bidirectional Streaming)：双方互相发多个消息
    rpc BidiStream (stream Request) returns (stream Response);
}

// 请求消息
message Request {
    string data = 1;
}

// 响应消息
message Response {
    string data = 1;
}

/*
 * 同步服务端
 */
#include <grpcpp/grpcpp.h>
#include "./build/example.grpc.pb.h"
using grpc::Server;
using grpc::ServerBuilder;
using grpc::ServerContext;
using grpc::ServerReader;
using grpc::ServerWriter;
using grpc::ServerReaderWriter;
using grpc::Status;
using example::ExampleService;
using example::Request;
using example::Response;

// 服务实现类
class ExampleServiceImpl final : public ExampleService::Service {
    // 1. 一元 RPC
    Status UnaryCall(ServerContext* context, const Request* req, Response* res) override {
        res->set_data("Server: " + req->data());
        return Status::OK;
    }
    
    // 2. 服务端流式 RPC
    Status ServerStream(ServerContext* context, const Request* req, ServerWriter<Response>* writer) override {
        for (int i = 0; i < 3; ++i) {
            Response res;
            res.set_data("Server Stream " + std::to_string(i) + ": " + req->data());
            writer->Write(res); // 每次循环立即发送 1 条数据
        }
        return Status::OK; // 发送结束标记，告诉客户端'发完了'
    }
    
    // 3. 客户端流式 RPC
    Status ClientStream(ServerContext* context, ServerReader<Request>* reader, Response* res) override {
        std::string combined;
        Request req;
        while (reader->Read(&req)) { // Read()阻塞等待响应，收到数据时返回 true，收到结束标记时返回 false
            combined += req.data() + " ";
        }
        res->set_data("Server Combined: " + combined);
        return Status::OK;
    }
    
    // 4. 双向流式 RPC
    Status BidiStream(ServerContext* context, ServerReaderWriter<Response, Request>* stream) override {
        Request req;
        while (stream->Read(&req)) {
            Response res;
            res.set_data("Server Echo: " + req.data());
            stream->Write(res);
        }
        return Status::OK;
    }
};

void RunServer() {
    std::string addr("0.0.0.0:50051");
    ExampleServiceImpl service;
    ServerBuilder builder;
    builder.AddListeningPort(addr, grpc::InsecureServerCredentials());
    builder.RegisterService(&service);
    std::unique_ptr<Server> server(builder.BuildAndStart());
    server->Wait();
}

int main() {
    RunServer();
    return 0;
}

/*
 * 同步客户端
 */
#include <grpcpp/grpcpp.h>
#include "./build/example.grpc.pb.h"
#include <vector>
using grpc::Channel;
using grpc::ClientContext;
using grpc::ClientReader;
using grpc::ClientWriter;
using grpc::ClientReaderWriter;
using grpc::Status;
using example::ExampleService;
using example::Request;
using example::Response;

class ExampleClient {
public:
    ExampleClient(std::shared_ptr<Channel> channel) : stub_(ExampleService::NewStub(channel)) {}
    
    // 1. 一元 RPC
    void CallUnary(const std::string& msg) {
        Request req;
        req.set_data(msg);
        Response res;
        ClientContext ctx;
        Status status = stub_->UnaryCall(&ctx, req, &res);
        if (status.ok()) std::cout << "Unary: " << res.data() << std::endl;
    }
    
    // 2. 服务端流式 RPC
    void CallServerStream(const std::string& msg) {
        Request req;
        req.set_data(msg);
        ClientContext ctx;
        std::unique_ptr<ClientReader<Response>> reader = stub_->ServerStream(&ctx, req);
        Response res;
        while (reader->Read(&res)) { // Read()阻塞等待响应，收到数据时返回 true，收到结束标记时返回 false
            std::cout << "Server Stream: " << res.data() << std::endl;
        }
    }
    
    // 3. 客户端流式 RPC
    void CallClientStream(const std::vector<std::string>& msgs) {
        ClientContext ctx;
        Response res;
        std::unique_ptr<ClientWriter<Request>> writer = stub_->ClientStream(&ctx, &res);
        for (const auto& msg : msgs) {
            Request req;
            req.set_data(msg);
            writer->Write(req); // 发送数据给服务端
        }
        writer->WritesDone(); // 发送结束标记，告诉服务端'发完了'
        Status status = writer->Finish(); // 阻塞等待服务端的响应
        if (status.ok()) std::cout << "Client Stream: " << res.data() << std::endl;
    }
    
    // 4. 双向流式 RPC
    void CallBidiStream(const std::vector<std::string>& msgs) {
        ClientContext ctx;
        std::unique_ptr<ClientReaderWriter<Request, Response>> stream = stub_->BidiStream(&ctx);
        // 写请求
        for (const auto& msg : msgs) {
            Request req;
            req.set_data(msg);
            stream->Write(req);
        }
        stream->WritesDone(); // 读响应
        Response res;
        while (stream->Read(&res)) {
            std::cout << "Bidi Stream: " << res.data() << std::endl;
        }
    }
private:
    std::unique_ptr<ExampleService::Stub> stub_;
};

int main() {
    ExampleClient client(grpc::CreateChannel("localhost:50051", grpc::InsecureChannelCredentials()));
    client.CallUnary("Hello");
    client.CallServerStream("Hi");
    client.CallClientStream({"A", "B", "C"});
    client.CallBidiStream({"X", "Y", "Z"});
    return 0;
}

模式	客户端发送数据时机	服务端发送数据时机
一元	调用 `UnaryCall` 时	`return Status::OK` 时
服务端流	调用 `ServerStream` 时（发起请求，无后续主动发送，仅通过 `reader->Read()` 接收）	每次 `writer->Write` 时；`return Status::OK` 时发送结束标记
客户端流	每次 `writer->Write` 时；`writer->WritesDone()` 发送结束标记	`return Status::OK` 时
双向流	每次 `stream->Write` 时；`stream->WritesDone()` 发送结束标记	每次 `stream->Write` 时；`return Status::OK` 时发送结束标记

调用模式	客户端接收数据时机	服务端接收数据时机
一元 RPC（Unary）	调用 `stub->UnaryCall(&ctx, req, &res)` 阻塞返回时，从 `res` 中获取服务端响应	实现 `ExampleService::UnaryCall` 方法时，直接从入参 `req` 中获取客户端请求数据
服务端流（ServerStream）	调用 `stub->ServerStream(&ctx, req, &reader)` 后，循环调用 `reader->Read(&res)` 接收服务端推送的每一条数据；`Read()` 返回 `false` 表示流结束	实现 `ExampleService::ServerStream` 方法时，直接从入参 `req` 中获取客户端请求数据（仅 1 次）
客户端流（ClientStream）	调用 `writer->Finish(&res)` 阻塞返回时，从 `res` 中获取服务端最终响应	实现 `ExampleService::ClientStream` 方法时，循环调用 `reader->Read(&req)` 接收客户端推送的每一条数据；`Read()` 返回 `false` 表示客户端发送完毕
双向流（BidiStream）	调用 `stub->BidiStream(&ctx, &stream)` 后，循环调用 `stream->Read(&res)` 接收服务端推送的每一条数据；`Read()` 返回 `false` 表示服务端流结束	实现 `ExampleService::BidiStream` 方法时，循环调用 `stream->Read(&req)` 接收客户端推送的每一条数据；`Read()` 返回 `false` 表示客户端流结束

gRPC 同步 Server 与 Client 编写示例

一、proto 文件

二、server 同步

三、client 同步

四、消息的发送和接收的时机

1. 一元 RPC (Unary)

客户端发送时机

服务端发送时机

2. 服务端流式 RPC (Server Streaming)

客户端发送时机

服务端发送时机

3. 客户端流式 RPC (Client Streaming)

客户端发送时机

服务端发送时机

4. 双向流式 RPC (Bidirectional Streaming)

客户端发送时机

服务端发送时机

总结

更多推荐文章

相关免费在线工具

gRPC 同步 Server 与 Client 编写示例

一、proto 文件

二、server 同步

三、client 同步

四、消息的发送和接收的时机

1. 一元 RPC (Unary)

客户端发送时机

服务端发送时机

2. 服务端流式 RPC (Server Streaming)

客户端发送时机

服务端发送时机

3. 客户端流式 RPC (Client Streaming)

客户端发送时机

服务端发送时机

4. 双向流式 RPC (Bidirectional Streaming)

客户端发送时机

服务端发送时机

总结

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具