在 gRPC（1）：入门及简单使用（go） 中，我们实现了一个简单的 gRPC 应用程序，其中双方通信是简单的请求—响应模式，没发出一个请求都会得到一个响应，然而，借助 gRPC 可以实现不同的通信模式，这里介绍四种 gRPC 应用程序的基础通信模式：一元RPC、服务端流RPC、客户端流RPC、双向流RPC
1、一元RPC
一元 RPC 也被称为简单 RPC， 其实就是 gRPC（1）：入门及简单使用（go） 中实现的请求—响应模式，每调用一次得到一个结果，这里再以一个简单的订单管理程序做说明，实现两个服务：addOrder 用于添加订单；getOrder 用于根据 id 获取订单：
- 服务定义
syntax = "proto3";
package proto;
option go_package = "./proto";
service OrderManagement {
rpc addOrder(Order) returns (StringValue);
rpc getOrder(StringValue) returns (Order);
}
message Order {
string id = 1;
repeated string items = 2; // repeated 表示列表
string description = 3;
float price = 4;
string destination = 5;
}
message StringValue {
string value = 1;
}
- 服务端实现
package main
import (
"context"
"fmt"
"log"
"net"
"strings"
pb "order/proto"
"github.com/gofrs/uuid"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
const (
port = ":50051"
)
type server struct {
pb.UnimplementedOrderManagementServer
}
// 模拟存储
var orderMap = make(map[string]*pb.Order)
func (s *server) AddOrder(ctx context.Context, order *pb.Order) (*pb.StringValue, error) {
id, err := uuid.NewV4()
if err != nil {
return nil, status.Errorf(codes.Internal, "Error while generating Product ID", err)
}
order.Id = id.String()
orderMap[order.Id] = order
log.Printf("Order %v : %v - Added.", order.Id, order.Description)
return &pb.StringValue{Value: order.Id}, nil
}
func (s *server) GetOrder(ctx context.Context, orderID *pb.StringValue) (*pb.Order, error) {
order, exists := orderMap[orderID.Value]
if exists && order != nil {
log.Printf("Order %v : %v - Retrieved.", order.Id, order.Description)
return order, nil
}
return nil, status.Errorf(codes.NotFound, "Order does not exist.", orderID.Value)
}
func main() {
lis, err := net.Listen("tcp", port)
if err != nil {
log.Fatalf("failed to listen: %v", err)
}
s := grpc.NewServer()
pb.RegisterOrderManagementServer(s, &server{})
if err := s.Serve(lis); err != nil {
log.Fatalf("failed to serve: %v", err)
}
}
- 客户端实现
package main
import (
"context"
"io"
"log"
"time"
pb "order/proto"
"google.golang.org/grpc"
)
const (
address = "localhost:50051"
)
func main() {
conn, err := grpc.Dial(address, grpc.WithInsecure())
if err != nil {
log.Fatalf("did not connect: %v", err)
}
defer conn.Close()
c := pb.NewOrderManagementClient(conn)
orderID, err := c.AddOrder(context.Background(),
&pb.Order{
Items: []string{"XiaoMI 11"},
Description: "XiaoMI 11",
Price: 3999,
Destination: "suzhou",
})
if err != nil {
log.Fatalf("could not add order: %v", err)
}
log.Printf("Added order: %v", orderID.Value)
}
2、服务端流RPC
与一元 RPC 不同的是，流模式下响应或者请求都可以是一个序列，这个序列也被称为”流“，服务端流 RPC 下，客户端发出一个请求，但不会立即得到一个响应，而是在服务端与客户端之间建立一个单向的流，服务端可以随时向流中写入多个响应消息，最后主动关闭流，而客户端需要监听这个流，不断获取响应直到流关闭
下面以一个简单的关键词搜索功能为例，客户端发送关键字，服务端进行匹配，每找到一个就写进流中，在之前的基础上添加代码：
- 服务定义
service OrderManagement {
...
// stream 将返回参数指定为订单流
rpc searchOrders(StringValue) returns (stream Order);
}
- 服务端实现
func (s *server) SearchOrders(searchQuery *pb.StringValue, stream pb.OrderManagement_SearchOrdersServer) error {
for key, order := range orderMap {
for _, item := range order.Items {
if strings.Contains(item, searchQuery.Value) {
err := stream.Send(&order)
if err != nil {
return fmt.Errorf("error sending message to stream: %v", err)
}
log.Printf("order found: " + key)
break
}
}
}
return nil
}
- 客户端实现
...
// 获得建立的流对象
stream, err := c.SearchOrders(context.Background(), &pb.StringValue{Value: "XiaoMI"})
if err != nil {
log.Fatalf("search error: %v", err)
}
for {
// 循环读取
order, err := stream.Recv()
if err == io.EOF {
log.Print("EOF")
break
}
if err != nil {
log.Fatal("error: ", err)
}
log.Print(order)
}
3、客户端流RPC
客户端流，和服务端流一样的道理，只不过流的方向变为从客户端到服务端，可以发送多条响应，服务端只会响应一次，但何时响应取决于服务端的逻辑，以更新订单序列为例，客户端可以发送一系列订单，服务端可以选择在任意时候停止读取并发送响应：
- 服务定义
service OrderManagement {
...
rpc updateOrders(stream Order) returns (StringValue);
}
- 服务端实现
func (s *server) UpdateOrders(stream pb.OrderManagement_UpdateOrdersServer) error {
for {
order, err := stream.Recv()
if err == io.EOF {
return stream.SendAndClose(&pb.StringValue{Value: "finished"})
}
if err != nil {
return err
}
orderMap[order.Id] = order
log.Print("OrderID " + order.Id + " updated")
}
}
- 客户端实现
// 取得流
updateStream, err := c.UpdateOrders(context.Background())
if err != nil {
log.Fatalf("update err: %v", err)
}
// 发送 Order1
if err = updateStream.Send(&pb.Order{
Id: "1",
Items: []string{"Huawei P50"},
Description: "Huawei P50",
Price: 5999,
Destination: "suzhou",
}); err != nil {
log.Fatalf("send error: %v", err)
}
// 发送 Order2
if err = updateStream.Send(&pb.Order{
Id: "2",
Items: []string{"iphone 12"},
Description: "iphone 12",
Price: 8999,
Destination: "suzhou",
}); err != nil {
log.Fatalf("send error: %v", err)
}
...
// 关闭流，结束发送
updateRes, err := updateStream.CloseAndRecv()
if err != nil {
log.Fatalf("update stream close error: %v", err)
}
log.Printf("update res: %v", updateRes)
4、双向流RPC
双向流，顾名思义，由客户端发起调用后，将建立起双向的流，在这之后，通信将完全基于双方的应用逻辑，流的操作完全独立，客户端和服务端可以按照任意顺序进行读取和写入，以一个订单筛选过程为例，客户端发送一串订单 ID 序列，服务端进行检查，每遇到一个有效的 ID 就写入流中响应：
- 服务定义
service OrderManagement {
...
rpc processOrders(stream StringValue) returns (stream StringValue);
}
- 服务端实现
func (s *server) ProcessOrders(stream pb.OrderManagement_ProcessOrdersServer) error {
for {
orderId, err := stream.Recv()
if err == io.EOF {
return nil
}
if err != nil {
return err
}
order, exists := orderMap[orderId.Value]
if exists && order != nil {
stream.Send(&pb.StringValue{Value: order.Id})
}
}
}
- 客户端实现
...
// 取得双向流
processStream, err := c.ProcessOrders(context.Background())
// 同步channel，防止主程序提前退出
waitc := make(chan struct{})
// 双向流是完全异步的，开一个协程用于读取响应
go func() {
for {
orderId, err := processStream.Recv()
if err == io.EOF {
close(waitc)
return
}
if err != nil {
log.Fatalf("recv error: %v", err)
}
log.Print("recv " + orderId.Value)
}
}()
// 请求
if err = processStream.Send(&pb.StringValue{Value: "1"}); err != nil {
log.Fatalf("1 send error: %v", err)
}
if err = processStream.Send(&pb.StringValue{Value: "2"}); err != nil {
log.Fatalf("2 send error: %v", err)
}
if err = processStream.Send(&pb.StringValue{Value: "3"}); err != nil {
log.Fatalf("3 send error: %v", err)
}
if err = processStream.CloseSend(); err != nil {
log.Fatal(err)
}
// 等待读取结束
<-waitc
这就是 gRPC 中主要的四种通信模式，基于它们可以实现各种 gRPC 场景下的交互，至于选择哪种，还需根据具体的场景考虑