史上最细gRPC(Go)入门教程(三)---gRPC流式传输--Streaming

已于 2023-12-28 10:34:02 修改
阅读量8.1k 收藏 24
点赞数 3
分类专栏： Go gRPC 文章标签： golang
于 2021-01-30 13:55:47 首次发布
本文链接：https://blog.csdn.net/java_1996/article/details/113428990
版权
Go 同时被 2 个专栏收录
17 篇文章 5 订阅
订阅专栏
gRPC
15 篇文章 26 订阅
订阅专栏

来自：指月小筑 https://lixueduan.com

原文：https://lixueduan.com/post/grpc/03-stream/

本文主要讲述了 gRPC 中的四种类型的方法使用，包括普通的 Unary API 和三种 Stream API：ServerStreaming、ClientStreaming、BidirectionalStreaming。

如果你对云原生技术充满好奇，想要深入了解更多相关的文章和资讯，欢迎关注微信公众号。

扫描下方二维码或搜索公众号【探索云原生】即可订阅

1. 概述

gRPC 系列相关代码见 Github

gRPC 中的 Service API 有如下4种类型：

  • 1）UnaryAPI：普通一元方法
  • 2）ServerStreaming：服务端推送流
  • 3）ClientStreaming：客户端推送流
  • 4）BidirectionalStreaming：双向推送流

Unary API 就是普通的 RPC 调用，例如之前的 HelloWorld 就是一个 Unary API，本文主要讲解 Stream API。

Stream 顾名思义就是一种流，可以源源不断的推送数据，很适合大数据传输，或者服务端和客户端长时间数据交互的场景。Stream API 和 Unary API 相比，因为省掉了中间每次建立连接的花费，所以效率上会提升一些。

2. proto 文件定义

echo.proto文件定义如下：

syntax = "proto3";

option go_package = "github.com/lixd/grpc-go-example/features/proto/echo";

package echo;


// Echo 服务，包含了4种类型API
service Echo {
  // UnaryAPI
  rpc UnaryEcho(EchoRequest) returns (EchoResponse) {}
  // SServerStreaming
  rpc ServerStreamingEcho(EchoRequest) returns (stream EchoResponse) {}
  // ClientStreamingE
  rpc ClientStreamingEcho(stream EchoRequest) returns (EchoResponse) {}
  // BidirectionalStreaming
  rpc BidirectionalStreamingEcho(stream EchoRequest) returns (stream EchoResponse) {}
}

message EchoRequest {
  string message = 1;
}

message EchoResponse {
  string message = 1;
}

编译

lixd@17x:~/17x/projects/grpc-go-example/features/proto/echo$ protoc --go_out=. --go_opt=paths=source_relative \
--go-grpc_out=. --go-grpc_opt=paths=source_relative \
./echo.proto

3. UnaryAPI

比较简单，没有需要特别注意的地方。

Server

type Echo struct {
	pb.UnimplementedEchoServer
}

// UnaryEcho 一个普通的UnaryAPI
func (e *Echo) UnaryEcho(ctx context.Context, req *pb.EchoRequest) (*pb.EchoResponse, error) {
	log.Printf("Recved: %v", req.GetMessage())
	resp := &pb.EchoResponse{Message: req.GetMessage()}
	return resp, nil
}

Client

func main() {
	// 1.建立连接 获取client
	conn, err := grpc.Dial(address, grpc.WithInsecure(), grpc.WithBlock())
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()
	client := pb.NewEchoClient(conn)
	// 2.执行各个Stream的对应方法
	unary(client)
}
func unary(client pb.EchoClient) {
	resp, err := client.UnaryEcho(context.Background(), &pb.EchoRequest{Message: "hello world"})
	if err != nil {
		log.Printf("send error:%v\n", err)
	}
	fmt.Printf("Recved:%v \n", resp.GetMessage())
}

Test

Server

lixd@17x:~/17x/projects/grpc-go-example/features/stream/server$ go run main.go 
2021/01/23 19:00:30 Serving gRPC on 0.0.0.0:50051
2021/01/23 19:00:36 Recved: hello world

