【go 语言】gRPC 环境搭建(三)

简介: gRPC 环境搭建(三)

前言


昨晚写完【go 语言】gRPC 环境搭建(二) 后,今早爬起来继续踩坑,发现事情并不简单,版本更新太快,部分文档的滞后性相当明显,不过都已经解决了,相关内容,第一次看的话,直接跟着走就行。


好了,今天从继续往后面探索。


正文


gRPC 的调用方式简介


  • Unary RPC:一元 RPC。
  • Server-side streaming RPC:服务端流式 RPC。
  • Client-side streaming RPC:客户端流式 RPC。
  • Bidirectional streaming RPC:双向流式 RPC。


1. Unary RPC:一元 RPC


一元 RPC 也称为单次 RPC,简单来讲,就是客户单发起一次普通的 RPC 请求,是最基础的调用,也是最常用的方式,如下图所示,


45.webp.jpg

一元 RPC


服务端代码如下,


package main
import (
    "context"
    "google.golang.org/grpc"
    "net"
    pb "project_protoc/proto/helloworld"
)
type GreeterServer struct {
    pb.UnimplementedGreeterServer
}
func (g GreeterServer) SayHello(ctx context.Context, request *pb.HelloRequest) (*pb.HelloReply, error) {
    return &pb.HelloReply{Message: "hello world, QiJ"}, nil
}
func main() {
    server := grpc.NewServer()
    pb.RegisterGreeterServer(server, &GreeterServer{})
    lis, _ := net.Listen("tcp", ":"+"2021")
    server.Serve(lis)
}


代码说明,


  • 创建 gRPC Server 对象,可以把它理解为 Server 端的抽象对象。
  • 将 GreeterServer(其包含需要被调用的服务端接口)注册到 gRPC Server 的内部注册中心,这样在接收请求时,即可通过内部的“服务发现”发现该服务端接口,并进行逻辑处理。
  • 创建 Listen,监听 TCP 端口。
  • gRPC Server 开始 lis.Accept,直到 Stop 或 GracefulStop。


服务端代码需要注意的地方是 GreeterServer 这个结构体内必须带上 pb.UnimplementedGreeterServer,不然会报如下错误,


46.webp.jpg


Cannot use '&GreeterServer{}' (type *GreeterServer) as type GreeterServer Type does not implement 'GreeterServer' as some methods are missing: mustEmbedUnimplementedGreeterServer()


客户端代码如下,


package main
import (
    "context"
    "google.golang.org/grpc"
    "log"
    pb "project_protoc/proto/helloworld"
)
func main() {
    conn, _ := grpc.Dial(":"+"2021", grpc.WithInsecure())
    defer conn.Close()
    client := pb.NewGreeterClient(conn)
    _ = SayHello(client)
}
func SayHello(client pb.GreeterClient) error {
    resp, _ := client.SayHello(context.Background(), &pb.HelloRequest{Name: "七镜"})
    log.Printf("client.SayHello resp: %s", resp.Message)
    return nil
}


代码说明,


  • 创建与给定目标(服务端)的连接句柄。
  • 创建 Greeter 的客户端对象。
  • 发送 RPC 请求,等待同步响应,得到回调后返回响应结果。


二、Service-side streaming RPC:服务端流式 RPC


服务端流式 RPC 是一个单向流,指 Server 为 Stream、Client 为普通的一元 RPC 请求。

简单来讲,就是客户端发起一次普通的 RPC 请求,服务端通过流式响应多次发送数据集,客户端 Recv 接收数据集,如下图所示,


47.webp.jpg

服务端流式 RPC


proto 文件调整如下,


...
service Greeter {
  ...
  rpc SayList (HelloRequest) returns (stream HelloReply) {};
  ...
}
...


意思是新增一个 SayList 服务。加完之后,继续执行下述命令,重新生成 *.pb.go 和 *_grpc.pb.go 。


