gRPC使用简介

待我称王封你为后i 2022-09-03 09:27 264阅读 0赞

**本文是公众号读者上山打老虎的原创投稿。本文讲解了什么是RPC，什么是gRPC，以情侣状态模拟客户端与服务器，生动有趣地诠释了RPC的不同调用方式，最后通过代码Demo实现情侣之间的gRPC交互日常。**

**非常感谢上山打老虎的投稿。如果其他读者朋友们也想分享一些在Go学习中的心得笔记，欢迎来稿！**

**RPC**

对RPC不了解的人，或许会纠结其与TCP、HTTP等的关系。后者是网络传输中的协议，而RPC是一种设计、实现框架，通讯协议只是其中一部分，RPC不仅要解决协议通讯的问题，还有序列化与反序列化，以及消息通知。

一个完整的RPC架构里面包含了四个核心的组件，分别是Client,Server,ClientOptions以及ServerOptions，这个Options就是RPC需要设计实现的东西。

*  客户端（Client）：服务的调用方。
 *  服务端（Server）：真正的服务提供方。
 *  客户端存根（ClientOption）：socket管理，网络收发包的序列化。
 *  服务端存根（ServerOption）：socket管理，提醒server层rpc方法调用，以及网络收发包的序列化。

RPC的逻辑示意图如下

![0279acf144d36b5340f6ff0f066d1aba.png][]

**什么是gRPC**

gRPC是RPC的一种，它使用Protocol Buffer(简称Protobuf)作为序列化格式，Protocol Buffer是来自google的序列化框架，比Json更加轻便高效，同时基于 HTTP/2 标准设计，**带来诸如双向流、流控、头部压缩、单 TCP 连接上的多复用请求**等特性。这些特性使得其在移动设备上表现更好，更省电和节省空间占用。用protoc就能使用proto文件帮助我们生成上面的option层代码。

在gRPC中，客户端应用程序可以直接在另一台计算机上的服务器应用程序上调用方法，就好像它是本地对象一样，从而使您更轻松地创建分布式应用程序和服务。

gRPC的调用模型如下

![41770666d23716451a4a57e740b5296b.png][]

**适用场景**

*  分布式场景 ：gRPC设计为低延迟和高吞吐量通信，非常适用于效率至关重要的轻型微服务。
 *  点对点实时通信：gRPC对双向流媒体提供出色的支持，可以实时推送消息而无需轮询。
 *  多语言混合开发 ：支持主流的开发语言，使gRPC成为多语言开发环境的理想选择。
 *  网络受限环境 ：使用Protobuf（一种轻量级消息格式）序列化gRPC消息。gRPC消息始终小于等效的JSON消息。

**四种调用方式**

学习gRPC使用之前，先介绍一下RPC中客户端与服务端的关系。在RPC中，服务端会开启服务供客户端调用，每一句RPC调用都是一次客户端发请求到服务器获得响应的过程，中间过程被封装了，看起来像本地的一次调用一样，一次RPC调用也就是一次通讯过程。

RPC调用通常根据双端是否流式交互，分为了单项RPC、服务端流式RPC、客户端流式RPC、双向流PRC四种方式。为了便于大家理解四种grpc调用的应用场景，这里举一个例子，假设你是小超，有一个女朋友叫婷婷，婷婷的每种情绪代表一个微服务，你们之间的每一次对话可以理解为一次PRC调用，为了便于画流程图，RPC请求被封装成`client.SayHello`，请求包为`HelloRequest`，响应为`HelloReply`。

##### 1. 单项 RPC #####

当你在等婷婷回去吃饭，婷婷在加班时，你们之间的rpc调用可能是这样的：

小超：回来吃饭吗

婷婷：还在加班

这就是单项 RPC，即客户端发送一个请求给服务端，从服务端获取一个应答，就像一次普通的函数调用。

![e31c2e0da7e7a6af3447793c579f9b74.png][]

*  client层调用`SayHello`接口，把`HelloRequest`包进行序列化
 *  client option将序列化的数据发送到server端
 *  server option接收到rpc请求
 *  将rpc请求返回给server端，server端进行处理，将结果给server option
 *  server option将`HelloReply`进行序列化并发给client
 *  client option做反序列化处理，并返回给client层

##### 2. 服务端流式 RPC #####

当你比赛输了给婷婷发消息时：

小超：今天比赛输了

婷婷：没事，一次比赛而已

婷婷：晚上带你去吃好吃的

