grpc介绍（三）——流传输

已于 2022-10-07 21:15:11 修改
阅读量1.6k 收藏 1
点赞数 1
分类专栏： grpc 文章标签： grpc go rpc
于 2022-10-07 21:11:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/www_dong/article/details/127199296
版权

定义

使用stream关键字修饰来表示流程传输。

  • 当该关键字修饰参数时，表示为客户端流式的gRPC接口；
// 普通RPC
rpc SimplePing(PingRequest) returns (PingReply);

// 客户端流式RPC
rpc SimplePing(stream PingRequest) returns (PingReply);
  • 当该参数修饰返回值时，表示为服务端流式的gRPC接口；
// 服务端流式RPC
rpc SimplePing(PingRequest) returns (stream PingReply);
  • 当该参数修饰参数和返回值时，表示为双向流式的gRPC接口；
// 双向流式RPC
rpc SimplePing(stream PingRequest) returns (stream PingReply);

客户端流

1）修改.proto文件

// Product.proto

syntax = "proto3";

option go_package="../service";

package service;

message ProductRequest {
	int32 prod_id = 1;
}

message ProductReponse {
	int32 prod_stock = 1;
}

service ProdService {
	rpc GetProductStock(ProductRequest) returns(ProductReponse);
	
	// 增加客户端流定义方法
	rpc UpdateProductStockClientStream(stream ProductRequest) returns(ProductReponse);
}

2）修改接口实现文件

// product.go

package service

import (
	"context"

	"io"

	"fmt"
)

var ProductService = &productService{}

type productService struct {
}

// 接口实现
func (p *productService) GetProductStock(context context.Context, request *ProductRequest) (*ProductReponse, error) {
	stock := p.GetStockById(request.ProdId)
	return &ProductReponse{ProdStock: stock}, nil
}

// 新增客户端流实现接口
func (p *productService) UpdateProductStockClientStream(stream ProdService_UpdateProductStockClientStreamServer) error {
	count := 0
	for {
		recv, err := stream.Recv()
		if err != nil {
			if err == io.EOF {
				return nil
			}
			return err
		}

		fmt.Println("服务端接收到的流", recv.ProdId)
		count++
		if count > 10 {
			rsq := &ProductReponse{ProdStock: recv.ProdId}
			err := stream.SendAndClose(rsq)
			if err != nil {
				return err
			}

			return nil
		}
	}
}

func (p *productService) GetStockById(id int32) int32 {
	return id
}

3）修改客户端文件

// grpc_client.go

package main

import (
	"google.golang.org/grpc"

	"log"

	"service"

	"context"

	"fmt"

	"google.golang.org/grpc/credentials"

	"crypto/tls"

	"crypto/x509"

	"io/ioutil"

	"auth"

	"time"
)

