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

 
 
 
 
  
  
  
  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 的调用过程。

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

 
 
 
 
  
  
  
  // 定义发送请求信息 
  
  
  
  type SimpleRequest struct { 
  
  
  
   // 参数类型 参数名称 标识号 
  
  
  
   Data                 string   `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` 
  
  
  
  } 
  
  
  
   
  
  
  
  // 定义响应信息 
  
  
  
  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.为结构体生成了不同的方法。

 
 
 
 
  
  
  
  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.生成了服务端和客户端的接口定义，如下：

 
 
 
 
  
  
  
  // 客户端 
  
  
  
  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 
  
  
  
  }

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

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

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

总结

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

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

simple.pb.go 的内容;

本文题目：gRPC入门指南之简单RPC
网站路径：http://www.hnjierui.cn/article/dhehdpd.html

网站建设资讯