这就是服务端流式 RPC，即客户端发送一个请求给服务端，可获取一个数据流用来读取一系列消息。客户端从返回的数据流里一直读取直到没有更多消息为止。

![4bd8864da976b2dd493b6cbc0d8a43e3.png][]

*  client层调用`SayHello`接口，把`HelloRequest`包进行序列化
 *  client option将序列化的数据发送到server端
 *  server option接收到rpc请求
 *  将rpc请求返回给server端，server端进行处理，将将数据流给server option
 *  server option将`HelloReply`进行序列化并发给client
 *  client option做反序列化处理，并返回给client层

##### 3. 客户端流式 RPC #####

当你惹婷婷生气的时候：

小超：怎么了，宝贝

小超：别生气了，带你吃好吃的

婷婷：滚

客户端流式 RPC，即客户端用提供的一个数据流写入并发送一系列消息给服务端。一旦客户端完成消息写入，就等待服务端读取这些消息并返回应答。

![28211d7c7ea4ab27a1eae37b241b0eb5.png][]

*  client层调用`SayHello`接口，把`HelloRequest`包进行序列化
 *  client option将序列化的数据流发送到server端
 *  server option接收到rpc请求
 *  将rpc请求返回给server端，server端进行处理，将结果给server option
 *  server option将`HelloReply`进行序列化并发给client
 *  client option做反序列化处理，并返回给client层

##### 4. 双向流 RPC #####

当你哄好婷婷时：

小超：今天看了一个超好看的视频

婷婷：什么视频

小超：发给你看看

婷婷：这也叫好看？

双向流 RPC，即两边都可以分别通过一个读写数据流来发送一系列消息。这两个数据流操作是相互独立的，所以客户端和服务端能按其希望的任意顺序读写，例如：服务端可以在写应答前等待所有的客户端消息，或者它可以先读一个消息再写一个消息，或者是读写相结合的其他方式。每个数据流里消息的顺序会被保持。

![d319bf311e3c021b74a04583ea08f08f.png][]

这幅图就不做流程介绍了，读者可以自己试着看图能不能理解过程，相信理解了客户端流RPC和服务端流RPC俩种方式，这里一定可以理解的。

**代码实现**

gRPC 使用 Protobuf 作为序列化格式，Protobuf 比 Json 更加轻便高效。与 Json一样，它与开发语言和平台无关，具有良好的可扩展性。关于Protobuf 使用请参考官网地址 https://developers.google.com/protocol-buffers 。

下面我们实现Go语言版的四种gRPC调用方式。

##### 1. 单向RPC实现 #####

###### 编写proto ######

1//proto3标准
     2syntax = "proto3";
     3
     4//包名
     5package helloworld;
     6
     7//定义rpc接口
     8service Greets {
     9  rpc SayHello (HelloRequest) returns (HelloReply) {}
    10}
    11
    12//HelloReply协议内容
    13message HelloReply {
    14  string name = 1;
    15  string message = 2;
    16}
    17
    18//HelloRequest协议
    19message HelloRequest {
    20  string name = 1;
    21  string message = 2;
    22}

1.  `Greet`为定义rpc服务的类名，`rpc SayHello (HelloRequest) returns (HelloReply) {}`表示定义rpc方法`SayHello`，传入`HelloRequest`，返回`HelloReply`
2.  进入proto文件夹，运行命令`protoc -I . --go_out=plugins=grpc:. ./helloworld.proto`在.目录中生成helloworld.pb.go文件

###### 编写server ######

1type Server struct {
     2}
     3
     4//实现SayHello接口
     5func (s *Server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
     6    log.Println(in.Name, in.Message)
     7    return &pb.HelloReply{Name: "婷婷", Message: "不回来了"}, nil
     8}
     9
    10func main() {
    11    //协议类型以及ip，port
    12    lis, err := net.Listen("tcp", ":8002")
    13    if err != nil {
    14        fmt.Println(err)
    15        return
    16    }
    17
    18    //定义一个rpc的server
    19    server := grpc.NewServer()
    20    //注册服务，相当与注册SayHello接口
    21    pb.RegisterGreetsServer(server, &Server{})
    22    //进行映射绑定
    23    reflection.Register(server)
    24
    25    //启动服务
    26    err = server.Serve(lis)
    27    if err != nil {
    28        fmt.Println(err)
    29        return
    30    }
    31}

