Go语言与Protocol Buffers集成：从定义到实践

// syntax = "proto3"; 表示使用 Protocol Buffers 的第三个版本语法
syntax = "proto3";

// package 定义了 Go 代码中生成的包名
package user;

// 定义一个 User 消息
message User {
  // 字段类型 字段名称 = 字段编号;
  // 字段编号在消息中必须是唯一的，且一旦确定不应更改
  string id = 1;
  string name = 2;
  int32 age = 3;
  repeated string emails = 4; // repeated 表示这是一个列表
  bool is_active = 5;
}

// 定义一个 UserList 消息，包含多个 User
message UserList {
  repeated User users = 1;
}

protoc --go_out=. --go_opt=paths=source_relative user.proto

package main

import (
    "fmt"
    "log"

    // 导入生成的 user 包，路径根据你的项目结构可能有所不同
    // 如果 user.proto 在当前目录，且你的 Go 模块是 myproject
    // 则导入路径可能是 "myproject/user" 或 "./user"
    // 这里假设 user.pb.go 就在 main.go 同目录下，且包名为 user
    "user" // 注意：这里导入的包名是 .proto 文件中定义的 package user;
    "google.golang.org/protobuf/proto"
)

func main() {
    // 1. 创建一个 User 消息实例
    user1 := &user.User{
        Id:       "user-001",
        Name:     "Alice",
        Age:      30,
        Emails:   []string{"alice@example.com", "alice.work@example.com"},
        IsActive: true,
    }

    user2 := &user.User{
        Id:       "user-002",
        Name:     "Bob",
        Age:      25,
        Emails:   []string{"bob@example.com"},
        IsActive: false,
    }

    // 2. 将 User 消息序列化为字节切片
    data, err := proto.Marshal(user1)
    if err != nil {
        log.Fatalf("无法序列化 User: %v", err)
    }
    fmt.Printf("序列化后的 User 数据大小: %d 字节\n", len(data))
    // 打印字节数据（通常不直接查看，但可以用于调试）
    // fmt.Printf("序列化后的 User 数据: %x\n", data)

    // 3. 将字节切片反序列化回 User 消息实例
    newUser := &user.User{}
    err = proto.Unmarshal(data, newUser)
    if err != nil {
        log.Fatalf("无法反序列化 User: %v", err)
    }
    fmt.Printf("反序列化后的 User: %+v\n", newUser)
    fmt.Printf("反序列化后的 User ID: %s, Name: %s\n", newUser.GetId(), newUser.GetName())

    fmt.Println("\n--- 处理 UserList ---")

    // 4. 创建一个 UserList 消息实例
    userList := &user.UserList{
        Users: []*user.User{user1, user2},
    }

    // 5. 序列化 UserList
    listData, err := proto.Marshal(userList)
    if err != nil {
        log.Fatalf("无法序列化 UserList: %v", err)
    }
    fmt.Printf("序列化后的 UserList 数据大小: %d 字节\n", len(listData))

    // 6. 反序列化 UserList
    newUsers := &user.UserList{}
    err = proto.Unmarshal(listData, newUsers)
    if err != nil {
        log.Fatalf("无法反序列化 UserList: %v", err)
    }
    fmt.Printf("反序列化后的 UserList 包含 %d 个用户\n", len(newUsers.GetUsers()))
    for i, u := range newUsers.GetUsers() {
        fmt.Printf("  用户 %d: ID=%s, Name=%s\n", i+1, u.GetId(), u.GetName())
    }
}

序列化后的 User 数据大小: 50 字节
反序列化后的 User: id:"user-001" name:"Alice" age:30 emails:"alice@example.com" emails:"alice.work@example.com" is_active:true
反序列化后的 User ID: user-001, Name: Alice

--- 处理 UserList ---
序列化后的 UserList 数据大小: 104 字节
反序列化后的 UserList 包含 2 个用户
  用户 1: ID=user-001, Name=Alice
  用户 2: ID=user-002, Name=Bob