如何将嵌套Go结构体Client的数据自动复制到Server结构体？

方法一：手动字段映射 #

如果结构体层级不多，手动逐个字段复制最直观，性能也最优：

// 复制顶层字段
server.Name = client.Name

// 处理嵌套的ACL切片
server.ACL = make([]ACLRule, len(client.ACL))
for i, clientRule := range client.ACL {
    // 利用字段匹配直接转换结构体（指针解引用后转值类型）
    server.ACL[i] = ACLRule(*clientRule)
}

方法二：反射实现通用复制（自动化） #

如果需要支持任意同字段结构的嵌套结构体复制，可借助Go的reflect包实现通用工具函数，自动遍历字段完成复制：

import (
    "fmt"
    "reflect"
)

// CopyStruct 支持嵌套结构体/切片的通用复制，适配指针与值类型的转换
func CopyStruct(dst, src interface{}) error {
    dstVal := reflect.ValueOf(dst).Elem()
    srcVal := reflect.ValueOf(src).Elem()

    // 检查顶层字段数量是否匹配
    if dstVal.NumField() != srcVal.NumField() {
        return fmt.Errorf("struct field count mismatch")
    }

    for i := 0; i < srcVal.NumField(); i++ {
        srcField := srcVal.Field(i)
        dstField := dstVal.Field(i)

        if !dstField.CanSet() {
            continue
        }

        // 处理切片类型
        if srcField.Kind() == reflect.Slice && dstField.Kind() == reflect.Slice {
            dstSlice := reflect.MakeSlice(dstField.Type(), srcField.Len(), srcField.Len())
            for j := 0; j < srcField.Len(); j++ {
                srcElem := srcField.Index(j)
                dstElem := dstSlice.Index(j)

                // 解引用指针类型的切片元素
                if srcElem.Kind() == reflect.Ptr {
                    srcElem = srcElem.Elem()
                }

                // 嵌套结构体递归复制，普通类型直接赋值
                if srcElem.Kind() == reflect.Struct {
                    if err := CopyStruct(dstElem.Addr().Interface(), srcElem.Addr().Interface()); err != nil {
                        return err
                    }
                } else {
                    dstElem.Set(srcElem)
                }
            }
            dstField.Set(dstSlice)
            continue
        }

        // 处理嵌套结构体
        if srcField.Kind() == reflect.Struct && dstField.Kind() == reflect.Struct {
            if err := CopyStruct(dstField.Addr().Interface(), srcField.Addr().Interface()); err != nil {
                return err
            }
            continue
        }

        // 普通类型直接赋值，或处理指针-值类型转换
        if dstField.Type() == srcField.Type() {
            dstField.Set(srcField)
        } else {
            if srcField.Kind() == reflect.Ptr && dstField.Kind() == reflect.Struct && srcField.Elem().Type() == dstField.Type() {
                dstField.Set(srcField.Elem())
            } else if dstField.Kind() == reflect.Ptr && srcField.Kind() == reflect.Struct && dstField.Elem().Type() == srcField.Type() {
                dstField.Set(reflect.New(srcField.Type()))
                dstField.Elem().Set(srcField)
            } else {
                return fmt.Errorf("unsupported type conversion: %s -> %s", srcField.Type(), dstField.Type())
            }
        }
    }
    return nil
}

使用示例：

func main() {
    client := &Client{
        Name: "Test",
        ACL: []*ClientACLRule{
            {Id: 1, Role: "client1"},
            {Id: 2, Role: "client2"},
        },
    }
    server := &Server{}

    if err := CopyStruct(server, client); err != nil {
        fmt.Println("复制失败:", err)
        return
    }
    fmt.Printf("复制后的Server: %+v\n", server)
}

方法三：JSON序列化中转 #

通过JSON序列化做中间转换，代码简洁但性能略低，要求结构体字段支持JSON序列化：

import "encoding/json"

func main() {
    client := &Client{/* 已初始化数据 */}
    server := &Server{}

    data, err := json.Marshal(client)
    if err != nil {
        // 处理序列化错误
    }
    if err := json.Unmarshal(data, server); err != nil {
        // 处理反序列化错误
    }
}

内容的提问来源于stack exchange，提问作者Mohammed Saaduddin Ansari