C++使用grpc详例(使用CMake构建)

已于 2024-03-30 20:41:39 修改
阅读量614 收藏 8
点赞数 6
文章标签： c++ 开发语言 linux 服务器 rpc 微服务
于 2024-03-30 19:52:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QAZ600888/article/details/137181035
版权

文章目录

安装grpc(Ubuntu)

  1. 安装protobuf编译器和库

    sudo apt update
sudo apt install -y protobuf-compiler libprotobuf-dev

  2. 安装grpc

    安装依赖项

    sudo apt install -y build-essential autoconf libtool pkg-config libsystemd-dev libssl-dev

    安装c++支持

    sudo apt install -y libgflags-dev libgtest-dev libc++-dev clang

    克隆grpc库(需要挂梯子，不然下载速度太慢)

    git clone https://github.com/grpc/grpc.git
cd grpc

    在这里插入图片描述

    下载第三方库(挂梯子直接下就可以了，不要用国内镜像源，之前用了发现是陷阱，很多库没法下载)

    git submodule update --init

    在这里插入图片描述

    如果出现下载失败，进入third_party文件夹，将下载失败的库的文件夹删掉，重新执行以上命令即可

    下载完成后创建CMake对应的文件夹，并进入这个文件夹

    mkdir -p cmake/build
cd cmake/build

    编译安装

    cmake ../..
make
# 安装到系统目录
make install

C++使用grpc

  1. 编写.proto文件

    syntax = "proto3";

package device_service;

service DeviceService {
  // 返回一维字符串数组
  rpc GetDeviceStringList (DeviceNameListRequest) returns (DeviceNameListResponse) {}
  // 返回单个int值
  rpc GetDeviceSlaveCnt (DeviceSlaveCntRequest) returns (DeviceSlaveCntResponse) {}
  // 返回自定义结构体类型
  rpc GetDeviceInfo (DeviceInfoRequest) returns (DeviceInfoResponse) {}
  // 返回二维字符串数组
  rpc GetDeviceTableBySlaveId (DeviceTableBySlaveIdRequest) returns (DeviceTableBySlaveIdResponse) {}
}

// 设备列表信息
message DeviceNameListRequest {
  string device_name = 1;
}

message DeviceNameListResponse {
  repeated string device_names = 1;
}

message DeviceInfoDetail {
  string ip = 1;
  int32 port = 2;
  string type = 3;
  bool server_status = 4;
  bool simulate_status = 5;
  bool plan_status = 6;
}

// 设备详细信息
message DeviceInfoRequest {
  // 查询的设备名称
  string device_name = 1;
}

// 返回值是自定义结构体类型DeviceInfo
message DeviceInfoResponse {
  DeviceInfoDetail info = 1;
}

// 获取设备从机数量
message DeviceSlaveCntRequest {
  string device_name = 1;
}

message DeviceSlaveCntResponse {
  int32 slave_cnt = 1;
}

// 根据设备名称和从机id和测点信息 获取设备详细信息,回复是二维List
message DeviceTableBySlaveIdRequest {
  string device_name = 1;
  int32 slave_id = 2;
  string point_name = 3;
}

message DeviceTableRow{
  repeated string row = 1;
}

message DeviceTableBySlaveIdResponse {
  DeviceTableRow head_data = 1;
  repeated DeviceTableRow table_data = 2;
}

  2. 根据.proto文件，生成服务端和客户端代码

    生成客户端代码

    protoc --cpp_out=. device.proto

    生成服务端代码

    protoc --grpc_out=. --plugin=protoc-gen-grpc=`which grpc_cpp_plugin` device.proto

    在这里插入图片描述

  3. 编写grpc服务端代码

    定义device_rpc_server.h文件，有以下几个接口

    #include <memory>
#include <grpcpp/impl/codegen/server_context.h>
#include <grpcpp/impl/codegen/status.h>
#include "../proto/device.grpc.pb.h" // 由protoc生成的grpc服务头文件
#include "../proto/device.pb.h"      // 由protoc生成的消息头文件
using namespace device_service;

class DeviceRpcServer final : public DeviceService::Service
{
public:
    DeviceRpcServer() = default;
    
