Golang实现gRPC双向流聊天示例

本文详细演示了如何使用Go语言和gRPC构建一个高效、实时的双向流式聊天系统，通过定义proto接口、生成gRPC代码、实现支持消息广播的服务端以及并发处理收发的客户端，充分利用HTTP/2的双向流特性，轻松支撑在线客服、多人聊天室等低延迟交互场景——无需复杂轮询或WebSocket封装，一行代码即可开启真正的全双工实时通信。

在Go语言中使用gRPC实现双向流式聊天，可以实现实时通信场景，比如在线客服、多人聊天室等。gRPC默认基于HTTP/2，天然支持双向流（Bidirectional Streaming），非常适合这类需求。

1. 定义Proto文件

首先定义一个.proto文件来描述服务接口和消息格式。创建chat.proto：

syntax = "proto3";

package chat;

service ChatService {
  rpc ChatStream(stream Message) returns (stream Message);
}

message Message {
  string user = 1;
  string content = 2;
  int64 timestamp = 3;
}

这里定义了一个ChatStream方法，客户端和服务端都可以发送和接收消息流，实现真正的双向通信。

2. 生成Go代码

安装必要的工具并生成代码：

确保已安装 Protocol Buffers 编译器 protoc 和 Go 插件：

go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

执行命令生成Go代码：

protoc --go_out=. --go_opt=paths=source_relative \
       --go-grpc_out=. --go-grpc_opt=paths=source_relative \
       chat.proto

会生成chat.pb.go和chat_grpc.pb.go两个文件。

3. 实现gRPC服务端

编写服务端逻辑，处理每个连接的双向流：

package main

import (
    "context"
    "fmt"
    "log"
    "net"

    "your_project/chat"
    "google.golang.org/grpc"
)

type ChatServer struct {
    chat.UnimplementedChatServiceServer
    clients []chat.ChatService_ChatStreamServer
}

func (s *ChatServer) ChatStream(stream chat.ChatService_ChatStreamServer) error {
    s.clients = append(s.clients, stream)
    
    for {
        msg, err := stream.Recv()
        if err != nil {
            return err
        }

        fmt.Printf("[%s]: %s\n", msg.User, msg.Content)

        // 广播给所有其他客户端
        for _, client := range s.clients {
            go func(c chat.ChatService_ChatStreamServer) {
                _ = c.Send(msg)
            }(client)
        }
    }
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }

    grpcServer := grpc.NewServer()
    chat.RegisterChatServiceServer(grpcServer, &ChatServer{})
    
    log.Println("gRPC server running on port 50051...")
    if err := grpcServer.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

服务端将所有连接的客户端保存起来，每当收到一条消息，就广播给所有客户端（包括发送者）。

4. 实现gRPC客户端

客户端需要同时读取用户输入并监听来自服务端的消息：

package main

import (
    "bufio"
    "context"
    "fmt"
    "log"
    "os"
    "time"

    "your_project/chat"
    "google.golang.org/grpc"
)

func main() {
    conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure(), grpc.WithBlock())
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()

    client := chat.NewChatServiceClient(conn)
    stream, err := client.ChatStream(context.Background())
    if err != nil {
        log.Fatal(err)
    }

    // 开启协程接收消息
    go func() {
        for {
            msg, err := stream.Recv()
            if err != nil {
                fmt.Printf("receive error: %v\n", err)
                return
            }
            fmt.Printf("\n[%s] %s: %s\n", time.Unix(msg.Timestamp, 0).Format("15:04"), msg.User, msg.Content)
        }
    }()

    // 读取用户输入
    scanner := bufio.NewScanner(os.Stdin)
    for scanner.Scan() {
        text := scanner.Text()
        if text == "quit" {
            break
        }

        msg := &chat.Message{
            User:      "Alice", // 可改为从命令行输入
            Content:   text,
            Timestamp: time.Now().Unix(),
        }

        if err := stream.Send(msg); err != nil {
            fmt.Printf("send error: %v\n", err)
            break
        }
    }
}

客户端通过goroutine分离接收和发送逻辑，保证不会阻塞用户输入。

基本上就这些。运行服务端，再启动多个客户端，就能看到实时聊天效果了。这种方式扩展性好，适合构建分布式即时通讯系统。

今天关于《Golang实现gRPC双向流聊天示例》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！