当前位置：首页 > news >正文

windows系统下编译和使用grpc

news 来源：原创 2024/9/20 21:45:47

GRPC简介

GRPC 是一个高性能、开源和通用的 RPC 框架，面向服务端和移动端，基于 HTTP/2 设计；

GRPC 默认使用protocol buffers，使用protocol buffers作为IDL和消息交换格式，google开源的成熟的数据序列化机制；

定义服务：通过指定方法调用的参数和返回值来定义，就是使用IDL来描述你的服务接口和传输消息结构；

gRPC 特点:

①语言中立，支持多种语言；

②基于 IDL 文件定义服务，通过 proto3 工具生成指定语言的数据结构、服务端接口以及客户端 Stub；

③通信协议基于标准的 HTTP/2 设计，支持双向流、消息头压缩、单 TCP 的多路复用、服务端推送等特性，这些特性使得 gRPC 在移动端设备上更加省电和节省网络流量；

④序列化支持 PB（Protocol Buffer）和 JSON，PB 是一种语言无关的高性能序列化框架，基于 HTTP/2 + PB, 保障了 RPC 调用的高性能。

简单理解：Grpc Server 实现方法，Grpc Client 像调用本地方法一样调用server的方法,Server不主动进行通信，主要依靠client调用来进行交互通信;

准备编译环境

安装Git

作用：下载grpc代码以及相关的第三方库代码。

下载地址：Git

备注：可以不下载安装，因为通过git下载太慢了在这里都是直接下载zip压缩包，

安装CMake

作用：用来编译，生成grpc.sln

下载：Download CMake

备注：将Cmake 的bin目录配置到系统环境变量Path。

这里我下载的cmake-3.29.0-windows-x86_64.msi

安装Perl

作用：grpc依赖的第三方库依赖的包。

参考：https://jingyan.baidu.com/article/9f7e7ec0b798ae6f281554e9.html

备注：这里下载安装的是ActivePerl_5.16.2.3010812913.msi

说明：

Perl是一种功能丰富、强大而灵活的高级编程语言，由Larry Wall在1987年首次发布。它以其强大的文本处理能力和灵活的语法而闻名，被广泛用于系统管理、文本处理、网络编程和Web开发等领域。尤其擅长文本处理和自动化任务。

官网地址：Perl Download - www.perl.org

Windows版本有：Strawberry Perl和ActiveState Perl

ActiveState Perl和 Strawberry Perl区别是 Strawberry Perl 里面有多包含一些 CPAN 里的模块，所以Strawberry Perl 下载的安装文件有 80多M, 而ActiveState Perl 只有20M 左右。

ActiveState Perl: ActiveState提供了一个免费的社区版本和一个商业支持的Perl用于Win32和Perl的二进制分布。

Strawberry Perl:用于Windows的100%开源Perl，使用来自CPAN的模块不需要二进制包。

个人认为也可以安装Strawberry Perl，如strawberry-perl-5.32.1.1-64bit.msi

Strawberry Perl的官网地址：https://strawberryperl.com/

安装Go

作用：grpc依赖的第三方库依赖的包。

下载地址：Go下载 - Go语言中文网 - Golang中文社区

备注：我这里下载安装的是go1.22.0.windows-amd64.msi

安装yasm

作用：grpc依赖的第三方库依赖的包。

下载地址：http://yasm.tortall.net/Download.html

备注：下载的直接是exe,免安装的，将其名字改为yasm.exe，将yasm.exe所在目录配置到系统环境变量Path。我这里下载的是yasm-1.3.0-win64.exe

安装Visual Studio

下载地址：https://visualstudio.microsoft.com/zh-hans/vs/

注意：windows sdk选择10.0.2以上版本。

备注：我这里下载的是Visual Studio 2019

异议

下装ninja

作用：grpc依赖的第三方库依赖的包。

下载地址：https://github.com/ninja-build/ninja/releases

备注：将ninja.exe所在目录配置到系统环境变量Path。

已安装

说明：

Ninja 是一个高效的构建工具，被广泛用于编译软件项目。

访问 Ninja 的官方网站（https://ninja-build.org/）并下载最新的 Windows 版本的二进制文件。

可选非必须

安装配置openssl库

如果不想使用ssl库，而是使用openssl库。则需自己通过源码编译出openssl库。这一步操作非必须。可参考编译openssl文章。

