Golang使用reflect实现结构体深拷贝方法

reflect

reflect

package main

import (
    "fmt"
    "reflect"
)

// DeepCopy 尝试对传入的interface{}进行深拷贝。
// 它能够处理结构体、切片、映射以及它们的指针。
// 对于非复合类型（如基本类型），它会直接返回原值。
func DeepCopy(src interface{}) (interface{}, error) {
    if src == nil {
        return nil, nil // 空值直接返回空
    }

    srcValue := reflect.ValueOf(src)
    srcType := srcValue.Type()

    // 处理指针类型：如果是非空指针，则递归拷贝其指向的元素，然后创建一个新的指针指向新元素
    if srcType.Kind() == reflect.Ptr {
        if srcValue.IsNil() {
            // 如果是空指针，返回一个同类型的空指针
            return reflect.Zero(srcType).Interface(), nil
        }
        // 获取指针指向的元素，递归深拷贝
        elemCopy, err := DeepCopy(srcValue.Elem().Interface())
        if err != nil {
            return nil, err
        }
        // 创建一个新的指针，并将其指向新拷贝的元素
        newPtr := reflect.New(srcType.Elem())
        newPtr.Elem().Set(reflect.ValueOf(elemCopy))
        return newPtr.Interface(), nil
    }

    // 根据类型进行深拷贝
    switch srcType.Kind() {
    case reflect.Struct:
        // 创建一个新结构体实例
        newStruct := reflect.New(srcType).Elem()
        for i := 0; i < srcValue.NumField(); i++ {
            srcField := srcValue.Field(i)
            dstField := newStruct.Field(i)

            // 如果目标字段不可设置（通常是未导出的字段），则跳过。
            // 这是reflect的限制，如果确实需要拷贝未导出字段，可能需要unsafe包或通过序列化反序列化。
            if !dstField.CanSet() {
                continue
            }

            // 递归拷贝字段值
            copiedValue, err := DeepCopy(srcField.Interface())
            if err != nil {
                return nil, err
            }
            dstField.Set(reflect.ValueOf(copiedValue))
        }
        return newStruct.Interface(), nil

    case reflect.Slice:
        if srcValue.IsNil() {
            return reflect.Zero(srcType).Interface(), nil // 空切片直接返回同类型的空切片
        }
        // 创建一个新切片，具有相同的长度和容量
        newSlice := reflect.MakeSlice(srcType, srcValue.Len(), srcValue.Cap())
        for i := 0; i < srcValue.Len(); i++ {
            elemCopy, err := DeepCopy(srcValue.Index(i).Interface())
            if err != nil {
                return nil, err
            }
            newSlice.Index(i).Set(reflect.ValueOf(elemCopy))
        }
        return newSlice.Interface(), nil

    case reflect.Map:
        if srcValue.IsNil() {
            return reflect.Zero(srcType).Interface(), nil // 空映射直接返回同类型的空映射
        }
        // 创建一个新映射
        newMap := reflect.MakeMap(srcType)
        for _, key := range srcValue.MapKeys() {
            value := srcValue.MapIndex(key)
            // 递归拷贝键和值
            keyCopy, err := DeepCopy(key.Interface())
            if err != nil {
                return nil, err
            }
            valueCopy, err := DeepCopy(value.Interface())
            if err != nil {
                return nil, err
            }
            newMap.SetMapIndex(reflect.ValueOf(keyCopy), reflect.ValueOf(valueCopy))
        }
        return newMap.Interface(), nil

    default:
        // 对于所有其他类型（如基本类型、函数、通道等），直接返回原值。
        // 这些类型要么是值类型，要么不适合进行“深拷贝”概念上的复制。
        return src, nil
    }
}

// 示例结构体
type Address struct {
    City string
    Zip  string
}

type User struct {
    Name    string
    Age     int
    Address *Address
    Hobbies []string
    Meta    map[string]interface{}
    // unexportedField string // 未导出字段，DeepCopy默认会跳过
}

func main() {
    addr := &Address{City: "New York", Zip: "10001"}
    user1 := User{
        Name:    "Alice",
        Age:     30,
        Address: addr,
        Hobbies: []string{"reading", "hiking"},
        Meta: map[string]interface{}{
            "id":   123,
            "tags": []string{"developer", "golang"},
        },
    }

    user2I, err := DeepCopy(user1)
    if err != nil {
        fmt.Println("深拷贝失败:", err)
        return
    }
    user2 := user2I.(User) // 类型断言

    fmt.Printf("User1: %+v, Address指针: %p, Hobbies指针: %p, Meta指针: %p\n", user1, user1.Address, user1.Hobbies, user1.Meta)
    fmt.Printf("User2: %+v, Address指针: %p, Hobbies指针: %p, Meta指针: %p\n", user2, user2.Address, user2.Hobbies, user2.Meta)

    // 修改user1，观察user2是否独立
    user1.Name = "Bob"
    user1.Address.City = "Los Angeles"
    user1.Hobbies[0] = "swimming"
    user1.Meta["id"] = 456
    user1.Meta["new_key"] = "new_value"

    fmt.Println("\n修改User1后:")
    fmt.Printf("User1: %+v, Address指针: %p, Hobbies指针: %p, Meta指针: %p\n", user1, user1.Address, user1.Hobbies, user1.Meta)
    fmt.Printf("User2: %+v, Address指针: %p, Hobbies指针: %p, Meta指针: %p\n", user2, user2.Address, user2.Hobbies, user2.Meta)

    // 验证深拷贝效果
    fmt.Println("\n验证结果:")
    fmt.Println("User1 Name:", user1.Name, "User2 Name:", user2.Name)
    fmt.Println("User1 Address City:", user1.Address.City, "User2 Address City:", user2.Address.City)
    fmt.Println("User1 Hobbies[0]:", user1.Hobbies[0], "User2 Hobbies[0]:", user2.Hobbies[0])
    fmt.Println("User1 Meta[id]:", user1.Meta["id"], "User2 Meta[id]:", user2.Meta["id"])
    fmt.Println("User1 Meta[new_key]:", user1.Meta["new_key"], "User2 Meta[new_key]:", user2.Meta["new_key"])
}

int

string

bool

*T

[]T

map[K]V

User

Address *Address

user2 := user1

user2

user1

Name

Age

user2

Address

user2

Address

user1.Address

user1.Address

user2.Address

Address