《Go语言高级编程》gPRC概述

最新推荐文章于 2025-06-30 19:02:05 发布
最新推荐文章于 2025-06-30 19:02:05 发布
阅读量761 收藏 19
点赞数 17
CC 4.0 BY-SA版权
分类专栏： # 《Go语言高级编程》 文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woshihlf/article/details/149017969

《Go语言高级编程》gPRC概述

核心概念理解

1. Protobuf 与服务定义

gRPC 使用 Protobuf 来定义服务接口和消息格式。在你的例子中，hello.proto 文件定义了一个名为 HelloService 的服务，它包含一个方法 Hello，该方法接收一个 String 消息并返回一个 String 消息。

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

这类似于定义一个函数接口，但它是跨网络调用的。

2. 代码生成

通过 Protobuf 编译器和 gRPC 插件，你可以生成客户端和服务器的代码：

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

这行命令会生成：

  • 客户端代码：包含如何调用远程服务的方法
  • 服务器代码：包含如何实现服务的接口定义
3. 服务端实现

服务端需要实现 HelloServiceServer 接口：

type HelloServiceImpl struct{}

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

这里的 Hello 方法是服务的具体实现，它接收一个字符串参数，添加 “hello:” 前缀后返回。

4. 服务启动

服务端需要启动 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)
}

这部分代码：

  1. 创建 gRPC 服务器
  2. 注册服务实现
  3. 监听 TCP 端口
  4. 启动服务
5. 客户端调用

客户端需要连接到服务端并调用服务：

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())
}

这部分代码：

  1. 连接到服务端
  2. 创建客户端
  3. 调用远程方法
  4. 处理返回结果

与标准库 RPC 的区别

  1. 协议：gRPC 使用 HTTP/2，而标准库 RPC 使用自定义协议
  2. 序列化：gRPC 使用 Protobuf (二进制)，标准库 RPC 使用 JSON 或 Gob
  3. 性能：gRPC 通常更快，尤其是在高并发场景
  4. 跨语言支持：gRPC 支持多种语言，标准库 RPC 主要支持 Go
  5. 流模式：gRPC 支持双向流，标准库 RPC 不支持

客户端异步调用

你提到 gRPC 不直接支持异步调用，但可以通过 Goroutine 实现：

// 客户端异步调用示例
go func() {
    reply, err := client.Hello(context.Background(), &String{Value: "async"})
    if err != nil {
        log.Println("Error:", err)
        return
    }
    fmt.Println("Async reply:", reply.GetValue())
}()

gPRC流

1. 为什么需要 gRPC 流？

传统 RPC 调用是"请求-响应"模式：

  • 客户端发送一个请求
  • 服务器处理请求并返回一个响应
  • 整个过程是同步的，不适合大数据传输或实时通信

gRPC 流解决了这些问题，它允许：

  • 客户端和服务器之间持续交换数据
  • 支持四种流模式：
    • 客户端流（单向）
    • 服务器流（单向）
    • 双向流
    • 一元（普通 RPC，无流）
2. 定义流服务

在 .proto 文件中，使用 stream 关键字定义流：

service HelloService {
  // 普通 RPC（一元）
  rpc Hello (String) returns (String);
  
  // 双向流 RPC
  rpc Channel (stream String) returns (stream String);
}

这里的 Channel 方法支持双向流：

  • 客户端可以持续发送 String 消息
  • 服务器可以持续返回 String 消息
3. 流接口详解

生成的代码中，流接口包含 Send 和 Recv 方法：

// 服务端流接口
type HelloService_ChannelServer interface {
    Send(*String) error       // 向客户端发送消息
    Recv() (*String, error)   // 从客户端接收消息
    grpc.ServerStream
}

// 客户端流接口
type HelloService_ChannelClient interface {
    Send(*String) error       // 向服务器发送消息
    Recv() (*String, error)   // 从服务器接收消息
    grpc.ClientStream
}

这些方法允许双向、异步的数据交换。

4. 服务端实现

服务端实现 Channel 方法：