1.  pb为proto文件生成的文件别名
2.  定义server结构体作为rpc调用的结构体，这个结构体必须实现`SayHello`这个接口
3.  `listen` \-> `grpc.NewServer()` \-> `pb.RegisterGreetsServer(server, &Server{})` \-> `s.Serve(lis)`

###### 编写client ######

1func main() {
     2    //创建一个grpc连接
     3    conn, err := grpc.Dial("localhost:8002", grpc.WithInsecure())
     4    if err != nil {
     5        fmt.Println(err)
     6        return
     7    }
     8    defer conn.Close()
     9
    10    //创建RPC客户端
    11    client := pb.NewGreetsClient(conn)
    12    //设置超时时间
    13    _, cancel := context.WithTimeout(context.Background(), time.Second)
    14    defer cancel()
    15
    16    // 调用方法
    17    reply, err := client.SayHello(context.Background(), &pb.HelloRequest{Name: "小超", Message: "回来吃饭吗"})
    18    if err != nil {
    19        log.Fatalf("couldn not greet: %v", err)
    20    }
    21    log.Println(reply.Name, reply.Message)
    22}

1.  `grpc.Dial("localhost:8002", grpc.WithInsecure())`连接到服务器，`grpc.WithInsecure()`取消明文检测
2.  `context.WithTimeout(context.Background(), time.Second)`设置超时时间
3.  `c := pb.NewGreetsClient(conn)`创建rpc调用的客户端
4.  `c.SayHello(context.Background(), &pb.HelloRequest{Name: name})`进行rpc调用

###### 抽象接口 ######

其实也就是要实现这个接口，因为俩边都是单项调用，所以调用和实现的接口都是这个

1type GreetsClient interface {
    2   SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error)
    3}

#####     #####

##### 2. 服务端流RPC #####

###### 编写proto ######

1//proto3标准
     2syntax = "proto3";
     3
     4//包名
     5package helloworld;
     6
     7//定义rpc接口
     8
     9service Greet{
    10  rpc SayHello (HelloRequest) returns(stream HelloReply) {}
    11}
    12
    13//HelloReply协议内容
    14message HelloReply {
    15  string name = 1;
    16  string message = 2;
    17}
    18
    19//HelloRequest协议
    20message HelloRequest {
    21  string name = 1;
    22  string message = 2;
    23}

相比于单项RPC调用，因为是客户端流，所以在`HelloRequest`多了一个stream

###### 编写server ######

1type Server struct {
     2}
     3
     4//实现rpc接口
     5func (*Server) SayHello(request *pb.HelloRequest, server pb.Greet_SayHelloServer) error {
     6    fmt.Println(request)
     7    var err error
     8    for i := 0; i < 2; i++ {
     9        if i == 0 {
    10            err = server.Send(&pb.HelloReply{Name: "小超", Message: "没事，一次比赛而已"})
    11        } else {
    12            err = server.Send(&pb.HelloReply{Name: "小超", Message: "晚上带你去吃好吃的"})
    13        }
    14        if err != nil {
    15            fmt.Println(err)
    16            return err
    17        }
    18    }
    19    return nil
    20}
    21
    22func main() {
    23    //协议类型以及ip，port
    24    listen, err := net.Listen("tcp", ":8002")
    25    if err != nil {
    26        fmt.Println(err)
    27        return
    28    }
    29
    30    //定义一个rpc的server
    31    s := grpc.NewServer()
    32    //注册服务，相当与注册SayHello接口
    33    pb.RegisterGreetServer(s, &Server{})
    34    //进行映射绑定
    35    reflection.Register(s)
    36
    37    //启动服务
    38    err = s.Serve(listen)
    39    if err != nil {
    40        fmt.Println(err)
    41    }
    42}

###### 编写client ######

client发送的是一个流，与单项RPC方式不同，他通过rpc调用获得的是一个流传输对象`greetClient`，可以用流传输对象不停的往对端发送数据

###### 抽象接口 ######

服务器要实现的接口

1// GreetsServer is the server API for Greets service.
    2type GreetsServer interface {
    3   SayHello(Greets_SayHelloServer) error
    4}

客户端调用的接口

1type GreetsClient interface {
    2   SayHello(ctx context.Context, opts ...grpc.CallOption) (Greets_SayHelloClient, error)
    3}

#####     #####

##### 3. 服务端流RPC #####

###### 编写proto ######

