Golang原型模式如何应用 通过深拷贝复用对象方案

clone

DeepCopy

Cloner

package main

import (
    "fmt"
    "bytes"
    "encoding/gob" // 另一种深拷贝方式，但有局限性
)

// Cloner 定义原型模式的核心接口
type Cloner interface {
    DeepCopy() Cloner
}

// Config 是我们的原型对象，包含复杂结构
type Config struct {
    Name     string
    Version  string
    Settings map[string]string
    Plugins  []*Plugin
    Metadata *MetaData // 嵌套指针结构
}

type Plugin struct {
    ID   string
    Path string
}

type MetaData struct {
    Author string
    Date   string
}

// DeepCopy 手动实现Config的深拷贝
func (c *Config) DeepCopy() Cloner {
    if c == nil {
        return nil
    }

    // 1. 复制值类型字段
    newConfig := &Config{
        Name:    c.Name,
        Version: c.Version,
    }

    // 2. 深拷贝map
    if c.Settings != nil {
        newConfig.Settings = make(map[string]string, len(c.Settings))
        for k, v := range c.Settings {
            newConfig.Settings[k] = v
        }
    }

    // 3. 深拷贝slice，注意slice中的元素如果是指针，也需要深拷贝
    if c.Plugins != nil {
        newConfig.Plugins = make([]*Plugin, len(c.Plugins))
        for i, p := range c.Plugins {
            if p != nil {
                // 这里假设Plugin也是值类型或其内部字段也是值类型，
                // 如果Plugin内部还有引用类型，那Plugin也需要实现DeepCopy
                newConfig.Plugins[i] = &Plugin{
                    ID:   p.ID,
                    Path: p.Path,
                }
            }
        }
    }

    // 4. 深拷贝指针类型字段
    if c.Metadata != nil {
        newConfig.Metadata = &MetaData{
            Author: c.Metadata.Author,
            Date:   c.Metadata.Date,
        }
    }

    return newConfig
}

func main() {
    // 创建一个原型对象
    protoConfig := &Config{
        Name:    "ServiceA",
        Version: "1.0.0",
        Settings: map[string]string{
            "timeout": "5s",
            "logLevel": "info",
        },
        Plugins: []*Plugin{
            {ID: "plugin_auth", Path: "/usr/local/auth"},
            {ID: "plugin_log", Path: "/usr/local/log"},
        },
        Metadata: &MetaData{
            Author: "Alice",
            Date:   "2023-10-27",
        },
    }

    // 使用原型模式创建新对象
    clonedConfig := protoConfig.DeepCopy().(*Config)

    fmt.Println("--- Original Config ---")
    fmt.Printf("Name: %s, Version: %s\n", protoConfig.Name, protoConfig.Version)
    fmt.Printf("Settings: %v\n", protoConfig.Settings)
    for _, p := range protoConfig.Plugins {
        fmt.Printf("  Plugin: %+v\n", *p)
    }
    fmt.Printf("Metadata: %+v\n", *protoConfig.Metadata)

    // 修改克隆对象
    clonedConfig.Name = "ServiceB"
    clonedConfig.Settings["timeout"] = "10s"
    clonedConfig.Plugins[0].ID = "plugin_new_auth" // 修改克隆对象内部的引用类型
    clonedConfig.Metadata.Author = "Bob"

    fmt.Println("\n--- Cloned Config (Modified) ---")
    fmt.Printf("Name: %s, Version: %s\n", clonedConfig.Name, clonedConfig.Version)
    fmt.Printf("Settings: %v\n", clonedConfig.Settings)
    for _, p := range clonedConfig.Plugins {
        fmt.Printf("  Plugin: %+v\n", *p)
    }
    fmt.Printf("Metadata: %+v\n", *clonedConfig.Metadata)

    fmt.Println("\n--- Original Config (After clone modification) ---")
    // 验证原对象是否被修改，证明是深拷贝
    fmt.Printf("Name: %s, Version: %s\n", protoConfig.Name, protoConfig.Version)
    fmt.Printf("Settings: %v\n", protoConfig.Settings)
    for _, p := range protoConfig.Plugins {
        fmt.Printf("  Plugin: %+v\n", *p)
    }
    fmt.Printf("Metadata: %+v\n", *protoConfig.Metadata)

    // 额外提一下，如果结构体非常复杂，且所有字段都可导出，可以使用gob进行深拷贝，但有性能和通用性限制
    // func (c *Config) DeepCopyGob() Cloner {
    //  var buf bytes.Buffer
    //  enc := gob.NewEncoder(&buf)
    //  dec := gob.NewDecoder(&buf)
    //
    //  err := enc.Encode(c)
    //  if err != nil {
    //      panic(err) // 实际项目中应该返回错误
    //  }
    //
    //  var newConfig Config
    //  err = dec.Decode(&newConfig)
    //  if err != nil {
    //      panic(err)
    //  }
    //  return &newConfig
    // }
}

DeepCopy

map

slice

clone()