下载Grpc源码及第三方依赖库

Grpc源码

下载地址：GitHub - grpc/grpc: The C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#)

我下载的是master分支的，通过code->download zip方式直接下载zip压缩包

第三方依赖库

grpc依赖了大量第三方库，但是光下载grpc源码，还不能完全下载 grpc依赖的库。

解压grpc源码得到 grpc/third_party。把该目录下的所依赖的库文件都通过https://github.com/grpc/grpc/tree/master/third_party下载并解压放到grpc/third_party。

编译GRPC

编译工具选择vs2019 32bit

可选非必须

如果不想使用grpc/third_party的ssl库，而是自己从外面找openssl库，需要先配置Openssl库环境变量。

这个文件夹放到环境变量里面去。新建一个叫OPENSSL_ROOT_DIR的变量名称。因为在cmake-gui工具配置上需设置ssl的路径。

打开CMake工具设置

然后点击Configure，然后弹出，选择vs2019 32bit

修改INSTALL生成的路径

INSTALL生成的默认路径如下

如果想在INSTALL设置其他的路径，设置。在这里我设置install 生成在其他路径。

可选非必须

因为默认是生成dynamic_runtime，如果想生成的是静态库来调用的。则gRPC_MSVC_STATIC_RUNTIME、CARES_MSVC_STATIC_RUNTIME、protobuf_MSVC_STATIC_RUNTIME这几个项的前面那个框勾选上。

备注：经测试，如果生成静态库，在qt程序启动无法进去代码断点处，不知道为什么。还是不要勾选为好。

如果是使用openssl的库

则把gRPC_SSL_PROVIDER那个地方的module改成package。如果是使用grpc的third_party/boringssl-with-bazel,则不用改。在这里我不修改，直接使用boringssl-with-bazel

点击Configure。

会提示Configuring done

再点Generate

就生成VS工程文件，在编译vs工程输出目录如E:\grpc\build_32bit，双击打开grpc.sln

ALL_BUILD右键，生成。

在这里选择的是win32 release版本，等待好长一段时间。

单击INSTALL,右键，仅用于项目，仅生成INSTALL

install的路径就是在cmake设置的路径，如果使用默认install路径（C:\Program Files (x86)\grpc），需要是以管理员的身份执行INSTALL

打开INSTALL目录

（这里是E:\grpc\grpcinstall\win32\grpc），就可以看到完整的grpc，这样就可以直接使用了。

C:\Program Files (x86)\grpc是在cmake-gui配置上默认设置的，也可以自定义。

编程使用GRPC

创建.proto

.proto 文件用来定义客户端和服务端的服务接口和消息字段格式。

服务接口

HelloRequest为输入参数，HelloReply为返回值，Greeter 为服务类，服务端必须继承于它。

service Greeter {

// Sends a greeting

rpc SayHello (HelloRequest) returns (HelloReply) {}

rpc SayHelloStreamReply (HelloRequest) returns (stream HelloReply) {}

rpc SayHelloBidiStream (stream HelloRequest) returns (stream HelloReply) {}

}

消息字段

// 字段后面的数字并不表示该字段的值，只是 proto 程序用来生成相关源代码使用

message HelloRequest {

string name = 1;

}

完整的proto文件

syntax = "proto3";

option java_multiple_files = true;

option java_package = "io.grpc.examples.helloworld";

option java_outer_classname = "HelloWorldProto";

option objc_class_prefix = "HLW";

package helloworld;

// The greeting service definition.

service Greeter {

// Sends a greeting

rpc SayHello (HelloRequest) returns (HelloReply) {}

rpc SayHelloStreamReply (HelloRequest) returns (stream HelloReply) {}

rpc SayHelloBidiStream (stream HelloRequest) returns (stream HelloReply) {}

}

// The request message containing the user's name.

message HelloRequest {

string name = 1;

}

// The response message containing the greetings

message HelloReply {

string message = 1;

}

处理.proto文件

如命名上面的文件为helloworld.proto，通过执行命令会生成helloworld.grpc.pb.cc、helloworld.grpc.pb.h、helloworld.pb.cc和helloworld.pb.h。服务端和客户端就是通过引用这些文件编写代码.

配置环境变量

把protoc.exe(在grpc的bin目录下)所在的路径添加到环境变量。打开cmd，输入protoc,回车，可看到是否配置成功。

