gRPC 入門指南 — 簡單 RPC(一)
你好,我是 Seekload!
接下來一段時間我們來一段 gRPC 之旅,歡迎入坑!
需要的背景知識
學習 gRPC 需要提前掌握的背景知識:
-
Protocol Buffer 協議;
-
安裝 protoc 和 protoc-gen-go;
這兩部分知識不會重點講解,需要自行學習,我們把重點放在 gRPC。
介紹
gRPC 有四種數據交互模式:
-
簡單模式(Simple RPC),客戶端發起請求並等待服務端響應;
-
服務端流式 RPC(Server-side streaming RPC),客戶端發起一個請求到服務端,服務端返回一段連續的數據流響應;
-
客戶端流式 RPC(Client-side streaming RPC),與服務端流式相反,客戶端流式是客戶端不斷地向服務端發送數據流,最後由服務端返回一個響應;
-
雙向流式 RPC(Bidirectional streaming RPC),客戶端和服務端可同時向對方發送數據流,同時也可以接收數據;
先從簡單的入手,我們先來看下簡單模式 RPC,這種交互模式就是客戶端請求一次,服務端迴應一次,雙方一來一回就算單次通信結束了。
新建並編譯 proto 文件
新建文件 simple.proto
syntax = "proto3";
package proto;
// 定義發送請求信息
message SimpleRequest{
// 參數類型 參數名稱 標識號
string data = 1;
}
// 定義響應信息
message SimpleResponse{
int32 code = 1;
string value = 2;
}
// 定義我們的服務(可以定義多個服務,每個服務可以定義多個接口)
service Simple{
rpc GetSimpleInfo(SimpleRequest) returns (SimpleResponse){};
}
進入 simple.proto 所在的目錄,使用如下命令編譯文件
protoc --go_out=plugins=grpc:. simple.proto
執行完成之後會生成 simple.pb.go 文件,文件內容會在文章後半段給大家梳理,我們先把 demo 跑起來。
創建 server 端
需要在 server 端實現 GetSimpleInfo 方法。
package main
import (
"context"
pb "go-grpc-example/1-simple_rpc/proto"
"google.golang.org/grpc"
"log"
"net"
)
const (
Address string = ":8000"
Network string = "tcp"
)
// 定義我們的服務
type SimpleService struct{}
// 實現 GetSimpleInfo 方法
func (s *SimpleService) GetSimpleInfo(ctx context.Context, req *pb.SimpleRequest) (*pb.SimpleResponse, error) {
data := req.Data
log.Println("get from client: ", data)
resp := &pb.SimpleResponse{
Code: 8888,
Value: "grpc",
}
return resp, nil
}
func main() {
// 1.監聽端口
listener, err := net.Listen(Network, Address)
if err != nil {
log.Fatalf("net.listen err: %v", err)
}
log.Println(Address, " net listening...")
// 2.實例化gRPC服務端
grpcServer := grpc.NewServer()
// 3.註冊我們實現的服務 SimpleService
pb.RegisterSimpleServer(grpcServer, &SimpleService{})
// 4.啓動gRPC服務端
err = grpcServer.Serve(listener)
if err != nil {
log.Fatalf("grpc server err: %v",err)
}
}
服務端實現的主要流程,如上面代碼註釋的:1 -> 2 -> 3 -> 4。
運行服務端:
go run server.go
輸出:
:8000 net listening...
創建 client 端
客戶端可以直接調用服務端提供的服務(接口)
package main
import (
"context"
pb "go-grpc-example/1-simple_rpc/proto"
"google.golang.org/grpc"
"log"
)
const (
Address string = ":8000"
)
func main() {
// 1.創建於gRPC服務端的連接
conn, err := grpc.Dial(Address, grpc.WithInsecure())
if err != nil {
log.Fatalf("dial conn err: %v", err)
}
defer conn.Close()
// 2.創建grpc客戶端
client := pb.NewSimpleClient(conn)
// 3.調用服務端提供的服務
req := pb.SimpleRequest{
Data: "Hello,Server",
}
resp, err := client.GetSimpleInfo(context.Background(), &req)
if err != nil {
log.Fatalf("resp err: %v", err)
}
log.Printf("get from server,code: %v,value: %v", resp.Code, resp.Value)
}
客戶端實現的流程如上面註釋:1 -> 2 -> 3。
運行客戶端:
go run client.go
輸出:
get from server,code: 8888,value: grpc
成功調用了服務端提供的方法並返回數據。
simple.pb.go 文件詳解
擼完最基礎的 demo,現在來看下編譯完的 simple.proto 文件,熟悉這裏面的內容有助於我們理解 gRPC 的調用過程。
- 按照 simple.proto 定義的消息類型會生成不同的 struct。
// 定義發送請求信息
type SimpleRequest struct {
// 參數類型 參數名稱 標識號
Data string `protobuf:"bytes,1,opt,`
}
// 定義響應信息
type SimpleResponse struct {
Code int32 `protobuf:"varint,1,opt,`
Value string `protobuf:"bytes,2,opt,`
}
- 爲結構體生成了不同的方法。
func (m *SimpleRequest) Reset() { *m = SimpleRequest{} }
func (m *SimpleRequest) String() string { return proto.CompactTextString(m) }
func (m *SimpleResponse) Reset() { *m = SimpleResponse{} }
func (m *SimpleResponse) String() string { return proto.CompactTextString(m) }
func (m *SimpleResponse) GetCode() int32 {
if m != nil {
return m.Code
}
return 0
}
func (m *SimpleResponse) GetValue() string {
if m != nil {
return m.Value
}
return ""
}
- 生成了服務端和客戶端的接口定義,如下:
// 客戶端
type SimpleClient interface {
GetSimpleInfo(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error)
}
// 服務端
type SimpleServer interface {
GetSimpleInfo(context.Context, *SimpleRequest) (*SimpleResponse, error)
}
通信雙方都必須實現接口裏面定義的方法,仔細的同學可以發現,客戶端的方法 GetSimpleInfo() 實際上已經自動生成了,客戶端只需要調用即可。
func (c *simpleClient) GetSimpleInfo(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) {
out := new(SimpleResponse)
err := c.cc.Invoke(ctx, "/proto.Simple/GetSimpleInfo", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
但是服務端的方法需要自己實現,畢竟是服務提供方,服務的具體邏輯是由我們自己來定的。
- 最後還有一個註冊服務的函數,我們需要做的就是,自己去定義一個 struct 對象,實現上面提到的 SimpleServer 接口,然後把那個 struct 註冊到 gRPC 服務上。
func RegisterSimpleServer(s *grpc.Server, srv SimpleServer) {
s.RegisterService(&_Simple_serviceDesc, srv)
}
總結
這篇文章主要介紹了 gRPC 第一種交互模式 - Simple RPC,演示了最基礎的 demo,大家重點需要掌握以下兩點:
-
服務端和客戶端的實現流程;
-
simple.pb.go 的內容;
下篇我們接着來介紹第二種模式 - 服務端流式 RPC。
本文由 Readfog 進行 AMP 轉碼,版權歸原作者所有。
來源:https://mp.weixin.qq.com/s/GnDKAx9bLe90h0rvCQYb6g