gRPC入门指南之简单RPC

本文转载自微信公众号「Golang来啦」，作者Seekload 。转载本文请联系Golang来啦公众号。   

你好，我是 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

 
 
 
 
    
  
  
  
  
  1. syntax = "proto3"; 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. package proto; 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. // 定义发送请求信息 
    6. 
  
  
  
  
  6. message SimpleRequest{ 
    7. 
  
  
  
  
  7.   // 参数类型 参数名称 标识号 
    8. 
  
  
  
  
  8.   string data = 1; 
    9. 
  
  
  
  
  9. } 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. // 定义响应信息 
    12. 
  
  
  
  
  12. message SimpleResponse{ 
    13. 
  
  
  
  
  13.   int32 code = 1; 
    14. 
  
  
  
  
  14.   string value = 2; 
    15. 
  
  
  
  
  15. } 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17. // 定义我们的服务(可以定义多个服务，每个服务可以定义多个接口) 
    18. 
  
  
  
  
  18. service Simple{ 
    19. 
  
  
  
  
  19.   rpc GetSimpleInfo(SimpleRequest) returns (SimpleResponse){}; 
    20. 
  
  
  
  
  20. } 
    21.

进入 simple.proto 所在的目录，使用如下命令编译文件

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

执行完成之后会生成 simple.pb.go 文件，文件内容会在文章后半段给大家梳理，我们先把 demo 跑起来。

创建 server 端

需要在 server 端实现 GetSimpleInfo 方法。

 
 
 
 
    
  
  
  
  
  1. package main 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. import ( 
    4. 
  
  
  
  
  4.  "context" 
    5. 
  
  
  
  
  5.  pb "go-grpc-example/1-simple_rpc/proto" 
    6. 
  
  
  
  
  6.  "google.golang.org/grpc" 
    7. 
  
  
  
  
  7.  "log" 
    8. 
  
  
  
  
  8.  "net" 
    9. 
  
  
  
  
  9. ) 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. const ( 
    12. 
  
  
  
  
  12.  Address string = ":8000" 
    13. 
  
  
  
  
  13.  Network string = "tcp" 
    14. 
  
  
  
  
  14. ) 
    15. 
  
  
  
  
  15.  
    16. 
  
  
  
  
  16. // 定义我们的服务 
    17. 
  
  
  
  
  17. type SimpleService struct{} 
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19. // 实现 GetSimpleInfo 方法 
    20. 
  
  
  
  
  20. func (s *SimpleService) GetSimpleInfo(ctx context.Context, req *pb.SimpleRequest) (*pb.SimpleResponse, error) { 
    21. 
  
  
  
  
  21.  data := req.Data 
    22. 
  
  
  
  
  22.  log.Println("get from client: ", data) 
    23. 
  
  
  
  
  23.  resp := &pb.SimpleResponse{ 
    24. 
  
  
  
  
  24.   Code:  8888, 
    25. 
  
  
  
  
  25.   Value: "grpc", 
    26. 
  
  
  
  
  26.  } 
    27. 
  
  
  
  
  27.  return resp, nil 
    28. 
  
  
  
  
  28. } 
    29. 
  
  
  
  
  29.  
    30. 
  
  
  
  
  30. func main() { 
    31. 
  
  
  
  
  31.  
    32. 
  
  
  
  
  32.  // 1.监听端口 
    33. 
  
  
  
  
  33.  listener, err := net.Listen(Network, Address) 
    34. 
  
  
  
  
  34.  if err != nil { 
    35. 
  
  
  
  
  35.   log.Fatalf("net.listen err: %v", err) 
    36. 
  
  
  
  
  36.  } 
    37. 
  
  
  
  
  37.  log.Println(Address, " net listening...") 
    38. 
  
  
  
  
  38.  // 2.实例化gRPC服务端 
    39. 
  
  
  
  
  39.  grpcServer := grpc.NewServer() 
    40. 
  
  
  
  
  40.  
    41. 
  
  
  
  
  41.  // 3.注册我们实现的服务 SimpleService 
    42. 
  
  
  
  
  42.  pb.RegisterSimpleServer(grpcServer, &SimpleService{}) 
    43. 
  
  
  
  
  43.  
    44. 
  
  
  
  
  44.  // 4.启动gRPC服务端 
    45. 
  
  
  
  
  45.  err = grpcServer.Serve(listener) 
    46. 
  
  
  
  
  46.  if err != nil { 
    47. 
  
  
  
  
  47.   log.Fatalf("grpc server err: %v",err) 
    48. 
  
  
  
  
  48.  } 
    49. 
  
  
  
  
  49.  
    50. 
  
  
  
  
  50. } 
    51.