func main() {
	// 添加公钥
	// creds, err0 := credentials.NewClientTLSFromFile("../cert/server.pem", "*.dong.com")
	// if err0 != nil {
	// 	log.Fatal("证书错误: ", err0)
	// }

	// 证书认证-双向认证
	// 从证书相关文件中读取解析信息, 得到证书公钥、密钥对
	cert, err0 := tls.LoadX509KeyPair("../cert/client.pem", "../cert/client.key")
	if err0 != nil {
		log.Fatal("证书读取失败", err0)
	}

	fmt.Println("证书读取成功")

	// 创建一个新的、空的CertPool
	certPool := x509.NewCertPool()
	ca, err1 := ioutil.ReadFile("../cert/ca.crt")
	if err1 != nil {
		log.Fatal("ca证书读取失败", err1)
	}

	fmt.Println("ca证书读取成功")

	// 尝试解析所传入的PEM编码的证书，如果解析成功会将其加到CertPool中，便于后面使用
	certPool.AppendCertsFromPEM(ca)
	// 构建基于TLS的TransportCredentials选项
	creds := credentials.NewTLS(&tls.Config{
		// 设置证书链, 允许包含一个或多个
		Certificates: []tls.Certificate{cert},
		ServerName:   "*.dong.com",
		RootCAs:      certPool,
	})

	fmt.Println("设置TLS的TransportCredentials选项成功")

	token := &auth.Authentication{
		User:   "admin",
		Passwd: "admin@123",
	}

	// 创建连接
	conn, err := grpc.Dial(":8800", grpc.WithTransportCredentials(creds), grpc.WithPerRPCCredentials(token))
	if err != nil {
		log.Fatal("服务端连接失败: ", err)
	}

	fmt.Println("证书认证通过")

	// 退出时关闭连接
	defer conn.Close()

	// 创建客户端实例
	productServiceClient := service.NewProdServiceClient(conn)

	// 方法请求
	// resq, err := productServiceClient.GetProductStock(context.Background(), &service.ProductRequest{ProdId: 233})
	// if err != nil {
	// 	log.Fatal("调用gRPC方法失败: ", err)
	// }

	// fmt.Println("调用gRPC方法成功, ProdStock = ", resq.ProdStock)

	// 获取流
	stream, err := productServiceClient.UpdateProductStockClientStream(context.Background())
	if err != nil {
		log.Fatal("获取流失败", err)
	}

    // 定义切片，设置请求
	rsq := make(chan struct{}, 1)
	go prodRequest(stream, rsq)
    
    // 等待数据接收
	select {
	case <-rsq:
        // 接收数据
		recv, err := stream.CloseAndRecv()
		if err != nil {
			log.Fatal(err)
		}

		stock := recv.ProdStock
		fmt.Println("客户端收到响应: ", stock)
	}
}

// 请求接口
func prodRequest(stream service.ProdService_UpdateProductStockClientStreamClient, rsq chan struct{}) {
	count := 0
	for {
		request := &service.ProductRequest{
			ProdId: 100,
		}

        // 发送数据
		err := stream.Send(request)
		if err != nil {
			log.Fatal(err)
		}

		time.Sleep(time.Second)
		count++
		if count > 10 {
			rsq <- struct{}{}
			break
		}
	}
}

4）测试

先后启动服务端和客户端，打印如下：

服务端：

在这里插入图片描述

客户端：

在这里插入图片描述

服务端流

1）修改.proto文件

//新增服务端流定义方法

syntax = "proto3";

option go_package="../service";

package service;

message ProductRequest {
	int32 prod_id = 1;
}

message ProductReponse {
	int32 prod_stock = 1;
}

service ProdService {
	rpc GetProductStock(ProductRequest) returns(ProductReponse);
	
	// 客户端流定义方法
	rpc UpdateProductStockClientStream(stream ProductRequest) returns(ProductReponse);
	
	// 服务端流定义方法
	rpc GetProductStockServerStream(ProductRequest) returns(stream ProductReponse); 
}

2）修改接口实现文件

// product.go

package service

import (
	"context"

	"io"

	"fmt"

	"time"
)

var ProductService = &productService{}

type productService struct {
}

// 接口实现
func (p *productService) GetProductStock(context context.Context, request *ProductRequest) (*ProductReponse, error) {
	stock := p.GetStockById(request.ProdId)
	return &ProductReponse{ProdStock: stock}, nil
}

// 新增客户端接口实现
func (p *productService) UpdateProductStockClientStream(stream ProdService_UpdateProductStockClientStreamServer) error {
	count := 0
	for {
		recv, err := stream.Recv()
		if err != nil {
			if err == io.EOF {
				return nil
			}
			return err
		}

		fmt.Println("服务端接收到的流", recv.ProdId)
		count++
		if count > 10 {
			rsq := &ProductReponse{ProdStock: recv.ProdId}
			err := stream.SendAndClose(rsq)
			if err != nil {
				return err
			}

			return nil
		}
	}
}

// 新增服务端接口实现
func (p *productService) GetProductStockServerStream(request *ProductRequest, stream ProdService_GetProductStockServerStreamServer) error {
	count := 0
	for {
		rsp := &ProductReponse{ProdStock: request.ProdId}
		err := stream.Send(rsp)
		if err != nil {
			return err
		}
		time.Sleep(time.Second)
		count++
		if count > 10 {
			return nil
		}
	}
}

