grpc流式传输示例（c++)

目录

grpc理解

流式传输方式

Attention

---

grpc理解

grpc是结合protobuf的远程调用框架，服务端和客户端均支持同步和异步模式。同步模式下，服务器的service函数会阻塞，且当前线程不能再服务其它的client,类似于多线程模式，一个线程服务一个client,可通过ResourceQuota设置最大线程数；异步模式下，grpc提供类似poll方式管理事件，用户注册事件，并接收通知，一个线程管理一个CompletionQueue，通过轮询管理clients，线程模型可以用户自定义，在追求性能的情况下官方推荐异步模式。

grpc::ResourceQuota resource_quata;
resource_quata.SetMaxThreads(2);
builder.SetResourceQuota(resource_quata);

流式传输方式

grpc自定义的service函数可以定义流式的参数和返回值，对应的函数实现通过Reader，Writer，ReaderWriter实现用户自定义的逻辑，从而减少内存的使用，同时在部分数据到来时就可以进行数据处理。

proto文件

syntax="proto3";
package support;

service SupportGenerator{
    rpc GenSupport(stream STL) returns( stream STL){}
}

message Point{
    float x=1;
    float y=2;
    float z=3;
}

message STL {    
    repeated Point points=1;
}

服务端的代码如下

#pragma once
#include<memory>
#include<grpc++/grpc++.h>
#include"support.grpc.pb.h"
#include"support.pb.h"

//server impl
class SupportGeneratorService final :public support::SupportGenerator::Service
{
public://important
	grpc::Status GenSupport(grpc::ServerContext* context, grpc::ServerReaderWriter<support::STL, support::STL>* stl_reader_writer) override
	{
		vector<support::STL> stls_; //recv
		vector<support::Point> vertics_;//recv
		vector<float> coordinates_;//recv
		support::STL stl;//send
		while (stl_reader_writer->Read(&stl))
		{
			google::protobuf::RepeatedPtrField<support::Point> points = stl.points();
			CoutInLine("recieved from client ", points.size());
			stls_.emplace_back(stl);	
			for (auto& point : points)
			{
				vertics_.push_back(point);	
				coordinates_.push_back(point.x());
				coordinates_.push_back(point.y());
				coordinates_.push_back(point.z());
			}
		}		
        //return the request stl
		//for (auto stl_recieved : stls_)
		//{
		//	stl_reader_writer->Write(stl_recieved);
		//}		
		//return grpc::Status::OK;

		//handle	
#pragma region handle request
		
#pragma endregion

		auto support_vertics = what you return ;
		int once_count = 100;
		int loop_count = support_vertics.size() / once_count + 1;
		int index = 0;
		for (int loop = 0; loop < loop_count; loop++)
		{
			support::STL stl;
			for (int j = 0; j < once_count && index < support_vertics.size(); j++)
			{
				auto vertic = support_vertics[index++];
				auto point = stl.add_points();
				point->set_x(vertic.x);
				point->set_y(vertic.y);
				point->set_z(vertic.z);
			}
			stl_reader_writer->Write(stl);
		}
		return grpc::Status::OK;
	}
};

class HServer
{
public:

	HServer()
	{		
		grpc::ServerBuilder builder;
		builder.AddListeningPort("0.0.0.0:5000", grpc::InsecureServerCredentials());
		builder.RegisterService(&support_generator_service_);
		//对于同步server 的资源管理
		grpc::ResourceQuota resource_quata;
		resource_quata.SetMaxThreads(2);
		builder.SetResourceQuota(resource_quata);
		server_ = builder.BuildAndStart();
	}

	~HServer()
	{
		Stop();
	}

	void RunBackground();
	
	void Stop();

private:
	unique_ptr<grpc::Server> server_;	
	SupportGeneratorService support_generator_service_;
};

客户端代码

std::shared_ptr<grpc::Channel> channel = grpc::CreateChannel("127.0.0.1:5000", grpc::InsecureChannelCredentials());
	std::unique_ptr<support::SupportGenerator::Stub> stub = support::SupportGenerator::NewStub(channel);
		
	while (true)
	{
		getchar();
		grpc::ClientContext client_context;
		std::shared_ptr<grpc::ClientReaderWriter<support::STL, support::STL>> client_reader_writer(stub->GenSupport(&client_context));


        //recieved
        std::vector<support::Point> points;
		//read stl
        

        int n_vertics = vertics.size();
        int once_count = 100;
        int loop_count = n_vertics / once_count + 1;
        int index = 0;
		for (int loop = 0; loop < loop_count; loop++)
		{
            auto vertics = ReadStl("");//vertics should be read once_count every time in loop
			support::STL stl;
			for (int i = 0; i < once_count && index<n_vertics; i++)
			{
                
				auto point = stl.add_points();
				point->set_x(vertics[index].x());
				point->set_y(vertics[index].y());
				point->set_z(vertics[index].z());

                index++;
			}
			client_reader_writer->Write(stl);
			std::cout << "client write stl " << loop <<"   "<<index<< std::endl;
		}
		client_reader_writer->WritesDone();
		std::cout << "write done " <<index<< std::endl;

		support::STL stl;
		while (client_reader_writer->Read(&stl))
		{
            auto points_once = stl.points();
            for (auto& point : points_once)
            {
                points.emplace_back(point);//get all data in memory
            }
            Save("", points_once);//save by many times can reduce memory usage
			std::cout << "recieved from server  " <<points_once.size()<< std::endl;
		}
        std::cout << "recieved done  " << points.size() << std::endl;

        

Attention

protobuf 二进制序列化和反序列化需要protoc可执行文件产生序列化对象的相关代码；与grpc结合需要grpc自带的对应编程语言的插件产生服务基类的相关代码，二者版本需要相容。直接通过grpc安装protobuf。