c++中grpc简单使用---函数介绍及其代码演示

前言

C++ gRPC（Google Remote Procedure Call）是一种高性能、开源的远程过程调用框架，用于在不同服务之间进行通信。
配置gRPC可以访问该网站：grpc配置

一.函数介绍

下面是一些常见的 C++ gRPC 函数及其功能：

1. grpc::Channel：表示一个 gRPC 通道，客户端通过这个通道与服务端进行通信。

2. grpc::CreateChannel(const std::string& target, grpc::ChannelArguments channel_args =grpc::ChannelArguments())：创建一个 gRPC 通道。target 是服务端地址，例如 “localhost:50051”。channel_args 是可选的通道参数，例如超时时间、压缩方式等。

3. grpc::ChannelArguments：表示 gRPC 通道的参数，例如超时时间、压缩方式等。

4. grpc::ClientContext：表示一个 gRPC 客户端上下文，用于存储请求和响应的相关信息。

5. grpc::Status：表示 gRPC 请求的状态，包括请求是否成功、错误代码和错误信息等。

6. grpc::StubOptions：表示 gRPC 存根选项，用于配置 gRPC 存根的行为。

7. grpc::ServerBuilder：表示 gRPC 服务器构建器，用于配置 gRPC 服务器。

8. grpc::Server：表示一个 gRPC 服务器，用于处理客户端请求。

9. grpc::ServerContext：表示一个 gRPC 服务器上下文，用于存储请求和响应的相关信息。

10. grpc::Service：表示一个 gRPC 服务，包含一组接口和方法，用于处理客户端请求。

11. grpc::ServerBuilder::AddListeningPort(const std::string& addr, grpc::ServerBuilder::Protocol protocol = grpc::ServerBuilder::Protocol::HTTP)：添加一个监听端口。addr 是监听地址，例如 “localhost:50051”。protocol 是可选的协议，默认为 HTTP。

12. grpc::ServerBuilder::RegisterService(const grpc::Service* service)：注册一个 gRPC 服务。

13. grpc::ServerBuilder::BuildAndStart()：构建并启动 gRPC 服务器。

14. grpc::ServerBuilder::Shutdown()：关闭 gRPC 服务器。

15. grpc::ServerBuilder::WaitForShutdown()：等待 gRPC 服务器关闭。

16. grpc::ServerBuilder::cq()：返回 gRPC 服务器的 completion queue（完成队列），用于处理异步请求。

二.代码演示

api.proto

syntax = "proto3";
option java_multiple_files = true;
option java_package = "io.grpc.examples.routeguide";
option java_outer_classname = "RouteGuideProto";
option objc_class_prefix = "RTG";

package routeguide;

service Route {

  rpc Echo(RestRequest) returns (stream RestResponse) {}
}

// Response
message RestResponse {
  // The location from which the message is sent.
  int32 code = 1;
  string message = 2;
  string body = 3;
}
message RestRequest {
  string url = 1;
  string body = 2;
}

server.cc

#include <grpc/grpc.h>
#include <string>
#include "../grpc/api.grpc.pb.h"

#include <grpcpp/security/server_credentials.h>
#include <grpcpp/server_builder.h>
#include <grpcpp/server_context.h>
#include <iostream>
#include <dlfcn.h>
#include<iostream>
using grpc::Server;
using grpc::ServerBuilder;
using grpc::ServerContext;
using grpc::ServerReader;
using grpc::ServerReaderWriter;
using grpc::ServerWriter;
using grpc::Status;
using routeguide::Route;
using std::chrono::system_clock;
using routeguide::RestResponse;
using routeguide::RestRequest;
using std::string;
using std::wstring;
class RouteGuideImpl final : public routeguide::Route::Service{
   public:
    explicit RouteGuideImpl(){}
    Status Echo(ServerContext*context ,const RestRequest*request,ServerWriter<RestResponse>*write)override{
      std::cout<<"32"<<std::endl;
        request->GetMetadata();

//进行数据处理
        ///
        std::cout<<"client message::  "<<request->body()<<std::endl;
        RestResponse response;
        response.set_code(1);
        response.set_message("sadfgh");
        response.set_body("sadfgh");
        
        write->Write(response);
        return Status::OK;
    }
};
//我们通过使用ServerBuilder去构建和启动服务器
void RunServer(){
    std::string server_address("127.0.0.1:5000");
    //std::string server_address("0.0.0.0:5000");
    //创建我们的服务实现类 RouteGuideImpl 的一个实例
    RouteGuideImpl service;
    std::cout<<"46"<<std::endl;
    //创建工厂类 ServerBuilder 的一个实例。
    ServerBuilder builder;
      std::cout<<"50"<<std::endl;
    //在生成器的 AddListeningPort() 方法中指定客户端请求时监听的地址和端口。
    builder.AddListeningPort(server_address,grpc::InsecureServerCredentials());
    //用生成器注册我们的服务实现。
      std::cout<<"54"<<std::endl;

    builder.RegisterService(&service);
      std::cout<<"61"<<std::endl;

    //调用生成器的 BuildAndStart() 方法为我们的服务创建和启动一个RPC服务器。    
    std::unique_ptr<Server>server(builder.BuildAndStart());
    调用服务器的 Wait() 方法实现阻塞等待，直到进程被杀死或者 Shutdown() 被调用
    std::cout<<"server listen on"<<server_address<<std::endl;
    server->Wait();


}

