C++ gRPC 项目全面解析：构建高性能分布式系统的利器

icy 昨天 20 抢沙发

默认

摘要： C++ gRPC 项目全面解析：构建高性能分布式系统的利器项目概述 gRPC 是一个由 Google 开发的高性能、开源、通用的 RPC（远程过程调用）框架，基于 HTTP/2...

C++ gRPC 项目全面解析：构建高性能分布式系统的利器

项目概述

gRPC 是一个由 Google 开发的高性能、开源、通用的 RPC（远程过程调用）框架，基于 HTTP/2 协议和 Protocol Buffers 序列化协议。C++ 版本的 gRPC 提供了强大的跨平台能力，支持构建高效、可扩展的分布式系统。

核心特性

1. 多语言支持

gRPC 支持多种编程语言，C++ 版本作为核心实现之一，为其他语言提供了底层支持。

2. 高性能通信

基于 HTTP/2 协议，支持多路复用、头部压缩
二进制传输，效率高于传统的 RESTful API
支持双向流式通信

3. 强类型接口

使用 Protocol Buffers 定义服务接口，提供编译时类型检查。

安装与配置

快速安装

text

# 克隆项目
git clone -b RELEASE_TAG_HERE https://github.com/grpc/grpc
cd grpc
git submodule update --init

# 编译安装
mkdir -p cmake/build
cd cmake/build
cmake ../..
make
sudo make install

实战示例

1. 定义 Protocol Buffers 服务

example.proto

text

syntax = "proto3";

package example;

// 定义服务
service Greeter {
  // 简单 RPC
  rpc SayHello (HelloRequest) returns (HelloReply) {}
  
  // 服务端流式 RPC
  rpc LotsOfReplies (HelloRequest) returns (stream HelloReply) {}
  
  // 客户端流式 RPC
  rpc LotsOfGreetings (stream HelloRequest) returns (HelloReply) {}
  
  // 双向流式 RPC
  rpc BidiHello (stream HelloRequest) returns (stream HelloReply) {}
}

// 请求消息
message HelloRequest {
  string name = 1;
}

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

2. 服务端实现

server.cpp

text

#include <iostream>
#include <memory>
#include <string>
#include <grpcpp/grpcpp.h>
#include "example.grpc.pb.h"

using grpc::Server;
using grpc::ServerBuilder;
using grpc::ServerContext;
using grpc::Status;
using example::Greeter;
using example::HelloRequest;
using example::HelloReply;

class GreeterServiceImpl final : public Greeter::Service {
  // 实现简单 RPC
  Status SayHello(ServerContext* context, 
                  const HelloRequest* request,
                  HelloReply* reply) override {
    std::string prefix("Hello ");
    reply->set_message(prefix + request->name());
    return Status::OK;
  }

  // 实现服务端流式 RPC
  Status LotsOfReplies(ServerContext* context,
                       const HelloRequest* request,
                       grpc::ServerWriter<HelloReply>* writer) override {
    for (int i = 0; i < 10; i++) {
      HelloReply reply;
      reply.set_message("Hello " + request->name() + " #" + std::to_string(i));
      writer->Write(reply);
    }
    return Status::OK;
  }
};

void RunServer() {
  std::string server_address("0.0.0.0:50051");
  GreeterServiceImpl 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;
}

3. 客户端实现

client.cpp

text

#include <iostream>
#include <memory>
#include <string>
#include <grpcpp/grpcpp.h>
#include "example.grpc.pb.h"

using grpc::Channel;
using grpc::ClientContext;
using grpc::Status;
using example::Greeter;
using example::HelloRequest;
using example::HelloReply;

class GreeterClient {
public:
  GreeterClient(std::shared_ptr<Channel> channel)
      : stub_(Greeter::NewStub(channel)) {}

  std::string SayHello(const std::string& user) {
    HelloRequest request;
    request.set_name(user);

    HelloReply reply;
    ClientContext context;

    Status status = stub_->SayHello(&context, request, &reply);

    if (status.ok()) {
      return reply.message();
    } else {
      std::cout << status.error_code() << ": " 
                << status.error_message() << std::endl;
      return "RPC failed";
    }
  }

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

int main() {
  std::string target_str = "localhost:50051";
  GreeterClient greeter(
      grpc::CreateChannel(target_str, grpc::InsecureChannelCredentials()));
  
  std::string user("world");
  std::string reply = greeter.SayHello(user);
  std::cout << "Greeter received: " << reply << std::endl;

  return 0;
}

4. 构建配置

CMakeLists.txt

text

cmake_minimum_required(VERSION 3.5.1)
project(grpc_example)

set(CMAKE_CXX_STANDARD 11)

# 查找 gRPC 和 Protocol Buffers
find_package(Protobuf REQUIRED)
find_package(gRPC REQUIRED)

# 生成 Protocol Buffers 代码
protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS example.proto)
grpc_generate_cpp(GRPC_SRCS GRPC_HDRS example.proto)

