gRPC-Go基础（3）基础gRPC服务

最新推荐文章于 2024-11-06 22:02:44 发布
最新推荐文章于 2024-11-06 22:02:44 发布
阅读量1.4k 收藏 9
点赞数 47
文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jzpfbpx/article/details/141688012
版权

文章目录

1. 服务定义

前面说过，proto中定义消息结构体的关键字是message，同样，定义服务的关键字是service。

service Route {
  // ...
}

1.1 一元RPC

一元RPC（Unary RPC）的客户端就像调用本地函数一样地向服务端发送请求，并且等待服务端的返回。

message SimpleRequest {
  string data = 1;
}

message SimpleResponse {
  int32 code = 1;
  string data = 2;
}

service Route {
  rpc SimpleRoute(SimpleRequest) returns (SimpleResponse);
}

1.2 服务端流式RPC

客户端发送请求到服务器，拿到一个流去读取返回的消息序列。 客户端读取返回的流，直到里面没有任何消息，比如数据下载的场景。

message SimpleRequest {
  string data = 1;
}

message StreamResponse{
  string stream_value = 1;
}

service Route {
  rpc ListValue(SimpleRequest) returns (stream StreamResponse){};
}

1.3 客户端流式RPC

相反，客户端会不断地向服务器发送数据流，比如客户端进行数据上传的场景。

message SimpleResponse {
  int32 code = 1;
  string data = 2;
}

message StreamRequest{
  string stream_data = 1;
}

service Route {
  rpc RouteList(stream StreamRequest) returns (SimpleResponse){};
}

1.4 双向流式RPC

客户端和服务端同时使用读写流去发送消息序列，两个流独立操作，可以同时发送和接收，比如双方会话的场景。

message StreamResponse{
  string stream_value = 1;
}

message StreamRequest{
  string stream_data = 1;
}

service Route {
  rpc DoubleSideStream(stream StreamRequest) returns (stream StreamResponse){};
}

2. 生成GRPC代码

以下指令可以生成xx.pb.go和xx_grpc.pb.go，至于protoc工具的安装和使用等，可以参照前面的教程。