Client

lixd@17x:~/17x/projects/grpc-go-example/features/stream/client$ go run main.go 
Recved:hello world

4. ServerStream

服务端流：服务端可以发送多个数据给客户端。

使用场景: 例如图片处理的时候，客户端提供一张原图，服务端依次返回多个处理后的图片。

Server

注意点：可以多次调用 stream.Send() 来返回多个数据。

//  ServerStreamingEcho 客户端发送一个请求 服务端以流的形式循环发送多个响应
/*
1. 获取客户端请求参数
2. 处理完成后返回过个响应
3. 最后返回nil表示已经完成响应
*/
func (e *Echo) ServerStreamingEcho(req *pb.EchoRequest, stream pb.Echo_ServerStreamingEchoServer) error {
	log.Printf("Recved %v", req.GetMessage())
    // 具体返回多少个response根据业务逻辑调整
	for i := 0; i < 2; i++ {
		// 通过 send 方法不断推送数据
		err := stream.Send(&pb.EchoResponse{Message: req.GetMessage()})
		if err != nil {
			log.Fatalf("Send error:%v", err)
			return err
		}
	}
	// 返回nil表示已经完成响应
	return nil
}

Client

注意点：调用方法获取到的不是单纯的响应，而是一个 stream。通过 stream.Recv() 接收服务端的多个返回值。

/*
1. 建立连接 获取client
2. 通过 client 获取stream
3. for循环中通过stream.Recv()依次获取服务端推送的消息
4. err==io.EOF则表示服务端关闭stream了
*/
func serverStream(client pb.EchoClient) {
	// 2.调用获取stream
	stream, err := client.ServerStreamingEcho(context.Background(), &pb.EchoRequest{Message: "Hello World"})
	if err != nil {
		log.Fatalf("could not echo: %v", err)
	}

	// 3. for循环获取服务端推送的消息
	for {
		// 通过 Recv() 不断获取服务端send()推送的消息
		resp, err := stream.Recv()
		// 4. err==io.EOF则表示服务端关闭stream了 退出
		if err == io.EOF {
			log.Println("server closed")
			break
		}
		if err != nil {
			log.Printf("Recv error:%v", err)
			continue
		}
		log.Printf("Recv data:%v", resp.GetMessage())
	}
}

Test

Server

lixd@17x:~/17x/projects/grpc-go-example/features/stream/server$ go run main.go 
2021/01/23 19:06:18 Serving gRPC on 0.0.0.0:50051
2021/01/23 19:06:27 Recved Hello World

Client

lixd@17x:~/17x/projects/grpc-go-example/features/stream/client$ go run main.go 
2021/01/23 19:06:27 Recv data:Hello World
2021/01/23 19:06:27 Recv data:Hello World
2021/01/23 19:06:27 server closed

5. ClientStream

和 ServerStream 相反，客户端可以发送多个数据。

Server

注意点：循环调用 stream.Recv() 获取数据，err == io.EOF 则表示数据已经全部获取了，最后通过 stream.SendAndClose() 返回响应。

// ClientStreamingEcho 客户端流
/*
1. for循环中通过stream.Recv()不断接收client传来的数据
2. err == io.EOF表示客户端已经发送完毕关闭连接了,此时在等待服务端处理完并返回消息
3. stream.SendAndClose() 发送消息并关闭连接(虽然在客户端流里服务器这边并不需要关闭 但是方法还是叫的这个名字，内部也只会调用Send())
*/
func (e *Echo) ClientStreamingEcho(stream pb.Echo_ClientStreamingEchoServer) error {
	// 1.for循环接收客户端发送的消息
	for {
		// 2. 通过 Recv() 不断获取客户端 send()推送的消息
		req, err := stream.Recv() // Recv内部也是调用RecvMsg
		// 3. err == io.EOF表示已经获取全部数据
		if err == io.EOF {
			log.Println("client closed")
			// 4.SendAndClose 返回并关闭连接
			// 在客户端发送完毕后服务端即可返回响应
			return stream.SendAndClose(&pb.EchoResponse{Message: "ok"})
		}
		if err != nil {
			return err
		}
		log.Printf("Recved %v", req.GetMessage())
	}
}

