如何使用Golang实现通用对象复制_结合反射深拷贝结构体_技术教程

Go语言通过反射实现通用深拷贝，递归处理指针、切片、映射、结构体等类型，跳过不可导出字段，确保内存独立且避免循环引用。

Go 语言本身不支持直接的深拷贝语法，但通过反射（reflect）可以实现通用、类型安全的结构体深拷贝。关键在于递归处理指针、切片、映射、嵌套结构体等复合类型，同时避免循环引用导致的无限递归。

核心思路：用反射遍历并重建值

深拷贝的本质是创建一个与原对象内容相同、但内存地址完全独立的新对象。反射允许我们在运行时检查任意类型的字段、类型和值，并逐层复制：

对基本类型（int、string、bool 等），直接赋值即可
对指针，需解引用后复制目标值，再新建指针指向新副本
对 slice，需新建底层数组，逐项递归拷贝元素
对 map，需新建 map，递归拷贝每个 key 和 value
对 struct，遍历所有可导出字段（仅导出字段可被反射读写），递归拷贝每个字段值
对 interface{}，先判断其实际类型，再按对应逻辑处理

一个简洁可靠的深拷贝函数实现

以下是一个生产可用的通用深拷贝函数，支持嵌套结构体、指针、slice、map、interface{}，并自动跳过不可导出字段：

func DeepCopy(src interface{}) interface{} {
	v := reflect.ValueOf(src)
	if !v.IsValid() {
		return nil
	}
	return deepCopyValue(v).Interface()
}

func deepCopyValue(v reflect.Value) reflect.Value {
	// 处理零值或不可设置的情况
	if !v.IsValid() {
		return reflect.Zero(v.Type())
	}

	// 处理指针：解引用后拷贝，再取地址
	if v.Kind() == reflect.Ptr {
		if v.IsNil() {
			return reflect.Zero(v.Type())
		}
		elem := deepCopyValue(v.Elem())
		ptr := reflect.New(elem.Type())
		ptr.Elem().Set(elem)
		return ptr
	}

	// 处理 slice：新建 slice，逐项拷贝
	if v.Kind() == reflect.Slice {
		if v.IsNil() {
			return reflect.Zero(v.Type())
		}
		newSlice := reflect.MakeSlice(v.Type(), v.Len(), v.Cap())
		for i := 0; i < v.Len(); i++ {
			newSlice.Index(i).Set(deepCopyValue(v.Index(i)))
		}
		return newSlice
	}

	// 处理 map：新建 map，递归拷贝键值对
	if v.Kind() == reflect.Map {
		if v.IsNil() {
			return reflect.Zero(v.Type())
		}
		newMap := reflect.MakeMap(v.Type())
		for _, key := range v.MapKeys() {
			newKey := deepCopyValue(key)
			newVal := deepCopyValue(v.MapIndex(key))
			newMap.SetMapIndex(newKey, newVal)
		}
		return newMap
	}

	// 处理 struct：逐字段拷贝（仅导出字段）
	if v.Kind() == reflect.Struct {
		newStruct := reflect.New(v.Type()).Elem()
		for i := 0; i < v.NumField(); i++ {
			field := v.Field(i)
			if !field.CanInterface() { // 跳过不可导出字段
				continue
			}
			newStruct.Field(i).Set(deepCopyValue(field))
		}
		return newStruct
	}

	// 处理 interface{}：递归处理其底层值
	if v.Kind() == reflect.Interface {
		if v.IsNil() {
			return reflect.Zero(v.Type())
		}
		return deepCopyValue(v.Elem())
	}

	// 基本类型、chan、func、unsafe.Pointer 等：直接返回（func/chan 不可拷贝，此处返回零值）
	if v.CanInterface() {
		return reflect.ValueOf(v.Interface())
	}

	return reflect.Zero(v.Type())
}

使用示例与注意事项

你可以这样使用它：

立即学习“go语言免费学习笔记（深入）”；

type Address struct {
	City string
	Code int
}

type Person struct {
	Name    string
	Age     int
	Address *Address
	Tags    []string
	Meta    map[string]interface{}
}

p1 := &Person{
	Name: "Alice",
	Age:  30,
	Address: &Address{City: "Beijing", Code: 100000},
	Tags:    []string{"dev", "golang"},
	Meta:    map[string]interface{}{"active": true, "score": 95.5},
}

p2 := DeepCopy(p1).(*Person) // 类型断言还原为 *Person
p2.Name = "Bob"
p2.Address.City = "Shanghai"

fmt.Println(p1.Name, p1.Address.City) // Alice Beijing（未被修改）
fmt.Println(p2.Name, p2.Address.City) // Bob Shanghai（独立副本）

注意：

该函数只拷贝可导出（首字母大写）字段，私有字段会被忽略
不支持函数类型、channel、unsafe.Pointer 的拷贝（这些类型本身无意义深拷贝）
不检测或处理循环引用，若结构体存在自引用（如树节点含 parent 指针），会无限递归 panic —— 如需支持，需额外维护已访问对象的地址缓存
性能不如手动克隆，高频场景建议结合代码生成（如 go:generate + deepcopy-gen）或序列化反序列化（如 json.Marshal/Unmarshal，但会丢失非 JSON 友好类型）