int main(){
    RunServer();
    
}

client.cc

#include"grpc/api.grpc.pb.h"
#include<grpc++/grpc++.h>
#include<iostream>
#include<string>
#include<unistd.h>
using grpc::Channel;
using grpc::ClientContext;
using grpc::Status;

using routeguide::RestResponse;
using routeguide::RestRequest;
using routeguide::Route;
class StringReverseClient{
    public:
    StringReverseClient(std::shared_ptr<grpc::Channel>channel)
    :stub_(Route::NewStub(channel)){
    }
    void fun(){
        RestRequest req;
        req.set_body("body");
       
        req.set_url("message");
        RestResponse reply;
        ClientContext context;
       std::unique_ptr< ::grpc::ClientReader< ::routeguide::RestResponse>> reader = stub_->Echo(&context, req);
    // 循环读取 reader 中的数据，并将其存入 reply 中
    while (reader->Read(&reply))
    {
      // 打印 reply 中的 message 字段
      std::cout << "message:" << reply.message() << std::endl;
    }
    // 获取 reader 中的状态码
    Status status = reader->Finish();

    // 如果状态码为 ok()，则提示成功获取 grpc 响应，并打印响应消息
    if (status.ok()) {
        //AlertMessage("Get grpc response success,the messsage is:" +reply.message());
      std::cout << "Rpc Request success!:"  << std::endl;
    } else {
        // 如果状态码不为 ok()，则提示失败获取 grpc 响应，并打印状态码和错误消息
        //AlertMessage("Get grpc response failed!:" +std::to_string(status.error_code())+":"+ status.error_message());
      std::cout << "Rpc Request failed!:"  << std::endl;
      std::cout << status.error_code() << ": " << status.error_message()
                << std::endl;
    }
    }
    private:
    std::unique_ptr<Route::Stub>stub_;
};
void RunClient(){
    std::string target_address("127.0.0.1:5000");
    StringReverseClient client(
        grpc::CreateChannel(target_address,grpc::InsecureChannelCredentials())
    );
    client.fun();
}
int main(){
     RunClient();
  // 等待2秒
 sleep(2);
  return 0;
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.11)
project(hello_grpc)

set(Protobuf_USE_STATIC_LIBS ON)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g")
# cmake-format: off
# ubuntu通过apt包管理器安装的grpc没有findgrpc.cmake这样的文件，但是有.pc这样的文件
# windows通过vcpkg库管理器安装的grpc有gRPCConfig.cmake,但是没有.pc文件
# 。。无语，大无语。。
# Linux上用PkgConfig获取库;windows上直接通过find_package查找;
# cmake-format: on
find_package(PkgConfig REQUIRED)
find_package(Protobuf REQUIRED)
if(WIN32)
  find_package(GRPC REQUIRED)
  get_target_property(GRPC_CPP_PLUGIN gRPC::grpc_cpp_plugin LOCATION)
  set(GRPC_LIBRARIES gRPC::grpc++) # 这样也可以,nb
else()
  find_program(GRPC_CPP_PLUGIN grpc_cpp_plugin REQUIRED)
  pkg_check_modules(GRPC REQUIRED grpc++)
endif()

# Proto file
set(calcu_proto "${CMAKE_SOURCE_DIR}/api.proto")
get_filename_component(calcu_proto_path "${calcu_proto}" PATH)

set(calcu_proto_srcs "${CMAKE_CURRENT_BINARY_DIR}/api.pb.cc")
set(calcu_proto_hdrs "${CMAKE_CURRENT_BINARY_DIR}/api.pb.h")
set(calcu_grpc_srcs "${CMAKE_CURRENT_BINARY_DIR}/api.grpc.pb.cc")
set(calcu_grpc_hdrs "${CMAKE_CURRENT_BINARY_DIR}/api.grpc.pb.h")

# 不要使用execute_process(),它在配置的时候调用
# 使用add_custom_command(),当有target使用OUTPUT中的输出时,将调用这个命令重新生成
add_custom_command(
  OUTPUT "${calcu_proto_srcs}" "${calcu_proto_hdrs}" "${calcu_grpc_srcs}"
         "${calcu_grpc_hdrs}"
  COMMAND
    ${Protobuf_PROTOC_EXECUTABLE} ARGS --grpc_out "${CMAKE_CURRENT_BINARY_DIR}"
    --cpp_out "${CMAKE_CURRENT_BINARY_DIR}" -I "${calcu_proto_path}"
    --plugin=protoc-gen-grpc="${GRPC_CPP_PLUGIN}" "${calcu_proto}"
  DEPENDS "${calcu_proto}")

# Include generated *.pb.h files
include_directories("${CMAKE_CURRENT_BINARY_DIR}")

add_library(calcu_grpc_proto ${calcu_proto_srcs} ${calcu_proto_hdrs}
                             ${calcu_grpc_srcs} ${calcu_grpc_hdrs})

target_link_libraries(calcu_grpc_proto ${GRPC_LIBRARIES} ${Protobuf_LIBRARIES})

foreach(_target server client)
  add_executable(${_target} "${CMAKE_SOURCE_DIR}/${_target}.cc")
  target_link_libraries(${_target} calcu_grpc_proto ${GRPC_LIBRARIES}
                        ${Protobuf_LIBRARIES})
endforeach()