服务端实现的主要流程，如上面代码注释的：1 -> 2 -> 3 -> 4。

运行服务端：

 
 
 
 
    
  
  
  
  
  1. go run server.go 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. 输出： 
    4. 
  
  
  
  
  4. :8000  net listening... 
    5.

创建 client 端

客户端可以直接调用服务端提供的服务(接口)

 
 
 
 
    
  
  
  
  
  1. package main 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. import ( 
    4. 
  
  
  
  
  4.  "context" 
    5. 
  
  
  
  
  5.  pb "go-grpc-example/1-simple_rpc/proto" 
    6. 
  
  
  
  
  6.  "google.golang.org/grpc" 
    7. 
  
  
  
  
  7.  "log" 
    8. 
  
  
  
  
  8. ) 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10. const ( 
    11. 
  
  
  
  
  11.  Address string = ":8000" 
    12. 
  
  
  
  
  12. ) 
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14. func main() { 
    15. 
  
  
  
  
  15.  // 1.创建于gRPC服务端的连接 
    16. 
  
  
  
  
  16.  conn, err := grpc.Dial(Address, grpc.WithInsecure()) 
    17. 
  
  
  
  
  17.  if err != nil { 
    18. 
  
  
  
  
  18.   log.Fatalf("dial conn err: %v", err) 
    19. 
  
  
  
  
  19.  } 
    20. 
  
  
  
  
  20.  defer conn.Close() 
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22.  // 2.创建grpc客户端 
    23. 
  
  
  
  
  23.  client := pb.NewSimpleClient(conn) 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25.  // 3.调用服务端提供的服务 
    26. 
  
  
  
  
  26.  req := pb.SimpleRequest{ 
    27. 
  
  
  
  
  27.   Data: "Hello,Server", 
    28. 
  
  
  
  
  28.  } 
    29. 
  
  
  
  
  29.  resp, err := client.GetSimpleInfo(context.Background(), &req) 
    30. 
  
  
  
  
  30.  if err != nil { 
    31. 
  
  
  
  
  31.   log.Fatalf("resp err: %v", err) 
    32. 
  
  
  
  
  32.  } 
    33. 
  
  
  
  
  33.  log.Printf("get from server,code: %v,value: %v", resp.Code, resp.Value) 
    34. 
  
  
  
  
  34.  
    35. 
  
  
  
  
  35. } 
    36.

客户端实现的流程如上面注释：1 -> 2 -> 3。

运行客户端：

 
 
 
 
    
  
  
  
  
  1. go run client.go 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. 输出： 
    4. 
  
  
  
  
  4. get from server,code: 8888,value: grpc 
    5.

成功调用了服务端提供的方法并返回数据。

simple.pb.go 文件详解

撸完最基础的 demo，现在来看下编译完的 simple.proto 文件，熟悉这里面的内容有助于我们理解 gRPC 的调用过程。

