Go 語言，gRPC 的使用瞭解 -- 上

安裝

在我們的項目根下，在命令行執行 Go 語言的 gRPC 庫的安裝命令，如下：

$ go get -u google.golang.org/grpc@v1.29.1

示例

修改 hello.proto 文件，新增了 HelloService 接口：

syntax = "proto3";

package proto;

message String {
    string value = 1;
}

service HelloService {
    rpc Hello (String) returns (String);
}

然後使用 protoc-gen-go 內置的 gRPC 插件生成 gRPC 代碼：

$ protoc --go_out=plugins=grpc:. ./proto/*.proto

查看生產的 hello.pb.go 文件，gRPC 插件爲服務端和客戶端生成不同的接口：

// HelloServiceServer is the server API for HelloService service.
type HelloServiceServer interface {
 Hello(context.Context, *String) (*String, error)
}

// HelloServiceClient is the client API for HelloService service.
type HelloServiceClient interface {
 Hello(ctx context.Context, in *String, opts ...grpc.CallOption) (*String, error)
}

gRPC 通過 context.Context 參數，爲每個方法調用提供了上下文支持。

基於服務端的 HelloServiceServer 接口，我們重新來實現 HelloService 服務：

package main

import (
 "context"
 "google.golang.org/grpc"
 "log"
 "net"
 pb "rpc/proto" // 設置引用別名
)

type HelloServiceImpl struct{}

func (p *HelloServiceImpl) Hello(ctx context.Context, args *pb.String) (*pb.String, error) {
 reply := &pb.String{Value: "hello:" + args.GetValue()}
 return reply, nil
}

func main() {
 grpcServer := grpc.NewServer()
 pb.RegisterHelloServiceServer(grpcServer, new(HelloServiceImpl))

 lis, err := net.Listen("tcp", ":1234")
 if err != nil {
  log.Fatal(err)
 }

 grpcServer.Serve(lis)
}

首先通過 grpc.NewServer() 構造一個 gRPC 服務對象，然後通過 gRPC 插件生成的 RegisterHelloServiceServer 函數註冊我們實現的 HelloServiceImpl 服務。然後通過 grpcServer.Serve(lis) 在一個監聽端口上提供 gRPC 服務。

客戶端鏈接 gRPC 服務：

package main

import (
 "context"
 "fmt"
 "google.golang.org/grpc"
 "log"
 pb "rpc/proto" // 設置引用別名
)

func main() {
 conn, err := grpc.Dial("localhost:1234", grpc.WithInsecure())
 if err != nil {
  log.Fatal("dialing err:", err)
 }
 defer conn.Close()

 client := pb.NewHelloServiceClient(conn)
 reply, err := client.Hello(context.Background(), &pb.String{Value: "wekenw"})
 if err != nil {
  log.Fatal(err)
 }
 fmt.Println(reply.GetValue())
}

其中 grpc.Dial 負責和 gRPC 服務建立鏈接，然後 NewHelloServiceClient 函數基於已經建立的鏈接構造 HelloServiceClient 對象。返回的 client 其實是一個 HelloServiceClient 接口對象，通過接口定義的方法就可以調用服務端對應的 gRPC 服務提供的方法。

開啓服務器端，開啓客戶端。客戶端的執行結果如下：

$ go run client.go
hello:wekenw

以上爲 grpc 的一元 RPC(Unary RPC)調用方式。還有三種方式，下面我們分別介紹下。

Server-side streaming RPC：服務端流式 RPC

服務器端流式 RPC，單向流，Server 爲 Stream，Client 爲普通的一元 RPC 請求。

簡單來講就是客戶端發起一次普通的 RPC 請求，服務端通過流式響應多次發送數據集，客戶端 Recv 接收數據集。

Proto :

syntax = "proto3";

package proto;

message String {
    string value = 1;
}

service HelloService {
    rpc Hello (String) returns (stream String){};
}

Server:

package main

import (
 "google.golang.org/grpc"
 "log"
 "net"
 pb "rpc/proto" // 設置引用別名
 "strconv"
)

// HelloServiceImpl 定義我們的服務
type HelloServiceImpl struct{}

//實現Hello方法
func (p *HelloServiceImpl) Hello(req *pb.String, srv pb.HelloService_HelloServer) error {
 for n := 0; n < 5; n++ {
  // 向流中發送消息， 默認每次send送消息最大長度爲`math.MaxInt32`bytes
  err := srv.Send(&pb.String{
   Value: req.Value + strconv.Itoa(n),
  })
  if err != nil {
   return err
  }
 }
 return nil
}

func main() {
 // 新建gRPC服務器實例
 grpcServer := grpc.NewServer()
 // 在gRPC服務器註冊我們的服務
 pb.RegisterHelloServiceServer(grpcServer, new(HelloServiceImpl))

 lis, err := net.Listen("tcp", ":1234")
 if err != nil {
  log.Fatal(err)
 }
 log.Println(" net.Listing...")
 //用服務器 Serve() 方法以及我們的端口信息區實現阻塞等待，直到進程被殺死或者 Stop() 被調用
 err = grpcServer.Serve(lis)
 if err != nil {
  log.Fatalf("grpcServer.Serve err: %v", err)
 }
}

Hello 的參數和返回值是編譯 proto 時生成的 .pb.go 文件中有定義，我們只需要實現就可以了。

Server 端，主要留意 stream.Send 方法，通過閱讀源碼，可得知是 protoc 在生成時，根據定義生成了各式各樣符合標準的接口方法。最終再統一調度內部的 SendMsg 方法，該方法涉及以下過程:

Client:

package main

import (
 "context"
 "google.golang.org/grpc"
 "io"
 "log"
 pb "rpc/proto" // 設置引用別名
)

// SayHello 調用服務端的 Hello 方法
func SayHello(client pb.HelloServiceClient, r *pb.String) error {
 stream, _ := client.Hello(context.Background(), r)
 for {
  resp, err := stream.Recv()
  if err == io.EOF {
   break
  }
  if err != nil {
   return err
  }

  log.Printf("resp: %v", resp)
 }

 return nil
}


func main() {
 conn, err := grpc.Dial("localhost:1234", grpc.WithInsecure())
 if err != nil {
  log.Fatal("dialing err:", err)
 }
 defer conn.Close()

 // 建立gRPC連接
 client := pb.NewHelloServiceClient(conn)

 // 創建發送結構體
 req := pb.String{
  Value: "stream server grpc ",
 }
 SayHello(client, &req)
}

在 Client 端，主要留意 stream.Recv() 方法，此方法，是對 ClientStream.RecvMsg方法的封裝，而 RecvMsg 方法會從流中讀取完整的 gRPC 消息體，我們可得知：

RecvMsg 是阻塞等待的。
RecvMsg 當流成功 / 結束（調用了 Close）時，會返回 io.EOF。
RecvMsg 當流出現任何錯誤時，流會被中止，錯誤信息會包含 RPC 錯誤碼。而在 RecvMsg 中可能出現如下錯誤，例如：
io.EOF、io.ErrUnexpectedEOF
transport.ConnectionError
google.golang.org/grpc/codes（gRPC 的預定義錯誤碼）需要注意的是，默認的 MaxReceiveMessageSize 值爲 1024 1024 4，若有特別需求，可以適當調整。

開啓服務器端，開啓客戶端。執行結果如下：

$ go run server.go
2021/11/16 21:57:18  net.Listing...

$ go run client.go
2021/11/16 21:57:31 resp: value:"stream server grpc 0"
2021/11/16 21:57:31 resp: value:"stream server grpc 1"
2021/11/16 21:57:31 resp: value:"stream server grpc 2"
2021/11/16 21:57:31 resp: value:"stream server grpc 3"
2021/11/16 21:57:31 resp: value:"stream server grpc 4"

客戶端流式 RPC、雙向流式 RPC，未完，待續...

圖片及部分相關技術知識點來源於網絡搜索，侵權刪！

參考資料：

https://golang2.eddycjy.com/posts/ch3/03-simple-grpc/

https://www.cnblogs.com/FireworksEasyCool/p/12693749.html

本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/e9Us1a2uBBahl22yByOK8Q

安裝

示例

Server-side streaming RPC：服務端流式 RPC

猜你喜歡