func (p *HelloServiceImpl) Channel(stream HelloService_ChannelServer) error {
    for {
        // 接收客户端消息
        args, err := stream.Recv()
        if err != nil {
            if err == io.EOF {
                return nil // 客户端关闭流
            }
            return err // 处理其他错误
        }

        // 处理消息并返回响应
        reply := &String{Value: "hello:" + args.GetValue()}
        err = stream.Send(reply)
        if err != nil {
            return err
        }
    }
}

关键点：

  • stream.Recv() 从客户端接收消息
  • stream.Send() 向客户端发送消息
  • io.EOF 表示客户端关闭了流
5. 客户端实现

客户端需要启动两个 Goroutine 分别处理发送和接收：

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

// 发送消息的 Goroutine
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 != nil {
        if err == io.EOF {
            break // 服务器关闭流
        }
        log.Fatal(err)
    }
    fmt.Println("Received:", reply.GetValue())
}

关键点：

  • 发送和接收是完全独立的
  • 客户端和服务器可以随时发送数据
  • io.EOF 表示服务器关闭了流
6. 流的工作模式

gRPC 流有四种工作模式：

1. 一元 RPC（无流）
rpc UnaryMethod(Request) returns (Response) {}
  • 客户端发送一个请求，服务器返回一个响应
2. 服务器流
rpc ServerStreamingMethod(Request) returns (stream Response) {}
  • 客户端发送一个请求
  • 服务器返回一个数据流
  • 示例：实时数据推送
3. 客户端流
rpc ClientStreamingMethod(stream Request) returns (Response) {}
  • 客户端发送一个数据流
  • 服务器返回一个响应
  • 示例：大数据上传
4. 双向流
rpc BidirectionalStreamingMethod(stream Request) returns (stream Response) {}
  • 客户端和服务器可以同时发送和接收数据流
  • 示例：实时聊天、多人游戏
7. 流的特性
  1. 全双工通信：客户端和服务器可以同时发送和接收数据
  2. 异步处理：发送和接收操作不阻塞其他操作
  3. 高效传输：基于 HTTP/2 的多路复用，单个连接支持多个流
  4. 大数据支持：适合传输大文件或持续数据流
  5. 实时性：数据可以立即传输，无需等待整个消息完成
8. 适用场景
  • 实时数据推送（股票行情、实时通知）
  • 大数据上传/下载
  • 实时聊天系统
  • 监控系统（持续数据流）
  • 游戏服务器（低延迟通信）
9. 注意事项
  1. 错误处理：流可能因网络问题或服务器关闭而中断，需要适当处理错误
  2. 资源管理：流使用完后需要关闭，避免资源泄漏
  3. 并发控制：多个 Goroutine 访问同一个流时需要考虑同步问题
  4. 消息顺序：在双向流中，发送和接收的顺序可能不同步

gRPC发布-订阅

发布-订阅（PubSub）模式是一种消息传递模式，其中发送者（发布者）不会直接将消息发送给特定的接收者（订阅者），而是将消息分类发布到主题中。订阅者可以订阅一个或多个主题，只接收他们感兴趣的消息。这种模式实现了发布者和订阅者之间的解耦，非常适合构建分布式系统。

本地发布-订阅实现

首先，我们看一下基于 moby/moby/pkg/pubsub 包的本地实现：

import (
    "github.com/moby/moby/pkg/pubsub"
)

func main() {
    // 创建发布者，设置超时和队列大小
    p := pubsub.NewPublisher(100*time.Millisecond, 10)

    // 订阅golang主题
    golang := p.SubscribeTopic(func(v interface{}) bool {
        if key, ok := v.(string); ok {
            return strings.HasPrefix(key, "golang:")
        }
        return false
    })
    
    // 订阅docker主题
    docker := p.SubscribeTopic(func(v interface{}) bool {
        if key, ok := v.(string); ok {
            return strings.HasPrefix(key, "docker:")
        }
        return false
    })

    // 发布消息
    go p.Publish("hi")
    go p.Publish("golang: https://golang.org")
    go p.Publish("docker: https://www.docker.com/")
    
    // 接收消息
    go func() {
        fmt.Println("golang topic:", <-golang)
    }()
    go func() {
        fmt.Println("docker topic:", <-docker)
    }()

    <-make(chan bool) // 保持主程序运行
}