    grpc::Status checkDevice(grpc::ServerContext *context, auto *request, auto *response);
    // 返回一维字符串列表
    grpc::Status GetDeviceStringList(grpc::ServerContext *context, const DeviceNameListRequest *request, DeviceNameListResponse *response);
    // 返回单个int类型
    grpc::Status GetDeviceSlaveCnt(grpc::ServerContext *context, const DeviceSlaveCntRequest *request, DeviceSlaveCntResponse *response);
    // 返回自定义结构体类型DeviceInfo
    grpc::Status GetDeviceInfo(grpc::ServerContext *context, const DeviceInfoRequest *request, DeviceInfoResponse *response);
    // 返回二维字符串列表
    grpc::Status GetDeviceTableBySlaveId(grpc::ServerContext *context, const DeviceTableBySlaveIdRequest *request, DeviceTableBySlaveIdResponse *response);

private:
    std::map<std::string, bool> _deviceMap = {
        {"PCS1", true},
        {"PCS2", true},
        {"BMS1", true},
        {"BMS2", true},
    };
};

    编写device_rpc_server.cpp文件

    1. 检查设备是否存在

      grpc::Status DeviceRpcServer::checkDevice(grpc::ServerContext *context, auto *request, auto *response)
{
    // 获取request中的设备名称
    std::string device_name = request->device_name();
    auto device = _deviceMap.find(device_name);
    if (device == _deviceMap.end())
    {
        // 处理设备不存在的情况，返回错误状态
        return grpc::Status(grpc::StatusCode::NOT_FOUND, "未找到" + device_name + "设备");
    }
    // 设备存在，返回成功状态
    return grpc::Status::OK;
}

    2. 返回一维字符串列表

      proto文件内容

      service DeviceService {
  // 返回一维字符串数组
  rpc GetDeviceStringList (DeviceNameListRequest) returns (DeviceNameListResponse) {}
}

// 设备列表信息
message DeviceNameListRequest {
  string device_name = 1;
}

message DeviceNameListResponse {
  repeated string device_names = 1;
}

      cpp文件内容

      grpc::Status DeviceRpcServer::GetDeviceStringList(grpc::ServerContext *context, const DeviceNameListRequest *request, DeviceNameListResponse *response)
{
    std::vector<std::string> deviceNameList = {"PCS1", "PCS2", "BMS1", "BMS2"};
    for (const auto &name : deviceNameList)
    {
        // 这个函数是grpc自动生成的，名称与.proto文件里面的变量名有关
        response->add_device_names(name);
    }
    return grpc::Status::OK;
}

    3. 返回单个int类型

      proto文件内容

      service DeviceService {
  // 返回单个int值
  rpc GetDeviceSlaveCnt (DeviceSlaveCntRequest) returns (DeviceSlaveCntResponse) {}
}

// 获取设备从机数量
message DeviceSlaveCntRequest {
  string device_name = 1;
}

message DeviceSlaveCntResponse {
  int32 slave_cnt = 1;
}

      cpp文件内容

      grpc::Status DeviceRpcServer::GetDeviceSlaveCnt(grpc::ServerContext *context, const DeviceSlaveCntRequest *request, DeviceSlaveCntResponse *response)
{
    auto check = checkDevice(context, request, response);
    if (check.ok())
    {
        int slaveCnt = 1;
        response->set_slave_cnt(slaveCnt);
        return grpc::Status::OK;
    }
    else
    {
        return check;
    }
}

    4. 返回自定义结构体类型

      proto文件内容

      service DeviceService {
  // 返回自定义结构体类型
  rpc GetDeviceInfo (DeviceInfoRequest) returns (DeviceInfoResponse) {}
}

message DeviceInfoDetail {
  string ip = 1;
  int32 port = 2;
  string type = 3;
  bool server_status = 4;
  bool simulate_status = 5;
  bool plan_status = 6;
}

// 设备详细信息
message DeviceInfoRequest {
  // 查询的设备名称
  string device_name = 1;
}

// 返回值是自定义结构体类型DeviceInfo
message DeviceInfoResponse {
  DeviceInfoDetail info = 1;
}

      cpp文件内容

      grpc::Status DeviceRpcServer::GetDeviceInfo(grpc::ServerContext *context, const DeviceInfoRequest *request, DeviceInfoResponse *response)
{
    std::string device_name = request->device_name();
    auto check = checkDevice(context, request, response);
    if (check.ok())
    {
        DeviceInfoDetail deviceInfo;
        std::string ip = "127.0.0.1";
        deviceInfo.set_ip(ip);

        int port = 502;
        deviceInfo.set_port(port);

        std::string type = "tcp";
        deviceInfo.set_type(type);

        bool serverStatus = true;
        deviceInfo.set_server_status(serverStatus);

        bool simulatorStatus = true;
        deviceInfo.set_simulate_status(simulatorStatus);

        bool planStatus = false;
        deviceInfo.set_plan_status(planStatus);
		
        // 将自定义类型DeviceInfo拷贝到返回消息里面去
        response->mutable_info()->CopyFrom(deviceInfo);
        return grpc::Status::OK;
    }
    else
    {
        return check;
    }
}

    5. 返回二维字符串列表

      proto文件

      service DeviceService {
  // 返回二维字符串数组
  rpc GetDeviceTableBySlaveId (DeviceTableBySlaveIdRequest) returns (DeviceTableBySlaveIdResponse) {}
}

