徹底學會 gRPC：用 Go 實現一個迷你考試服務

作者：孔令飛 2025-05-20 09:39:57

本文將通過用 Go 編寫一個最簡化的考試服務，一步步演示 gRPC 支持的四種 RPC 形式：一元調用、服務器端流、客戶端流和雙向流。

lack、Netflix 甚至 Kubernetes 這類現代系統，都能高效地完成實時通信。它們龐大的后端被拆分為一個個微服務。那么，這些服務之間到底如何通信？大概率就是 gRPC 在背后發揮魔法。

本文將通過用 Go 編寫一個最簡化的考試服務，一步步演示 gRPC 支持的四種 RPC 形式：一元調用（Unary）、服務器端流（Server Streaming）、客戶端流（Client Streaming）和雙向流（Bidirectional Streaming）。

在此之前，我們先快速掃清一些概念和行話，做好充電。如果你已經很熟悉并且只想要代碼，可以在這里查看相關倉庫：https://github.com/pixperk/grpc_exam。

一、RPC 是啥？

RPC（Remote Procedure Call，遠程過程調用）乍聽高大上，其實就是 “在另一臺機器上調用一個函數”。

想象你是客戶端，要問服務器 “學生 42 的成績是多少？”。借助 RPC，就像本地函數調用一樣簡單，雖然函數真正執行的地方在遠端。

早期 RPC 系統在今天看來問題多多：

數據格式混亂：XML、私有格式，臃腫又慢；
很難流式通信：實時或長鏈接幾乎做不了；
語言綁定有限：經常綁定特定生態（Java RMI、CORBA 等）；
自動化差：代碼生成寥寥，樣板代碼海量；
安全自己管：TLS、認證要開發者手寫；
擴展性差：不復用連接、無多路復用，高并發直接跪；

gRPC 則把這些痛點一次性解決：更快、更安全、開發體驗更爽。

二、gRPC — Google 出品的現代化 RPC 框架

gRPC 是 Google 開發的開源 RPC 框架。它旨在讓服務間通信變得更：

快速（得益于 HTTP/2）；
類型安全（通過 Protocol Buffers）；
流式友好（支持實時通信）。

1. HTTP/2 小科普

gRPC 在底層使用 HTTP/2。與 HTTP/1.1 相比，它具有：

多路復用：在同一連接上并行處理多個請求；
支持雙向流：客戶端和服務器可同時發送和接收數據；
內置頭部壓縮：加快數據傳輸速度。

得益于此，gRPC 能在低延遲下搞定實時通信。

2. gRPC vs REST

特性	REST	gRPC
數據格式	JSON / XML	Protocol Buffers
流式	罕見 / 需自己造輪子	內置
傳輸層	HTTP/1.1	HTTP/2
性能	冗長	緊湊 & 快
開發體驗	手動寫文檔	自動生成代碼

三、gRPC 支持的四種 RPC 通信方式

gRPC 在客戶端與服務器之間支持四種通信方式。下面我們逐一進行介紹。

1. Unary（單次請求-響應）

客戶端發送一次請求 → 服務器返回一次響應。類似普通函數：

rpc GetMarks(StudentRequest) returns (MarksResponse);

這是最常見的類型，非常適合 CRUD 風格的操作。

2. Server Streaming（服務器流）

客戶端一次請求，服務器持續推送多條響應。

rpc StreamSemesterResults(SemesterRequest) returns (stream MarksResponse);

當服務器需要發送大量數據時，這種方式特別有用——結果一準備好就會實時推送給你。

3. Client Streaming（客戶端流）

客戶端持續發送一連串請求 → 服務器最終返回一個匯總響應。也就是說，客戶端批量推送數據，服務器全部處理完畢后一次性給出結果。

rpc UploadAttendance(stream AttendanceEntry) returns (UploadStatus);

非常適合用于發送日志、監控指標或進行批量上傳。

4. Bidirectional Streaming（雙向流）