关键点：

  • pubsub.NewPublisher 创建一个发布者，负责管理主题和分发消息
  • SubscribeTopic 使用谓词函数过滤感兴趣的主题
  • 发布者发布消息时，所有订阅该主题的订阅者都会收到通知
  • 这是一个本地实现，无法跨网络工作
基于gRPC的远程发布-订阅系统

现在，我们将使用gRPC扩展这个系统，使其能够跨网络工作。

1. 定义服务接口
service PubsubService {
  rpc Publish (String) returns (String);       // 发布消息
  rpc Subscribe (String) returns (stream String); // 订阅主题
}

这里：

  • Publish 是一个普通的RPC方法，用于发布消息
  • Subscribe 是一个服务端流方法，允许客户端持续接收消息
2. 服务端实现
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
}

关键点：

  • 服务端维护一个 pubsub.Publisher 实例
  • Publish 方法将消息发布到本地发布者
  • Subscribe 方法创建一个主题订阅，并通过gRPC流将消息发送给客户端
3. 客户端发布消息
func main() {
    conn, err := grpc.Dial("localhost:1234", grpc.WithInsecure())
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    client := NewPubsubServiceClient(conn)

    // 发布golang主题消息
    _, err = client.Publish(context.Background(), &String{Value: "golang: hello Go"})
    if err != nil {
        log.Fatal(err)
    }
    
    // 发布docker主题消息
    _, err = client.Publish(context.Background(), &String{Value: "docker: hello Docker"})
    if err != nil {
        log.Fatal(err)
    }
}
4. 客户端订阅消息
func main() {
    conn, err := grpc.Dial("localhost:1234", grpc.WithInsecure())
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

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

    // 持续接收消息
    for {
        reply, err := stream.Recv()
        if err != nil {
            if err == io.EOF {
                break
            }
            log.Fatal(err)
        }

        fmt.Println(reply.GetValue())
    }
}
工作原理详解

  1. 服务端：

    • 创建一个本地的 pubsub.Publisher 实例
    • Publish 方法将接收到的消息发布到本地发布者
    • Subscribe 方法创建一个主题订阅，并通过gRPC流将消息实时发送给客户端

  2. 客户端发布：

    • 调用远程的 Publish 方法
    • 消息通过gRPC传输到服务端
    • 服务端将消息发布到本地主题

  3. 客户端订阅：

    • 调用远程的 Subscribe 方法，建立一个服务端流
    • 服务端为该客户端创建一个主题订阅
    • 当有匹配的消息发布时，服务端通过流将消息发送给客户端
    • 客户端持续接收并处理这些消息
优势与应用场景

这种基于gRPC的发布-订阅系统具有以下优势：

  1. 跨语言支持：gRPC支持多种语言，可以构建多语言混合的分布式系统
  2. 高性能：基于HTTP/2和Protobuf，性能优越
  3. 实时通信：使用流特性实现实时消息推送
  4. 解耦：发布者和订阅者不需要直接交互
  5. 扩展性：可以轻松扩展为支持多个主题和大量订阅者

典型应用场景包括：

  • 实时数据推送（如股票行情、新闻更新）
  • 微服务间的事件驱动通信
  • 实时聊天系统
  • 监控和警报系统

通过这种方式，你可以构建一个跨网络的、高效的发布-订阅系统，充分利用gRPC的流特性和类型安全优势。

