golang

gRPC 基础：构建高性能微服务通信

gRPC 是基于 HTTP/2 和 Protocol Buffers 的高性能 RPC 框架，支持四种调用模式与流式传输，是 Go 微服务架构中服务间通信的首选方案

Leeting Yan 2025-08-13 9 分钟阅读 4197 字

gRPC 基础：构建高性能微服务通信

在微服务架构中，服务间通信是关键。RESTful API 虽然流行，但在性能、类型安全和代码生成方面存在局限。gRPC 作为 Google 开源的高性能 RPC 框架，提供了更优的解决方案。

本文将深入讲解如何使用 gRPC 和 Protocol Buffers 构建高效的微服务通信。

什么是 gRPC？

gRPC 是一个现代开源的高性能 RPC 框架，具有以下特点：

基于 HTTP/2：支持多路复用、头部压缩、双向流
Protocol Buffers：高效的二进制序列化格式
强类型：通过 .proto 文件定义接口
代码生成：自动生成客户端和服务端代码
跨语言：支持多种编程语言

gRPC 的核心理念是使用接口定义语言（IDL，即 .proto 文件）来描述服务的 API。开发者定义服务方法和消息结构，gRPC 工具链自动为目标语言生成类型安全的客户端框架和服务端桩代码。这种声明式的方法避免了传统 REST API 中手动编写 URL 路径、解析 JSON 和处理版本兼容性的麻烦。

安装工具

# 安装 Protocol Buffers 编译器
brew install protobuf  # macOS
# 或从 https://github.com/protocolbuffers/protobuf/releases 下载

# 安装 Go 插件
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

定义服务（.proto 文件）

syntax = "proto3";

package user;

option go_package = "example.com/user";

// 用户服务
service UserService {
  // 一元 RPC
  rpc GetUser (GetUserRequest) returns (User);

  // 服务器流 RPC
  rpc ListUsers (ListUsersRequest) returns (stream User);

  // 客户端流 RPC
  rpc CreateUser (stream CreateUserRequest) returns (CreateUserResponse);

  // 双向流 RPC
  rpc Chat (stream ChatMessage) returns (stream ChatMessage);
}

// 用户消息
message User {
  int32 id = 1;
  string name = 2;
  string email = 3;
  int32 age = 4;
}

// 请求消息
message GetUserRequest {
  int32 id = 1;
}

message ListUsersRequest {
  int32 page = 1;
  int32 page_size = 2;
}

message CreateUserRequest {
  string name = 1;
  string email = 2;
  int32 age = 3;
}

message CreateUserResponse {
  int32 created_count = 1;
}

message ChatMessage {
  string sender = 1;
  string content = 2;
}

生成代码

protoc --go_out=. --go-grpc_out=. user.proto

这会生成两个文件：

user.pb.go：消息类型定义
user_grpc.pb.go：服务接口和客户端

实现服务端

package main

import (
    "context"
    "fmt"
    "io"
    "log"
    "net"
    "sync"

    "google.golang.org/grpc"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"

    pb "example.com/user"
)

type userServer struct {
    pb.UnimplementedUserServiceServer
    mu    sync.RWMutex
    users map[int32]*pb.User
}

func newServer() *userServer {
    return &userServer{
        users: make(map[int32]*pb.User),
    }
}

// GetUser 一元 RPC
func (s *userServer) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.User, error) {
    s.mu.RLock()
    defer s.mu.RUnlock()

    user, exists := s.users[req.Id]
    if !exists {
        return nil, status.Errorf(codes.NotFound, "user not found: %d", req.Id)
    }

    return user, nil
}

// ListUsers 服务器流 RPC
func (s *userServer) ListUsers(req *pb.ListUsersRequest, stream pb.UserService_ListUsersServer) error {
    s.mu.RLock()
    defer s.mu.RUnlock()

    start := (req.Page - 1) * req.PageSize
    end := start + req.PageSize

    count := int32(0)
    for _, user := range s.users {
        if count >= start && count < end {
            if err := stream.Send(user); err != nil {
                return err
            }
        }
        count++
    }

    return nil
}