protoc -I=. --go_out=. --go-grpc_out=. ./proto/*.proto


服务端代码调整如下,


...
func (s GreeterServer) SayList(r *pb.HelloRequest, stream pb.Greeter_SayListServer) error {
    for n := 0; n <= 6; n++ {
        _ = stream.Send(&pb.HelloReply{Message: "hello list, QiJ"})
    }
    return nil
}
...


在 Server 端,需重点留意 stream.Send 方法。通过阅读源码,可以得知 protoc 在生成时,根据定义生成了各式各样符合标准的接口方法。最终再统一调用内部的 SendMsg 方法,改方法涉及以下流程:

  • 消息体(对象)序列化。
  • 压缩序列化后的消息体。
  • 为正在传输的消息体增加 5 字节的 header(标志位)。
  • 判断压缩 + 序列化后的消息体总字节长度是否大于预设的 maxStreamMessageSize(预设值为 math.MaxInt32),若超出则提示错误。
  • 写入流的数据集。


客户端代码调整如下,


...
func SayList(client pb.GreeterClient, r *pb.HelloRequest) error {
    stream, _ := client.SayList(context.Background(), r)
    for {
        resp, err := stream.Recv()
        if err == io.EOF {
            break
        }
        if err != nil {
            return err
        }
        log.Printf("resp: %v", resp.Message)
    }
    return nil
}
...


在 Client 端,需重点留意 stream.Recv 方法,并思考一下,在什么情况下会出现 io.EOF,又在什么情况下会出现错误信息呢?实际上,stream.Recv 方法是对 ClientStream.RecvMsg 方法的封装,而 RecvMsg 方法会从流中读取完整的 gRPC 消息体,有次可以得知:


  • RecvMsg 是阻塞等待的。
  • 当流成功或结束(调用了 Close)是,RecvMsg 会返回 io.EOF。
  • 当流出现任何错误时,流都会被中止。错误信息中会包含 RPC 错误码。RecvMsg 中可能出现的错误如下,


  1. io.EOF、io.ErrUnexpectedEOF。
  2. transport.ConnectionError。
  3. google.golang.org/grpc/codes(gRPC 的预定义错误码)


需要注意的是,默认的 MaxReceiveMessageSize 值为 1024x1024x4。若有特殊需求,则可以适当调整。


三、 Client-side streaming RPC:客户端流式 RPC


客户端流式 RPC 是一个单向流,客户端通过流式发起多次 RPC 请求给服务端,而服务端又发起一次响应给客户端,如下图所示,


48.webp.jpg

客户端流式 RPC


proto 文件调整如下


...
rpc SayRecord (stream HelloRequest) returns (HelloReply) {};
...


再次执行下述命令,重新生成 *.pb.go 和 *_grpc.pb.go


protoc -I=. --go_out=. --go-grpc_out=. ./proto/*.proto


服务端代码调整如下


...
func (s *GreeterServer) SayRecord(stream pb.Greeter_SayRecordServer) error {
    for {
        resp, err := stream.Recv()
        if err == io.EOF {
            message := &pb.HelloReply{Message: "hello record, QiJ"}
            return stream.SendAndClose(message)
        }
        if err != nil {
            return err
        }
        log.Printf("resp: %v", resp)
    }
}
...


上述代码中,我们对每一个 Recv 都进行了处理。当 io.EOF(流关闭)后,需要通过 stream.SendAndClose 方法将最终的响应结果发送给客户端,同时关闭在另外一侧等待的 Recv。


客户端代码调整如下,


...
func SayRecord(client pb.GreeterClient, r *pb.HelloRequest) error {
    stream, _ := client.SayRecord(context.Background())
    for n := 0; n < 6; n++ {
        _ = stream.Send(r)
    }
    resp, _ := stream.CloseAndRecv()
    log.Printf("client.SayRecord resp: %v", resp.Message)
    return nil
}
...


Server 端的 stream.SendAndClose 方法与 Client 端的 stream.CloseAndRecv 方法是配套使用的。


四、Bidirectional streaming RPC:双向流式 RPC


双向流式 RPC,顾名思义是双向流,由客户端以流式的方式发起请求,服务端同样以流式的方式响应请求。

首个请求一定是客户端发起的,但具体的交互方式(谁先谁后、一次发多少、响应多少、什么时候关闭)则由程序编写的方式来确定(可以结合协程)。

假设双向流是按顺序发送的,则大致如下图所示,


49.webp.jpg

双向流式 RPC


proto 文件调整如下


...
rpc SayRoute (stream HelloRequest) returns (stream HelloReply) {};
...


再次执行下述命令,重新生成 *.pb.go 和 *_grpc.pb.go


protoc -I=. --go_out=. --go-grpc_out=. ./proto/*.proto


服务端代码调整如下,


...
func (s *GreeterServer) SayRoute(stream pb.Greeter_SayRouteServer) error {
    n := 0
    for {
        _ = stream.Send(&pb.HelloReply{Message: "hello route"})
        resp, err := stream.Recv()
        if err == io.EOF {
            return nil
        }
        if err != nil {
            return err
        }
        n++
        log.Printf("server.SayRoute resp: %v", resp)
    }
}
...


客户端代码调整如下,


...
func SayRoute(client pb.GreeterClient, r *pb.HelloRequest) error {
    stream, _ := client.SayRoute(context.Background())
    for n := 0; n <= 6; n++ {
        _ = stream.Send(r)
        resp, err := stream.Recv()
        if err == io.EOF {
            return nil
        }
        if err != nil {
            return err
        }
        log.Printf("client.SayRoute resp: %v", resp.Message)
    }
    _ = stream.CloseSend()
    return nil
}
...


四种 gRPC 调用方式的结果展示汇总


Client 端:


50.webp.jpg

客户端结果展示汇总


Server 端:


51.webp.jpg

服务端结果展示汇总


项目工程下载

下载地址:点击下载

目录
相关文章
|
21小时前
|
Go 开发者
Go语言入门:环境搭建与基础语法
本文将引导读者从零开始接触Go语言,介绍如何搭建Go语言开发环境,并详细讲解Go语言的基础语法,包括变量、数据类型、运算符、控制流语句等。通过本文的学习,读者将能够掌握Go语言的基本编程知识,为后续深入学习打下坚实基础。
|
4天前
|
Go
GO语言的变量与常量
介绍Go语言的变量与常量!
21 5
|
7天前
|
Go
Go语言定义变量
Go语言定义变量
14 3
|
18天前
|
Java Go 数据安全/隐私保护
Go语言学习7-函数类型
【2月更文挑战第3天】本篇 Huazie 向大家介绍 Go 语言的函数类型
25 1
Go语言学习7-函数类型
|
19天前
|
Unix Linux Go
开心档之 Go 语言环境安装
开心档之 Go 语言环境安装
|
19天前
|
编译器 Serverless Go
开心档之 Go 语言常量
开心档之 Go 语言常量
|
19天前
|
编译器 Go 索引
go 开发入门篇之 go 语言
go 开发入门篇之 go 语言
|
存储 IDE Java
go语言简单入门
go语言简单入门
131 0
|
缓存 搜索推荐 编译器
Go 语言入门很简单 -- 17. Go Package #私藏项目实操分享#
Go 语言入门很简单 -- 17. Go Package #私藏项目实操分享#
132 0
Go 语言入门很简单 -- 17. Go Package #私藏项目实操分享#
|
编译器 Shell 测试技术
Go 语言入门很简单--技巧和窍门(Tips and Tricks)
Go 语言入门很简单--技巧和窍门(Tips and Tricks)
147 0
Go 语言入门很简单--技巧和窍门(Tips and Tricks)