使用 Qt GRPC 构建高效的 Trojan-Go 客户端：详细指南
cheungxiongwei的博客
10-28 943
本文全面讲解了如何使用 Qt GRPC 实现高效的 Trojan-Go 客户端。通过 gRPC 的跨语言远程过程调用能力和 Qt 的自动化工具，我们实现了轻量级、快速响应的客户端通信。文章从环境配置、项目结构到主程序逻辑的实现逐步展开，详细介绍了 Protobuf 数据结构、CMake 配置、RPC 服务接口和流量监控。借助 Qt 的定时器功能，实现了每 500 毫秒更新一次流量数据，确保服务器状态的实时反馈。文中还涵盖了调试、性能优化的技巧，包括数据压缩和异步请求等，进一步提升了客户端的稳定性和效率。
C++下的gRPC与protobuf使用和介绍
yiyu20180729的博客
02-29 2221
gRPC 和协议缓冲区简介。本页介绍 gRPC 和协议缓冲区。gRPC 可以使用 协议缓冲区作为其接口定义语言 （IDL） 和基础消息 交换格式。如果你不熟悉 gRPC 和/或协议缓冲区，请阅读此内容！如果只想深入了解并首先查看 gRPC 的运行情况，请选择一种语言并尝试其快速入门。在 gRPC 中，客户端应用程序可以直接调用服务器应用程序上的方法 在不同的计算机上，就好像它是本地对象一样，使您可以更轻松地 创建分布式应用程序和服务。
Go中的gRPC简介
一个北漂的程序猿
09-05 3724
给使用 Go 语言的初学者的 gRPC 概述 RPC RPC 是用于 软件应用之间点对点通信 的 网络编程模型 或是 进程间通信技术。 RPC 是一种 协议，一个程序能够使用该协议，对位于另外一台计算机中的程序请求服务，而无需了解网络的详细信息。 RPC 代表 “远程过程调用”，它是一种 客户端 - 服务器交互 的形式 - 调用者是客户端，执行者是服务器 - 通常通过 " 请求 - 响应消息传递系...
Go使用grpc+http打造高性能微服务
chen
05-16 6340
大家可以发现，Go越来越流行，其一是目前云计算领域基本是使用Go作为底层开发语言；其二是随着区块链的火爆，引申出了其背后很多开源项目，很多都是使用Go语言进行开发；其三就是在微服务方面，Go也展示很大的优势性。那么微服务是什么，如何将其与Go做一个整合，来提升整体开发生产效率，下面会进行详细讲解。什么是微服务微服务的概念最早由 Martin Fowler 提出，在他的理论当中，微服务是一整套小的服...
Node.js 使用 gRPC：从定义到实现
weixin_71329368的博客
07-04 2271
gRPC（gRPC Remote Procedure Calls）是一个高性能、开源的远程过程调用（RPC）框架，由 Google 开发。它支持多种编程语言，旨在简化和优化分布式系统中的服务通信。2. gRPC的优势：高性能：使用 HTTP/2 和 protobuf 使得 gRPC 在性能和效率方面表现出色。二进制协议和 HTTP/2 的多路复用特性使其通信开销低，速度快。简化开发：自动代码生成和多语言支持简化了微服务的开发和维护
孰优孰劣，gRPC和Rest性能大比拼
u013643074的博客
10-26 590
本文通过示例比较REST和gRPC性能。
gRPC
dz45693的专栏
10-22 2966
概述 gRPC 一开始由 google 开发，是一款语言中立、平台中立、开源的远程过程调用(RPC)系统。 在 gRPC 里客户端应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法，使得您能够更容易地创建分布式应用和服务。与许多 RPC 系统类似，gRPC 也是基于以下理念：定义一个服务，指定其能够被远程调用的方法（包含参数和返回类型）。在服务端实现这个接口，并运行一个 gR...
gRPC学习与应用（1）
maximejia的博客
12-10 2054
gRPC框架的学习与实践应用，以探索用以支撑深度强化学习训练交互的框架范式。本篇中主要围绕gRPC的功能及使用进行了简介，后面将通过具体的例子进行具体实践开发的介绍。
gRPC Guides
Ybt_c_index的博客
12-25 762
What is gRPC https://grpc.io/docs/guides/index.html gRPC可以使用protocol buffers 作为其接口定义语言（IDL）及其底层信息交互格式。 Overview 在grpc中，一个client应用可以直接调用不同机器上的server应用的方法，好像它是一个局部对象，可以让你更加容易的构建分布式应用和服务。与许多RPC系统一样，gRPC基...
Golang实现GPRC服务与安全特性：Redis、AES、DES加密及ActiveMQ应用
资源摘要信息:"该文件主要介绍了如何使用Go语言实现gRPC框架下的自签名CA证书、服务器和客户端证书以及双向认证的过程，并结合AES和DES加密算法进行数据的加密与解密操作，同时介绍了如何在使用Redis时实现分布式锁...
gprc做物联网
03-08
可以参考开源仓库 `go-grpc-example` 中给出的具体实例学习如何操作[golang版gRPC][^3]。该项目展示了基本 CRUD 操作的同时也包含了认证鉴权部分的内容，有助于理解实际应用场景下可能遇到的问题及其解决方案。 ```...
普罗米修斯服务发现：使用etcd后端架构
GPRC（gRPC）是一种高性能的、开源的通用RPC框架，它支持多种编程语言，因此该组件可以被各种服务方便地集成。 2. **导出程序服务** 这个组件负责将注册中心的数据导出到一个Prometheus可以读取的格式，例如...
微服务架构系列一：关键技术与原理研究
腾讯技术工程
08-15 4388
导语：人不为己，天诛地灭这个成语中的“为”念作wéi，阳平二声，是“修养，修为”的意思。成语的意思是：如果人不修身，那么就会为天地所不容。本意并不是经常被很多人曲解的人如...
Go语言TFLite应用开发全指南
keny-大成的博客
06-25 378
摘要：本文介绍了Go语言和Rust中TensorFlow/PyTorch框架的应用实践。在Go部分，详细说明了TFLite C库的安装绑定、模型加载与解释器配置、输入输出处理以及完整应用框架的构建流程。Rust部分则通过10个典型示例，涵盖了张量操作、模型构建、MNIST处理、CNN实现、训练循环、模型保存、GPU加速、自定义数据集、预训练模型使用及自动微分等核心功能，特别是展示了tch-rs库加载MNIST数据集的完整实现。两种语言案例均强调从环境配置到实际推理的完整开发链路，为跨平台机器学习应用开发提供
8、做中学 | 四年级下期 Golang运算符
liu_dongdong55的博客
06-26 1282
本文介绍了编程中常见的运算符类型及其使用方法。主要包括五种运算符：算术运算符（+、-、*、/、%、++、--）用于基础数学运算；关系运算符（==、!=、>、<、>=、<=）用于比较值并返回布尔结果；逻辑运算符（&&、||、!）用于条件判断；位运算符（&、|、^、<<、>>）用于二进制运算和性能优化；赋值运算符（=、+=、-=等）用于简化赋值操作。文章通过Go语言代码示例展示了各类运算符的具体应用，并特别指出自增/自减运算符的使用限制（不
Go 语言核心概念解析：开启高效编程之门（二）
shsjssnn的博客
06-30 569
  在Go语言中，命名为main包的具体特殊的含义，Go语言的编译程序会试图把这种名字的包编译为二进制可执行文件，所有用Go语言编译的可执行文件都必须有一个名为main的包，一个可执行程序有且仅有一个main包。
python与go实现卷积神经网络
keny-大成的博客
06-25 358
本文介绍了使用PyTorch实现CNN模型对CIFAR-10/MNIST数据集进行分类的全过程。代码包含数据预处理（归一化、加载）、CNN模型构建（含卷积层、池化层和全连接层）、训练过程（使用交叉熵损失和SGD优化器）以及结果可视化。示例展示了如何显示测试图片并对比真实标签与预测结果，改进版本达到了99.10%的测试准确率。最后还提供了模型保存与加载的方法，方便实际应用部署。整个实现简洁完整，可作为深度学习入门的实践参考。
Golang的多环境配置
最新发布
pingguocu3的博客
06-30 179
我们可以定义一些通用的环境变量，比如`APP_ENV`来表示当前运行的环境，然后针对不同的环境设置不同的环境变量。我们可以通过环境变量和配置文件相结合的方式，来管理和切换不同环境下的配置，使得我们的应用具备更好的灵活性和可维护性。我们可以将通用的配置放在配置文件中，然后通过环境变量来覆盖或补充特定环境下的配置。比如，我们可以先加载通用配置文件，然后根据环境变量的值再加载特定环境的配置文件，从而实现灵活的配置管理。通过上述示例代码，我们可以根据不同的`APP_ENV`环境变量值加载不同的配置信息。
Go 语言测试与调试：`go test` 工具用法
tenkofx的博客
06-29 753
功能命令示例普通测试go test显示详情go test -v跑部分测试基准测试内存分配并发检测覆盖率报告可视化覆盖率统计稳定性如你有具体场景（如测试数据库、模拟网络等）或对 Mock、Testify 等第三方库感兴趣，也欢迎继续深入探讨！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值