执行cmd命令

打开cmd, 使用cd命令进入到helloworld.proto文件所在的目录（E:\study\grpc\win_32bit_release\hello）。同时把protoc.exe和grpc_cpp_plugin.exe拷贝到该目录，这两个软件在grpc\bin目录下。

执行protoc.exe ./helloworld.proto --cpp_out=./

会生成helloworld.pb.h和helloworld.pb.cc文件

执行protoc.exe --grpc_out=. --plugin=protoc-gen-grpc=grpc_cpp_plugin.exe helloworld.proto

会生成helloworld.grpc.pb.h和helloworld.grpc.pb.cc文件

服务端编程

使用vs2019 操作编程

以x86 release版本为例。

配置grpc的头文件和依赖库

配置头文件

将grpc的include目录添加进附加包含目录

配置lib库路径

配置依赖库

在VS项目工程的“属性>配置属性>链接器>命令行>其他选项”中，设置"[lib目录]\*.lib "即可在工程中一次性引入全部lib。

处理增加_WIN32_WINNT=0x0A00

项目右键–> 属性–>c/c++ -->预处理器—>预处理定义

运行库模式设置

Release模式选择“多线程(/MD)”

多线程(/MT) ：对应的是MD_StaticRelease

多线程(/MTd)：对应的是MD_StaticDebug

多线程Dll (/MD) ：对应的是MD_DynamicRelease

多线程调试Dll (/MDd) ：对应的是MD_DynamicDebug

需要确保你的项目设置与所链接的库的运行库设置相匹配.

添加文件到项目

因为这里直接使用grpc/example的现成例子，greeter_server.cc可以从grpc\examples\cpp\helloworld目录下获取。

把所有的文件拷贝到工程目录中（E:\study\grpc\win_32bit_release\hello），然后在VS中添加helloworld.proto、greeter_server.cc进创建的新项目。

编译代码

然后编译代码，出现一个错误。

解决方案：发现旧版本的container.h并没有这个函数，现在直接把部分代码给屏蔽。

输出目录设置bin/release目录，同时需要把zlib.dll拷贝到输出目录。

运行程序

最后先运行服务端，再运行客户端。

使用qt5.15 编程

使用qt的文件目录如下，依赖的grpc全放在grpc文件夹

配置grpc头文件和依赖库

配置头文件

Qt配置头文件，是配置.pro文件

配置lib库

Qt配置lib库不能像vs设置"[lib目录]\*.lib "加入依赖库。需要手动自己一个一个把所有的lib库加进来。其中libprotoc、libprotobuf-lite、libprotobuf、zlib、zlibstatic这5个库还区分是debug还是release. 另外还需配置WS2_32、Advapi32库。加上预定义DEFINES += _WIN32_WINNT=0x600

如下就是在pro文件配置lib库

CONFIG(debug, debug|release){

DESTDIR += $$PWD/../bin/debug/

gRPC_libpath = $$PWD/../../grpc/lib/debug

LIBS += -L$$gRPC_libpath \

-llibprotocd \

-llibprotobuf-lited \

-llibprotobufd \

-lzlibd \

-lzlibstaticd \

}else{

DESTDIR += $$PWD/../bin/release/

gRPC_libpath = $$PWD/../../grpc/lib/release

LIBS += -L$$gRPC_libpath \

-llibprotoc \

-llibprotobuf-lite \

-llibprotobuf \

-lzlib \

-lzlibstatic \

}

LIBS += -L$$gRPC_libpath \

-labsl_bad_any_cast_impl \

-labsl_bad_optional_access \

-labsl_bad_variant_access \

-labsl_base \

-labsl_city \

-labsl_civil_time \

-labsl_cord \

-labsl_cord_internal \

-labsl_cordz_functions \

-labsl_cordz_handle \

-labsl_cordz_info \

-labsl_cordz_sample_token \

-labsl_crc_cord_state \

-labsl_crc_cpu_detect \

-labsl_crc_internal \

-labsl_crc32c \

-labsl_debugging_internal \

-labsl_demangle_internal \

-labsl_die_if_null \

-labsl_examine_stack \

-labsl_exponential_biased \

-labsl_failure_signal_handler \

-labsl_flags_commandlineflag \

-labsl_flags_commandlineflag_internal \

-labsl_flags_config \

-labsl_flags_internal \

-labsl_flags_marshalling \

