grpc 是 google 開源的一款網絡框架，具有極好的性能，可能是目前性能最好的網絡框架，支持流式 rpc，可以很方便地構建消息訂閱發(fā)布系統(tǒng)，支持幾乎所有主流的語言，使用上面也很簡單，公司很多服務基于 grpc 框架構建，運行非常穩(wěn)定
開始之前首先你要知道網絡框架為你做了哪些事情：
- 網絡協(xié)議序列化與反序列化
- 網絡底層通信
- 并發(fā)管理
以及需要你做哪些事情：
- 定義通信的內容（通過協(xié)議文件）
- 實現(xiàn)通信的方法（實現(xiàn)協(xié)議接口）
以下面兩個例子來分別說明兩種 rpc 服務的簡單用法
下面使用的完整代碼下列地址：
實現(xiàn)文件：https://github.com/hatlonely/hellogolang/tree/master/cmd/grpc
協(xié)議文件：https://github.com/hatlonely/hellogolang/tree/master/api
簡單 echo 服務
要實現(xiàn)的這個服務很簡單，功能和 echo 命令類似，用一個字符串請求服務器，返回相同的字符串
獲取 grpc
go get google.golang.org/grpc
go get google.golang.org/genproto/
go get 上面兩個庫就可以了。可能被墻了，需要 vpn；如果沒有 vpn，可以找一臺能下載的服務器下載下來再傳到本地；如果也沒有服務器，可以點擊這里下載，解壓后放到 vendor/ 目錄下即可，不過可能不是最新版本
定義協(xié)議文件
首先要定義通信的協(xié)議，grpc 使用的是 proto3 序列化協(xié)議，這是一個高效的協(xié)議，關于這個協(xié)議的跟多內容可以參考下面鏈接：https://developers.google.com/protocol-buffers/docs/proto3
syntax = "proto3";
package echo;
message EchoReq {
string msg = 1;
}
message EchoRes {
string msg = 1;
}
service Echo {
rpc echo (EchoReq) returns (EchoRes);
}
執(zhí)行如下命令會自動生成 echo.pb.go 文件，這個過程其實是把上面這個協(xié)議翻譯成 golang：
protoc --go_out=plugins=grpc:. echo.proto
實際項目中可以把這個命令放到一個 Makefile 文件中，執(zhí)行 make 命令即可生成代碼：
上面命令依賴 protoc 工具，以及 golang 插件 protoc-gen-go，可以通過如下命令獲取
Mac
brew install grpc
go get -u github.com/golang/protobuf/{proto,protoc-gen-go}
Linux
wget https://github.com/google/protobuf/releases/download/v3.2.0/protobuf-cpp-3.2.0.tar.gz
tar -xzvf protobuf-cpp-3.2.0.tar.gz
cd protobuf-3.2.0
./configure --prefix=${output}
make -j8
[sudo] make install
go get -u github.com/golang/protobuf/{proto,protoc-gen-go}
實現(xiàn)協(xié)議接口
type EchoServerImp struct {
}
func (e *EchoServerImp) Echo(ctx context.Context, req *echo.EchoReq) (*echo.EchoRes, error) {
fmt.Printf("message from client: %v\n", req.GetMsg())
res := &echo.EchoRes{
Msg: req.GetMsg(),
}
return res, nil
}
首先要定義一個接口的實現(xiàn)類 EchoServerImp，接口的的定義可以在上面生成的文件 echo.pb.go 中找到，這個類里面也可以有一些和業(yè)務邏輯相關的成員變量，這里我們的需求比較簡單，沒有其他的成員
然后需要在接口函數里面實現(xiàn)我們具體的業(yè)務邏輯，這里僅僅把請求里面的內容讀出來，再寫回到響應里面
你還可以為這個類增加其他的函數，比如初始化之類的，根據你具體的業(yè)務需求就好
實現(xiàn)服務端
func main() {
server := grpc.NewServer()
echo.RegisterEchoServer(server, &EchoServerImp{})
address, err := net.Listen("tcp", ":3000")
if err != nil {
panic(err)
}
if err := server.Serve(address); err != nil {
panic(err)
}
}
把我們剛剛實現(xiàn)的類實例注冊到 grpc 里，再綁定到本地的一個端口上就可以了，現(xiàn)在可以啟動服務了 go run echo_server.go
實現(xiàn)客戶端
func main() {
conn, err := grpc.Dial("127.0.0.1:3000", grpc.WithInsecure())
if err != nil {
fmt.Errorf("dial failed. err: [%v]\n", err)
return
}
client := echo.NewEchoClient(conn)
res, err := client.Echo(context.Background(), &echo.EchoReq{
Msg: strings.Join(os.Args[1:], " "),
})
if err != nil {
fmt.Errorf("client echo failed. err: [%v]", err)
return
}
fmt.Printf("message from server: %v", res.GetMsg())
}
創(chuàng)建一個 client 之后，就可以像訪問本地方法一樣訪問我們的服務了，go run echo_client.go hellogrpc
流式 rpc 服務
實現(xiàn)一個 counter 服務，客戶端傳過來一個數字，服務端從這個數字開始，不停地向下計數返回
定義協(xié)議文件
syntax = "proto3";
package counter;
message CountReq {
int64 start = 1;
}
message CountRes {
int64 num = 1;
}
service Counter {
rpc count (CountReq) returns (stream CountRes);
}
定義一個流式的 rpc 只需要在返回的字段前加一個 stream 關鍵字就可以
實現(xiàn)服務端
type CounterServerImp struct {
}
func (c *CounterServerImp) Count(req *counter.CountReq, stream counter.Counter_CountServer) error {
fmt.Printf("request from client. start: [%v]\n", req.GetStart())
i := req.GetStart()
for {
i++
stream.Send(&counter.CountRes{
Num: i,
})
time.Sleep(time.Duration(500) * time.Millisecond)
}
return nil
}
func main() {
server := grpc.NewServer()
counter.RegisterCounterServer(server, &CounterServerImp{})
address, err := net.Listen("tcp", ":3000")
if err != nil {
panic(err)
}
if err := server.Serve(address); err != nil {
panic(err)
}
}
接口實現(xiàn)上需要寫一個死循環(huán)，不停地調用 Send 函數返回結果即可
實現(xiàn)客戶端
func main() {
start, _ := strconv.ParseInt(os.Args[1], 10, 64)
conn, err := grpc.Dial("127.0.0.1:3000", grpc.WithInsecure())
if err != nil {
fmt.Errorf("dial failed. err: [%v]\n", err)
return
}
client := counter.NewCounterClient(conn)
stream, err := client.Count(context.Background(), &counter.CountReq{
Start: start,
})
if err != nil {
fmt.Errorf("count failed. err: [%v]\n", err)
return
}
for {
res, err := stream.Recv()
if err != nil {
fmt.Errorf("client count failed. err: [%v]", err)
return
}
fmt.Printf("server count: %v\n", res.GetNum())
}
}
客戶端的 Count 接口返回的是一個 stream，不斷地調用這個 stream 的 Recv 方法，可以不斷地獲取來自服務端的返回
參考鏈接
- grpc 官方文檔中文版: http://doc.oschina.net/grpc?t=60133
- grpc 官方示例: https://github.com/grpc/grpc-go/tree/master/examples/route_guide
- proto3 語法: https://developers.google.com/protocol-buffers/docs/proto3
轉載請注明出處
本文鏈接：http://hatlonely.github.io/2018/02/03/golang-%E7%BD%91%E7%BB%9C%E6%A1%86%E6%9E%B6%E4%B9%8B-grpc/
