Golang原型模式实现与应用解析

package main
import "fmt"
// Cloneable 接口定义克隆方法
type Cloneable interface {
Clone() Cloneable
}
// Person 是一个具体的原型结构体
type Person struct {
Name string
Age  int
Addr *Address
}
// Address 是嵌套结构体，用于演示深拷贝问题
type Address struct {
City  string
Street string
}
// 实现 Clone 方法（浅拷贝）
func (p *Person) Clone() Cloneable {
if p == nil {
return nil
}
return &Person{
Name: p.Name,
Age:  p.Age,
Addr: p.Addr, // 浅拷贝：地址相同
}
}
// 深拷贝版本的 Clone
func (p Person) DeepCopy() Cloneable {
if p == nil {
return nil
}
var addr Address
if p.Addr != nil {
addr = &Address{
City:  p.Addr.City,
Street: p.Addr.Street,
}
}
return &Person{
Name: p.Name,
Age:  p.Age,
Addr: addr,
}
}
func main() {
original := &Person{
Name: "Alice",
Age:  30,
Addr: &Address{City: "Beijing", Street: "Chang'an Ave"},
}
// 使用浅拷贝
cloned := original.Clone().(*Person)
cloned.Name = "Bob"
cloned.Addr.City = "Shanghai" // 影响原对象

fmt.Println("Original:", original) // Addr.City 变成了 Shanghai
fmt.Println("Cloned:", cloned)

// 使用深拷贝
deep := original.DeepCopy().(*Person)
deep.Addr.City = "Guangzhou"

fmt.Println("After deep copy - Original:", original) // 不受影响
fmt.Println("Deep clone:", deep)
}

var prototypeRegistry = make(map[string]Cloneable)
func RegisterPrototype(name string, proto Cloneable) {
prototypeRegistry[name] = proto
}
func GetPrototype(name string) (Cloneable, bool) {
proto, exists := prototypeRegistry[name]
return proto, exists
}
// 示例使用
func main() {
personProto := &Person{Name: "Default", Age: 0}
RegisterPrototype("person", personProto)
if proto, ok := GetPrototype("person"); ok {
    newPerson := proto.Clone().(*Person)
    newPerson.Name = "Tom"
    fmt.Println(newPerson)
}
}

import (
    "encoding/gob"
    "bytes"
)
func DeepCopyViaGob(src interface{}) (interface{}, error) {
var buf bytes.Buffer
enc := gob.NewEncoder(&buf)
dec := gob.NewDecoder(&buf)
if err := enc.Encode(src); err != nil {
return nil, err
}
var dest interface{}
if err := dec.Decode(&dest); err != nil {
return nil, err
}
return dest, nil
}