// 根据设备名称和从机id和测点信息 获取设备详细信息,回复是二维List
message DeviceTableBySlaveIdRequest {
  string device_name = 1;
  int32 slave_id = 2;
  string point_name = 3;
}

message DeviceTableRow{
  repeated string row = 1;
}

message DeviceTableBySlaveIdResponse {
  DeviceTableRow head_data = 1;
  repeated DeviceTableRow table_data = 2;
}

      cpp文件

      grpc::Status DeviceRpcServer::GetDeviceTableBySlaveId(grpc::ServerContext *context, const DeviceTableBySlaveIdRequest *request, DeviceTableBySlaveIdResponse *response)
{
    auto check = checkDevice(context, request, response);
    if (check.ok())
    {
        // 构造一组二维列表数据
        std::vector<std::string> headData = {
            "设备名称",
            "设备类型",
            "设备IP",
            "设备端口",
            "设备状态",
            "模拟状态",
            "计划状态",
        };
        std::vector<std::vector<std::string>> tableData = {
            {"PCS1", "tcp", "127.0.0.1", "502", "true", "true", "false"},
            {"PCS2", "tcp", "127.0.0.1", "503", "true", "true", "false"},
            {"BMS1", "tcp", "127.0.0.1", "504", "true", "true", "false"},
            {"BMS2", "tcp", "127.0.0.1", "505", "true", "true", "false"},
        };
        
        // 返回列表头
        DeviceTableRow headRow;
        for (const auto &data : headData)
        {
            headRow.add_row(data);
        }
        response->mutable_head_data()->CopyFrom(headRow);
		
        // 返回列表数据
        for (const auto &data : tableData)
        {
            DeviceTableRow table;
            for (const auto &item : data)
            {
                table.add_row(item);
            }
            response->add_table_data()->CopyFrom(table);
        }
        return grpc::Status::OK;
    }
    else
    {
        return check;
    }
}

    6. 服务端main函数代码

      #include <memory>
#include <grpcpp/grpcpp.h>
#include "device_rpc_server.h"

using grpc::Server;
using grpc::ServerBuilder;
using grpc::ServerContext;
using grpc::Status;

void runServer()
{
    std::string server_address("0.0.0.0:50051");
    DeviceRpcServer rpcServer;

    ServerBuilder builder;
    builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
    builder.RegisterService(&rpcServer);
    std::unique_ptr<Server> server(builder.BuildAndStart());
    std::cout << "Server listening on " << server_address << std::endl;
    server->Wait();
}

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

    7. CMakeLists.txt

      set(TARGET device_rpc_server)

# rpc服务端
file(GLOB_RECURSE RPC_SERVER_SOURCES "${CMAKE_SOURCE_DIR}/src/server/*.cpp" "${CMAKE_SOURCE_DIR}/src/proto/*.cc")

# 查找 gRPC 和 Protobuf  
find_package(Protobuf CONFIG REQUIRED)
find_package(gRPC CONFIG REQUIRED)

# 获取版本
message(STATUS "Using protobuf-${Protobuf_VERSION}")
message(STATUS "Using gRPC-${gRPC_VERSION}")

# 包含 gRPC 和 Protobuf 的头文件  
include_directories(${GRPC_INCLUDE_DIRS} ${PROTOBUF_INCLUDE_DIRS})

add_executable(${TARGET} ${RPC_SERVER_SOURCES})

target_include_directories(${TARGET} PUBLIC ${GTEST_INCLUDE_DIRS})
target_link_libraries(${TARGET} PUBLIC gtest gtest_main)
target_link_libraries(${TARGET} PUBLIC gRPC::grpc++_reflection protobuf::libprotobuf)

  4. 编写grpc客户端代码

    定义device_rpc_client.h文件，有以下几个接口

    #include <grpcpp/grpcpp.h>
#include <memory>
#include <string>
#include <vector>
#include <map>
#include "../proto/device.grpc.pb.h" // 由protoc生成的grpc服务头文件