-labsl_flags_parse \

-labsl_flags_private_handle_accessor \

-labsl_flags_program_name \

-labsl_flags_reflection \

-labsl_flags_usage \

-labsl_flags_usage_internal \

-labsl_graphcycles_internal \

-labsl_hash \

-labsl_hashtablez_sampler \

-labsl_int128 \

-labsl_kernel_timeout_internal \

-labsl_leak_check \

-labsl_log_entry \

-labsl_log_flags \

-labsl_log_globals \

-labsl_log_initialize \

-labsl_log_internal_check_op \

-labsl_log_internal_conditions \

-labsl_log_internal_fnmatch \

-labsl_log_internal_format \

-labsl_log_internal_globals \

-labsl_log_internal_log_sink_set \

-labsl_log_internal_message \

-labsl_log_internal_nullguard \

-labsl_log_internal_proto \

-labsl_log_severity \

-labsl_log_sink \

-labsl_low_level_hash \

-labsl_malloc_internal \

-labsl_periodic_sampler \

-labsl_random_distributions \

-labsl_random_internal_distribution_test_util \

-labsl_random_internal_platform \

-labsl_random_internal_pool_urbg \

-labsl_random_internal_randen \

-labsl_random_internal_randen_hwaes \

-labsl_random_internal_randen_hwaes_impl \

-labsl_random_internal_randen_slow \

-labsl_random_internal_seed_material \

-labsl_random_seed_gen_exception \

-labsl_random_seed_sequences \

-labsl_raw_hash_set \

-labsl_raw_logging_internal \

-labsl_scoped_set_env \

-labsl_spinlock_wait \

-labsl_stacktrace \

-labsl_status \

-labsl_statusor \

-labsl_str_format_internal \

-labsl_strerror \

-labsl_string_view \

-labsl_strings \

-labsl_strings_internal \

-labsl_symbolize \

-labsl_synchronization \

-labsl_throw_delegate \

-labsl_time \

-labsl_time_zone \

-labsl_vlog_config_internal \

-laddress_sorting \

-lcares \

-lcrypto \

-lgpr \

-lgrpc \

-lgrpc_authorization_provider \

-lgrpc_plugin_support \

-lgrpc_unsecure \

-lgrpc++ \

-lgrpc++_alts \

-lgrpc++_error_details \

-lgrpc++_reflection \

-lgrpc++_unsecure \

-lgrpcpp_channelz \

-lre2 \

-lssl \

-lupb_base_lib \

-lupb_json_lib \

-lupb_mem_lib \

-lupb_message_lib \

-lupb_textformat_lib \

-lutf8_range \

-lutf8_range_lib \

-lutf8_validity \

LIBS += -lWS2_32

LIBS += -lAdvapi32

DEFINES += _WIN32_WINNT=0x600

添加文件到项目

把helloworld.proto、helloworld.pb.h、helloworld.pb.cc、helloworld.grpc.pb.h、helloworld.grpc.pb.cc添加到server项目中，同时greeter_server.cc的代码拷贝到main.cpp文件，并稍微改造一下。

编译代码

然后编译服务端，输出目录设置bin/release目录，同时需要把zlib.dll拷贝到输出目录。

运行程序

最后先运行服务端，再运行客户端。

编程思路

创建继承于服务类的子类

class GreeterServiceImpl final : public Greeter::Service {

};

重写虚函数的方式，实现服务接口。

Status SayHello(ServerContext* context, const HelloRequest* request, HelloReply* reply) override

{

std::string prefix("Hello ");

reply->set_message(prefix + request->name());

return Status::OK;

}

注册服务、创建开始服务。

std::string server_address = absl::StrFormat("0.0.0.0:%d", port);

GreeterServiceImpl service;

grpc::EnableDefaultHealthCheckService(true);

grpc::reflection::InitProtoReflectionServerBuilderPlugin();

ServerBuilder builder;

// Listen on the given address without any authentication mechanism.

builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());

// Register "service" as the instance through which we'll communicate with

// clients. In this case it corresponds to an *synchronous* service.

builder.RegisterService(&service);

// Finally assemble the server.

std::unique_ptr<Server> server(builder.BuildAndStart());

std::cout << "Server listening on " << server_address << std::endl;

// Wait for the server to shutdown. Note that some other thread must be

// responsible for shutting down the server for this call to ever return.