客戶端和服務器可以同時向對方持續發送數據流。就像實時聊天一樣，雙方能夠一邊說話一邊收聽彼此的消息。

rpc LiveQuiz(stream QuizMessage) returns (stream QuizMessage);

這正是 gRPC 大顯身手的地方：實時多人游戲、協作工具、實時儀表盤——統統不在話下。

四、Protocol Buffers（Protobuf）簡介

Google 推出的跨語言、跨平臺序列化協議。

相較 JSON：

體積更小：二進制編碼；
速度更快：序列化 / 反序列化省時；
字段用編號：解析無需比對字符串；

Protobuf Buffers 工作流程：

寫 .proto 描述文件；
protoc 編譯生成各語言代碼；
在代碼里直接調用序列化 / 反序列化方法；

示例：

syntax = "proto3";

message StudentRequest {
  string student_id = 1;
}

五、動手實踐：Go 版 Exam Service

1. 倉庫初始化

首先，來初始化一個 Go 項目：

mkdir grpc_exam && cd grpc_exam
go mod init github.com/pixperk/grpc_exam

安裝必要的生成插件：

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

如果你沒有安裝 protoc 編譯工具，可以參考 https://protobuf.dev/installation/ 進行安裝。

接下來，準備好目錄結構：

├── client/
│   ├── clients/
│   │   ├── unary.go
│   │   ├── server_stream.go
│   │   ├── client_stream.go
│   │   ├── bi_stream.go
│   └── main.go
├── proto/
│   ├── exam.proto
│   └── generated/exampb/
│       ├── exam.pb.go
│       └── exam_grpc.pb.go
├── server/
│   ├── main.go
│   └── servers/
│       ├── unary.go
│       ├── server_stream.go
│       ├── client_stream.go
│       ├── bi_stream.go
│       └── exam_service_server.go
├── utils/
│   └── logger.go
├── go.mod
├── go.sum
└── Makefile

接下來，編寫一個 Makefile，避免每次都執行很長的命令來執行操作：