func (p *productService) GetStockById(id int32) int32 {
	return id
}

3）修改客户端文件

package main

import (
	"google.golang.org/grpc"

	"log"

	"service"

	"context"

	"fmt"

	"google.golang.org/grpc/credentials"

	"crypto/tls"

	"crypto/x509"

	"io/ioutil"

	"io"

	"auth"

	"time"
)

func main() {
	// 添加公钥
	// creds, err0 := credentials.NewClientTLSFromFile("../cert/server.pem", "*.dong.com")
	// if err0 != nil {
	// 	log.Fatal("证书错误: ", err0)
	// }

	// 证书认证-双向认证
	// 从证书相关文件中读取解析信息, 得到证书公钥、密钥对
	cert, err0 := tls.LoadX509KeyPair("../cert/client.pem", "../cert/client.key")
	if err0 != nil {
		log.Fatal("证书读取失败", err0)
	}

	fmt.Println("证书读取成功")

	// 创建一个新的、空的CertPool
	certPool := x509.NewCertPool()
	ca, err1 := ioutil.ReadFile("../cert/ca.crt")
	if err1 != nil {
		log.Fatal("ca证书读取失败", err1)
	}

	fmt.Println("ca证书读取成功")

	// 尝试解析所传入的PEM编码的证书，如果解析成功会将其加到CertPool中，便于后面使用
	certPool.AppendCertsFromPEM(ca)
	// 构建基于TLS的TransportCredentials选项
	creds := credentials.NewTLS(&tls.Config{
		// 设置证书链, 允许包含一个或多个
		Certificates: []tls.Certificate{cert},
		ServerName:   "*.dong.com",
		RootCAs:      certPool,
	})

	fmt.Println("设置TLS的TransportCredentials选项成功")

	token := &auth.Authentication{
		User:   "admin",
		Passwd: "admin@123",
	}

	// 创建连接
	conn, err := grpc.Dial(":8800", grpc.WithTransportCredentials(creds), grpc.WithPerRPCCredentials(token))
	if err != nil {
		log.Fatal("服务端连接失败: ", err)
	}

	fmt.Println("证书认证通过")

	// 退出时关闭连接
	defer conn.Close()

	// 创建客户端实例
	productServiceClient := service.NewProdServiceClient(conn)

	// 方法请求
	// resq, err := productServiceClient.GetProductStock(context.Background(), &service.ProductRequest{ProdId: 233})
	// if err != nil {
	// 	log.Fatal("调用gRPC方法失败: ", err)
	// }

	// fmt.Println("调用gRPC方法成功, ProdStock = ", resq.ProdStock)

	// 获取流
	// stream, err := productServiceClient.UpdateProductStockClientStream(context.Background())
	// if err != nil {
	// 	log.Fatal("获取流失败", err)
	// }

	// rsq := make(chan struct{}, 1)
	// go prodRequest(stream, rsq)
	// select {
	// case <-rsq:
	// 	recv, err := stream.CloseAndRecv()
	// 	if err != nil {
	// 		log.Fatal(err)
	// 	}

	// 	stock := recv.ProdStock
	// 	fmt.Println("客户端收到响应: ", stock)
	// }

	request := &service.ProductRequest{
		ProdId: 100,
	}

    // 调用服务端接口获取流
	stream, err := productServiceClient.GetProductStockServerStream(context.Background(), request)
	if err != nil {
		log.Fatal("获取流失败")
	}

    // 循环获取流
	for {
		recv, err := stream.Recv()
		if err != nil {
            // 流数据接收完成标志
			if err == io.EOF {
				fmt.Println("客户端接收数据完成")
				stream.CloseSend()
				break
			}

			log.Fatal(err)
		}
		fmt.Println("客户端收到的流", recv.ProdStock)
	}
}

func prodRequest(stream service.ProdService_UpdateProductStockClientStreamClient, rsq chan struct{}) {
	count := 0
	for {
		request := &service.ProductRequest{
			ProdId: 100,
		}

		err := stream.Send(request)
		if err != nil {
			log.Fatal(err)
		}

		time.Sleep(time.Second)
		count++
		if count > 10 {
			rsq <- struct{}{}
			break
		}
	}
}

