[[404879]]

本文轉(zhuǎn)載自微信公眾號「Golang來啦」，作者Seekload 。轉(zhuǎn)載本文請聯(lián)系Golang來啦公眾號。   

你好，我是 Seekload!

接下來一段時間我們來一段 gRPC 之旅，歡迎入坑!

需要的背景知識

學(xué)習(xí) gRPC 需要提前掌握的背景知識：

• Protocol Buffer 協(xié)議;
• 安裝 protoc 和 protoc-gen-go;

這兩部分知識不會重點講解，需要自行學(xué)習(xí)，我們把重點放在 gRPC。

介紹

gRPC 有四種數(shù)據(jù)交互模式：

• 簡單模式(Simple RPC)，客戶端發(fā)起請求并等待服務(wù)端響應(yīng);
• 服務(wù)端流式 RPC(Server-side streaming RPC)，客戶端發(fā)起一個請求到服務(wù)端，服務(wù)端返回一段連續(xù)的數(shù)據(jù)流響應(yīng);
• 客戶端流式 RPC(Client-side streaming RPC)，與服務(wù)端流式相反，客戶端流式是客戶端不斷地向服務(wù)端發(fā)送數(shù)據(jù)流，最后由服務(wù)端返回一個響應(yīng);
• 雙向流式 RPC(Bidirectional streaming RPC)，客戶端和服務(wù)端可同時向?qū)Ψ桨l(fā)送數(shù)據(jù)流，同時也可以接收數(shù)據(jù);

先從簡單的入手，我們先來看下簡單模式 RPC，這種交互模式就是客戶端請求一次，服務(wù)端回應(yīng)一次，雙方一來一回就算單次通信結(jié)束了。

新建并編譯 proto 文件

新建文件 simple.proto

syntax = "proto3"; 
 
package proto; 
 
// 定義發(fā)送請求信息 
message SimpleRequest{ 
  // 參數(shù)類型 參數(shù)名稱 標(biāo)識號 
  string data = 1; 
} 
 
// 定義響應(yīng)信息 
message SimpleResponse{ 
  int32 code = 1; 
  string value = 2; 
} 
 
// 定義我們的服務(wù)(可以定義多個服務(wù)，每個服務(wù)可以定義多個接口) 
service Simple{ 
  rpc GetSimpleInfo(SimpleRequest) returns (SimpleResponse){}; 
} 

進(jìn)入 simple.proto 所在的目錄，使用如下命令編譯文件

protoc --go_out=plugins=grpc:. simple.proto 

執(zhí)行完成之后會生成 simple.pb.go 文件，文件內(nèi)容會在文章后半段給大家梳理，我們先把 demo 跑起來。

創(chuàng)建 server 端

需要在 server 端實現(xiàn) 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" 
) 
 
// 定義我們的服務(wù) 
type SimpleService struct{} 
 
// 實現(xiàn) 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.監(jiān)聽端口 
 listener, err := net.Listen(Network, Address) 
 if err != nil { 
  log.Fatalf("net.listen err: %v", err) 
 } 
 log.Println(Address, " net listening...") 
 // 2.實例化gRPC服務(wù)端 
 grpcServer := grpc.NewServer() 
 
 // 3.注冊我們實現(xiàn)的服務(wù) SimpleService 
 pb.RegisterSimpleServer(grpcServer, &SimpleService{}) 
 
 // 4.啟動gRPC服務(wù)端 
 err = grpcServer.Serve(listener) 
 if err != nil { 
  log.Fatalf("grpc server err: %v",err) 
 } 
 
} 

服務(wù)端實現(xiàn)的主要流程，如上面代碼注釋的：1 -> 2 -> 3 -> 4。

運行服務(wù)端：

go run server.go 
 
輸出： 
:8000  net listening... 

創(chuàng)建 client 端

客戶端可以直接調(diào)用服務(wù)端提供的服務(wù)(接口)

package main 
 
import ( 
 "context" 
 pb "go-grpc-example/1-simple_rpc/proto" 
 "google.golang.org/grpc" 
 "log" 
) 
 
const ( 
 Address string = ":8000" 
) 
 
func main() { 
 // 1.創(chuàng)建于gRPC服務(wù)端的連接 
 conn, err := grpc.Dial(Address, grpc.WithInsecure()) 
 if err != nil { 
  log.Fatalf("dial conn err: %v", err) 
 } 
 defer conn.Close() 
 
 // 2.創(chuàng)建grpc客戶端 
 client := pb.NewSimpleClient(conn) 
 
 // 3.調(diào)用服務(wù)端提供的服務(wù) 
 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) 
 
} 

客戶端實現(xiàn)的流程如上面注釋：1 -> 2 -> 3。

運行客戶端：

go run client.go 
 
輸出： 
get from server,code: 8888,value: grpc 

成功調(diào)用了服務(wù)端提供的方法并返回數(shù)據(jù)。

simple.pb.go 文件詳解

擼完最基礎(chǔ)的 demo，現(xiàn)在來看下編譯完的 simple.proto 文件，熟悉這里面的內(nèi)容有助于我們理解 gRPC 的調(diào)用過程。

1.按照 simple.proto 定義的消息類型會生成不同的 struct。

// 定義發(fā)送請求信息 
type SimpleRequest struct { 
 // 參數(shù)類型 參數(shù)名稱 標(biāo)識號 
 Data                 string   `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` 
} 
 
// 定義響應(yīng)信息 
type SimpleResponse struct { 
 Code                 int32    `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` 
 Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` 
} 

2.為結(jié)構(gòu)體生成了不同的方法。

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 "" 
} 

3.生成了服務(wù)端和客戶端的接口定義，如下：

// 客戶端 
type SimpleClient interface { 
 GetSimpleInfo(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) 
} 
 
// 服務(wù)端 
type SimpleServer interface { 
 GetSimpleInfo(context.Context, *SimpleRequest) (*SimpleResponse, error) 
} 

通信雙方都必須實現(xiàn)接口里面定義的方法，仔細(xì)的同學(xué)可以發(fā)現(xiàn)，客戶端的方法 GetSimpleInfo() 實際上已經(jīng)自動生成了，客戶端只需要調(diào)用即可。

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 
} 

但是服務(wù)端的方法需要自己實現(xiàn)，畢竟是服務(wù)提供方，服務(wù)的具體邏輯是由我們自己來定的。

4.最后還有一個注冊服務(wù)的函數(shù)，我們需要做的就是，自己去定義一個 struct 對象，實現(xiàn)上面提到的 SimpleServer 接口，然后把那個 struct 注冊到 gRPC 服務(wù)上。

func RegisterSimpleServer(s *grpc.Server, srv SimpleServer) { 
 s.RegisterService(&_Simple_serviceDesc, srv) 
} 

總結(jié)

這篇文章主要介紹了 gRPC 第一種交互模式 - Simple RPC，演示了最基礎(chǔ)的 demo，大家重點需要掌握以下兩點：

服務(wù)端和客戶端的實現(xiàn)流程;

simple.pb.go 的內(nèi)容;