Client

注意点：通过多次调用 stream.Send() 像服务端推送多个数据，最后调用 stream.CloseAndRecv() 关闭stream并接收服务端响应。

// clientStream 客户端流
/*
1. 建立连接并获取client
2. 获取 stream 并通过 Send 方法不断推送数据到服务端
3. 发送完成后通过stream.CloseAndRecv() 关闭steam并接收服务端返回结果
*/
func clientStream(client pb.EchoClient) {
	// 2.获取 stream 并通过 Send 方法不断推送数据到服务端
	stream, err := client.ClientStreamingEcho(context.Background())
	if err != nil {
		log.Fatalf("Sum() error: %v", err)
	}
	for i := int64(0); i < 2; i++ {
		err := stream.Send(&pb.EchoRequest{Message: "hello world"})
		if err != nil {
			log.Printf("send error: %v", err)
			continue
		}
	}

	// 3. 发送完成后通过stream.CloseAndRecv() 关闭steam并接收服务端返回结果
	// (服务端则根据err==io.EOF来判断client是否关闭stream)
	resp, err := stream.CloseAndRecv()
	if err != nil {
		log.Fatalf("CloseAndRecv() error: %v", err)
	}
	log.Printf("sum: %v", resp.GetMessage())

}

Test

Server

lixd@17x:~/17x/projects/grpc-go-example/features/stream/server$ go run main.go 
2021/01/23 19:10:34 Serving gRPC on 0.0.0.0:50051
2021/01/23 19:10:42 Recved hello world
2021/01/23 19:10:42 Recved hello world
2021/01/23 19:10:42 client closed

Cliet

lixd@17x:~/17x/projects/grpc-go-example/features/stream/client$ go run main.go 
2021/01/23 19:10:42 sum: ok

6. BidirectionalStream

双向推送流则可以看做是结合了 ServerStream 和 ClientStream 二者。客户端和服务端都可以向对方推送多个数据。

注意：服务端和客户端的这两个Stream 是独立的。

Server

注意点：一般是使用两个 Goroutine，一个接收数据，一个推送数据。最后通过 return nil 表示已经完成响应。

// BidirectionalStreamingEcho 双向流服务端
/*
// 1. 建立连接 获取client
// 2. 通过client调用方法获取stream
// 3. 开两个goroutine（使用 chan 传递数据） 分别用于Recv()和Send()
// 3.1 一直Recv()到err==io.EOF(即客户端关闭stream)
// 3.2 Send()则自己控制什么时候Close 服务端stream没有close 只要跳出循环就算close了。 具体见https://github.com/grpc/grpc-go/issues/444
*/
func (e *Echo) BidirectionalStreamingEcho(stream pb.Echo_BidirectionalStreamingEchoServer) error {
	var (
		waitGroup sync.WaitGroup
		msgCh     = make(chan string)
	)
	waitGroup.Add(1)
	go func() {
		defer waitGroup.Done()

		for v := range msgCh {
			err := stream.Send(&pb.EchoResponse{Message: v})
			if err != nil {
				fmt.Println("Send error:", err)
				continue
			}
		}
	}()

	waitGroup.Add(1)
	go func() {
		defer waitGroup.Done()
		for {
			req, err := stream.Recv()
			if err == io.EOF {
				break
			}
			if err != nil {
				log.Fatalf("recv error:%v", err)
			}
			fmt.Printf("Recved :%v \n", req.GetMessage())
			msgCh <- req.GetMessage()
		}
		close(msgCh)
	}()
	waitGroup.Wait()

	// 返回nil表示已经完成响应
	return nil
}

Client

注意点：和服务端类似，不过客户端推送结束后需要主动调用 stream.CloseSend() 函数来关闭Stream。

