深入理解gRPC：从基础到高级应用-优快云博客

本文链接：https://blog.youkuaiyun.com/gitblog_00717/article/details/148374517

深入理解gRPC：从基础到高级应用

advanced-go-programming-book :books: 《Go语言高级编程》开源图书，涵盖CGO、Go汇编语言、RPC实现、Protobuf插件实现、Web框架实现、分布式系统等高阶主题(完稿) 项目地址: https://gitcode.com/gh_mirrors/ad/advanced-go-programming-book

引言

在现代分布式系统开发中，远程过程调用(RPC)框架扮演着至关重要的角色。gRPC作为Google开源的高性能RPC框架，凭借其跨语言支持、基于HTTP/2协议等优势，已成为微服务架构中的重要组件。本文将深入探讨gRPC的核心概念、技术实现以及高级应用场景。

gRPC技术架构解析

gRPC的技术栈采用分层设计，每一层都提供特定的功能：

传输层：基于TCP或Unix Socket协议，提供基础的网络通信能力
协议层：采用HTTP/2协议，支持多路复用、头部压缩等高级特性
核心层：gRPC核心库实现了RPC的核心功能
应用层：通过Protobuf生成的Stub代码与业务逻辑交互

这种分层架构使得gRPC既保持了高性能，又提供了良好的扩展性。

gRPC基础使用

服务定义与代码生成

gRPC使用Protobuf作为接口定义语言(IDL)。一个典型的服务定义如下：

syntax = "proto3";

message String {
  string value = 1;
}

service HelloService {
  rpc Hello (String) returns (String);
}

通过protoc编译器配合gRPC插件，可以生成服务端和客户端代码：

protoc --go_out=plugins=grpc:. hello.proto

生成的代码包含两个关键接口：

// 服务端接口
type HelloServiceServer interface {
  Hello(context.Context, *String) (*String, error)
}

// 客户端接口
type HelloServiceClient interface {
  Hello(context.Context, *String, ...grpc.CallOption) (*String, error)
}

服务端实现

服务端实现需要遵循生成的接口：

type HelloServiceImpl struct{}

func (p *HelloServiceImpl) Hello(ctx context.Context, args *String) (*String, error) {
  reply := &String{Value: "hello:" + args.GetValue()}
  return reply, nil
}

启动gRPC服务器的流程：

func main() {
  grpcServer := grpc.NewServer()
  RegisterHelloServiceServer(grpcServer, new(HelloServiceImpl))
  
  lis, err := net.Listen("tcp", ":1234")
  if err != nil {
    log.Fatal(err)
  }
  grpcServer.Serve(lis)
}

客户端调用

客户端调用流程同样简单明了：

func main() {
  conn, err := grpc.Dial("localhost:1234", grpc.WithInsecure())
  if err != nil {
    log.Fatal(err)
  }
  defer conn.Close()

  client := NewHelloServiceClient(conn)
  reply, err := client.Hello(context.Background(), &String{Value: "hello"})
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(reply.GetValue())
}

gRPC流式通信

传统RPC在处理大数据量或长时间运行的操作时存在局限性。gRPC提供了三种流式通信模式：

服务端流式RPC：客户端发送单个请求，服务端返回流式响应
客户端流式RPC：客户端发送流式请求，服务端返回单个响应
双向流式RPC：客户端和服务端都可以发送流式消息

双向流实现示例

服务定义：

service HelloService {
  rpc Channel (stream String) returns (stream String);
}

服务端实现：

func (p *HelloServiceImpl) Channel(stream HelloService_ChannelServer) error {
  for {
    args, err := stream.Recv()
    if err == io.EOF {
      return nil
    }
    if err != nil {
      return err
    }

    reply := &String{Value: "hello:" + args.GetValue()}
    if err := stream.Send(reply); err != nil {
      return err
    }
  }
}

客户端使用：

stream, err := client.Channel(context.Background())
if err != nil {
  log.Fatal(err)
}

// 发送协程
go func() {
  for {
    if err := stream.Send(&String{Value: "hi"}); err != nil {
      log.Fatal(err)
    }
    time.Sleep(time.Second)
  }
}()

// 接收协程
for {
  reply, err := stream.Recv()
  if err == io.EOF {
    break
  }
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(reply.GetValue())
}

高级应用：发布订阅系统

gRPC的流式特性非常适合实现发布订阅模式。下面展示如何构建一个基于gRPC的发布订阅系统。

服务定义

service PubsubService {
  rpc Publish (String) returns (String);
  rpc Subscribe (String) returns (stream String);
}

服务端实现

type PubsubService struct {
  pub *pubsub.Publisher
}

func NewPubsubService() *PubsubService {
  return &PubsubService{
    pub: pubsub.NewPublisher(100*time.Millisecond, 10),
  }
}

func (p *PubsubService) Publish(ctx context.Context, arg *String) (*String, error) {
  p.pub.Publish(arg.GetValue())
  return &String{}, nil
}

func (p *PubsubService) Subscribe(arg *String, stream PubsubService_SubscribeServer) error {
  ch := p.pub.SubscribeTopic(func(v interface{}) bool {
    if key, ok := v.(string); ok {
      return strings.HasPrefix(key, arg.GetValue())
    }
    return false
  })

  for v := range ch {
    if err := stream.Send(&String{Value: v.(string)}); err != nil {
      return err
    }
  }
  return nil
}

发布者客户端

func main() {
  conn, err := grpc.Dial("localhost:1234", grpc.WithInsecure())
  if err != nil {
    log.Fatal(err)
  }
  defer conn.Close()

  client := NewPubsubServiceClient(conn)
  
  _, err = client.Publish(context.Background(), &String{Value: "golang: hello Go"})
  if err != nil {
    log.Fatal(err)
  }
}

订阅者客户端

func main() {
  conn, err := grpc.Dial("localhost:1234", grpc.WithInsecure())
  if err != nil {
    log.Fatal(err)
  }
  defer conn.Close()

  client := NewPubsubServiceClient(conn)
  stream, err := client.Subscribe(context.Background(), &String{Value: "golang:"})
  if err != nil {
    log.Fatal(err)
  }

  for {
    reply, err := stream.Recv()
    if err == io.EOF {
      break
    }
    if err != nil {
      log.Fatal(err)
    }
    fmt.Println(reply.GetValue())
  }
}