第八节——实现双向流式GRPC

最新推荐文章于 2024-05-12 21:14:39 发布
最新推荐文章于 2024-05-12 21:14:39 发布
阅读量1.7k 收藏 1
点赞数
分类专栏： # grpc学习 文章标签： grpc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37589805/article/details/124033531
版权

第八章——实现双向流式 gRPC

8.1、定义双向流式 gRPC protobuf

  1. 在proto/laptop_service.proto文件中定义一个新的消息RateLaptopRequest，具有两个属性：笔记本电脑 ID 和分数
message RateLaptopRequest {
  string laptop_id = 1;
  double score = 2;
}
  1. 定义一个消息RateLaptopResponse，具有三个属性笔记本电脑 ID、这台笔记本电脑的评分次数和平均评分
message RateLaptopResponse {
  string laptop_id = 1;
  uint32 rated_count = 2;
  double average_score = 3;
}
  1. 定义一个新的双向流 RPC
service LaptopService {
  ...
  rpc RateLaptop(stream RateLaptopRequest) returns (stream RateLaptopResponse) {};
}
  1. 运行命令：make gen

8.2、实现评级商店

  1. 创建新文件service/rating_store.go
  2. 定义一个RatingStore接口。它有 1 个函数Add，将笔记本电脑 ID 和分数作为输入，并返回更新的笔记本电脑评级或错误。
type RatingStore interface {
	Add(laptopID string, score float64) (*Rating, error)
}

type Rating struct {
	Count uint32
	Sum   float64
}
  1. 定义InMemoryRatingStore结构体来实现接口
type InMemoryRatingStore struct {
    mutex  sync.RWMutex
    rating map[string]*Rating
}

func NewInMemoryRatingStore() *InMemoryRatingStore {
    return &InMemoryRatingStore{
        rating: make(map[string]*Rating),
    }
}
  1. 为InMemoryRatingStore结构体实现Add功能
    • 要更改存储的内部数据，必须获得一个锁
    • 从map中获得笔记本电脑 ID 的评级
    • 如果未找到评分，我们只需创建一个 count 为 1 且 sum 为输入分数的新对象。否则，我们将评分计数增加 1 并将分数添加到总和中
    • 将更新后的评分放回地图并将其返回给调用者
func (store *InMemoryRatingStore) Add(laptopID string, score float64) (*Rating, error) {
    store.mutex.Lock()
    defer store.mutex.Unlock()

    rating := store.rating[laptopID]
    if rating == nil {
        rating = &Rating{
            Count: 1,
            Sum:   score,
        }
    } else {
        rating.Count++
        rating.Sum += score
    }

    store.rating[laptopID] = rating
    return rating, nil
}
  1. 在service/laptop_server.go文件中使用InMemoryRatingStore结构体
    • 向LaptopServer结构添加RatingStore属性
    • 向NewLaptopServer()函数添加RatingStore结构体参数
type LaptopServer struct {
	pb.UnimplementedLaptopServiceServer
	laptopStore LaptopStore
	imageStore  ImageStore
	ratingStore RatingStore
}

func NewLaptopServer(laptopStore LaptopStore, imageStore ImageStore, ratingStore RatingStore) *LaptopServer {
	return &LaptopServer{
		laptopStore: laptopStore,
		imageStore:  imageStore,
		ratingStore: ratingStore,
	}
}
  1. 修改cmd/server/main.go文件中的main函数
func main() {
	laptopStore := service.NewInMemoryLaptopStore()
	imageStore := service.NewDiskImageStore("img")
	ratingStore := service.NewInMemoryRatingStore()
	laptopServer := service.NewLaptopServer(laptopStore, imageStore, ratingStore)
	grpcServer := grpc.NewServer()
	pb.RegisterLaptopServiceServer(grpcServer, laptopServer)
	listener, _ := net.Listen("tcp", ":8888")
	grpcServer.Serve(listener)
}

8.3、服务端代码完善

  1. 在service/laptop_server.go文件中，实现在proto中定义的服务RateLaptop
func (server *LaptopServer) RateLaptop(stream pb.LaptopService_RateLaptopServer) error {
    return nil
}
  1. 使用 for 循环从流中接收多个请求，接受前检查上下文错误以查看它是否已被取消或是否已超过截止日期
func (server *LaptopServer) RateLaptop(stream pb.LaptopService_RateLaptopServer) error {
	for {
		err := contextError(stream.Context())
		if err != nil {
			return nil
		}

		req, err := stream.Recv()
		if err == io.EOF {
			log.Print("no more data")
			break
		}
		if err != nil {
			return logError(status.Errorf(codes.Unknown, "cannot receive stream request: %v", err))
		}
	}
	return nil
}