// bidirectionalStream 双向流
/*
1. 建立连接 获取client
2. 通过client获取stream
3. 开两个goroutine 分别用于Recv()和Send()
	3.1 一直Recv()到err==io.EOF(即服务端关闭stream)
	3.2 Send()则由自己控制
4. 发送完毕调用 stream.CloseSend()关闭stream 必须调用关闭 否则Server会一直尝试接收数据 一直报错...
*/
func bidirectionalStream(client pb.EchoClient) {
	var wg sync.WaitGroup
	// 2. 调用方法获取stream
	stream, err := client.BidirectionalStreamingEcho(context.Background())
	if err != nil {
		panic(err)
	}
	// 3.开两个goroutine 分别用于Recv()和Send()
	wg.Add(1)
	go func() {
		defer wg.Done()
		for {
			req, err := stream.Recv()
			if err == io.EOF {
				fmt.Println("Server Closed")
				break
			}
			if err != nil {
				continue
			}
			fmt.Printf("Recv Data:%v \n", req.GetMessage())
		}
	}()

	wg.Add(1)
	go func() {
		defer wg.Done()

		for i := 0; i < 2; i++ {
			err := stream.Send(&pb.EchoRequest{Message: "hello world"})
			if err != nil {
				log.Printf("send error:%v\n", err)
			}
			time.Sleep(time.Second)
		}
		// 4. 发送完毕关闭stream
		err := stream.CloseSend()
		if err != nil {
			log.Printf("Send error:%v\n", err)
			return
		}
	}()
	wg.Wait()
}

Test

Server

lixd@17x:~/17x/projects/grpc-go-example/features/stream/server$ go run main.go 
2021/01/23 19:14:56 Serving gRPC on 0.0.0.0:50051
Recved :hello world 
Recved :hello world

Client

lixd@17x:~/17x/projects/grpc-go-example/features/stream/client$ go run main.go 
Recved:hello world 
Recved:hello world 
Server Closed

7. 小结

客户端或者服务端都有对应的 推送 或者 接收对象，我们只要 不断循环 Recv(),或者 Send() 就能接收或者推送了！

gRPC Stream 和 goroutine 配合简直完美。通过 Stream 我们可以更加灵活的实现自己的业务。如 订阅，大数据传输等。

Client发送完成后需要手动调用Close()或者CloseSend()方法关闭stream，Server端则return nil就会自动 Close。

1）ServerStream

  • 服务端处理完成后return nil代表响应完成
  • 客户端通过 err == io.EOF判断服务端是否响应完成

2）ClientStream

  • 客户端发送完毕通过`CloseAndRecv关闭stream 并接收服务端响应
  • 服务端通过 err == io.EOF判断客户端是否发送完毕，完毕后使用SendAndClose关闭 stream并返回响应。

3）BidirectionalStream

  • 客户端服务端都通过stream向对方推送数据
  • 客户端推送完成后通过CloseSend关闭流，通过err == io.EOF`判断服务端是否响应完成
  • 服务端通过err == io.EOF判断客户端是否响应完成,通过return nil表示已经完成响应

通过err == io.EOF来判定是否把对方推送的数据全部获取到了。

客户端通过CloseAndRecv或者CloseSend关闭 Stream，服务端则通过SendAndClose或者直接 return nil来返回响应。

gRPC 系列相关代码见 Github

如果你对云原生技术充满好奇，想要深入了解更多相关的文章和资讯，欢迎关注微信公众号。

扫描下方二维码或搜索公众号【探索云原生】即可订阅

8. 参考

https://grpc.io/docs/languages/go/basics/#server-side-streaming-rpc

https://github.com/grpc/grpc-go