using grpc::Channel;
using grpc::ClientContext;
using grpc::Status;
using namespace device_service;

class DeviceServiceClient
{
public:
    DeviceServiceClient(std::shared_ptr<Channel> channel)
        : _stub(DeviceService::NewStub(channel)) {}

    std::vector<std::string> GetDeviceStringList();
    int GetDeviceSlaveCnt(const std::string &deviceName);
    std::map<std::string, std::string> GetDeviceInfo(const std::string &deviceName);
    std::vector<std::vector<std::string>> GetDeviceTableBySlaveId(const std::string &deviceName, int slaveId, std::string pointName);

private:
    std::unique_ptr<DeviceService::Stub> _stub;
};

    编写device_rpc_client.cpp文件

    1. 获取一维字符串列表

      std::vector<std::string> DeviceServiceClient::GetDeviceStringList()
{
    ClientContext context;
    DeviceNameListRequest request;
    DeviceNameListResponse response;

    Status status = _stub->GetDeviceStringList(&context, request, &response);

    if (status.ok())
    {
        std::vector<std::string> device_names;
        for (const auto &name : response.device_names())
        {
            device_names.push_back(name);
        }
        return device_names;
    }
    else
    {
        std::cerr << "GetDeviceStringList Failed: " << status.error_code() << ": " << status.error_message()
                  << std::endl;
        return {};
    }
}

    2. 获取单个int值

      int DeviceServiceClient::GetDeviceSlaveCnt(const std::string &deviceName)
{
    DeviceSlaveCntRequest request;
    request.set_device_name(deviceName);
    DeviceSlaveCntResponse response;
    ClientContext context;
    Status status = _stub->GetDeviceSlaveCnt(&context, request, &response);
    if (status.ok())
    {
        int slaveCnt = response.slave_cnt();
        return slaveCnt;
    }
    else
    {
        std::cerr << "GetDeviceSlaveCnt Failed:" << status.error_code() << ": " << status.error_message()
                  << std::endl;
        return -1;
    }
}

    3. 获取自定义结构体信息

      std::map<std::string, std::string> DeviceServiceClient::GetDeviceInfo(const std::string &deviceName)
{
    DeviceInfoRequest request;
    request.set_device_name(deviceName);
    DeviceInfoResponse response;
    ClientContext context;
    Status status = _stub->GetDeviceInfo(&context, request, &response);
    if (status.ok())
    {
        std::map<std::string, std::string> infoMap;
        infoMap["ip"] = response.info().ip();
        infoMap["port"] = std::to_string(response.info().port());
        infoMap["type"] = response.info().type();
        infoMap["server_status"] = std::to_string(response.info().server_status());
        infoMap["simulate_status"] = std::to_string(response.info().simulate_status());
        infoMap["plan_status"] = std::to_string(response.info().plan_status());
        return infoMap;
    }
    else
    {
        std::cerr << "GetDeviceInfo Failed: " << status.error_code() << ": " << status.error_message()
                  << std::endl;
        return {};
    }
}

    4. 获取二维字符串列表

      std::vector<std::vector<std::string>> DeviceServiceClient::GetDeviceTableBySlaveId(const std::string &deviceName, int slaveId, std::string pointName)
{
    DeviceTableBySlaveIdRequest request;
    DeviceTableBySlaveIdResponse response;
    ClientContext context;
    request.set_device_name(deviceName);
    request.set_slave_id(slaveId);
    request.set_point_name(pointName);

    Status status = _stub->GetDeviceTableBySlaveId(&context, request, &response);
    if (status.ok())
    {
        std::vector<std::vector<std::string>> table;

        // 处理列表头数据
        DeviceTableRow headRow = response.head_data();
        std::vector<std::string> head;
        for (const std::string &value : headRow.row())
        {
            head.push_back(value);
        }
        table.push_back(head);

        // 处理列表数据
        for (int i = 0; i < response.table_data().size(); i++)
        {
            DeviceTableRow tableRow = response.table_data().Get(i);
            std::vector<std::string> row;
            for (const std::string &value : tableRow.row())
            {
                row.push_back(value);
            }
            table.push_back(row);
        }
        return table;
    }
    else
    {
        std::cout << "GetDeviceTableBySlaveId error: " << status.error_message() << std::endl;
        return {};
    }
}

    5. 客户端main函数代码

      #include "device_rpc_client.h"