4）测试

先后启动服务端和客户端，打印如下：

服务端：

在这里插入图片描述

客户端

在这里插入图片描述

双向流

1）修改.proto文件

// 说明: 新增双向流定义方法

syntax = "proto3";

option go_package="../service";

package service;

message ProductRequest {
	int32 prod_id = 1;
}

message ProductReponse {
	int32 prod_stock = 1;
}

service ProdService {
	rpc GetProductStock(ProductRequest) returns(ProductReponse);
	
	// 客户端流定义方法
	rpc UpdateProductStockClientStream(stream ProductRequest) returns(ProductReponse);
	
	// 服务端流定义方法
	rpc GetProductStockServerStream(ProductRequest) returns(stream ProductReponse); 
	
	// 双向流定义方法
	rpc SayHelloStream(stream ProductRequest) returns(stream ProductReponse); 
}

2）修改接口实现文件

package service

import (
	"context"

	"io"

	"fmt"

	"time"
)

var ProductService = &productService{}

type productService struct {
}

// 接口实现
func (p *productService) GetProductStock(context context.Context, request *ProductRequest) (*ProductReponse, error) {
	stock := p.GetStockById(request.ProdId)
	return &ProductReponse{ProdStock: stock}, nil
}

func (p *productService) UpdateProductStockClientStream(stream ProdService_UpdateProductStockClientStreamServer) error {

	count := 0
	for {
		recv, err := stream.Recv()
		if err != nil {
			if err == io.EOF {
				return nil
			}
			return err
		}

		fmt.Println("服务端接收到的流", recv.ProdId)
		count++
		if count > 10 {
			rsq := &ProductReponse{ProdStock: recv.ProdId}
			err := stream.SendAndClose(rsq)
			if err != nil {
				return err
			}

			return nil
		}
	}
}

func (p *productService) GetProductStockServerStream(request *ProductRequest, stream ProdService_GetProductStockServerStreamServer) error {

	count := 0
	for {
		rsp := &ProductReponse{ProdStock: request.ProdId}
		err := stream.Send(rsp)
		if err != nil {
			return err
		}
		time.Sleep(time.Second)
		count++
		if count > 10 {
			return nil
		}
	}
}

func (p *productService) SayHelloStream(stream ProdService_SayHelloStreamServer) error {
	for {
		// 接收消息
		recv, err := stream.Recv()
		if err != nil {
			return nil
		}

		fmt.Println("服务端接收客户端的消息", recv.ProdId)
		time.Sleep(time.Second)

		// 发送消息
		rsp := &ProductReponse{ProdStock: recv.ProdId}
		err = stream.Send(rsp)
		if err != nil {
			return err
		}
	}
}

func (p *productService) GetStockById(id int32) int32 {
	return id
}

3）修改客户端文件

package main

import (
	"google.golang.org/grpc"

	"log"

	"service"

	"context"

	"fmt"

	"google.golang.org/grpc/credentials"

	"crypto/tls"

	"crypto/x509"

	"io/ioutil"

	//	"io"

	"auth"

	"time"
)