server->Wait();

完成的代码：

#include <iostream>

#include <memory>

#include <string>

#include "absl/flags/flag.h"

#include "absl/flags/parse.h"

#include "absl/strings/str_format.h"

#include <grpcpp/ext/proto_server_reflection_plugin.h>

#include <grpcpp/grpcpp.h>

#include <grpcpp/health_check_service_interface.h>

#ifdef BAZEL_BUILD

#include "examples/protos/helloworld.grpc.pb.h"

#else

#include "helloworld.grpc.pb.h"

#endif

using grpc::Server;

using grpc::ServerBuilder;

using grpc::ServerContext;

using grpc::Status;

using helloworld::Greeter;

using helloworld::HelloReply;

using helloworld::HelloRequest;

ABSL_FLAG(uint16_t, port, 50051, "Server port for the service");

// Logic and data behind the server's behavior.

class GreeterServiceImpl final : public Greeter::Service {

Status SayHello(ServerContext* context, const HelloRequest* request, HelloReply* reply) override

{

std::string prefix("Hello ");

reply->set_message(prefix + request->name());

return Status::OK;

}

};

void RunServer(uint16_t port) {

std::string server_address = absl::StrFormat("0.0.0.0:%d", port);

GreeterServiceImpl service;

grpc::EnableDefaultHealthCheckService(true);

grpc::reflection::InitProtoReflectionServerBuilderPlugin();

ServerBuilder builder;

// Listen on the given address without any authentication mechanism.

builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());

// Register "service" as the instance through which we'll communicate with

// clients. In this case it corresponds to an *synchronous* service.

builder.RegisterService(&service);

// Finally assemble the server.

std::unique_ptr<Server> server(builder.BuildAndStart());

std::cout << "Server listening on " << server_address << std::endl;

// Wait for the server to shutdown. Note that some other thread must be

// responsible for shutting down the server for this call to ever return.

server->Wait();

}

int main(int argc, char** argv) {

absl::ParseCommandLine(argc, argv);

RunServer(absl::GetFlag(FLAGS_port));

return 0;

}

客户端编程

使用vs2019 操作编程

配置grpc的头文件和依赖库

和服务端一样的配置

配置头文件

将grpc的include目录添加进附加包含目录

配置lib库路径

配置依赖库

在VS项目工程的“属性>配置属性>链接器>命令行>其他选项”中，设置"[lib目录]\*.lib "即可在工程中一次性引入全部lib。

处理增加_WIN32_WINNT=0x0A00

项目右键–> 属性–>c/c++ -->预处理器—>预处理定义

运行库模式设置

添加文件到项目

因为这里直接使用grpc/example的现成例子，greeter_client.cc可以从grpc\examples\cpp\helloworld目录下获取。

把所有的文件拷贝到工程目录中（E:\study\grpc\win_32bit_release\hello），然后在VS中添加helloworld.proto、greeter_server.cc进创建的新项目。

编译代码

然后编译服务端，输出目录设置bin/release目录，同时需要把zlib.dll拷贝到输出目录。

运行程序

最后先运行服务端，再运行客户端。

使用qt5.15 编程

客户端配置grpc的头文件和依赖库、添加文件到项目、编译程序、运行程序的操作和服务端一样的，这里就不写了。

编程思路

客户端封装成一个自定义类，定义一个独占智能指针std::unique_ptr<MathTest::Stub> stub_;

class GreeterClient {

public:

GreeterClient(std::shared_ptr<Channel> channel)

: stub_(Greeter::NewStub(channel)) {}

private:

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

};

自定义一个函数，然后通过私有成员变量 stub_ 向服务端发送请求消息并接收返回结果。

