gRPC 简介与环境搭建

一、gRPC 简介

1.1 什么是 gRPC

gRPC 是 Google 开发的高性能、开源的 RPC（Remote Procedure Call）框架。

核心特点：

• 基于 HTTP/2 协议
• 使用 Protobuf 作为序列化协议
• 支持多种编程语言
• 支持四种通信模式
• 内置流式传输支持

1.2 gRPC 架构

1.3 为什么使用 gRPC

1.4 gRPC vs REST

特性	gRPC	REST
协议	HTTP/2	HTTP/1.1
数据格式	Protobuf（二进制）	JSON（文本）
性能	高	中
流式传输	原生支持	有限支持
浏览器支持	需要 gRPC-Web	原生支持
接口定义	.proto 文件	OpenAPI/Swagger
代码生成	自动	手动或工具

二、环境搭建

2.1 安装 protoc

macOS：

brew install protobuf
protoc --version

Linux：

wget https://github.com/protocolbuffers/protobuf/releases/download/v25.1/protoc-25.1-linux-x86_64.zip
unzip protoc-25.1-linux-x86_64.zip -d protoc
sudo mv protoc/bin/protoc /usr/local/bin/
sudo mv protoc/include/* /usr/local/include/

2.2 安装 Go 插件

# protoc-gen-go：生成消息代码
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest

# protoc-gen-go-grpc：生成 gRPC 代码
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

# 确保在 PATH 中
export PATH="$PATH:$(go env GOPATH)/bin"

2.3 安装 Go 依赖

go get google.golang.org/grpc
go get google.golang.org/protobuf

2.4 验证安装

protoc --version
which protoc-gen-go
which protoc-gen-go-grpc

三、快速开始

3.1 项目结构

grpc-demo/
├── proto/
│   └── hello.proto
├── pb/
│   ├── hello.pb.go
│   └── hello_grpc.pb.go
├── server/
│   └── main.go
├── client/
│   └── main.go
├── Makefile
└── go.mod

3.2 定义服务（hello.proto）

syntax = "proto3";

package hello;

option go_package = "grpc-demo/pb";

// 请求消息
message HelloRequest {
  string name = 1;
}

// 响应消息
message HelloResponse {
  string message = 1;
}

// 服务定义
service Greeter {
  rpc SayHello(HelloRequest) returns (HelloResponse);
}

3.3 生成代码

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

3.4 实现服务端

// server/main.go
package main

import (
    "context"
    "log"
    "net"
    
    "google.golang.org/grpc"
    pb "grpc-demo/pb"
)

// 实现服务
type server struct {
    pb.UnimplementedGreeterServer
}

func (s *server) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloResponse, error) {
    log.Printf("收到请求: %s", req.Name)
    return &pb.HelloResponse{
        Message: "Hello, " + req.Name + "!",
    }, nil
}

func main() {
    // 监听端口
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("监听失败: %v", err)
    }
    
    // 创建 gRPC 服务器
    s := grpc.NewServer()
    
    // 注册服务
    pb.RegisterGreeterServer(s, &server{})
    
    log.Println("gRPC 服务器启动，监听端口 :50051")
    
    // 启动服务
    if err := s.Serve(lis); err != nil {
        log.Fatalf("服务启动失败: %v", err)
    }
}

3.5 实现客户端

// client/main.go
package main

import (
    "context"
    "log"
    "time"
    
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
    pb "grpc-demo/pb"
)

func main() {
    // 连接服务器
    conn, err := grpc.Dial(
        "localhost:50051",
        grpc.WithTransportCredentials(insecure.NewCredentials()),
    )
    if err != nil {
        log.Fatalf("连接失败: %v", err)
    }
    defer conn.Close()
    
    // 创建客户端
    client := pb.NewGreeterClient(conn)
    
    // 设置超时
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    
    // 调用服务
    resp, err := client.SayHello(ctx, &pb.HelloRequest{Name: "张三"})
    if err != nil {
        log.Fatalf("调用失败: %v", err)
    }
    
    log.Printf("响应: %s", resp.Message)
}

3.6 运行

# 终端1：启动服务器
go run server/main.go

# 终端2：运行客户端
go run client/main.go
# 输出：响应: Hello, 张三!

四、Makefile

.PHONY: proto server client clean

proto:
	protoc --go_out=. --go_opt=paths=source_relative \
		--go-grpc_out=. --go-grpc_opt=paths=source_relative \
		proto/*.proto

server:
	go run server/main.go

client:
	go run client/main.go

clean:
	rm -f pb/*.pb.go

五、四种通信模式

5.1 一元 RPC（Unary）

rpc SayHello(HelloRequest) returns (HelloResponse);

客户端发送一个请求，服务端返回一个响应。

5.2 服务端流（Server Streaming）

rpc ListUsers(ListRequest) returns (stream User);

客户端发送一个请求，服务端返回多个响应。

5.3 客户端流（Client Streaming）

rpc UploadFile(stream FileChunk) returns (UploadResponse);

客户端发送多个请求，服务端返回一个响应。

5.4 双向流（Bidirectional Streaming）

rpc Chat(stream ChatMessage) returns (stream ChatMessage);

客户端和服务端都可以发送多个消息。

六、HTTP/2 特性

6.1 多路复用

6.2 头部压缩

HTTP/2 使用 HPACK 压缩头部，减少传输数据量。

6.3 服务器推送

服务器可以主动向客户端推送数据。

七、总结