通过gRPC，客户端应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法，使得您能够更容易地创建分布式应用和服务。与许多RPC系统类似，gRPC也是基于以下理念：
定义一个服务，指定其能够被远程调用的方法（包含参数和返回类型）。在服务端实现这个接口，并运行一个gRPC服务器来处理客户端调用。在客户端拥有一个存根能够像服务端一样的方法。
image.png
一个gRPC从开始发起请求到返回总共要经历过序列化，编解码，以及网络传输这些内容。这些东西在我们使用gRPC框架做远程服务调用的时候完全感知不到！至于gRPC的stub之间的连接管理，健康检查，负载均衡，异常重试，优雅启停机，熔断限流等等是需要我们从gRPC源码中获得这些知识的！

参考教程：

https://grpc.io/docs/languages/cpp/quickstart/

安装gRPC

注意：windows平台要使用MSVC编译，MinGW实测编译失败（缺少Linux系统调用）

安装依赖

  1. sudo apt install -y build-essential autoconf libtool pkg-config

下载grpc源码(国内镜像)

  1. git clone -b v1.43.0 https://gitee.com/mirrors/grpc-framework grpc

修改更新submodule(GitHub的submodule下载很慢很慢, 一天都下不下来)

  1. cd grpc
  2. cat .gitmodules // 查看文件里的submodule, 将GitHub改成Gitee
  3. git submodule update --init

安装gRPC

  1. mkdir build
  2. cd build
  3. cmake -DCMAKE_INSTALL_PREFIX=/usr/local ..
  4. make -j2
  5. sudo make install

使用示例

  1. |--- protos
  2. |   |--- helloworld.proto -------定义文件，生成.cc或者.h文件
  3. |--- server_cpp
  4. |--- client.cpp
  5. |--- CMakeLists.txt

helloworld.proto

  1. syntax = "proto3";
  3. option java_package = "ex.grpc";
  5. package helloworld;
  7. message Reply {
  8.     int32 result = 1;
  9. }
  11. message HelloMessage {
  12.     int32 a = 1;
  13.     int32 b = 2;
  14. }
  16. service TestServer {
  17.     rpc hello_request (HelloMessage) returns (Reply) {}
  18. }

