为什么 grpc message 不可直接值复制

// Protobuf消息定义示例
syntax = "proto3";

message UserRequest {
    int64 user_id = 1;
    string name = 2;
    int32 age = 3;
}

message UserResponse {
    int64 user_id = 1;
    string status = 2;
}

// 1. 先定义 Protobuf 消息（user.proto）
syntax = "proto3";
package demo;

message User {
  string name = 1;
  int32 age = 2;
  Address addr = 3; // 嵌套 message
}

message Address {
  string city = 1;
  string street = 2;
}

// 2. 通过 protoc 生成 Go 结构体（简化后关键部分）
type User struct {
  Name string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
  Age  int32    `protobuf:"varint,2,opt,name=age,proto3" json:"age,omitempty"`
  Addr *Address `protobuf:"bytes,3,opt,name=addr,proto3" json:"addr,omitempty"` // 指针类型
  // 未导出字段
  XXX_unrecognized []byte `json:"-"`
}

// 3. 直接值复制导致的问题
func main() {
  // 构造源消息
  srcUser := &demo.User{
    Name: "张三",
    Age:  25,
    Addr: &demo.Address{
      City:  "北京",
      Street: "朝阳路",
    },
  }

  // 直接值复制（浅拷贝）
  copyUser := *srcUser // 注意：这里是值复制，copyUser.Addr 与 srcUser.Addr 指向同一地址

  // 修改复制消息的嵌套字段
  copyUser.Addr.City = "上海"

  // 结果：源消息的 Addr.City 也被修改了！
  fmt.Printf("源消息城市：%s\n", srcUser.Addr.City)  // 输出：上海（预期应为北京）
  fmt.Printf("复制消息城市：%s\n", copyUser.Addr.City) // 输出：上海
}

type InternalUser struct {
    ID   string
    Name string
    Age  int
}

type UserRequest struct {
    UserId int64  `protobuf:"varint,1,opt,name=user_id"`
    Name   string `protobuf:"bytes,2,opt,name=name"`
    Age    int32  `protobuf:"varint,3,opt,name=age"`
}

// 错误：直接字段复制
func convertUser(internal *InternalUser) *UserRequest {
    return &UserRequest{
        UserId: internal.ID,  // 错误：string vs int64
        Name:   internal.Name,
        Age:    internal.Age, // 错误：int vs int32
    }
}

func safeCloneExample() {
    original := &UserRequest{
        UserId: 123,
        Name:   "张三",
        Age:    25,
    }

    // 正确方式1：使用Clone方法（如果生成）
    cloned := proto.Clone(original).(*UserRequest)

    // 正确方式2：手动创建新实例
    cloned2 := &UserRequest{
        UserId: original.UserId,
        Name:   original.Name,
        Age:    original.Age,
    }

    fmt.Printf("Original: %+v\n", original)
    fmt.Printf("Cloned: %+v\n", cloned)
}

import "github.com/jinzhu/copier"

type InternalUser struct {
    ID   string `copier:"UserId"`  // 指定字段映射
    Name string
    Age  int    `copier:"Age"`     // 支持自动类型转换
}

func safeCopyWithCopier() error {
    internal := &InternalUser{
        ID:   "123",
        Name: "李四",
        Age:  30,
    }

    var grpcReq UserRequest

    // 自动处理字段映射和类型转换
    if err := copier.Copy(&grpcReq, internal); err != nil {
        return fmt.Errorf("复制失败: %v", err)
    }

    fmt.Printf("转换结果: UserId=%d, Name=%s, Age=%d\n", 
        grpcReq.UserId, grpcReq.Name, grpcReq.Age)
    return nil
}

func advancedCopyExample() error {
    // 注册自定义类型转换器
    copier.CopyWithOption(&grpcReq, internal, copier.Option{
        Converters: []copier.TypeConverter{
            {
                // string -> int64 转换
                SrcType: string(""),
                DstType: int64(0),
                Fn: func(src interface{}) (interface{}, error) {
                    str, ok := src.(string)
                    if !ok {
                        return nil, fmt.Errorf("类型断言失败")
                    }
                    return strconv.ParseInt(str, 10, 64)
                },
            },
            {
                // int -> int32 转换  
                SrcType: int(0),
                DstType: int32(0),
                Fn: func(src interface{}) (interface{}, error) {
                    i, ok := src.(int)
                    if !ok {
                        return nil, fmt.Errorf("类型断言失败")
                    }
                    return int32(i), nil
                },
            },
        },
    })

    return nil
}