Golang语言gRPC怎么使用?

01介绍

在之前的两篇文章中,我们已经介绍了使用 gRPC 创建 RPC 应用的前导知识。我们了解到 gRPC 支持多语言,本文我们介绍在 Golang 语言中怎么使用 gRPC。

目前创新互联已为上1000+的企业提供了网站建设、域名、网站空间、网站托管、服务器租用、企业网站设计、兴山网站维护等服务,公司将坚持客户导向、应用为本的策略,正道将秉承"和谐、参与、激情"的文化,与客户和合作伙伴齐心协力一起成长,共同发展。

02准备工作

既然我们要介绍 gRPC 怎么在 Golang 语言中使用,那么我们必须搭建 Golang 开发环境。这部分内容比较简单,本文就不再赘述了,如果有读者朋友对这块内容不清楚,建议阅读 Golang 官网文档。

此外,我们还需要安装接口设计语言 Protocol buffer 的编译器 protoc,我们在之前的文章「Protobuf - 更小、更快、更简单的交互式数据语言」中也已经介绍过 protoc 的安装方法,本文就不再赘述了,如果有需要了解的读者朋友,可以翻阅一下这篇文章。

最后,我们介绍一下 protoc 编译生成 pb 文件需要使用的插件 protoc-gen-go 和 protoc-gen-go-grpc。插件安装方式,具体如下:

执行 go install 命令安装插件

 
 
 
  1. go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.26
  2.  go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.1

修改 PATH

 
 
 
  1. $ export PATH="$PATH:$(go env GOPATH)/bin"

完成以上两步之后,我们就可以使用 protoc 编译 .proto 文件,生成 pb 文件了。

03编写 .proto 文件和生成 pb 文件

在 Golang 语言中使用 gRPC,首先编写 .proto 文件,然后使用 protoc 编译 .proto 文件生成 pb 文件,最后编写剩余的 Golang 代码。

接口设计语言 protobuf,在之前的文章 「Golang 语言 gRPC 使用的接口设计语言 protobuf」 中也已经介绍过了,本文不再赘述,如果有需要了解的读者朋友,可以翻阅一下这篇文章。

示例代码:

编写 .proto 文件。

 
 
 
  1. syntax = "proto3";
  2. option go_package = "advanced_go/lesson06/proto/greeter";
  3. service Greeter {
  4.   rpc SayHello (HelloRequest) returns (HelloReply) {}
  5. }
  6. message HelloRequest {
  7.   string name = 1;
  8. }
  9. message HelloReply {
  10.   string message = 1;
  11. }

使用 protoc 编译 .proto 文件,生成 pb 文件。

 
 
 
  1. $ protoc --go_out=. --go_opt=paths=source_relative \
  2. --go-grpc_out=. --go-grpc_opt=paths=source_relative \
  3. proto/helloworld.proto

04编写服务端和客户端 Golang 代码

我们在之前的文章中介绍过 gRPC 是什么,接下来,我们通过示例代码介绍在 Golang 语言中怎么使用 gRPC,本文先来介绍使用 gRPC 的编码流程,限于篇幅,关于 gRPC 的更多使用方法,后续会新开篇文章介绍。

首先使用接口设计语言 protobuf 的编译器 protoc、protoc-gen-go 和 protoc-gen-go-grpc 插件生成 pb 文件,我们通过查看生成的 pb 文件,可以看到 protoc 为我们自动生成结构体、接口和方法等 Golang 代码。

接下来,我们只需把剩余的 Golang 代码写完就可以了,具体实现如下:

服务端示例代码:

 
 
 
  1. const (
  2.  port = ":50051"
  3. )
  4. type server struct {
  5.  pb.UnimplementedGreeterServer
  6. }
  7. func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
  8.  log.Printf("Received: %v", in.GetName())
  9.  return &pb.HelloReply{Message: "Hello " + in.GetName()}, nil
  10. }
  11. func main () {
  12.  lis, err := net.Listen("tcp", port)
  13.  if err != nil {
  14.   log.Fatalf("failed to listen: %v", err)
  15.  }
  16.  s := grpc.NewServer()
  17.  pb.RegisterGreeterServer(s, &server{})
  18.  log.Printf("server listening at %v", lis.Addr())
  19.  if err := s.Serve(lis); err != nil {
  20.   log.Fatalf("failed to serve: %v", err)
  21.  }
  22. }