func main() {
	// 添加公钥
	// creds, err0 := credentials.NewClientTLSFromFile("../cert/server.pem", "*.dong.com")
	// if err0 != nil {
	// 	log.Fatal("证书错误: ", err0)
	// }

	// 证书认证-双向认证
	// 从证书相关文件中读取解析信息, 得到证书公钥、密钥对
	cert, err0 := tls.LoadX509KeyPair("../cert/client.pem", "../cert/client.key")
	if err0 != nil {
		log.Fatal("证书读取失败", err0)
	}

	fmt.Println("证书读取成功")

	// 创建一个新的、空的CertPool
	certPool := x509.NewCertPool()
	ca, err1 := ioutil.ReadFile("../cert/ca.crt")
	if err1 != nil {
		log.Fatal("ca证书读取失败", err1)
	}

	fmt.Println("ca证书读取成功")

	// 尝试解析所传入的PEM编码的证书，如果解析成功会将其加到CertPool中，便于后面使用
	certPool.AppendCertsFromPEM(ca)
	// 构建基于TLS的TransportCredentials选项
	creds := credentials.NewTLS(&tls.Config{
		// 设置证书链, 允许包含一个或多个
		Certificates: []tls.Certificate{cert},
		ServerName:   "*.dong.com",
		RootCAs:      certPool,
	})

	fmt.Println("设置TLS的TransportCredentials选项成功")

	token := &auth.Authentication{
		User:   "admin",
		Passwd: "admin@123",
	}

	// 创建连接
	conn, err := grpc.Dial(":8800", grpc.WithTransportCredentials(creds), grpc.WithPerRPCCredentials(token))
	if err != nil {
		log.Fatal("服务端连接失败: ", err)
	}

	fmt.Println("证书认证通过")

	// 退出时关闭连接
	defer conn.Close()

	// 创建客户端实例
	productServiceClient := service.NewProdServiceClient(conn)

	// 方法请求
	// resq, err := productServiceClient.GetProductStock(context.Background(), &service.ProductRequest{ProdId: 233})
	// if err != nil {
	// 	log.Fatal("调用gRPC方法失败: ", err)
	// }

	// fmt.Println("调用gRPC方法成功, ProdStock = ", resq.ProdStock)

	// 获取流
	// stream, err := productServiceClient.UpdateProductStockClientStream(context.Background())
	// if err != nil {
	// 	log.Fatal("获取流失败", err)
	// }

	// rsq := make(chan struct{}, 1)
	// go prodRequest(stream, rsq)
	// select {
	// case <-rsq:
	// 	recv, err := stream.CloseAndRecv()
	// 	if err != nil {
	// 		log.Fatal(err)
	// 	}

	// 	stock := recv.ProdStock
	// 	fmt.Println("客户端收到响应: ", stock)
	// }

	// request := &service.ProductRequest{
	// 	ProdId: 100,
	// }

	// stream, err := productServiceClient.GetProductStockServerStream(context.Background(), request)
	// if err != nil {
	// 	log.Fatal("获取流失败")
	// }

	// for {
	// 	recv, err := stream.Recv()
	// 	if err != nil {
	// 		if err == io.EOF {
	// 			fmt.Println("客户端接收数据完成")
	// 			stream.CloseSend()
	// 			break
	// 		}

	// 		log.Fatal(err)
	// 	}
	// 	fmt.Println("客户端收到的流", recv.ProdStock)
	// }

    // 获取双向流
	stream, err := productServiceClient.SayHelloStream(context.Background())

	for {
		// 发送消息
		request := &service.ProductRequest{
			ProdId: 100,
		}
		err = stream.Send(request)
		if err != nil {
			log.Fatal(err)
		}
		time.Sleep(time.Second)
		recv, err := stream.Recv()
		if err != nil {
			log.Fatal(err)
		}

		fmt.Println("客户端接收服务端的消息", recv.ProdStock)
	}
}

func prodRequest(stream service.ProdService_UpdateProductStockClientStreamClient, rsq chan struct{}) {
	count := 0
	for {
		request := &service.ProductRequest{
			ProdId: 100,
		}

		err := stream.Send(request)
		if err != nil {
			log.Fatal(err)
		}

		time.Sleep(time.Second)
		count++
		if count > 10 {
			rsq <- struct{}{}
			break
		}
	}
}

4）测试

先后启动服务端和客户端，打印如下：

服务端：

在这里插入图片描述

客户端：

在这里插入图片描述

类似于心跳的功能。

部分参考：
HTTP/2介绍：https://blog.youkuaiyun.com/qq_34827674/article/details/115188949