std::string SayHello(const std::string& user) {

// Data we are sending to the server.

HelloRequest request;

request.set_name(user);

// Container for the data we expect from the server.

HelloReply reply;

// Context for the client. It could be used to convey extra information to

// the server and/or tweak certain RPC behaviors.

ClientContext context;

// The actual RPC.

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

// Act upon its status.

if (status.ok()) {

return reply.message();

} else {

std::cout << status.error_code() << ": " << status.error_message()

<< std::endl;

return "RPC failed";

}

初始化自定义类对象，通过地址创建实例化stub_对象。

ABSL_FLAG(std::string, target, "localhost:50051", "Server address");

std::string target_str = absl::GetFlag(FLAGS_target);

// We indicate that the channel isn't authenticated (use of

// InsecureChannelCredentials()).

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;

std::cin.get();//防止客户端一闪而过

完成的代码：

#include <iostream>

#include <memory>

#include <string>

#include "absl/flags/flag.h"

#include "absl/flags/parse.h"

#include <grpcpp/grpcpp.h>

#ifdef BAZEL_BUILD

#include "examples/protos/helloworld.grpc.pb.h"

#else

#include "helloworld.grpc.pb.h"

#endif

ABSL_FLAG(std::string, target, "localhost:50051", "Server address");

using grpc::Channel;

using grpc::ClientContext;

using grpc::Status;

using helloworld::Greeter;

using helloworld::HelloReply;

using helloworld::HelloRequest;

class GreeterClient {

public:

GreeterClient(std::shared_ptr<Channel> channel)

: stub_(Greeter::NewStub(channel)) {}

// Assembles the client's payload, sends it and presents the response back

// from the server.

std::string SayHello(const std::string& user) {

// Data we are sending to the server.

HelloRequest request;

request.set_name(user);

// Container for the data we expect from the server.

HelloReply reply;

// Context for the client. It could be used to convey extra information to

// the server and/or tweak certain RPC behaviors.

ClientContext context;

// The actual RPC.

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

// Act upon its status.

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(int argc, char** argv) {

absl::ParseCommandLine(argc, argv);

// Instantiate the client. It requires a channel, out of which the actual RPCs

// are created. This channel models a connection to an endpoint specified by

// the argument "--target=" which is the only expected argument.

std::string target_str = absl::GetFlag(FLAGS_target);

// We indicate that the channel isn't authenticated (use of

// InsecureChannelCredentials()).

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;

std::cin.get();//防止客户端一闪而过

return 0;

}

参考

Windows GRPC源码编译C++库——详细步骤_grpc源码下载-CSDN博客
https://blog.csdn.net/w13l14/article/details/118155498?spm=1001.2014.3001.5506

延伸扩展

.proto 简介

.proto 文件用来定义客户端和服务端的服务接口和消息字段格式。

syntax = "proto3";

option java_multiple_files = true;

option java_package = "io.grpc.examples.helloworld";

option java_outer_classname = "HelloWorldProto";

option objc_class_prefix = "HLW";

package helloworld;//表示定义消息的包名,对于 C++ 程序，消息类将会被包装在命名空间中

服务接口

HelloRequest为输入参数，HelloReply为返回值，Greeter 为服务类，服务端必须继承于它。

service Greeter {

// Sends a greeting

rpc SayHello (HelloRequest) returns (HelloReply) {}

rpc SayHelloStreamReply (HelloRequest) returns (stream HelloReply) {}

rpc SayHelloBidiStream (stream HelloRequest) returns (stream HelloReply) {}

}

消息字段

// 字段后面的数字并不表示该字段的值，只是 proto 程序用来生成相关源代码使用

message HelloRequest {

string name = 1;

}

关键字

required

required是必须的意思，数据发送方和接收方都必须处理这个字段。

message Person {

required int32 age = 1;

required string name = 2;

}

optional

字面意思是可选的意思，具体protobuf里面怎么处理这个字段呢，就是protobuf处理的时候另外加了一个bool的变量，用来标记这个optional字段是否有值，发送方在发送的时候，如果这个字段有值，那么就给bool变量标记为true，否则就标记为false，接收方在收到这个字段的同时，也会收到发送方同时发送的bool变量，拿着bool变量就知道这个字段是否有值了，这就是option的意思。

Repeated

Repeated是protobuf中的一种限定修饰符，从字面意思看有“重复”的意思，实际上它就是用来指定某一个字段可以存放同一个类型的多个数据，相当于C++中的vector或者Java中的List。

message Family {

repeated Person person = 1;

}

代码中实现关键字

简单数据

xx( )函数为直接获取该变量 xx对应在proto定义的字段

赋值直接采用set_xx()即可，xx对应在proto定义的字段

Person person;

Int age = Person.age ;

Person.set_age = 20;

嵌套数据

嵌套消息即在proto定义了结构体，在c++使用主要对set_allocated_和mutable_的使用

1 使用set_allocated_，赋值的对象需要new出来，不能用局部的，这里保存的是对象的指针。

2 使用mutable_，赋值时候，可以使用局部变量，因为在调用时，内部做了new操作。

在proto定义

message ErrorCode {

string message = 1; //错误信息

string note = 2; //注释

uint32 code = 3; //错误码

}

message HashProjectRet{

ErrorCode errorCode=1;//错误码

string hashValue=2;// hash值

}

在c++代码使用

HashProjectRet *response;

std::string hashvalue = “qwert”;

response->set_hashvalue(hashvalue);

ErrorCode* errorcode = new ErrorCode;

errorcode->set_note("getHashProject");

errorcode->set_code(0);

errorcode->set_message("OK");

response->set_allocated_errorcode(errorcode);

重复数据

重复数据即在proto定义使用了repeated

message Family {

repeated Person person = 1;

}

获取数据

int size = family.person_size();

for( int i=0; i<size; i++)

{

Person psn = family.person(i);

cout <<” 姓名” << psn.name() << ", 年龄 " << psn.age() << endl;

}

设置数据

person = family.add_person();

person->set_age(25);

person->set_name("John");

grpc有四种交互模式

简单模式（Simple RPC）

客户端发起请求并等待服务端响应；

在proto定义为：

rpc SayHello (HelloRequest) returns (HelloReply) {}

具体例子见上面的代码

服务端流式 RPC（Server-side streaming RPC）

客户端发起一个请求到服务端，服务端返回一段连续的数据流响应

在proto定义为：

rpc SayHelloStreamReply (HelloRequest) returns (stream HelloReply) {}

服务端

重写虚函数SayHelloStreamReply

Status SayHelloStreamReply(::grpc::ServerContext* context, const ::helloworld::HelloRequest* request, ::grpc::ServerWriter< ::helloworld::HelloReply>* writer)

{

std::cout << "request:" << request->name() << std::endl;

HelloReply reply;

int i = 1;

while(1)

{

reply.set_message("server stream reply:" + std::to_string(i));

::grpc::WriteOptions options;

writer->Write(reply, options);

Sleep(300);

if (i > 10)

break;

i++;

}

Sleep(3000);

std::cout << "SayHelloStreamReply end" << std::endl;

return Status::OK;

}

延伸：分块传输多个文件

#include <iostream>

#include <fstream>

#define SEND_FILESIZE 1024*1024

for(auto strFilePath : strFilePathList)

{

int epos = strFilePath.lastIndexOf("/");//从后面开始查找

QString strFileName = strFilePath.right(strFilePath.size()-epos-1);

std::string strpath = strFilePath.toStdString();

std::ifstream infile;

infile.open(strpath, std::ifstream::in | std::ifstream::binary| std::ios::ate);//std::ios::ate 先定位到末尾

int nFileSize = infile.tellg();

infile.seekg(0,std::ios::beg);

char data[SEND_FILESIZE];

while(!infile.eof())

{

infile.read(data, SEND_FILESIZE);

FaultLogFileReply reply;

reply.set_filename(strFileName.toStdString());

reply.set_filesize(nFileSize);

int nlen = infile.gcount();

reply.set_filecontent(data,nlen);

vate_lib::ReturnStatusCode *errorcode = new vate_lib::ReturnStatusCode;

errorcode->set_note("getFaultLogFile");

errorcode->set_code(statuscode.nCode);

errorcode->set_message(statuscode.strMessage.toStdString());

reply.set_allocated_statuscode(errorcode);

::grpc::WriteOptions options;

if(!writer->Write(reply, options))

{

break;

}

if(infile.peek() == EOF)

{

break;

}

infile.close();

QThread::msleep(10);

}

客户端

自定义一个函数，在该函数中通过Stub调用SayHelloStreamReply函数。

void sayserveralltime()

{

ClientContext context;

HelloRequest request;

request.set_name("request server stream ");

std::unique_ptr<grpc::ClientReader<HelloReply>> reader = stub_->SayHelloStreamReply(&context, request);//异步

HelloReply response;

int count = 0;

while (reader->Read(&response)) //客户端不断read //阻塞测试过了：服务端没有WritesDone，所以只能等到服务端的函数返回，才退出循环

{

time_t currentTime = time(0);

struct tm* localTime = localtime(¤tTime);

std::cout << localTime->tm_hour << ":" << localTime->tm_min << ":" << localTime->tm_sec << " " << response.message() << std::endl;

}

Status status = reader->Finish();

if (!status.ok())

std::cout << "error:" << status.error_message() << std::endl;

std::cout << "exit sayserveralltime" << std::endl;

}

延伸：分块传输多个文件

ClientContext context;

FaultLogFileRequest request;

request.set_nstationid(nStationID);

request.set_nslotnum(nSlotNum);

FaultLogFileReply response;

std::unique_ptr<::grpc::ClientReader<FaultLogFileReply>> reader = m_stub->getFaultLogFile(&context, request);//异步

QList<std::string> filelist;

std::ofstream outfile;

QString strFileDir = strfiledir;

int nRecvFileSize = 0;

while (reader->Read(&response)) //客户端不断read //阻塞服务端没有WritesDone，所以只等等到服务端的函数返回，才退出循环

{

int ncode = response.statuscode().code();

if(ncode == 0)

{

std::string strfilename = response.filename();

int nFileSize = response.filesize();

bool bcontains = filelist.contains(strfilename);

if(!bcontains)

{

QString strfilepath = strFileDir + "/" + QString::fromStdString(strfilename);

std::string filepath = strfilepath.toStdString();

outfile.open(filepath, std::ios::binary | std::ios::out | std::ios::trunc);

filelist.append(strfilename);

nRecvFileSize = 0;

}

int nContentLen = response.filecontent().length();

const char *data = response.filecontent().c_str();

outfile.write(data, nContentLen);

nRecvFileSize += nContentLen;

if(nRecvFileSize == nFileSize)

{

outfile.close();

}

QThread::msleep(10);

}

else

{

if(outfile.is_open())

outfile.close();

break;

}

Status status = reader->Finish();

if (!status.ok())

std::cout << "error:" << status.error_message() << std::endl;

std::cout << "exit getFaultlog" << std::endl;

return status;

客户端流式 RPC（Client-side streaming RPC）

与服务端流式相反，客户端流式是客户端不断地向服务端发送数据流，最后由服务端返回一个响应。

rpc SayHelloStreamRequest (stream HelloRequest) returns (HelloReply) {}

服务端实现

Status SayHelloStreamRequest(::grpc::ServerContext* context, ::grpc::ServerReader< ::helloworld::HelloRequest>* reader, ::helloworld::HelloReply* response)override

{

HelloRequest request;

while (reader->Read(&request)) //阻塞需要client运行writedone()才会返回false结束

{

//handle request

std::cout << "request:" << request.name() << std::endl;

}

response->set_message("server only reply");

std::cout << "SayHelloStreamRequest end" << std::endl;

return Status::OK;

}

客户端实现

void sayclientalltime()

{

ClientContext context;

HelloRequest request;

HelloReply response;

std::unique_ptr<::grpc::ClientWriter<HelloRequest>> wRriter = stub_->SayHelloStreamRequest(&context, &response);//异步

grpc::WriteOptions args;

int count = 1;

bool status = false;

//send request //此处可以使用线程同时执行

while (1)

{

request.set_name("request client stream : " + std::to_string(count));

if (wRriter->Write(request, args))

{

}

else

{

break;

}

if (count > 10)

break;

Sleep(500);

++count;

}

wRriter->WritesDone(); //写入结束如果不执行此函数会导server 出现read一直不结束会阻塞在那

Status st = wRriter->Finish(); //这个函数阻塞，直到SayHelloStreamRequest函数返回才执行后面代码

if (!st.ok())

std::cout << "status error:" << st.error_message() << std::endl;

//get response

std::cout << "response:" << response.message() << std::endl;

std::cout << "exit " << std::endl;

}

双向流式 RPC（Bidirectional streaming RPC）

客户端和服务端可同时向对方发送数据流，同时也可以接收数据。

在proto定义：

rpc SayHelloBidiStream (stream HelloRequest) returns (stream HelloReply) {}

服务端实现

重写虚函数SayHelloBidiStream

Status SayHelloBidiStream(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< ::helloworld::HelloReply, ::helloworld::HelloRequest>* stream) override

{

HelloRequest request;

HelloReply response;

int i = 1;

bool status = true;

//在这里我是进行read and write 一起进行的（实际开发中可以添加线程进入同时执行）

while (1)

{

//handle request

if (stream->Read(&request)) //阻塞需要client运行writedone()返回false结束

{

std::cout << "request:" << request.name() << std::endl;