int main(int argc, char **argv)
{
    DeviceServiceClient client(grpc::CreateChannel(
        "localhost:50051", grpc::InsecureChannelCredentials()));

    // 获取设备列表
    std::cout << "获取设备列表信息" << std::endl;
    std::vector<std::string> device_names = client.GetDeviceStringList();
    for (const auto &name : device_names)
    {
        std::cout << name << std::endl;
    }
    std::cout << std::endl;

    // 获取从机数量
    std::cout << "获取从机数量" << std::endl;
    int slaveCnt = client.GetDeviceSlaveCnt("PCS1");
    std::cout << "slaveCnt: " << slaveCnt << std::endl;
    std::cout << std::endl;

    // 获取设备具体信息
    std::cout << "获取设备具体信息" << std::endl;
    std::map<std::string, std::string> deviceInfo = client.GetDeviceInfo("PCS1");
    for (const auto &info : deviceInfo)
    {
        std::cout << info.first << ": " << info.second << std::endl;
    }
    std::cout << std::endl;

    // 获取从机表
    std::cout << "获取从机表" << std::endl;
    std::vector<std::vector<std::string>> table = client.GetDeviceTableBySlaveId("PCS1", 1, "");
    for (const auto &row : table)
    {
        for (const auto &col : row)
        {
            std::cout << col << " ";
        }
        std::cout << std::endl;
    }
    std::cout << std::endl;
    return 0;
}

    6. CMakeLists.txt

      set(TARGET device_rpc_client)

# rpc客户端
file(GLOB_RECURSE RPC_CLIENT_SOURCES "${CMAKE_SOURCE_DIR}/src/client/*.cpp" "${CMAKE_SOURCE_DIR}/src/proto/*.cc")

# 查找 gRPC 和 Protobuf  
find_package(Protobuf CONFIG REQUIRED)
find_package(gRPC CONFIG REQUIRED)

# 获取版本
message(STATUS "Using protobuf-${Protobuf_VERSION}")
message(STATUS "Using gRPC-${gRPC_VERSION}")

# 包含 gRPC 和 Protobuf 的头文件  
include_directories(${GRPC_INCLUDE_DIRS} ${PROTOBUF_INCLUDE_DIRS})

add_executable(${TARGET} ${RPC_CLIENT_SOURCES})

target_include_directories(${TARGET} PUBLIC ${GTEST_INCLUDE_DIRS})
target_link_libraries(${TARGET} PUBLIC gtest gtest_main)
target_link_libraries(${TARGET} PUBLIC gRPC::grpc++_reflection protobuf::libprotobuf)

  5. grpc服务端和客户端通信效果展示

    在这里插入图片描述

  6. 样例源码仓库
    https://gitee.com/chen-dongyu123/grpc_example

总结

在C++中使用grpc还是有一定难度的，因为安装grpc的途中就伴有一大堆坑，其中重要的一点是千万不能使用国内镜像源下载，这个是大陷阱，很多依赖库版本对不上，最终会导致安装失败，挂VPN在Github上下载很快就能安装成功。后面我会继续讲一下c++和python使用grpc跨语言通讯的方法。