1//proto3标准
     2syntax = "proto3";
     3
     4//包名
     5package helloworld;
     6
     7//定义rpc接口
     8service Greets{
     9  rpc SayHello (stream HelloRequest) returns (HelloReply) {}
    10}
    11
    12//HelloReply协议内容
    13message HelloReply {
    14  string name = 1;
    15  string message = 2;
    16}
    17
    18//HelloRequest协议
    19message HelloRequest {
    20  string name = 1;
    21  string message = 2;
    22}

###### 编写服务器 ######

1type Server struct{}
     2
     3//实现rpc方法，直到对端调用CloseAndRecv就会读到EOF
     4func (*Server) SayHello(in pb.Greets_SayHelloServer) error {
     5    for {
     6        recv, err := in.Recv()
     7        //接收完数据之后发送响应
     8        if err == io.EOF {
     9            err := in.SendAndClose(&pb.HelloReply{Name: "婷婷", Message: "滚"})
    10            if err != nil {
    11                return err
    12            }
    13            return nil
    14        } else if err != nil {
    15            return err
    16        }
    17        fmt.Println(recv)
    18    }
    19}
    20
    21func main() {
    22    //绑定协议，ip以及端口
    23    lis, err := net.Listen("tcp", ":8002")
    24    if err != nil {
    25        fmt.Println("failed to listen: %v", err)
    26        return
    27    }
    28
    29    //创建一个grpc服务对象
    30    server := grpc.NewServer()
    31    //注册rpc服务
    32    pb.RegisterGreetsServer(server, &Server{})
    33    //注册服务端反射
    34    reflection.Register(server)
    35
    36    //启动服务器
    37    err = server.Serve(lis)
    38    if err != nil {
    39        fmt.Println(err)
    40        return
    41    }
    42}

###### 编写客户端 ######

1func main() {
     2    //创建一个grpc的连接
     3    grpcConn, err := grpc.Dial("127.0.0.1"+":8002", grpc.WithInsecure())
     4    if err != nil {
     5        fmt.Println(err)
     6        return
     7    }
     8
     9    //创建grpc的client
    10    client := pb.NewGreetsClient(grpcConn)
    11
    12    //设置超时时间
    13    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    14    defer cancel()
    15
    16    //调用rpc方法，得到一个客户端用于循环发送数据
    17    greetClient, err := client.SayHello(ctx)
    18
    19    if err != nil {
    20        fmt.Println("sayHello error")
    21        fmt.Println(err)
    22        return
    23    }
    24
    25    maxCount := 2
    26    curCount := 0
    27
    28    //循环发送
    29    //调了CloseAndRecv()服务端就会读到EOF，server端可根据是否读到EOF来判断客户端是否将数据发完
    30    for {
    31        if curCount == 0 {
    32            err = greetClient.Send(&pb.HelloRequest{Name: "小超", Message: "怎么了，宝贝"})
    33        } else {
    34            err = greetClient.Send(&pb.HelloRequest{Name: "小超", Message: "别生气了，带你吃好吃的"})
    35        }
    36
    37        if err != nil {
    38            fmt.Println("send error")
    39            fmt.Println(err)
    40            return
    41        }
    42        curCount += 1
    43        if curCount >= maxCount {
    44            res, err := greetClient.CloseAndRecv()
    45            if err != nil {
    46                fmt.Println(err)
    47                break
    48            }
    49            fmt.Println(res)
    50            break
    51        }
    52    }
    53}

###### 抽象接口 ######

客户端接口

1type GreetsClient interface {
    2   SayHello(ctx context.Context, opts ...grpc.CallOption) (Greets_SayHelloClient, error)
    3}

服务器接口

1type GreetsServer interface {
    2   SayHello(Greets_SayHelloServer) error
    3}

#####     #####

##### 4. 双向流RPC #####

双向流RPC就交给读者自己练习吧，相信理解了单项RPC，客户端流RPC，服务端流RPC三种传输方式，写出双向流RPC应该没任何问题。

**实现总结**

其实弄懂了单项RPC、服务端流式RPC、客户端流式RPC、双向流PRC四种gRPC应用场景，实现起来将非常容易。

1.  根据应用场景选择好哪种gRPC服务
2.  写好proto文件，用protoc生成.pb.go文件
3.  服务端实现接口->`listen` \-> `grpc.NewServer()` \-> `pb.RegisterGreetsServer(server, &Server{})` \-> `s.Serve(lis)`
4.  客户端`grpc.Dial`\->`pb.NewGreetsClient`\->`context.WithTimeout`\->`client.SayHello`(调用接口)->如果是流传输则循环读取数据