阅读上面这段代码,我们使用 Golang 语言编写了 SayHello 方法,该方法实际上就是 pb 文件中自动生成的 SayHello 方法的具体实现,对应自动生成的 pb 文件 helloworld_grpc.pb.go 中的代码如下:

 
 
 
  1. // UnimplementedGreeterServer must be embedded to have forward compatible implementations.
  2. type UnimplementedGreeterServer struct {
  3. }
  4. func (UnimplementedGreeterServer) SayHello(context.Context, *HelloRequest) (*HelloReply, error) {
  5.  return nil, status.Errorf(codes.Unimplemented, "method SayHello not implemented")
  6. }

在 main 函数中,我们使用 grpc 调用 NewServer 函数创建一个服务,然后使用 pb 文件中的 RegisterGreeterServer 函数注册服务,对应自动生成的 pb 文件 helloworld_grpc.pb.go 中的代码如下:

 
 
 
  1. func RegisterGreeterServer(s grpc.ServiceRegistrar, srv GreeterServer) {
  2.  s.RegisterService(&Greeter_ServiceDesc, srv)
  3. }

客户端示例代码:

 
 
 
  1. const(
  2.  address = ":50051"
  3.  defaultName = "word"
  4. )
  5. func main () {
  6.  conn, err := grpc.Dial(address, grpc.WithInsecure(), grpc.WithBlock())
  7.  if err != nil {
  8.   log.Fatalf("did not connect: %v", err)
  9.  }
  10.  defer conn.Close()
  11.  c := pb.NewGreeterClient(conn)
  12.  name := defaultName
  13.  if len(os.Args) > 1 {
  14.   name = os.Args[1]
  15.  }
  16.  ctx, cancel := context.WithTimeout(context.Background(), time.Second)
  17.  defer cancel()
  18.  r, err := c.SayHello(ctx, &pb.HelloRequest{Name: name})
  19.  if err != nil {
  20.   log.Fatalf("could not greet: %v", err)
  21.  }
  22.  log.Printf("Greeting: %s", r.GetMessage())
  23. }

阅读上面这段代码,我们使用 pb 文件中的 NewGreeterClient 方法创建一个客户端,然后就可以使用创建的客户端直接调用服务端的 SayHello 方法,对应自动生成的 pb 文件 helloworld_grpc.pb.go 中的代码如下:

 
 
 
  1. type GreeterClient interface {
  2.  SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error)
  3. }
  4. type greeterClient struct {
  5.  cc grpc.ClientConnInterface
  6. }
  7. func NewGreeterClient(cc grpc.ClientConnInterface) GreeterClient {
  8.  return &greeterClient{cc}
  9. }
  10. func (c *greeterClient) SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error) {
  11.  out := new(HelloReply)
  12.  err := c.cc.Invoke(ctx, "/Greeter/SayHello", in, out, opts...)
  13.  if err != nil {
  14.   return nil, err
  15.  }
  16.  return out, nil
  17. }

编写完服务端和客户端代码,接下来,我们分别启动服务端和客户端,执行结果如下:

 
 
 
  1. go run grpc_server/main.go 
  2. 2021/09/11 23:02:59 server listening at [::]:50051
  3. 2021/09/11 23:03:23 Received: word
  4. 2021/09/11 23:03:31 Received: frank
  5. go run grpc_client/main.go 
  6. 2021/09/11 23:03:23 Greeting: Hello word
  7. go run grpc_client/main.go frank
  8. 2021/09/11 23:03:31 Greeting: Hello frank

05总结

本文我们介绍在 Golang 语言中怎么使用 gRPC,为了方便读者朋友们理解,文章通过一个简单示例从零到一的实现,介绍了在 Golang 语言中使用 gRPC 的编码流程。

建议读者朋友们阅读完本文,动手敲一遍示例代码,来进一步加深理解。限于篇幅,关于 gRPC 的更多使用方法,我们后续撰文介绍。

编码流程归纳如下:

  1. 搭建 Golang 开发环境。
  2. 安装 protobuf 编译器 protoc 和插件 protoc-gen-go、protoc-gen-go-grpc,设置环境变量。
  3. 初始化项目 go mod init。
  4. 编写 protobuf,生成 pb 文件,执行 go mod tidy 整理依赖包。
  5. 编写剩余 Golang 代码。

本文名称:Golang语言gRPC怎么使用?
路径分享:http://www.shufengxianlan.com/qtweb/news41/217141.html

网站建设、网络推广公司-创新互联,是专注品牌与效果的网站制作,网络营销seo公司;服务项目有等

广告

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