proto:
    protoc \
        --proto_path=proto \
        --go_out=proto \
        --go-grpc_out=proto \
        proto/*.proto
    @echo "Proto files generated in the 'proto' directory."

server:
    go run server/main.go

client_unary:
    go run client/main.go unary

client_server:
    go run client/main.go server

client_client:
    go run client/main.go client

client_bidi:
    go run client/main.go bidi

.PHONY: proto server client_unary client_server client_client client_bidi

make proto 一鍵生成 Go 代碼。

2. 構建 Unary RPC

在 exam.proto 文件中編寫 Exam Service：

syntax = "proto3";

package exam;

option go_package = "generated/exampb";

service ExamService {
rpc GetExamResult(GetExamResultRequest) returns (GetExamResultResponse); //unary
}

message GetExamResultRequest {
string student_id = 1;
string exam_id = 2;
}

message GetExamResultResponse {
string student_name = 1;
string subject = 2;
int32 marks_obtained = 3;
int32 total_marks = 4;
string grade = 5;
}

執行 make proto 生成 Go 代碼，代碼會被放到 proto/generated 目錄。

在 server/servers/exam_service_server.go 中定義：

package servers

import"github.com/pixperk/grpc_exam/proto/generated/exampb"

type ExamServiceServer struct {
    exampb.UnimplementedExamServiceServer
    examData map[string]*exampb.GetExamResultResponse
}

func NewExamServiceServer() *ExamServiceServer {
    data := map[string]*exampb.GetExamResultResponse{
        "123_math101": {
            StudentName:   "John Doe",
            Subject:       "Math 101",
            MarksObtained: 95,
            TotalMarks:    100,
            Grade:         "A+",
        },
        "456_phy101": {
            StudentName:   "Jane Smith",
            Subject:       "Physics 101",
            MarksObtained: 88,
            TotalMarks:    100,
            Grade:         "A",
        },
    }

    return &ExamServiceServer{
        examData: data,
    }
}

接下來設計服務端和客戶端。先寫開發客戶端和服務端的 main.go。

server/main.go：

package main

import (
    "net"

    "log/slog"

    "github.com/pixperk/grpc_exam/proto/generated/exampb"
    "github.com/pixperk/grpc_exam/server/servers"

    "github.com/pixperk/grpc_exam/utils"
    "google.golang.org/grpc"
)

func main() {
    utils.InitLogger(true)
    //Spin up a TCP Server
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        slog.Error("failed to listen", "error", err)
    }

    //New gRPC server instance
    s := grpc.NewServer()

    //Register services
    exampb.RegisterExamServiceServer(s, servers.NewExamServiceServer())

// Start serving gRPC requests
    if err := s.Serve(lis); err != nil {
        slog.Error("failed to serve", "error", err)
    }

}

client/main.go：

package main

import (
    "log/slog"
    "os"

    "github.com/pixperk/grpc_exam/client/clients"
    "github.com/pixperk/grpc_exam/proto/generated/exampb"
    "github.com/pixperk/grpc_exam/utils"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
)

func main() {
    // Initialize logger (true = debug mode)
    utils.InitLogger(true)

    // Create a gRPC client connection to the server
    conn, err := grpc.Dial("localhost:50051", grpc.WithTransportCredentials(insecure.NewCredentials()))
    if err != nil {
        slog.Error("Failed to connect to server", "error", err)
        return
    }
    defer conn.Close()

    // Create a client for the ExamService
    client := exampb.NewExamServiceClient(conn)

    clients.Unary(client)
}

3. 編寫 Unary 服務端和客戶端

服務端 (server/servers/unary.go)：

package servers

import (
    "context"
    "fmt"

    "github.com/pixperk/grpc_exam/proto/generated/exampb"
)

func (s *ExamServiceServer) GetExamResult(ctx context.Context, req *exampb.GetExamResultRequest) (*exampb.GetExamResultResponse, error) {
    key := fmt.Sprintf("%s_%s", req.StudentId, req.ExamId)
    if result, ok := s.examData[key]; ok {
        return result, nil
    } else {
        returnnil, fmt.Errorf("exam result not found for student ID %s and exam ID %s", req.StudentId, req.ExamId)
    }
}

客戶端 (client/clients/unary.go)：

package clients

import (
    "context"
    "fmt"
    "time"

    "github.com/pixperk/grpc_exam/proto/generated/exampb"
)

func Unary(client exampb.ExamServiceClient) {

    fmt.Println("Enter student ID and exam ID (e.g., 123 math101):")
    var studentID, examID string
    fmt.Scanf("%s %s", &studentID, &examID)

    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    resp, err := client.GetExamResult(ctx, &exampb.GetExamResultRequest{StudentId: studentID, ExamId: examID})
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    fmt.Printf("Student Name: %s\n", resp.StudentName)
    fmt.Printf("Subject: %s\n", resp.Subject)
    fmt.Printf("Marks Obtained: %d out of %d\n", resp.MarksObtained, resp.TotalMarks)
    fmt.Printf("Grade: %s\n", resp.Grade)
    fmt.Println("Unary RPC call completed successfully.")

}

上面的代碼，就是一些基礎的函數調用與簡單的 Go 編程。在兩個終端分別運行 make server 和 make client 即可看到效果。

Server Streaming 和 Client Streaming 也很簡單，只要熟悉 Go 流式處理即可。下面直接跳到雙向流（Bidirectional Streaming）。

六、構建雙向 RPC

在 exam.proto 中增加：

rpc LiveExamQuery(stream GetExamResultRequest) returns (stream GetExamResultResponse); //bidi streaming

在 servers/bi_stream.go 文件中開發以下代碼：

package servers

import (
    "fmt"
    "io"

    "github.com/pixperk/grpc_exam/proto/generated/exampb"
)


func (s *ExamServiceServer) LiveExamQuery(stream exampb.ExamService_LiveExamQueryServer) error {
    for {
        // Receive a stream request from the client
        req, err := stream.Recv()
        if err != nil {
            // If the client closes the stream (EOF), stop the loop gracefully
            if err == io.EOF {
                returnnil
            }
            // If another error occurred, return it
            return err
        }

        key := fmt.Sprintf("%s_%s", req.StudentId, req.ExamId)

        result, ok := s.examData[key]

        // If result is not found, send a default "Not Found" response
        if !ok {
            err := stream.Send(&exampb.GetExamResultResponse{
                StudentName:   "N/A",
                Subject:       req.ExamId,
                MarksObtained: 0,
                TotalMarks:    0,
                Grade:         "Not Found",
            })
            if err != nil {
                return err // Stop on send error
            }
            continue
        }

        // If result is found, send it back to the client over the stream
        if err := stream.Send(result); err != nil {
            return err // Stop on send error
        }
    }
}

LiveExamQuery 函數邏輯如下：

不斷從客戶端接收查詢；
立即返回對應結果（若存在）；
直到客戶端結束（EOF）；

七、Go Channel 簡介

Go Channel 像管道一樣在 goroutine 間傳遞數據，可安全同步，無需顯式 mutex。

創建：done := make(chan struct{})
發送：done <- struct{}{}
接收：<-done

Go Channel 發送或接收前都會阻塞，非常適合協同。

八、回到 bi-dir 客戶端

package clients

import (
    "bufio"
    "context"
    "fmt"
    "io"
    "log"
    "os"
    "strings"

    "github.com/pixperk/grpc_exam/proto/generated/exampb"
)

func BiDirectional(client exampb.ExamServiceClient) {
    //body
}

讓我們逐步來看看這個函數體里都發生了什么：

stream, err := client.LiveExamQuery(context.Background())
done := make(chan struct{})

LiveExamQuery 會與服務器建立一個雙向流。

創建 done 通道是為了在接收方 goroutine 結束時發出信號。

go func() {
        for {
            res, err := stream.Recv() //receive stream from the server
            if err != nil {
                if err == io.EOF {
                    break
                }
                log.Fatalf("Error receiving response: %v", err)
                break
            }
            fmt.Printf("?? %s | %s: %d/%d (%s)\n",
                res.StudentName, res.Subject, res.MarksObtained, res.TotalMarks, res.Grade)

            fmt.Print("Enter student_id and exam_id (or 'exit'): ")
        }
        close(done)

    }()

    // Initial prompt
    fmt.Print("Enter student_id and exam_id (or 'exit'): ")

這個 goroutine 用來監聽服務器的響應并將其打印出來。

它在后臺運行，而主線程負責處理用戶輸入。

reader := bufio.NewReader(os.Stdin)
//Send data
    for {
        line, _ := reader.ReadString('\n')
        line = strings.TrimSpace(line)
        if line == "exit" {
            stream.CloseSend()
            break
        }
        parts := strings.Fields(line)
        iflen(parts) != 2 {
            fmt.Println("??  Usage: <student_id> <exam_id>")
            continue
        }
        req := &exampb.GetExamResultRequest{
            StudentId: parts[0],
            ExamId:    parts[1],
        }
        if err := stream.Send(req); err != nil {
            log.Printf("send error: %v", err)
            break
        }
    }

讀取用戶輸入（student_id exam_id）。
通過流將每個請求發送到服務器。
如果輸入 exit，客戶端會關閉發送流。

<-done
fmt.Println("?? Session ended.")

通過 done 通道等待接收端 goroutine 結束。
確保所有通信完成后程序才退出。
現在可以像之前那樣，使用 make 命令來測試這個雙向 RPC。

九、收獲總結

通過該項目你將學會了以下知識：

編寫 .proto 并生成 Go 代碼；
實現 Unary / Streaming / 雙向流全套 RPC；
在 Go 中用通道與協程管理并發；
組織微服務項目結構，保持易維護、可擴展。

無論你是剛入門 RPC，還是想在微服務中實現高效通信，都希望這份項目能提供一個良好的起點。

責任編輯：趙寧寧來源：令飛編程

Go gRPC 微服務

成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看