// CreateUser 客户端流 RPC
func (s *userServer) CreateUser(stream pb.UserService_CreateUserServer) error {
    s.mu.Lock()
    defer s.mu.Unlock()

    createdCount := int32(0)

    for {
        req, err := stream.Recv()
        if err == io.EOF {
            return stream.SendAndClose(&pb.CreateUserResponse{
                CreatedCount: createdCount,
            })
        }
        if err != nil {
            return err
        }

        id := int32(len(s.users) + 1)
        user := &pb.User{
            Id:    id,
            Name:  req.Name,
            Email: req.Email,
            Age:   req.Age,
        }

        s.users[id] = user
        createdCount++

        log.Printf("Created user: %d", id)
    }
}

// Chat 双向流 RPC
func (s *userServer) Chat(stream pb.UserService_ChatServer) error {
    for {
        msg, err := stream.Recv()
        if err == io.EOF {
            return nil
        }
        if err != nil {
            return err
        }

        log.Printf("Received from %s: %s", msg.Sender, msg.Content)

        reply := &pb.ChatMessage{
            Sender:  "Server",
            Content: fmt.Sprintf("Echo: %s", msg.Content),
        }

        if err := stream.Send(reply); err != nil {
            return err
        }
    }
}

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

    s := grpc.NewServer()
    pb.RegisterUserServiceServer(s, newServer())

    log.Println("gRPC server listening on :50051")
    if err := s.Serve(lis); err != nil {
        log.Fatalf("Failed to serve: %v", err)
    }
}

实现客户端

package main

import (
    "context"
    "io"
    "log"
    "time"

    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"

    pb "example.com/user"
)

func main() {
    conn, err := grpc.Dial("localhost:50051",
        grpc.WithTransportCredentials(insecure.NewCredentials()))
    if err != nil {
        log.Fatalf("Failed to connect: %v", err)
    }
    defer conn.Close()

    client := pb.NewUserServiceClient(conn)
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    // 一元 RPC
    log.Println("=== Unary RPC ===")
    user, err := client.GetUser(ctx, &pb.GetUserRequest{Id: 1})
    if err != nil {
        log.Printf("GetUser error: %v", err)
    } else {
        log.Printf("User: %v", user)
    }

    // 服务器流 RPC
    log.Println("\n=== Server Streaming RPC ===")
    stream, err := client.ListUsers(ctx, &pb.ListUsersRequest{
        Page:     1,
        PageSize: 10,
    })
    if err != nil {
        log.Fatalf("ListUsers error: %v", err)
    }

    for {
        user, err := stream.Recv()
        if err == io.EOF {
            break
        }
        if err != nil {
            log.Fatalf("Stream error: %v", err)
        }
        log.Printf("User: %v", user)
    }

    // 客户端流 RPC
    log.Println("\n=== Client Streaming RPC ===")
    stream2, err := client.CreateUser(ctx)
    if err != nil {
        log.Fatalf("CreateUser error: %v", err)
    }

    users := []*pb.CreateUserRequest{
        {Name: "Alice", Email: "alice@example.com", Age: 30},
        {Name: "Bob", Email: "bob@example.com", Age: 25},
        {Name: "Charlie", Email: "charlie@example.com", Age: 35},
    }

    for _, req := range users {
        if err := stream2.Send(req); err != nil {
            log.Fatalf("Send error: %v", err)
        }
        log.Printf("Sent: %v", req)
    }

    resp, err := stream2.CloseAndRecv()
    if err != nil {
        log.Fatalf("CloseAndRecv error: %v", err)
    }
    log.Printf("Created %d users", resp.CreatedCount)

    // 双向流 RPC
    log.Println("\n=== Bidirectional Streaming RPC ===")
    stream3, err := client.Chat(ctx)
    if err != nil {
        log.Fatalf("Chat error: %v", err)
    }

    go func() {
        messages := []string{"Hello", "How are you?", "Goodbye"}
        for _, msg := range messages {
            if err := stream3.Send(&pb.ChatMessage{
                Sender:  "Client",
                Content: msg,
            }); err != nil {
                log.Printf("Send error: %v", err)
                return
            }
            log.Printf("Sent: %s", msg)
            time.Sleep(1 * time.Second)
        }
        stream3.CloseSend()
    }()

    for {
        reply, err := stream3.Recv()
        if err == io.EOF {
            break
        }
        if err != nil {
            log.Fatalf("Recv error: %v", err)
        }
        log.Printf("Received from %s: %s", reply.Sender, reply.Content)
    }
}

进阶概念：protobuf 编码解码原理