gRPC 流式传输极简入门指南
素履独行 | 元培的个人博客
02-28 708
本文内容从 HTTP/2 说起gRPC 中的流式传输客户端流服务器端流双向流本文小结 最近一直在研究 gRPC 的 ServerReflection，顾名思义，这是 gRPC 里提供的反射接口，当你需要获取某个接口的描述信息，或者是希望动态调用 gRPC 的时候，这一切就会变得非常有用，如果你经常使用 gRPC UI 这款工具来调试 gRPC 接口，那么，你一定会注意到一件事情，即它要求服务端必须支持 ServerReflection API，而这一点在 ASP.NET Core 中已经得到支持，对此感兴趣
python grpc流式_Python——gRPC详解及实战避坑方案(下)
weixin_39903375的博客
12-19 1064
作者：henry_czh(授权转载，勿二次转载)来源：https://juejin.im/post/6854573218884222989前言上一篇文章讲述了RPC服务的概念和gRPC的基本使用、proto语法的使用教程。然而在我们真正把gRPC服务部署到生产环境上的时候，会遇到很多问题，首选要考虑的就是协议的数据认证问题，其次，gRPC也支持流式通信的模式，本篇文章会做一个介绍说明。RPC的身份...
eventing-stream:玩grpc进行流式传输
03-06
事件流 玩grpc进行流式传输
gRPC之gRPC流
YIYIYI
09-12 2686
gRPC之gRPC流
史上最细gRPC(Go)入门教程(三)---gRPC流式传输--Streaming
探索云原生
01-30 8746
本文主要讲述了 gRPC 中的四种类型的方法使用，包括普通的 Unary API 和三种 Stream API：ServerStreaming、ClientStreaming、BidirectionalStreaming。 gRPC 系列文章欢迎访问我的个人博客 指月 1. 概述 gRPC 系列相关代码见 Github gRPC 中的 Service API 有如下4种类型： 1）UnaryAPI：普通一元方法 2）ServerStreaming：服务端推送流 3）ClientStreaming
gRPC流数据传输
Yaixihn
04-22 1182
stream的实现其实和service一样是接口； 1. 普通服务，5小节就是此部分的实现 .proto文件： rpc 方法名(变量类型)returns(变量类型){} 服务器： func(grpc服务端结构体)方法名(ctx,入参类型指针)回参类型指针,error{ } 客户端： 返回值,错误 = 创建好的grpc客户端连接.方法名(ctx,入参) 2. 流式传入，返回是普通的(客户端流传入，服务端普通返回) .proto文件： rpc 方法名(stream 变量类型)returns(变量类型){}
android gRPC 简单使用（csdn）————程序.pdf
12-01
gRPC 还支持流式接收，用于处理大规模数据传输： ```java // 创建 channel ManagedChannel channel = ManagedChannelBuilder.forAddress(ip, port).usePlaintext().build(); // 创建请求服务 ServiceBlockingStub ...
flask-web —— RPC定义、结构、gRPC、Protocol Buffers
Shallow的博客
07-26 2356
一、RPC简介 1. 什么是RPC 远程过程调用（英语：Remote Procedure Call，缩写为 RPC，也叫远程程序调用）是一个计算机通信协议。该协议允许运行于一台计算机的程序调用另一台计算机的子程序，而程序员无需额外地为这个交互作用编程。如果涉及的软件采用面向对象编程，那么远程过程调用亦可称作远程调用或远程方法调用 2. 背景与用途 在单台计算机中，我们可以通过程序调用来传递控制和数据；或者说通过程序调用，我们可以将多个程序组成一个整体来实现某个功能。 如果将这种调用机制推广到多台彼此间可以
springboot——grpc实现demo
JHC23的专栏
10-15 2735
grpc实现demo一、前言1、应用场景：Java做为服务端给go 提供接口2、 grpc: 数据的序列化以及进城数据通信的交互方式二、springboot 构建grpc 的demo1、版本对应：2、项目构建2.1 项目结构2.2 根pom文件2.3 grpc-lib 模块2.3.1 文件结构2.3.2 pom文件2.4 grpc-server 模块2.4.1 对应的pom 文件2.4.2 对应的...
Python——gRPC详解及实战避坑方案！为啥非要踩坑呢？
爬遍所有网站
08-08 2245
前言 什么是RPC服务RPC，是Remote Procedure Call的简称，翻译成中文就是远程过程调用。RPC就是允许程序调用另一个地址空间（通常是另一台机器上）的类方法或函数的一种服务。它是一种架设在计算机网络之上并隐藏底层网络技术，可以像调用本地服务一样调用远端程序，在编码代价不高的情况下提升吞吐的能力。 为什么要使用RPC服务随着计算机技术的快速发展，单台机器运行服务的方案已经不足以支撑越来越多的网络请求负载，分布式方案开始兴起，一个业务场景可以被拆分在多个机器上运行，每个机器分别只完成一个
使用gRPC流在两个设备之间传输文件。-Golang开发
05-26
使用gRPC流在两个设备之间传输文件。 出现文件传输使用gRPC流在两个设备之间传输文件。 使用Go进行安装get -u github.com/arisetransfer/arise或从发行版下载二进制文件并添加到您的路径中设置配置文件创建配置文件mkdir -p $ HOME / .arise / &&触摸$ HOME / .arise /config.toml并添加服务器的IP和端口示例config.toml＃发生中继和端口的配置文件ip =“ 127.0.0.1” port =“ 6969”用法要发送文件，请发送文件名T
Go-使用grpcgo和python的双向流式RPC的快速演示
08-14
使用grpc，go和python的双向流式RPC的快速演示
gRPC 四种流模式概述
最新发布
MPY_3的博客
07-13 1375
gRPC 提供了四种主要的流模式，以满足不同的通信需求。这些模式包括简单 RPC（Unary RPC）、服务器流式 RPC（Server Streaming RPC）、客户端流式 RPC（Client Streaming RPC）和双向流式 RPC（Bidirectional Streaming RPC）。每种模式都有其独特的特点和适用场景，本文主要介绍这四种流模式的特性和使用场景，及各自的代码实现。
grpc流式传输示例（c++)
qq_42734954的博客
12-16 3317
grpc是结合protobuf的远程调用框架，服务端和客户端均支持同步和异步模式。同步模式下，服务器的service函数会阻塞，且当前线程不能再服务其它的client,类似于多线程模式，一个线程服务一个client,可通过ResourceQuota设置最大线程数；异步模式下，grpc提供类似poll方式管理事件，用户注册事件，并接收通知，一个线程管理一个CompletionQueue，通过轮询管理clients，线程模型可以用户自定义，在追求性能的情况下官方推荐异步模式。
golang grpc数据传输的流模式
qq_46081276的博客
10-08 1667
本篇将举例grpc的流模式数据传输,包括服务端流，客户端流，双向流
grpc学习golang版（ 六、服务器流式传输 ）
Sahara_Savage
06-27 1488
grpc学习golang版（六、服务器流式传输）
gRPC 流式调用
dotNET跨平台
10-28 1581
gRPC 使用 Protocol buffers 作为接口定义语言（IDL）来描述服务接口和输入输出消息的结构，目前支持 4 种定义服务方法类型：类型说明简单 RPC客户...
Grpc之流模式
屈帅波的技术博客
12-30 1333
一 流模式简介 RPC是远程函数调用，因此每次调用的函数参数和返回值不能太大，否则将严重影响每次调用的响应时间。因此传统的RPC方法调用对于上传和下载较大数据量场景并不适合。同时传统RPC模式也不适用于对时间不确定的订阅和发布模式。为此，gRPC框架针对服务器端和客户端分别提供了流特性。 //hello.proto syntax = "proto3"; option go_package = "./;proto"; service StreamService{ // 关键字stream指定启用流特
grpc流式使用和注意事项
a...Z
06-02 1554
stream server client 流式grpc Server-side streaming RPC：服务器端流式 RPC Client-side streaming RPC：客户端流式 RPC Bidirectional streaming RPC：双向流式 RPC 1、proto syntax = "proto3"; package stream; service StreamService { rpc Eat(EatRequest) returns (stream EatRespons
Java开发者必看：未来的RPC框架趋势——Java gRPC框架教程
标题所指的知识点为Java gRPC框架。gRPC是一个高性能、开源和通用的RPC框架，由Google主导开发。它基于HTTP/2协议传输，并使用Protocol Buffers作为接口描述语言。gRPC非常适合Java开发者使用，因为它提供了生成特定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值