Go中如何跨语言实现传输？ - GRPC

gRPC 是 Google 开源的高性能 RPC 框架，基于 HTTP/2 协议和 Protocol Buffers（Protobuf）序列化，支持多语言、流式传输和企业级特性。与 RESTful API 相比，它性能更高、接口定义更规范，特别适合微服务架构和跨语言服务调用。

# 1. 安装 protoc 编译器
# Mac 
brew install protobuf 
# Linux 
apt install -y protobuf-compiler

# 2. 安装 Go 插件
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
# 3. 安装 gRPC 核心库
go get google.golang.org/grpc

Unary RPC （一元 RPC）

grpc-demo/
├── proto/ 
│ └── user.proto # Protobuf 定义文件 
├── server/ 
│ └── main.go # gRPC 服务端
├── client/ 
│ └── main.go # gRPC 客户端 
└── go.mod

编写 Protobuf 定义（proto/user.proto）

这是 gRPC 开发的核心，定义接口契约。

// 指定 Protobuf 版本 
syntax = "proto3"; 
// 指定生成的 Go 代码的包路径 
option go_package = "./proto"; 
// 定义包名 
package user;

// 定义消息（数据结构）
message User {
  uint32 id = 1; // 字段编号：1-15 占 1 字节，常用字段优先
  string username = 2;
  string email = 3;
}

message GetUserRequest {
  uint32 user_id = 1;
}

message GetUserResponse {
  User user = 1;
}

// 定义服务
service UserService {
  // 一元 RPC 方法
  rpc GetUser(GetUserRequest) returns (GetUserResponse);
}

• syntax = "proto3"; ：指定使用 Protobuf v3 版本（推荐，比 v2 更简洁）。

• option go_package = "./proto"; ：指定生成的 Go 代码的包路径。

• 消息字段编号：每个字段必须有唯一的编号，1-15 占 1 字节，16-2047 占 2 字节，常用字段建议用 1-15。

• service Xxx { rpc Yyy(Req) returns (Resp) }：定义服务，包含多个 RPC 方法。

• rpc 方法名(请求) returns (响应) ：定义 RPC 方法。

• message Xxx { type field = tag; }:定义消息结构，tag 必须唯一

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

执行成功后，会在 proto/ 目录下生成两个文件：

• user.pb.go：消息结构的 Go 代码
• user_grpc.pb.go：服务接口的 Go 代码

服务端实现

import (pb "grpc-demo/proto")

// 定义服务结构体，必须嵌入 Unimplemented*Server
type UserServer struct {
	pb.UnimplementedUserServiceServer // 必须嵌入，保证向前兼容
}

// 实现 Protobuf 中定义的 RPC 方法
func (s *UserServer) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.GetUserResponse, error) {
	// 核心业务逻辑：查询数据库等
	user := &pb.User{
		Id:       req.UserId,
		Username: "zhangsan",
		Email:    "zhangsan@example.com",
	}
	return &pb.GetUserResponse{User: user}, nil
}

func main() {
	// 监听端口
	lis, _ := net.Listen("tcp", ":50051")
	// 创建 gRPC 服务器
	s := grpc.NewServer()
	// 将服务实现注册到 gRPC 服务器
	pb.RegisterUserServiceServer(s, &UserServer{})
	// 启动服务,监听 TCP 连接
	s.Serve(lis)
}

• type XxxServer struct { pb.UnimplementedXxxServer }:定义服务结构体，必须嵌入 Unimplemented

• pb.UnimplementedUserServiceServer：必须嵌入这个结构体，确保向前兼容，即使后续服务添加了新方法，旧的服务端代码也不会报错。

• 实现服务接口：必须实现 .proto 文件中定义的所有 RPC 方法。

客户端实现

import (pb "grpc-demo/proto")

func main() {
	// 连接服务端
	conn, _ := grpc.Dial(
		"localhost:50051",
		grpc.WithTransportCredentials(insecure.NewCredentials()),
	)
	defer conn.Close()

	// 创建客户端
	client := pb.NewUserServiceClient(conn)

	// 调用 RPC 方法
	ctx := context.Background() // 空根上下文
	resp, _ := client.GetUser(ctx, &pb.GetUserRequest{UserId: 1})

	fmt.Printf("获取用户：%+v\n", resp.User)
}

• client.Yyy(ctx, &Req{}):调用 RPC 方法

拦截器

拦截器类似 Gin 中间件，用于处理通用逻辑（日志、认证、限流）。

// 日志拦截器
func LogInterceptor(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) {
	// 请求前逻辑
	fmt.Printf("收到请求：%s\n", info.FullMethod)
	
	// 调用实际 RPC 方法
	resp, err := handler(ctx, req)
	
	// 请求后逻辑
	return resp, err
}

// 注册拦截器
func main() {
	lis, _ := net.Listen("tcp", ":50051")
	// 创建服务器时注册拦截器
	s := grpc.NewServer(grpc.UnaryInterceptor(LogInterceptor))
	pb.RegisterUserServiceServer(s, &UserServer{})
	s.Serve(lis)
}

• grpc.NewServer(grpc.UnaryInterceptor(...)):创建 gRPC 服务器并注册拦截器