# 编译服务端
add_executable(server server.cpp ${PROTO_SRCS} ${PROTO_HDRS} ${GRPC_SRCS} ${GRPC_HDRS})
target_link_libraries(server ${Protobuf_LIBRARIES} ${gRPC_LIBRARIES})

# 编译客户端
add_executable(client client.cpp ${PROTO_SRCS} ${PROTO_HDRS} ${GRPC_SRCS} ${GRPC_HDRS})
target_link_libraries(client ${Protobuf_LIBRARIES} ${gRPC_LIBRARIES})

高级特性

1. 异步 API 使用

text

// 异步服务端示例
class AsyncGreeterServiceImpl final : public Greeter::AsyncService {
public:
  ~AsyncGreeterServiceImpl() {
    server_->Shutdown();
    cq_->Shutdown();
  }

  void Run() {
    std::string server_address("0.0.0.0:50051");
    ServerBuilder builder;
    builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
    builder.RegisterService(&service_);
    cq_ = builder.AddCompletionQueue();
    server_ = builder.BuildAndStart();
    
    // 处理 RPC 调用
    HandleRpcs();
  }

private:
  void HandleRpcs() {
    new CallData(&service_, cq_.get());
    void* tag;
    bool ok;
    while (true) {
      GPR_ASSERT(cq_->Next(&tag, &ok));
      GPR_ASSERT(ok);
      static_cast<CallData*>(tag)->Proceed();
    }
  }
  
  std::unique_ptr<ServerCompletionQueue> cq_;
  Greeter::AsyncService service_;
  std::unique_ptr<Server> server_;
};

2. 拦截器（Interceptors）

text

// 自定义拦截器
class LoggingInterceptor : public grpc::experimental::Interceptor {
public:
  void Intercept(grpc::experimental::InterceptorBatchMethods* methods) override {
    if (methods->QueryInterceptionHookPoint(
        grpc::experimental::InterceptionHookPoints::PRE_SEND_INITIAL_METADATA)) {
      // 在发送前记录日志
      std::cout << "Sending request..." << std::endl;
    }
    methods->Proceed();
  }
};

3. 健康检查

text

// 启用健康检查服务
grpc::reflection::InitProtoReflectionServerBuilderPlugin();
grpc::health::v1::HealthCheckService health_service;
health_service.SetServingStatus("", true);
builder.RegisterService(&health_service);

最佳实践

1. 连接管理

text

// 使用连接池
class ConnectionPool {
public:
  std::shared_ptr<grpc::Channel> GetChannel(const std::string& target) {
    std::lock_guard<std::mutex> lock(mutex_);
    auto it = channels_.find(target);
    if (it == channels_.end()) {
      auto channel = grpc::CreateChannel(
          target, 
          grpc::InsecureChannelCredentials());
      channels_[target] = channel;
      return channel;
    }
    return it->second;
  }

private:
  std::mutex mutex_;
  std::unordered_map<std::string, std::shared_ptr<grpc::Channel>> channels_;
};

2. 错误处理

text

Status MakeRpcCall() {
  ClientContext context;
  // 设置超时
  context.set_deadline(std::chrono::system_clock::now() + 
                       std::chrono::seconds(5));
  
  // 设置重试策略
  grpc::ChannelArguments args;
  args.SetInt(GRPC_ARG_ENABLE_RETRIES, 1);
  
  Status status = stub_->SomeMethod(&context, request, &response);
  
  if (!status.ok()) {
    // 处理不同错误类型
    switch (status.error_code()) {
      case grpc::StatusCode::DEADLINE_EXCEEDED:
        std::cerr << "Timeout occurred" << std::endl;
        break;
      case grpc::StatusCode::UNAVAILABLE:
        std::cerr << "Service unavailable" << std::endl;
        break;
      default:
        std::cerr << "RPC failed: " << status.error_message() << std::endl;
    }
  }
  return status;
}