徹底學會 gRPC：用 Go 實現一個迷你考試服務
作者：孔令飛
本文將通過用 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：
- 體積更?。憾M制編碼；
- 速度更快：序列化 / 反序列化省時；
- 字段用編號：解析無需比對字符串；
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_bidimake 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，還是想在微服務中實現高效通信，都希望這份項目能提供一個良好的起點。
責任編輯：趙寧寧
來源：
令飛編程