**往期推荐**

*  [一个容易让gopher理解不当的小细节][gopher]
 *  [append扩容机制][append]
 *  [同步原语的基石][Link 1]  
    
 *  [详解内联优化][Link 2]
 *  [详解逃逸分析][Link 3]  
    
 *  [CPU缓存体系对Go程序的影响][CPU_Go]
 *  [Go精妙的互斥锁设计][Go]

![581fd48eaa81e79f0b5de0152fb5529a.png][]

**机器铃砍菜刀**

欢迎添加小菜刀微信

加入Golang分享群学习交流！

感谢你的**点赞**和**在看**哦~

![8f8c9587798d847e6a7e2584952ba3b8.gif][]

[0279acf144d36b5340f6ff0f066d1aba.png]: /images/20220829/8bff2f89794e410a86f5dc203276a7ce.png
[41770666d23716451a4a57e740b5296b.png]: /images/20220829/36ef0e77bf364bd78f6b2224f1ce572c.png
[e31c2e0da7e7a6af3447793c579f9b74.png]: /images/20220829/e60086bda7134976a9284ed65124bc25.png
[4bd8864da976b2dd493b6cbc0d8a43e3.png]: /images/20220829/c6db95d1cc1049e6bc47bc7d0ad0c640.png
[28211d7c7ea4ab27a1eae37b241b0eb5.png]: /images/20220829/2353f980fa3a4711932a2cf374dacdcf.png
[d319bf311e3c021b74a04583ea08f08f.png]: /images/20220829/d9e5f58a8d0f45819b44d24e0d303cf5.png
[gopher]: http://mp.weixin.qq.com/s?__biz=MzIwNTA4MDAwMQ%3D%3D&chksm=9737118fa040989916f5b5e26f8328202a3d23ee309e403c9830d7784011bf3d37f734044180&idx=1&mid=2247484705&scene=21&sn=b00255892cc47ffe57c519fd60898f9a#wechat_redirect
[append]: http://mp.weixin.qq.com/s?__biz=MzIwNTA4MDAwMQ%3D%3D&chksm=973711b8a04098ae61da7527262a5dc938822799f8b6fd8235409b328987b5dd14d4d6ca30fc&idx=1&mid=2247484694&scene=21&sn=60be587613cbb3e431f193f7367c4776#wechat_redirect
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzIwNTA4MDAwMQ%3D%3D&chksm=97371030a04099263dfbf16dc24438f409166a053fd9fef802f9f9e4f8fd3c4aba9dd97df8f8&idx=1&mid=2247484574&scene=21&sn=5bbe2668e64455f428c70f00c09f28a2#wechat_redirect
[Link 2]: http://mp.weixin.qq.com/s?__biz=MzIwNTA4MDAwMQ%3D%3D&chksm=97371028a040993e374c998dc7eac23f92b30fcf443352daa860cec21b577fa95240a5dc44ee&idx=1&mid=2247484550&scene=21&sn=023890f77dddfd7d1262d76fb62c13c0#wechat_redirect
[Link 3]: http://mp.weixin.qq.com/s?__biz=MzIwNTA4MDAwMQ%3D%3D&chksm=973710d5a04099c3c2dde737eb9de31eddb9d3707ea5885abed6a06fa7fc9855fad7de8561f7&idx=1&mid=2247484539&scene=21&sn=be23b39e21067e3017f15afb36271570#wechat_redirect
[CPU_Go]: http://mp.weixin.qq.com/s?__biz=MzIwNTA4MDAwMQ%3D%3D&chksm=973710e8a04099fe6f113c38a9e9940c0ff590877ad7ba0a0f4c383356e91619574f052a6064&idx=1&mid=2247484486&scene=21&sn=83ebd97be71caad3537502e459182f88#wechat_redirect
[Go]: http://mp.weixin.qq.com/s?__biz=MzIwNTA4MDAwMQ%3D%3D&chksm=9737106ba040997d4bdd3aa077186d89568b0019b4b83164dc59b9b2e8c4a408e4496aa93d1a&idx=1&mid=2247484613&scene=21&sn=d79c33be877e8124d050ed3669b26e24#wechat_redirect
[581fd48eaa81e79f0b5de0152fb5529a.png]: /images/20220829/4bfc7a03013343b3b20475fc8c4e7017.png
[8f8c9587798d847e6a7e2584952ba3b8.gif]: /images/20220829/0b3bfcc2052d4c09800dbcc2f096c0ee.png