编译命令,自动生成grpc.pb和pb的cc和h文件(CMakeLists.txt中集成如下命令，不需要单独编译）:

  1. protoc --cpp_out=. helloworld.proto
  2. protoc --grpc_out=. --plugin=protoc-gen-grpc=`which grpc_cpp_plugin` helloworld.proto

client

  1. #include <iostream>
  2. #include <memory>
  3. #include <string>
  4. #include <grpcpp/grpcpp.h>
  5. #include "helloworld.grpc.pb.h"
  7. using grpc::Channel;
  8. using grpc::ClientContext;
  9. using grpc::Status;
  10. using helloworld::TestServer;
  11. using helloworld::HelloMessage;
  12. using helloworld::Reply;
  14. class GreeterClient {
  15.     public:
  16.         GreeterClient(std::shared_ptr<Channel> channel):stub_(TestServer::NewStub(channel)) {}
  17.         int say_hello(const std::string& user) 
  18.         {
  19.             HelloMessage request;
  20.             Reply reply;
  21.             ClientContext context;
  22.                         //传入两个值，让server计算乘积
  23.             request.set_a(21);
  24.             request.set_b(22);
  26.             Status status = stub_->hello_request(&context, request, &reply);
  27.             if (status.ok()) {
  28.                 return reply.result();
  29.             } else {
  30.                 std::cout << status.error_code() << ": " << status.error_message() << std::endl;
  31.                 return 0;
  32.             }
  33.         }
  35.     private:
  36.         std::unique_ptr<TestServer::Stub> stub_;
  37. };
  39. int main(int argc, char** argv) 
  40. {
  41.     GreeterClient greeter(grpc::CreateChannel("127.0.0.1:5000", grpc::InsecureChannelCredentials()));
  42.     std::string user("world");
  43.     int reply = greeter.say_hello(user);
  44.     std::cout << "Greeter received: " << reply << std::endl;
  45.     return 0;
  46. }

server

  1. #include <string>
  2. #include <grpcpp/grpcpp.h>
  3. #include "helloworld.grpc.pb.h"
  5. using grpc::Server;
  6. using grpc::ServerBuilder;
  7. using grpc::ServerContext;
  8. using grpc::Status;
  9. using helloworld::TestServer;
  10. using helloworld::HelloMessage;
  11. using helloworld::Reply;
  13. class HelloServiceImplementation final : public TestServer::Service {
  14.     Status hello_request(ServerContext* context, const HelloMessage* request, Reply* reply) override
  15.     {
  16.         int a = request->a();
  17.         int b = request->b();
  18.         reply->set_result(a * b);//返回乘积
  19.         return Status::OK;
  20.     }
  21. };
  23. int main(int argc, char** argv) {
  24.     std::string address("0.0.0.0:5000");
  25.     HelloServiceImplementation service;
  26.     ServerBuilder builder;
  27.     builder.AddListeningPort(address, grpc::InsecureServerCredentials());
  28.     builder.RegisterService(&service);
  29.     std::unique_ptr<Server> server(builder.BuildAndStart());
  30.     std::cout << "Server listening on port: " << address << std::endl;
  31.     server->Wait();
  32.     return 0;
  33. }

CMakeLists

  1. cmake_minimum_required(VERSION 3.14)
  3. project(grpcdemo)
  5. set(CMAKE_CXX_STANDARD 14)
  7. set(protobuf_MODULE_COMPATIBLE TRUE)
  8. find_package(Protobuf CONFIG REQUIRED)
  9. message(STATUS "Using protobuf ${Protobuf_VERSION}")
  11. set(_PROTOBUF_LIBPROTOBUF protobuf::libprotobuf)
  12. set(_REFLECTION gRPC::grpc++_reflection)
  13. if(CMAKE_CROSSCOMPILING)
  14.     find_program(_PROTOBUF_PROTOC protoc)
  15. else()
  16.     set(_PROTOBUF_PROTOC $<TARGET_FILE:protobuf::protoc>)
  17. endif()
  19. # Find gRPC installation
  20. # Looks for gRPCConfig.cmake file installed by gRPC's cmake installation.
  21. find_package(gRPC CONFIG REQUIRED)
  22. message(STATUS "Using gRPC ${gRPC_VERSION}")
  24. set(_GRPC_GRPCPP gRPC::grpc++)
  25. if(CMAKE_CROSSCOMPILING)
  26.     find_program(_GRPC_CPP_PLUGIN_EXECUTABLE grpc_cpp_plugin)
  27. else()
  28.     set(_GRPC_CPP_PLUGIN_EXECUTABLE $<TARGET_FILE:gRPC::grpc_cpp_plugin>)
  29. endif()
  31. # Proto file
  32. get_filename_component(hw_proto "protos/helloworld.proto" ABSOLUTE)
  33. get_filename_component(hw_proto_path "${hw_proto}" PATH)
  35. # Generated sources
  36. set(hw_proto_srcs "${CMAKE_CURRENT_BINARY_DIR}/helloworld.pb.cc")
  37. set(hw_proto_hdrs "${CMAKE_CURRENT_BINARY_DIR}/helloworld.pb.h")
  38. set(hw_grpc_srcs "${CMAKE_CURRENT_BINARY_DIR}/helloworld.grpc.pb.cc")
  39. set(hw_grpc_hdrs "${CMAKE_CURRENT_BINARY_DIR}/helloworld.grpc.pb.h")
  40. add_custom_command(
  41.       OUTPUT "${hw_proto_srcs}" "${hw_proto_hdrs}" "${hw_grpc_srcs}" "${hw_grpc_hdrs}"
  42.       COMMAND ${_PROTOBUF_PROTOC}
  43.       ARGS --grpc_out "${CMAKE_CURRENT_BINARY_DIR}"
  44.         --cpp_out "${CMAKE_CURRENT_BINARY_DIR}"
  45.         -I "${hw_proto_path}"
  46.         --plugin=protoc-gen-grpc="${_GRPC_CPP_PLUGIN_EXECUTABLE}"
  47.         "${hw_proto}"
  48.       DEPENDS "${hw_proto}")
  50. # Include generated *.pb.h files
  51. include_directories("${CMAKE_CURRENT_BINARY_DIR}")
  53. # hw_grpc_proto
  54. add_library(hw_grpc_proto
  55.   ${hw_grpc_srcs}
  56.   ${hw_grpc_hdrs}
  57.   ${hw_proto_srcs}
  58.   ${hw_proto_hdrs})
  59. target_link_libraries(hw_grpc_proto
  60.   ${_REFLECTION}
  61.   ${_GRPC_GRPCPP}
  62.   ${_PROTOBUF_LIBPROTOBUF})
  64. # executable target
  65. foreach(_target client server)
  66.     add_executable(${_target} "${_target}.cpp")
  67.     target_link_libraries(${_target}
  68.         ${_REFLECTION}
  69.         ${_GRPC_GRPCPP}
  70.         ${_PROTOBUF_LIBPROTOBUF}
  71.         hw_grpc_proto)
  72. endforeach()