Protocol Buffers 是一种二进制序列化协议，其核心优势在于紧凑的数据表示和高效的编解码性能。protobuf 使用变长编码（Varint）来表示整数，相比 JSON 的文本表示方式可以大幅减少数据体积。

编码规则包括以下关键点：每个字段由字段编号和 wire type 组合而成的 tag 标识。Varint 编码使小整数只需 1 个字节。字符串采用长度前缀编码。嵌套消息作为字节块嵌入。掌握这些原理有助于理解 gRPC 的高效性能来源。

// protobuf 的 wire type 定义
const (
    WireVarint     = 0 // int32, int64, uint32, uint64, sint32, sint64, bool, enum
    WireFixed64    = 1 // fixed64, sfixed64, double
    WireLengthDelimited = 2 // string, bytes, embedded messages, packed repeated fields
    WireStartGroup = 3 // group 的开始（已弃用）
    WireEndGroup   = 4 // group 的结束（已弃用）
    WireFixed32    = 5 // fixed32, sfixed32, float
)

进阶概念：gRPC 调用生命周期

gRPC 一次完整的调用经过以下阶段：DNS 解析获取服务端地址、建立 HTTP/2 连接（可以复用现有连接）、发送 HEADERS 帧携带元数据和调用方法信息、发送请求消息体（DATA 帧）、服务端处理并返回响应（HEADERS + DATA 帧）、客户端接收响应并关闭流。在 Go 的实现中，grpc.Dial 返回的 *grpc.ClientConn 是一个连接池，可以复用连接处理多个并发 RPC。

进阶概念：拦截器执行顺序与流控机制

gRPC 拦截器的执行顺序值得特别关注。服务端一元拦截器按注册顺序正序执行，流拦截器按正序执行。客户端一元拦截器按注册顺序的逆序执行。理解这个顺序对调试和正确使用拦截器至关重要。流控机制方面，gRPC 基于 HTTP/2 的流控制实现背压，接收方可通告可用的窗口大小，发送方仅在窗口足够时发送数据。这能防止消费者被生产者压垮。

package main

import (
    "context"
    "log"
    "time"

    "google.golang.org/grpc"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/metadata"
    "google.golang.org/grpc/status"
)

// 服务端日志拦截器
func loggingInterceptor(
    ctx context.Context,
    req interface{},
    info *grpc.UnaryServerInfo,
    handler grpc.UnaryHandler,
) (interface{}, error) {
    start := time.Now()
    resp, err := handler(ctx, req)
    log.Printf("Method: %s, Duration: %v, Error: %v",
        info.FullMethod, time.Since(start), err)
    return resp, err
}

// 服务端认证拦截器
func authInterceptor(
    ctx context.Context,
    req interface{},
    info *grpc.UnaryServerInfo,
    handler grpc.UnaryHandler,
) (interface{}, error) {
    md, ok := metadata.FromIncomingContext(ctx)
    if !ok {
        return nil, status.Error(codes.Unauthenticated, "missing metadata")
    }
    tokens := md["authorization"]
    if len(tokens) == 0 {
        return nil, status.Error(codes.Unauthenticated, "missing token")
    }
    if tokens[0] != "Bearer valid-token" {
        return nil, status.Error(codes.Unauthenticated, "invalid token")
    }
    return handler(ctx, req)
}

// 客户端重试拦截器
func retryInterceptor(
    ctx context.Context,
    method string,
    req, reply interface{},
    cc *grpc.ClientConn,
    invoker grpc.UnaryInvoker,
    opts ...grpc.CallOption,
) error {
    maxRetries := 3
    for i := 0; i < maxRetries; i++ {
        err := invoker(ctx, method, req, reply, cc, opts...)
        if err == nil {
            return nil
        }
        st, ok := status.FromError(err)
        if !ok || st.Code() != codes.Unavailable {
            return err
        }
        log.Printf("Retry %d/%d for %s", i+1, maxRetries, method)
        time.Sleep(time.Duration(i+1) * time.Second)
    }
    return status.Error(codes.Unavailable, "max retries exceeded")
}

实战：完整的服务注册与发现

package main

import (
    "context"
    "fmt"
    "log"
    "net"
    "sync"
    "time"

    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
    "google.golang.org/grpc/resolver"

    pb "example.com/user"
)

// ServiceRegistry 简单的内存服务注册中心
type ServiceRegistry struct {
    mu       sync.RWMutex
    services map[string][]string // 服务名 -> 地址列表
}