func contextError(ctx context.Context) error {
	switch ctx.Err() {
	case context.Canceled:
		return logError(status.Error(codes.Canceled, "request is canceled"))
	case context.DeadlineExceeded:
		return logError(status.Error(codes.DeadlineExceeded, "deadline is exceeded"))
	default:
		return nil
	}
}
  1. 从请求中获取笔记本电脑 ID 和分数。在这里写一个日志，说明收到了带有此笔记本电脑 ID 和分数的请求
func (server *LaptopServer) RateLaptop(stream pb.LaptopService_RateLaptopServer) error {
    for {
        ...
        laptopID := req.GetLaptopId()
        score := req.GetScore()

        log.Printf("received a rate-laptop request: id = %s, score = %.2f", laptopID, score)

        ...
    }

    return nil
}
  1. 调用ratingStore.Add()将新的笔记本电脑分数添加到商店并取回更新的评分对象
func (server *LaptopServer) RateLaptop(stream pb.LaptopService_RateLaptopServer) error {
    for {
        ...

        rating, err := server.ratingStore.Add(laptopID, score)
        if err != nil {
            return logError(status.Errorf(codes.Internal, "cannot add rating to the store: %v", err))
        }
        
        ...

    return nil
}
  1. 创建一个RateLaptopResponse笔记本电脑 ID 是输入笔记本电脑 ID，从评级对象中获取评级计数，并使用评级的总和和计数计算平均分数.调用stream.Send()将响应发送给客户端
func (server *LaptopServer) RateLaptop(stream pb.LaptopService_RateLaptopServer) error {
    for {
        ...
        
        res := &pb.RateLaptopResponse{
            LaptopId:     laptopID,
            RatedCount:   rating.Count,
            AverageScore: rating.Sum / float64(rating.Count),
        }

        err = stream.Send(res)
        if err != nil {
            return logError(status.Errorf(codes.Unknown, "cannot send stream response: %v", err))
        }
    }

    return nil
}

8.4、客户端代码完善

  1. 在sample/random.go文件中添加一个新函数来生成随机笔记本电脑分数
func RandomLaptopScore() float64 {
    return float64(randomInt(1, 10))
}
  1. 在cmd/client/main.go文件中定义一个rateLaptop()函数
func rateLaptop(laptopClient pb.LaptopServiceClient, laptopIDs []string, scores []float64) error {
}
  1. 创建一个 5 秒后超时的新上下文,并用函数laptopClient.RateLaptop()调用上下文
func rateLaptop(laptopClient pb.LaptopServiceClient, laptopIDs []string, scores []float64) error {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    stream, err := laptopClient.RateLaptop(ctx)
    if err != nil {
        return fmt.Errorf("cannot rate laptop: %v", err)
    }

    ...
}
  1. 创建一个通道来等待来自服务器的响应
func rateLaptop(laptopClient pb.LaptopServiceClient, laptopIDs []string, scores []float64) error {
    ...

    waitResponse := make(chan error)

    ...
}
  1. 启动一个新的 go 例程来接收响应。在 go 例程中，我们使用 for 循环，并调用stream.Recv()以从服务器获取响应
func rateLaptop(laptopClient pb.LaptopServiceClient, laptopIDs []string, scores []float64) error {
    ...

    // go routine to receive responses
    go func() {
        for {
            res, err := stream.Recv()
            if err == io.EOF {
                log.Print("no more responses")
                waitResponse <- nil
                return
            }
            if err != nil {
                waitResponse <- fmt.Errorf("cannot receive stream response: %v", err)
                return
            }

            log.Print("received response: ", res)
        }
    }()

    ...
}
  1. 遍历笔记本电脑列表，并使用输入笔记本电脑 ID 和相应的输入分数为每台笔记本电脑创建一个新请求，之后调用stream.Send()将请求发送到服务器
func rateLaptop(laptopClient pb.LaptopServiceClient, laptopIDs []string, scores []float64) error {
    ...

    // send requests
    for i, laptopID := range laptopIDs {
        req := &pb.RateLaptopRequest{
            LaptopId: laptopID,
            Score:    scores[i],
        }

        err := stream.Send(req)
        if err != nil {
            return fmt.Errorf("cannot send stream request: %v - %v", err, stream.RecvMsg(nil))
        }

        log.Print("sent request: ", req)
    }

    ...
}
  1. 在发送完所有请求后调用stream.CloseSend()告诉服务器我们不再发送任何数据。最后从waitResponse通道中读取并返回接收到的错误。
func rateLaptop(laptopClient pb.LaptopServiceClient, laptopIDs []string, scores []float64) error {
    ...

    err = stream.CloseSend()
    if err != nil {
        return fmt.Errorf("cannot close send: %v", err)
    }

    err = <-waitResponse
    return err
}

  1. 写一个testRateLaptop()函数来调用rateLaptop()功能

    • 假设我们要评价 3 台笔记本电脑，所以我们声明一个切片来保留笔记本电脑的 ID。

    • 使用 for 循环生成随机笔记本电脑，将其 ID 保存到切片中，

    • 调用createLaptop()函数在服务器上创建它。

func testRateLaptop(laptopClient pb.LaptopServiceClient) {
    n := 3
    laptopIDs := make([]string, n)

    for i := 0; i < n; i++ {
        laptop := sample.NewLaptop()
        laptopIDs[i] = laptop.GetId()
        createLaptop(laptopClient, laptop)
    }

    ...
}
  1. 做一个切片来保持分数。我想对这 3 台笔记本电脑进行多轮评分，因此我将在这里使用 for 循环并询问我们是否要进行另一轮评分
func testRateLaptop(laptopClient pb.LaptopServiceClient) {
    ...

    scores := make([]float64, n)
    for {
        fmt.Print("rate laptop (y/n)? ")
        var answer string
        fmt.Scan(&answer)

        if strings.ToLower(answer) != "y" {
            break
        }

        for i := 0; i < n; i++ {
            scores[i] = sample.RandomLaptopScore()
        }

        err := rateLaptop(laptopClient, laptopIDs, scores)
        if err != nil {
            log.Fatal(err)
        }
    }
}
  1. 在 main 函数中，只需调用testRateLaptop()，就可以了
func main() {
	conn, _ := grpc.Dial("localhost:8888", grpc.WithInsecure())

	laptopClient := pb.NewLaptopServiceClient(conn)
	testRateLaptop(laptopClient)
}

8.5、启动服务

  1. 启动服务端，命令：make server
  2. 启动客户端，命令：make client
想学习安全的小白
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python grpc流式_Python——gRPC详解及实战避坑方案(下)
weixin_39903375的博客
12-19 900
作者：henry_czh(授权转载，勿二次转载)来源：https://juejin.im/post/6854573218884222989前言上一篇文章讲述了RPC服务的概念和gRPC的基本使用、proto语法的使用教程。然而在我们真正把gRPC服务部署到生产环境上的时候，会遇到很多问题，首选要考虑的就是协议的数据认证问题，其次，gRPC也支持流式通信的模式，本篇文章会做一个介绍说明。RPC的身份...
gRPC
热门推荐
uxff的专栏
10-18 5万+
gRPC分享概述gRPC 一开始由 google 开发，是一款语言中立、平台中立、开源的远程过程调用(RPC)系统。在 gRPC 里客户端应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法，使得您能够更容易地创建分布式应用和服务。与许多 RPC 系统类似，gRPC 也是基于以下理念：定义一个服务，指定其能够被远程调用的方法（包含参数和返回类型）。在服务端实现这个接口，并运行一个 g
grpc双向流式调用——构建一个简单的流数据分析器
程序员Sunny的博客
08-13 6000
本文地址： 传送门： grpc实战——构建一个简单的名称解析服务 grpc实战——服务端流式调用 grpc实战——客户端流式调用 本实例源码 关于grpc，之前已经基于循序渐进的原则和大家聊过简单调用，服务端流式调用和客户端流式调用。那么我们今天聊的grpc应该就是双向流式调用了。相对之前的有所复杂，但是其实有了前面服务端流式调用和客户端流式调用的基础，双向流式调用其实只是两者的结合...
用Python进行gRPC接口测试(二)_python 如何执行 grpc 接口测试(1)
2401_84141219的博客
05-12 748
各位被困在家中的小伙伴们，大家新年好~今天将继续为大家带来用Python进行gRPC接口测试的续集，上次主要讲了一下前期准备工作和简单RPC通信方式的实现，这次我们将着眼于另一类gRPC接口的通信形式——流式RPC。
grpc实战——构建一个简单的名称解析服务
程序员Sunny的博客
05-27 4544
本文地址：https://blog.csdn.net/m0_37595562/article/details/80474037 环境说明： 语言主要用java实现，ide使用的是idea，使用maven作为软件项目管理工具。 说明：本项目源码已发布，点击grpc名称服务可以看到本项目的源码。欢迎大家fork实践体验。 本篇主要是对grpc的一个实战过程。主要完成服务简单调用，后面的文章中我...
Python——gRPC详解及实战避坑方案(下)
Python猫
08-06 6724
????“Python猫” ，一个值得加星标的公众号剧照 | 《三十而已》作者：henry_czh（授权转载，勿二次转载）来源：https://juejin.im/post/68545...
重新定义cloud 第19章 gRPC上篇.md
qq120631157的博客
12-19 162
dobbo RPC框架 通常情况下 Http 不会开启 keepAlive 。即：通常都是短连接 内部服务之间用 http 性能低下 现有 更高效的 调用方案 是 GRPC gRPC 吞吐量 是 json 的 3倍，而且只用了 1/4 的 资源 gRPC 和 http/json区别 gRPC 采用 了 Proto Buffer 作为 序列化工具 gRPC 采用了 HTTP2协议，进行了 头部信息压缩，对连接进行了 复用（减少了连接的次数） gRPC 采用了 Netty 作为 IO 处理框架 GRPC.
Nacos源码服务端集群系列第2篇gRPC 流入门
wuchsh123的专栏
06-05 950
上一章节我们通过一个简单的例子入门和了解了gRPC的一元rpc，知道如何配置一个服务和请求、相应消息，并通编译工具生成java代码。以及讲解了如何创启动一个服务器，并添加我们的服务类。使用client stub 跟服务端完成服务的调用和返回。...
fabirc1.0商业正式版本源码解析6——GRPC服务
u011386109的博客
08-31 905
GRPC简介 GRPC是由自谷歌开发的一项多语言开源的RPC技术，在fabric用于实现客户端与服务器端的远程调用。比如chaincode，客户定义了一项rpc服务并相应生成了客户端代码和服务端代码，在此基础上进行业务逻辑上的开发后，分别运行服务端代码和客户端代码，实现客户端调用服务器端服务的目的。由于gprc相对来说还是很复杂的，所有还请自行学习。在gprc官网非常详细的资料和例子。
GRPC入门原理及使用
fjiajia0423的博客
01-12 988
通过.proto文件来描述服务接口及其参数，服务契约明确且易于维护。没有严格的服务定义规范，通常是自文档化，通过URI、HTTP方法和媒体类型（Content-Type）来表达资源模型和操作。
CMPE273-Lab-2:cmpe 273 实验 2——REST API 到 gRPC API 的转换
06-17
4. **实现客户端**：在客户端，使用生成的stub与服务端建立连接并调用gRPC方法。可以异步或同步地执行这些调用，以适应不同的需求。 5. **测试与调试**：编写单元测试验证API的正确性，并使用gRPC的工具进行性能...
gRPC的通信方式-客户端流式、服务端流式、双向流式在Java的调用示例代码.rar
09-24
gRPC的通信方式-客户端流式、服务端流式、双向流式在Java的调用示例代码;gRPC的通信方式-客户端流式、服务端流式、双向流式在Java的调用示例代码.;gRPC的通信方式-客户端流式、服务端流式、双向流式在Java的调用示例...
利用grpc框架c++编码实现异步双向流调用，可实现客户端服务端的主动调用链接
03-30
在本文中，我们将深入探讨如何使用gRPC框架在C++中实现异步双向流调用。gRPC是一个高性能、开源的RPC（远程过程调用）框架，它支持多种语言，包括C++。异步双向流调用是gRPC提供的一种通信模式，允许客户端和服务端...
基于c++实现的GRPC服务端demo
09-02
在本文中，我们将深入探讨如何使用 C++ 实现一个简单的 gRPC 服务端 demo。首先，我们需要了解 gRPC 的核心概念和工作原理。 1. **gRPC 基本概念** - **RPC**：远程过程调用，允许一个程序调用另一个位于不同地址...
Go-使用grpcgo和python的双向流式RPC的快速演示
08-14
本项目"Go-使用grpcgo和python的双向流式RPC的快速演示"是一个实战教程，旨在帮助开发者了解如何在Go和Python之间实现双向流式RPC。下面将详细介绍其中涉及的关键知识点： 1. **gRPC基础知识**：gRPC基于ProtoBuf...
java毕业作品-JAVA技术在《堡垒》手机游戏开发中的应用与探索(源代码+论文)
最新发布
08-03
java毕业作品_JAVA技术在《堡垒》手机游戏开发中的应用与探索(源代码+论文)
联想M8500T(Q87主板)BIOS加入NVME协议,用编程器直接刷入 8M+4M一起刷入 刷之前备份原bios避免翻车
08-03
联想M8500T(Q87主板)BIOS加入NVME协议,用编程器直接刷入 8M+4M一起刷入。刷之前备份原bios避免翻车
第5章 传输层 计算机网络思维导图，结合学习通作业
08-03
计算机网络思维导图，结合学习通作业，方便备考复习。
使用c++实现双向通信 grpc
12-08
总结：使用C实现双向通信的gRPC，通过定义协议、生成代码、实现服务、使用双向流式RPC等步骤，可以实现高效、可扩展的双向通信。双向通信可以满足多种应用场景的需求，如实时聊天、实时数据推送等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值