MC皮蛋侠客
关注
  • 6
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
CMake使用gRPC(Protobuf) 的c++ demo
06-29
使用cmake运行gRPC的demo https://blog.csdn.net/howard789/article/details/131460959
基于c++实现的GRPC服务端demo
09-02
基于c++实现的GRPC服务端demo
gRPC：以 C++为例
you_fathe的博客
12-06 6767
以C++的实例介绍了 grpc 的相关内容
c++实现gRPC
qq_39466755的博客
05-22 2016
无论什么语言，实现grpc的核心是.proto文件，通过protoc命令将.proto文件生成grpc框架的接口文件*gb*, 该文件中包含.proto定义的方法及参数接口，服务器，客户端相关操作接口；然后再编写服务器，客户端代码，调用*gb*文件生成的接口。后期会发布一篇grpc程序编写的完整流程，从proto，*.pb.cc, *.grpc.pb.cc解析 到服务器 客户端代码编写，cmake编写，返回状态设置，.cmake文件解析的全面刨析，让您一篇文章学会grpc。
gRPC C++ 入门教程
大草的博客
06-29 2961
gRPC C++ 入门教程
C++ 使用gRPC入门教程
weixin_43968559的博客
10-10 2470
在项目GrpcLibrary里添加HelloWorld.proto用以生成代码。}执行命令命令执行成功后，GrpcLibrary目录下会生成HelloWorld.grpc.pb.cc、HelloWorld.grpc.pb.h、HelloWorld.pb.cc和HelloWorld.pb.h。
C++使用gRPC实例
qq_42120843的博客
12-02 6370
C++使用gRPC实例
java 使用grpc的完整代码
08-21
java 使用grpc的完整代码
在Python中使用gRPC的方法示例
09-20
主要介绍了在Python中使用gRPC的方法示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Android上使用grpc的方法教程
08-30
主要给大家介绍了在Android上使用grpc的方法教程，文中通过示例代码给大家详细介绍了在android上使用grpc的方法以及可能遇到的种种问题的解决方法，对大家具有一定的参考学习价值，需要的朋友们下面来一起看看吧。
快速入门|c++|gRPC
qq_58806884的博客
06-09 910
通过一个简单的工作示例，C++开始使用 gRPC。 在C++世界中，没有普遍接受的项目管理标准 依赖。在生成和运行之前，需要生成并安装 gRPC 本快速入门的 Hello World 示例。
Grpc学习总结--四种模式（C++实现）
qq_22545985的博客
04-06 5708
目录 Protobuf定义（包括四种模式的接口定义和所用到的简单传输结构） Service 传输结构 单向模式 服务端函数实现 客户端函数实现 运行结果 服务端流 服务端实现 客户都安实现 运行结果 客户端流 服务端实现 客户端实现 运行结果 双向流 服务端实现 客户端实现 运行结果 踩过的一些坑 GRPC的四种模式，分别实现了单工，双工通信，客户端和服务...
gRPC简介及简单使用(C++)
热门推荐
网络资源是无限的
09-08 3万+
gRPC是一个现代的、开源的、高性能远程过程调用(RPC)框架，可以在任何平台运行。gRPC使客户端和服务器端应用程序能够透明地进行通信，并简化了连接系统的构建。gRPC支持的语言包括C++、Ruby、Python、Java、Go等。 gRPC默认使用Google的Protocol Buffers，关于Protocol Buffers的介绍可以参考：https://blog.csdn.net/f...
我为什么更推荐你使用cmake编译grpc程序？
最新发布
ALex_zry的博客
11-19 174
因为库实在有点多，为避免因为静态库顺序的坑，直接使用了“–start-group”和“–end-group”忽略顺序关系。建议使用CMake或automake编译，以省去处理依赖的麻烦。事情源于我最近在使用gRPC库，在编译时下意识使用了makefile编译，然后，编译时报错找不到库文件。然后就开始了漫长的查找过程，期间发现使用的是静态库，尝试编译成动态库，发现反而让库文件彻底混乱损坏了。从这里看到缺失的都是它自己的一些库依赖。你可以尝试使用这个makefile。其中引用的上级cmake 为。
C++ 使用GRPC框架简单示例
WZY31014332886的专栏
07-12 524
简单GRPC示例，包含服务端及客户端代码
CMake 方式编译 gRPC
一见
04-01 4577
首先，下载 grpc 源代码到本地： git clone https://github.com/grpc/grpc.git 如果只想下载指定版本的，如以版本“1.27.3”为例，可改成如下语句： git clone -b v1.27.3 https://github.com/grpc/grpc.git 上列操作成功完成后，grpc 源码的第三方依赖目录 third_party 实际是空的，...
grpc库的使用, cmake书写
06-06
下面是一个简单的使用gRPC库的CMakeLists.txt文件示例： ```cmake # CMake version cmake_minimum_required(VERSION 3.5) # Project name project(my_project) # gRPC requires C++11 set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED ON) # Find gRPC find_package(gRPC CONFIG REQUIRED) # Find protobuf find_package(Protobuf CONFIG REQUIRED) # Add the generated protobuf files to the project protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS my_proto.proto) # Add the gRPC generated files to the project grpc_generate_cpp(GRPC_SRCS GRPC_HDRS my_proto.proto) # Add the executable target add_executable(my_executable main.cpp ${PROTO_SRCS} ${GRPC_SRCS}) # Add the gRPC libraries to the target target_link_libraries(my_executable gRPC::grpc++ gRPC::grpc++_reflection gRPC::grpc++_unsecure protobuf::libprotobuf) ``` 在这个示例中，我们使用了CMake提供的官方gRPC和protobuf的Find模块来自动查找和链接所需的库。然后，我们使用protobuf_generate_cpp和grpc_generate_cpp函数生成protobuf和gRPC的源文件和头文件，并将其添加到可执行目标中。最后，我们使用target_link_libraries函数将gRPC和protobuf库链接到目标中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

MC皮蛋侠客

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值