func NewServiceRegistry() *ServiceRegistry {
    return &ServiceRegistry{
        services: make(map[string][]string),
    }
}

func (r *ServiceRegistry) Register(service, addr string) {
    r.mu.Lock()
    defer r.mu.Unlock()
    r.services[service] = append(r.services[service], addr)
}

func (r *ServiceRegistry) Discover(service string) []string {
    r.mu.RLock()
    defer r.mu.RUnlock()
    addrs := make([]string, len(r.services[service]))
    copy(addrs, r.services[service])
    return addrs
}

// 自定义 grpc resolver
func init() {
    resolver.Register(&staticBuilder{})
}

type staticBuilder struct{}

func (*staticBuilder) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOptions) (resolver.Resolver, error) {
    addrs := []resolver.Address{
        {Addr: "localhost:50051"},
        {Addr: "localhost:50052"},
    }
    cc.UpdateState(resolver.State{Addresses: addrs})
    return &staticResolver{}, nil
}

func (*staticBuilder) Scheme() string { return "static" }

type staticResolver struct{}

func (*staticResolver) ResolveNow(resolver.ResolveNowOptions) {}
func (*staticResolver) Close()                                   {}

func startServer(port int, registry *ServiceRegistry) {
    lis, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
    if err != nil {
        log.Fatal(err)
    }
    s := grpc.NewServer()
    pb.RegisterUserServiceServer(s, newServer())
    registry.Register("user-service", lis.Addr().String())
    log.Printf("Server started on %s", lis.Addr().String())
    s.Serve(lis)
}

func main() {
    registry := NewServiceRegistry()

    // 启动多个服务实例
    go startServer(50051, registry)
    go startServer(50052, registry)

    time.Sleep(1 * time.Second)

    // 客户端使用自定义 resolver
    conn, err := grpc.Dial("static:///",
        grpc.WithTransportCredentials(insecure.NewCredentials()),
        grpc.WithDefaultServiceConfig(`{"loadBalancingPolicy":"round_robin"}`),
    )
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

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

    // 发送请求（自动负载均衡）
    for i := 0; i < 5; i++ {
        _, err := client.GetUser(ctx, &pb.GetUserRequest{Id: int32(i)})
        if err != nil {
            log.Printf("Error: %v", err)
            continue
        }
    }
}

性能对比：gRPC vs HTTP/1.1 REST

维度	gRPC	HTTP/1.1 REST
传输协议	HTTP/2（多路复用）	HTTP/1.1（串行）
序列化	Protocol Buffers（二进制）	JSON（文本）
压缩比	小 3-10 倍	原始大小
解析速度	快 5-10 倍	较慢
类型安全	编译时检查	运行时检查
流支持	双向流	无原生支持
浏览器兼容	需 grpc-web	原生支持

在内部服务通信场景中，gRPC 的性能优势非常明显。以 10000 次调用为例，gRPC 的延迟通常只有 REST 的 30% 到 50%，CPU 占用也更低。但在面向客户端的 API 中，REST 因其简单性和浏览器兼容性仍是更好的选择。

错误处理与状态码映射

// 服务端：返回错误
func (s *userServer) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.User, error) {
    user, exists := s.users[req.Id]
    if !exists {
        return nil, status.Errorf(codes.NotFound, "user %d not found", req.Id)
    }
    return user, nil
}

// 客户端：处理错误
func handleGRPCError(err error) {
    st, ok := status.FromError(err)
    if !ok {
        log.Printf("Unknown error: %v", err)
        return
    }
    switch st.Code() {
    case codes.NotFound:
        log.Println("资源不存在")
    case codes.InvalidArgument:
        log.Println("参数无效")
    case codes.Unauthenticated:
        log.Println("认证失败")
    case codes.PermissionDenied:
        log.Println("权限不足")
    case codes.Unavailable:
        log.Println("服务不可用")
    default:
        log.Printf("Error: %v", st.Message())
    }
}

最佳实践：proto 包管理与优雅关闭

proto 文件应该集中管理，使用独立的仓库或模块作为协议定义的中心源。所有依赖该协议的服务引用同一份 proto 文件，避免因版本不一致导致的兼容性问题。服务端优雅关闭的实现如下：

package main

import (
    "log"
    "net"
    "os"
    "os/signal"
    "syscall"

    "google.golang.org/grpc"
    pb "example.com/user"
)