探索云原生
关注
专栏目录
golang grpc数据传输的流模式
qq_46081276的博客
10-08 1581
本篇将举例grpc的流模式数据传输,包括服务端流，客户端流，双向流
【RPC】Grpc的Streaming
龙套的博客
03-28 620
文章目录一、前言二、gRPC服务端流三、grpc客户端流四、gRPC双向流五、StreamObserver转换为反应式框架流六、总结 一、前言 grpc 是一个由 google 推出的、高性能、开源、通用的 rpc 框架。它是基于 HTTP2 协议标准设计开发，默认采用 Protocol Buffers 数据序列化协议，支持多种开发语言。 一般业务场景下，我们都是使用grpc的simple-rpc模式，也就是每次客户端发起请求，服务端会返回一个响应结果的模式。 但是grpc除了这种一来一往的请求模式外，还
gRPC之gRPC流
YIYIYI
09-12 2145
gRPC之gRPC流
golang grpc初体验
最新发布
weixin_44575660的博客
10-02 865
grpc 是一个高性能、开源和通用的 RPC 框架，面向服务端和移动端，基于 HTTP/2 设计。目前支持c、java和go，分别是grpc、grpc-java、grpc-go，目前c版本支持c、c++、node.js、ruby、python、objective-c、php和c#。
带入gRPC：gRPC Streaming, Client and Server
weixin_34244102的博客
09-24 433
带入gRPC：gRPC Streaming, Client and Server 原文地址：带入gRPC：gRPC Streaming, Client and Server 项目地址：go-grpc-example 前言 本章节将介绍 gRPC 的流式，分为三种类型： Server-side streaming RPC：服务器端流式 R...
grpc学习golang版（ 六、服务器流式传输 ）
Sahara_Savage
06-27 1349
grpc学习golang版（六、服务器流式传输）
grpc介绍（三）——流传输
www_dong的博客
10-07 1530
grpc流传输介绍
flutter-grpc-tutorial：[教程]带有Go聊天服务器的异步Flutter聊天客户端，由gRPC提供支持（简单和流式传输）
02-03
在本教程中，我们将深入探讨如何使用Flutter构建一个与Go语言聊天服务器通信的异步聊天客户端，该服务器基于gRPC框架，并支持简单的请求/响应模式和流式传输。这个项目适用于Android、iOS以及任何支持Flutter的移动...
grpc-web-devtools:Chrome和Firefox浏览器扩展程序可使用本机gRPC-Web拦截器帮助gRPC-Web开发
03-16
gRPC-Web开发工具：拦截器版 现在支持暗模式。 gRPC-Web拦截器支持 这个分支增加了对本机gRPC-Web拦截器的支持。 与其他gRPC-Web拦截器不兼容并破坏了它们，这使得无法通过gRPC-Web调试JWT授权之类的东西。 此...
Go-使用grpcgo和python的双向流式RPC的快速演示
08-14
本项目"Go-使用grpcgo和python的双向流式RPC的快速演示"是一个实战教程，旨在帮助开发者了解如何在Go和Python之间实现双向流式RPC。下面将详细介绍其中涉及的关键知识点： 1. **gRPC基础知识**：gRPC基于ProtoBuf...
service-mesh-primer:用Istio引导一个微小的服务网格，该网格支持HTTP + JSON和gRPC + Protobuf之间的代码转换，还支持服务器推送和流传输
03-17
服务器推送，将数据流式传输到客户端 处理Http / 1.1，Http / 2和gRPC 使用Istio 保护服务 gateway sidecar service1 http json |--| |--| grpc |--| ------------>| |---------------->| |------->...
eventing-stream:玩grpc进行流式传输
03-06
事件流 玩grpc进行流式传输
Go-通过HTTP流式传输ASCII电影
08-13
通过HTTP流式传输ASCII电影
java grpc 流式_java - Grpc流在发生写入之前已关闭 - 堆栈内存溢出
weixin_36483301的博客
02-25 1875
我有一个应客户要求通过GRPC从数据库流式处理数据的应用程序。当客户端在流完成之前关闭时。 该错误正在日志中引发，但我不知道如何捕获它以关闭基础数据库连接，从而导致数据库连接泄漏。我正在使用Java和grpc-java版本1.23.0。try {... events is a stream retrieved from DBStreamObservers.copyWithFlowControl(...
gRPC流数据传输
Yaixihn
04-22 1115
stream的实现其实和service一样是接口； 1. 普通服务，5小节就是此部分的实现 .proto文件： rpc 方法名(变量类型)returns(变量类型){} 服务器： func(grpc服务端结构体)方法名(ctx,入参类型指针)回参类型指针,error{ } 客户端： 返回值,错误 = 创建好的grpc客户端连接.方法名(ctx,入参) 2. 流式传入，返回是普通的(客户端流传入，服务端普通返回) .proto文件： rpc 方法名(stream 变量类型)returns(变量类型){}
gRPC入门系列之3-stream模式
dreambreeze110的博客
12-17 1017
而在后面的输出中，调用的是 Average 方法，客户端输入了 5 个数字:[1 2 3 4 5]，服务端返回的是已经输入的数字的平均值。在上面的代码中，我们从 stream 中读取数据，如果 err 为 io.EOF，则结束循环，否则将读取到的数据累加到 sum 变量中。如你所见，我们启动了一个 grpc 服务，使用的端口是 5633，并且进行了反射注册（这只是为了后面的测试，不是必须的）。在上面的测试中，我们分别输入了三个参数 5、2、3，服务端返回了三次，每次返回的都是已经输入的数字的平均值。
gRPC +Go
JJT
08-12 218
gRPC简介 grpc是google开源的一个高性能，通用的rpc框架，基于http2标准协议设计的，多语言支持。 作为高性能rpc框架，其优点如下 使用Protobuf，既与其他格式兼容，又大大提高了速率，减少了体积 使用HTTP2.0弥补了HTTP1.1的不足 在调用方和服务方使用协议约定文件 初步使用 参考这里 安装 Protocol buffer 下载对应版本的压缩包，直接解压，把bin目录加到环境变量里，或者直接把protoc.exe放进GOPATH中的bin中 安装相关的go扩展
go grpc 使用简明教程
攻城老湿的博客
05-30 1053
1 protobuf 定义接口 官网下载 protoc (本机为 Mac M1) https://github.com/protocolbuffers/protobuf/releases image-20220529155807106.png 解压并添加至 PATH image-20220529142245518.png 验证是否正确安装 protoc protoc...
2024年Go最新Go语言：gRPC调用_go语言调用grpc(2)，2024年最新头条Golang面试题
2401_84911273的博客
05-11 690
读取到的信息： OrderId:“201907310001” OrderName:“\351\233\266\351\243\237” OrderStatus:“\345\267\262\344\273\230\346\254\276”读取到的信息： OrderId:“201907310002” OrderName:“\351\243\237\345\223\201” OrderStatus:“\346\234\252\344\273\230\346\254\276”fmt.Println(“读取结束”)
grpc-server-spring-boot-starter
07-30
grpc-server-spring-boot-starter是一个基于Spring Boot框架的gRPC服务器的启动器。gRPC（Google Remote Procedure Call）是一种高性能的远程过程调用框架，它使用Protocol Buffers作为接口定义语言，并支持多种编程语言。 grpc-server-spring-boot-starter提供了一系列简化配置和集成的功能，使得在Spring Boot应用中启动和配置gRPC服务器变得更加容易。它提供了自动装配的功能，可以根据应用的配置自动创建和启动gRPC服务器。用户只需要在配置文件中设置相应的参数，如服务器的端口号、TLS证书等，即可完成服务器的启动配置。 在使用grpc-server-spring-boot-starter时，用户可以方便地定义服务接口和实现类。通过使用gRPC的接口定义语言（protobuf）定义接口，并生成对应的Java代码。然后，用户只需要在实现类中实现相应的接口方法即可。 在服务器启动后，grpc-server-spring-boot-starter会根据定义的接口和实现类，自动创建相应的gRPC服务，并将其注册到服务器中。当客户端发起远程调用时，服务器会根据接口定义和方法参数，将请求转发给对应的实现类，并返回执行结果给客户端。 grpc-server-spring-boot-starter还支持对gRPC服务器进行拦截器的配置。拦截器可以在请求和响应的过程中拦截和修改消息，用于实现日志记录、鉴权、性能监控等功能。 总之，grpc-server-spring-boot-starter简化了在Spring Boot应用中使用gRPC的配置和集成过程，使得开发者可以更加便捷地构建和部署gRPC服务器。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值