protoc -I./proto \
--go_out=./genproto --go_opt paths=source_relative \
--go-grpc_out=./genproto --go-grpc_opt paths=source_relative \
./proto/*/*.proto

3. 构建逻辑代码

3.1 Server端

package main

import (
   "context"
   "log"
   "net"

   "github.com/IguoChan/proto-prj/genproto/simplepb"
   "google.golang.org/grpc"
)

func NewRouteServer() *Server {
   return &Server{}
}

type Server struct {
   simplepb.UnimplementedRouteServer
}

func (r *Server) SimpleRoute(ctx context.Context, request *simplepb.SimpleRequest) (*simplepb.SimpleResponse, error) {
   //TODO implement me
   panic("implement me")
}

func (r *Server) ListValue(request *simplepb.SimpleRequest, server simplepb.Route_ListValueServer) error {
   //TODO implement me
   panic("implement me")
}

func (r *Server) RouteList(server simplepb.Route_RouteListServer) error {
   //TODO implement me
   panic("implement me")
}

func (r *Server) DoubleSideStream(server simplepb.Route_DoubleSideStreamServer) error {
   //TODO implement me
   panic("implement me")
}

const (
   Address string = ":8080"
   Network string = "tcp"
)

func main() {
   // 监听本地端口
   listener, err := net.Listen(Network, Address)
   if err != nil {
      log.Fatalf("net.Listen err: %v", err)
   }
   log.Println(Address + " net.Listing...")

   // 新建gRPC的服务端实例
   grpcServer := grpc.NewServer()

   // 在gRPC服务器中注册我们的服务
   simplepb.RegisterRouteServer(grpcServer, NewRouteServer())

   // 起服务，阻塞等待
   err = grpcServer.Serve(listener)
   if err != nil {
      log.Fatalf("grpcServer.Serve err: %v", err)
   }
}

代码如上所示，其基本可以分为以下几个部分:

  • 在生成的xx_grpc.pb.go文件中，生成了定义的服务的RouteServer接口，我们需要一个对象来实现这个接口，就是以上的Server结构体，这个结构体需要包含Unimplemented开头的一个结构体，之后就可以选择性地实现服务接口；
  • 其次就是我们需要监听一个本地端口，用作grpc服务的端口；
  • 然后我们需要构建一个gRPC服务端的实例，并且在这个服务中注册我们的Server结构，这样后续client端的请求就可以打到Server实现的方法中；
  • 最后我们起服务等待就好了。

3.2 Client端

package main

import (
   "context"
   "io"
   "log"
   "strconv"

   "github.com/IguoChan/proto-prj/genproto/simplepb"
   "google.golang.org/grpc"
)

const (
   // Address 连接地址
   Address string = ":8080"
)

var grpcClient simplepb.RouteClient

func main() {
   // 连接服务器
   conn, err := grpc.Dial(Address, grpc.WithInsecure())
   if err != nil {
      log.Fatalf("net.Connect err: %v", err)
   }
   defer conn.Close()

   // 建立gRPC连接
   grpcClient = simplepb.NewRouteClient(conn)

   simpleRoute()      // 一元rpc
   listValue()        // 服务端流式rpc
   routeList()        // 客户端流式rpc
   doubleSideStream() // 双向流式rpc
}
...

Client端的代码如上：

  • 和Server端一样，xx_grpc.pb.go文件中同样生成了RouteClient接口，不同的是，在文件中，直接生成了这些接口的实现方法，接收器是routeClient，我们只需要调用这些方法即可，这部分，应该就是grpc文档中所言的stub；
  • 然后就是连接建立连接，并利用grpcClient去调用服务端的方法，实现远程调用。

接下来我们就具体看一下四种grpc调用方式的实现。

3.3 一元RPC

func (r *Server) SimpleRoute(ctx context.Context, request *simplepb.SimpleRequest) (*simplepb.SimpleResponse, error) {
   res := simplepb.SimpleResponse{
      Code: 200,
      Data: "hello " + request.Data + " " + time.Now().String(),
   }
   return &res, nil
}

服务端实现代码如上，运行后打印：

$ go run server.go                    
2023/01/04 23:13:59 :8080 net.Listing...

客户端实现代码为：

func simpleRoute() {
   // invoke the service with grpcClient
   res, err := grpcClient.SimpleRoute(context.Background(), &simplepb.SimpleRequest{Data: "I am iguochan"})
   if err != nil {
      log.Fatalf("SimpleRoute err: %+v", err)
   }
   log.Println(res)
}

运行后打印：

$ go run client.go
2023/01/04 23:15:44 code:200  data:"hello I am iguochan 2023-01-04 23:15:44.158069 +0800 CST m=+104.656427709"

可以发现，很容易就实现了grpc的简单调用。

3.4 服务端流式RPC

服务端代码如下：

func (r *Server) ListValue(request *simplepb.SimpleRequest, server simplepb.Route_ListValueServer) error {
   for n := 0; n < 5; n++ {
      // 向流中发送消息， 默认每次send送消息最大长度为`math.MaxInt32`bytes
      err := server.Send(&simplepb.StreamResponse{
         StreamValue: request.Data + strconv.Itoa(n),
      })
      if err != nil {
         return err
      }
   }
   return nil
}

客户端代码如下：

func listValue() {
   // 创建发送结构体
   req := simplepb.SimpleRequest{
      Data: "stream server grpc ",
   }
   // 调用我们的服务(ListValue方法)
   stream, err := grpcClient.ListValue(context.Background(), &req)
   if err != nil {
      log.Fatalf("Call ListStr err: %v", err)
   }
   for {
      //Recv() 方法接收服务端消息，默认每次Recv()最大消息长度为`1024*1024*4`bytes(4M)
      res, err := stream.Recv()
      // 判断消息流是否已经结束
      if err == io.EOF {
         break
      }
      if err != nil {
         log.Fatalf("ListStr get stream err: %v", err)
      }
      // 打印返回值
      log.Println(res.StreamValue)
   }
}

运行如下

$ go run client.go
2023/01/04 23:36:49 stream server grpc 0
2023/01/04 23:36:49 stream server grpc 1
2023/01/04 23:36:49 stream server grpc 2
2023/01/04 23:36:49 stream server grpc 3
2023/01/04 23:36:49 stream server grpc 4

值得注意的是，当客户端想结束客户端的发送时，可以使用stream.CloseSend()方法暂停服务端的发送，但是如果后来又调用了stream.Recv()，服务端又会继续发送数据。

3.5 客户端流式RPC

func (r *Server) RouteList(server simplepb.Route_RouteListServer) error {
   for {
      //从流中获取消息
      res, err := server.Recv()
      if err == io.EOF {
         //发送结果，并关闭
         return server.SendAndClose(&simplepb.SimpleResponse{
            Code: 200,
            Data: "hello " + time.Now().String(),
         })
      }
      if err != nil {
         return err
      }
      log.Println(res.StreamData)
   }
}

服务端的代码如上，客户端代码如下：

func routeList() {
   //调用服务端RouteList方法，获流
   stream, err := grpcClient.RouteList(context.Background())
   if err != nil {
      log.Fatalf("Upload list err: %v", err)
   }
   for n := 0; n < 5; n++ {
      //向流中发送消息
      err := stream.Send(&simplepb.StreamRequest{StreamData: "stream client rpc " + strconv.Itoa(n)})
      if err != nil {
         log.Fatalf("stream request err: %v", err)
      }
   }
   //关闭流并获取返回的消息
   res, err := stream.CloseAndRecv()
   if err != nil {
      log.Fatalf("RouteList get response err: %v", err)
   }
   log.Println(res)
}

服务端的打印如下：

$ go run server.go       
2023/01/04 23:43:07 :8080 net.Listing...
2023/01/04 23:43:28 stream client rpc 0
2023/01/04 23:43:28 stream client rpc 1
2023/01/04 23:43:28 stream client rpc 2
2023/01/04 23:43:28 stream client rpc 3
2023/01/04 23:43:28 stream client rpc 4

客户端的打印：

$ go run client.go
2023/01/04 23:43:28 code:200  data:"hello 2023-01-04 23:43:28.970596 +0800 CST m=+21.749100126"

3.6 双向流式RPC

func (r *Server) DoubleSideStream(server simplepb.Route_DoubleSideStreamServer) error {
   n := 1
   for {
      req, err := server.Recv()
      if err == io.EOF {
         return nil
      }
      if err != nil {
         return err
      }
      err = server.Send(&simplepb.StreamResponse{
         StreamValue: "from stream server answer: the " + strconv.Itoa(n) + " question is " + req.StreamData,
      })
      if err != nil {
         return err
      }
      n++
      log.Printf("from stream client question: %s", req.StreamData)
   }
}

服务端代码如上，客户端代码如下：

func doubleSideStream() {
   //调用服务端的Conversations方法，获取流
   stream, err := grpcClient.DoubleSideStream(context.Background())
   if err != nil {
      log.Fatalf("get conversations stream err: %v", err)
   }
   for n := 0; n < 5; n++ {
      err := stream.Send(&simplepb.StreamRequest{StreamData: "stream client rpc " + strconv.Itoa(n)})
      if err != nil {
         log.Fatalf("stream request err: %v", err)
      }
      res, err := stream.Recv()
      if err == io.EOF {
         break
      }
      if err != nil {
         log.Fatalf("Conversations get stream err: %v", err)
      }
      // 打印返回值
      log.Println(res.StreamValue)
   }
   //最后关闭流
   err = stream.CloseSend()
   if err != nil {
      log.Fatalf("Conversations close stream err: %v", err)
   }
}

服务端的打印如下：

$ go run server.go
2023/01/04 23:52:07 :8080 net.Listing...
2023/01/04 23:52:11 from stream client question: stream client rpc 0
2023/01/04 23:52:11 from stream client question: stream client rpc 1
2023/01/04 23:52:11 from stream client question: stream client rpc 2
2023/01/04 23:52:11 from stream client question: stream client rpc 3
2023/01/04 23:52:11 from stream client question: stream client rpc 4

客户端的打印：

go run client.go                                                                                                                                                                                              1 ↵
2023/01/04 23:52:11 from stream server answer: the 1 question is stream client rpc 0
2023/01/04 23:52:11 from stream server answer: the 2 question is stream client rpc 1
2023/01/04 23:52:11 from stream server answer: the 3 question is stream client rpc 2
2023/01/04 23:52:11 from stream server answer: the 4 question is stream client rpc 3
2023/01/04 23:52:11 from stream server answer: the 5 question is stream client rpc 4
jzpfbpx
关注
15. 【gRPC系列学习】gRPC四种通信模式：一元RPC、客户端流RPC、服务端流RPC、双向流RPC
菜鸟的博客
12-22 1139
gRPC四种通信模式
开源项目-grpc-grpc-go.zip
10-18
总之，grpc-go 是 gRPC 在 Go 语言中的实现，它提供了高效的远程服务调用能力，结合 protobuf，使得跨平台、跨语言的通信变得简单且高效。开发者可以利用 grpc-go 快速构建稳定、安全的分布式应用程序。
GRPC远程调用
jianfeng123123的博客
11-30 2166
RPC 即远程过程调用协议（Remote Procedure Call Protocol），可以让我们像调用本地对象一样发起远程调用。RPC 凭借其强大的治理功能，成为解决分布式系统通信问题的一大利器。gRPC是一个现代的、高性能、开源的和语言无关的通用 RPC 框架，基于 HTTP2 协议设计，序列化使用PB(Protocol Buffer)，PB 是一种语言无关的高性能序列化框架，基于 HTTP2+PB 保证了的高性能。
gRPC 笔记（04）— gRPC 通信模式之简单RPC模式（一元RPC模式）
wohu1104的专栏
05-13 462
1. 简单 RPC 模式 一元 RPC 模式也被称为简单 RPC 模式。在该模式中，当客户端调用服务器端的远程方法时，客户端发送请求至服务器端并获得一个响应，与响应一起发送的还有状态细节以及元数据。 如图所示，客户端发送一个带有订单 ID 的请求，服务器端给出响应，响应中包含订单的信息。因此，它遵循一元 RPC 模式。 ...
gRPC 基础(二)-- Go 语言版 gRPC-Go
chinusyan的专栏
01-30 960
gRPC-go 基础
gRPC-Go基础（5）middleware
ldxxxxll的博客
01-02 1451
if err!= nil {类似于grpc_zap.UnaryServerInterceptor，我们在建立服务的时候设置拦截器。)),)),在handler之前的部分，先注册的拦截器先执行；在handler之后的部分，先注册的拦截器后执行；原因是，在ChainUnaryServer函数中，是倒序将注册的拦截器函数一个个包装，最里面的就是核心的处理逻辑，故而会展现出以上的规则。
gRPC-web:基础教程
aggs1990的专栏
07-06 1092
echo.proto​创建gRPC服务的第一步是使用协议缓冲区定义服务方法及其请求和响应消息类型。在这个例子中，我们在一个名为echo.proto的文件中定义了EchoService。有关协议缓冲区和proto3语法的更多信息，请参阅protobuf文档。
Golang gRPC-Gateway：gRPC转换为HTTP协议对外提供服务
weixin_36484898的博客
08-15 115
1、概述gRPC常用于服务端之间的相互调用，如果想把服务暴露给前端，虽然动手修改服务端也能实现，但似乎增加了不少工作量，此时还可以选择gRPC-Gateway方式来快速将gRPC服务以http的方式暴露出来；gRPC-Gateway 是 Google protocol buffers compiler protoc 的插件...
protoc-gen-grpc-java-1.9.1-windows-x86_64.exe
11-07
protoc-gen-grpc-java-1.9.1-windows-x86_64.exe
go-grpc-gateway-v2-microservice:使用 Go + gRPC-Gateway 实战小程序登录鉴权微服务
04-06
在本项目"Go-grpc-gateway-v2-microservice"中，我们将深入探讨如何使用Go语言结合gRPC-Gateway V2来构建一个实战中的微服务，特别是针对登录鉴权功能。gRPC-Gateway是一个工具，它允许我们为gRPC服务提供RESTful ...
20241107，LeetCode 每日一题，使用 Go 计算两数相加
专注于分享个人学习工作沉淀内容，不做网络搬运工
11-06 86
链表存储的是逆序数位，因此从头节点开始，逐位相加可以模拟正常的加法。每两个节点的值相加，并记录进位。：若链表长度不一，则将缺少的部分视为0；同时确保最后若存在进位，将其单独处理。：若最终计算完链表后进位不为0，则在结果链表末尾增加一个新节点表示进位。
Go的JSON转化
weixin_44719499的博客
11-06 247
在Go语言中，处理JSON（JavaScript Object Notation）数据非常常见，特别是在与Web服务交互时。Go提供了内置的包来支持JSON的序列化（将Go对象转换为JSON格式）和反序列化（将JSON格式的数据解析为Go对象）。
【Golang】Gin框架中如何使用JWT来实现登录认证
景天科技苑
11-01 5572
JWT: JSON Web Token，是一种用于身份验证和授权的开放标准，JWT可以在网络应用间安全的传输。JWT由三个部分组成:头部(Header)、载荷(Payload)和签名(Signature) JWT具有可扩展性、简单、轻量级、跨语言等优点，是前后端分离框架中最常用的验证方式。
Go 使用 Redis 实现分布式锁
qq_37106501的博客
11-06 833
Go 使用 Redis 实现分布式锁
15分钟学 Go 第 40 天：使用ORM库
最新发布
weixin_40780178的博客
11-06 617
ORM，或对象关系映射，是一种技术，旨在将对象编程语言中的对象与数据库中的数据表进行映射。ORM的主要目标是简化与数据库的交互，使开发者能够在代码中使用对象而不是SQL语言来进行数据库操作。ORM的优点：简化代码：ORM使得数据库交互变得更简单，减少了复杂的SQL查询。类型安全：通过编译时检查来确保类型安全。跨数据库兼容性：大多数ORM框架提供对多种数据库的支持，降低了迁移成本。
Go：接口和反射
海绵宝宝de派小星的博客
11-05 544
接口和反射
Go如何实现自旋锁
lisus2007的专栏
11-01 546
go如何实现自旋锁
grpc-go源码剖析
09-05
grpc-go是一款受欢迎的Go语言实现的高性能RPC框架，用于构建分布式系统。它基于Google的开源框架gRPC，并为Go语言提供了相应的接口和库。下面我将对grpc-go源码进行简要剖析。 在grpc-go源码中，最重要的是其核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值