func serveGraceful() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatal(err)
    }

    s := grpc.NewServer()
    pb.RegisterUserServiceServer(s, newServer())

    // 信号处理
    go func() {
        sigCh := make(chan os.Signal, 1)
        signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
        <-sigCh
        log.Println("Shutting down server...")
        s.GracefulStop()
    }()

    log.Println("Server starting on :50051")
    if err := s.Serve(lis); err != nil {
        log.Fatalf("Failed to serve: %v", err)
    }
}

FAQ

Q1：gRPC 和 REST 应该在什么场景下选择使用？
A：gRPC 适合内部微服务通信、实时数据流、多语言系统间的后端通信。REST 适合面向浏览器的 API、第三方公开 API、需要简单调试和手动测试的场景。

Q2：如何调试 gRPC 服务？
A：可以使用 grpcurl 命令行工具直接调用 gRPC 服务而无需编写客户端代码。结合 protoset 文件，grpcurl 能提供类似 curl 的体验。也可以使用 Postman 或 BloomRPC 等 GUI 工具。

Q3：protobuf 版本 proto2 和 proto3 有什么区别？
A：proto3 语法更简洁，去除了 required 字段，所有字段默认为 optional，不再支持默认值（全部为类型零值），枚举类型默认值是第一个值为 0 的枚举项。proto3 还增加了 JSON 映射支持。新项目推荐直接使用 proto3。

Q4：gRPC 流式调用的适用场景有哪些？
A：服务器流适用于分页列表、文件传输。客户端流适用于日志收集、批量上传。双向流适用于聊天应用、实时推送、游戏同步。

Q5：gRPC 连接池如何配置？
A：grpc.Dial 创建的 ClientConn 是一个连接池。通过配置 dial options 可以控制最大流数、连接超时、KeepAlive 参数等。对于客户端负载均衡，需要配置 resolver 和 load balancing policy。

Q6：如何处理 proto 文件的版本兼容性问题？
A：遵循 proto3 的版本兼容规则：不要重命名字段编号，不要更改现有字段的 wire type，新增字段使用未被占用的编号，删除字段的编号应保留（reserved）。这些规则确保新旧版本的客户端和服务端可以互相通信。

Q7：gRPC 如何实现认证和授权？
A：gRPC 支持多种认证方式：TLS 传输层加密、Token 认证（通过 metadata 传递 JWT 等令牌）、自定义认证拦截器。推荐使用拦截器模式统一处理认证逻辑。

Q8：gRPC 的 keepalive 机制有什么作用？
A：HTTP/2 连接长时间空闲可能被中间设备（如负载均衡器）断开。gRPC 的 keepalive 通过定期发送 PING 帧来维持连接活跃。服务端可以配置最小间隔和检查策略，防止恶意客户端频繁发送 PING 帧。

延伸阅读

-gRPC 官方文档：https://grpc.io/docs/languages/go/
-Go gRPC 入门指南：https://grpc.io/docs/languages/go/basics/
-protobuf 语言规范：https://developers.google.com/protocol-buffers/docs/proto3
-gRPC 拦截器最佳实践：https://github.com/grpc-ecosystem/go-grpc-middleware
-gRPC Go 源码：https://github.com/grpc/grpc-go

gRPC 为微服务通信提供了强大的支持。掌握一元 RPC、流式 RPC、拦截器和错误处理的最佳实践，配合 Protocol Buffers 的类型安全特性，可以构建出高性能且易于维护的微服务系统。记住：gRPC 适合内部服务通信，对于面向外部的 API，REST 或 GraphQL 可能更合适。理解 gRPC 的底层原理有助于在遇到问题时快速定位和解决，充分发挥其在高并发场景中的性能优势。

继续阅读

探索更多技术文章

浏览归档，发现更多关于系统设计、工具链和工程实践的内容。

全部文章返回首页

gRPC 基础：构建高性能微服务通信

什么是 gRPC？

安装工具

定义服务（.proto 文件）

生成代码

实现服务端

实现客户端

进阶概念：protobuf 编码解码原理

进阶概念：gRPC 调用生命周期

进阶概念：拦截器执行顺序与流控机制

实战：完整的服务注册与发现

性能对比：gRPC vs HTTP/1.1 REST

错误处理与状态码映射

最佳实践：proto 包管理与优雅关闭

FAQ

延伸阅读

探索更多技术文章

「golang」更多文章