1.按照 simple.proto 定义的消息类型会生成不同的 struct。

 
 
 
 
    
  
  
  
  
  1. // 定义发送请求信息 
    2. 
  
  
  
  
  2. type SimpleRequest struct { 
    3. 
  
  
  
  
  3.  // 参数类型 参数名称 标识号 
    4. 
  
  
  
  
  4.  Data                 string   `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` 
    5. 
  
  
  
  
  5. } 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. // 定义响应信息 
    8. 
  
  
  
  
  8. type SimpleResponse struct { 
    9. 
  
  
  
  
  9.  Code                 int32    `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` 
    10. 
  
  
  
  
  10.  Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` 
    11. 
  
  
  
  
  11. } 
    12.

2.为结构体生成了不同的方法。

 
 
 
 
    
  
  
  
  
  1. func (m *SimpleRequest) Reset()         { *m = SimpleRequest{} } 
    2. 
  
  
  
  
  2. func (m *SimpleRequest) String() string { return proto.CompactTextString(m) } 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4. func (m *SimpleResponse) Reset()         { *m = SimpleResponse{} } 
    5. 
  
  
  
  
  5. func (m *SimpleResponse) String() string { return proto.CompactTextString(m) } 
    6. 
  
  
  
  
  6. func (m *SimpleResponse) GetCode() int32 { 
    7. 
  
  
  
  
  7.  if m != nil { 
    8. 
  
  
  
  
  8.   return m.Code 
    9. 
  
  
  
  
  9.  } 
    10. 
  
  
  
  
  10.  return 0 
    11. 
  
  
  
  
  11. } 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13. func (m *SimpleResponse) GetValue() string { 
    14. 
  
  
  
  
  14.  if m != nil { 
    15. 
  
  
  
  
  15.   return m.Value 
    16. 
  
  
  
  
  16.  } 
    17. 
  
  
  
  
  17.  return "" 
    18. 
  
  
  
  
  18. } 
    19.

3.生成了服务端和客户端的接口定义，如下：

 
 
 
 
    
  
  
  
  
  1. // 客户端 
    2. 
  
  
  
  
  2. type SimpleClient interface { 
    3. 
  
  
  
  
  3.  GetSimpleInfo(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) 
    4. 
  
  
  
  
  4. } 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. // 服务端 
    7. 
  
  
  
  
  7. type SimpleServer interface { 
    8. 
  
  
  
  
  8.  GetSimpleInfo(context.Context, *SimpleRequest) (*SimpleResponse, error) 
    9. 
  
  
  
  
  9. } 
    10.

通信双方都必须实现接口里面定义的方法，仔细的同学可以发现，客户端的方法 GetSimpleInfo() 实际上已经自动生成了，客户端只需要调用即可。

 
 
 
 
    
  
  
  
  
  1. func (c *simpleClient) GetSimpleInfo(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) { 
    2. 
  
  
  
  
  2.  out := new(SimpleResponse) 
    3. 
  
  
  
  
  3.  err := c.cc.Invoke(ctx, "/proto.Simple/GetSimpleInfo", in, out, opts...) 
    4. 
  
  
  
  
  4.  if err != nil { 
    5. 
  
  
  
  
  5.   return nil, err 
    6. 
  
  
  
  
  6.  } 
    7. 
  
  
  
  
  7.  return out, nil 
    8. 
  
  
  
  
  8. } 
    9.

但是服务端的方法需要自己实现，毕竟是服务提供方，服务的具体逻辑是由我们自己来定的。

4.最后还有一个注册服务的函数，我们需要做的就是，自己去定义一个 struct 对象，实现上面提到的 SimpleServer 接口，然后把那个 struct 注册到 gRPC 服务上。

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

总结

这篇文章主要介绍了 gRPC 第一种交互模式 - Simple RPC，演示了最基础的 demo，大家重点需要掌握以下两点：

服务端和客户端的实现流程;

simple.pb.go 的内容;

文章题目：gRPC入门指南之简单RPC
文章路径：http://www.csdahua.cn/qtweb/news9/338009.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

品牌网站建设知识

行业网站建设

德阳东方电机技改　　 　温江网站制作　　 　雕琢时光食品　　 　重庆网站建设网络公司　　 　眉山电信机房　　 　眉山联通机房　　 　网络口碑营销　　 　乐山网站建设　　 　双流网站建设　　 　成都服务器托管　　 　添翼二手车鉴定评估　　 　买友情链接　　 　专业网站建设　　 　网上商城开发　　 　成都网站推广　　 　四川成都网站设计　　 　开元建筑　　 　专业网站设计　　 　网站建设开发　　 　绵阳服务器托管