原型模式 - 元素码农

发布时间: 2025-03-21 10:57

↑

# 原型模式

原型模式是一种创建型设计模式，它允许你复制已有对象，而无需使代码依赖它们所属的类。这种模式通过克隆现有对象来创建新对象，从而避免了创建子类的需要。

## 适用场景

1. 当需要创建一个与现有对象类似的对象，并且创建的过程比较复杂或耗时时
2. 当系统应该独立于产品的创建、构成和表示时
3. 当要实例化的类是在运行时刻指定时

## UML类图

```mermaid
classDiagram
    class Prototype {
        <<interface>>
        +clone()*Prototype
    }
    class ConcretePrototype1 {
        -field1
        +clone()*Prototype
    }
    class ConcretePrototype2 {
        -field2
        +clone()*Prototype
    }
    class Client {
        +operation()
    }
    Prototype <|-- ConcretePrototype1
    Prototype <|-- ConcretePrototype2
    Client ..> Prototype
```

## 代码示例

以下是一个使用Go语言实现的文档原型模式示例：

```go
package main

import (
    "fmt"
    "time"
)

// Document 接口定义了文档的克隆方法
type Document interface {
    clone() Document
    print()
}

// Page 代表文档中的一个页面
type Page struct {
    content string
}

// Document 具体实现
type DocumentImpl struct {
    title     string
    pages     []Page
    author    string
    createTime time.Time
}

// 浅拷贝实现
func (d *DocumentImpl) clone() Document {
    return &DocumentImpl{
        title:     d.title,
        pages:     d.pages,        // 浅拷贝：直接复制切片引用
        author:    d.author,
        createTime: time.Now(),    // 新对象获取新的创建时间
    }
}

// 深拷贝实现
func (d *DocumentImpl) deepClone() Document {
    // 创建新的页面切片
    newPages := make([]Page, len(d.pages))
    copy(newPages, d.pages)    // 复制页面内容
    
    return &DocumentImpl{
        title:     d.title,
        pages:     newPages,    // 深拷贝：复制页面内容到新的切片
        author:    d.author,
        createTime: time.Now(), // 新对象获取新的创建时间
    }
}

func (d *DocumentImpl) print() {
    fmt.Printf("文档标题: %s\n", d.title)
    fmt.Printf("作者: %s\n", d.author)
    fmt.Printf("创建时间: %v\n", d.createTime)
    fmt.Println("页面内容:")
    for i, page := range d.pages {
        fmt.Printf("  第%d页: %s\n", i+1, page.content)
    }
    fmt.Println()
}

func main() {
    // 创建原始文档
    originalDoc := &DocumentImpl{
        title:     "设计模式教程",
        pages:     []Page{{content: "第一章：简介"}, {content: "第二章：原型模式"}},
        author:    "张三",
        createTime: time.Now(),
    }
    
    // 使用浅拷贝创建副本
    shallowCopy := originalDoc.clone()
    
    // 使用深拷贝创建副本
    deepCopy := originalDoc.deepClone()
    
    fmt.Println("原始文档:")
    originalDoc.print()
    
    // 修改原始文档的页面内容
    originalDoc.pages[0].content = "第一章：设计模式概述"
    
    fmt.Println("浅拷贝文档(页面内容会受原始文档影响):")
    shallowCopy.print()
    
    fmt.Println("深拷贝文档(页面内容独立):")
    deepCopy.print()
}
```

## 优点

1. 可以不耦合具体类的情况下克隆对象
2. 避免重复的初始化代码
3. 快速生成复杂对象
4. 可以用继承以外的方式来处理复杂对象的不同配置

## 缺点

1. 克隆包含循环引用的复杂对象可能会非常麻烦
2. 深克隆时，对象引用的所有对象都需要实现克隆方法，可能会导致代码量增加

## 与其他模式的关系

1. 原型模式可以帮助实现抽象工厂模式
2. 原型模式与备忘录模式在某些情况下可以互相补充
3. 原型模式通常和命令模式一起使用，用于保存命令的历史记录

## 实际应用场景

1. 文档复制：如示例中的文档克隆
2. 对象缓存：保存常用对象的原型，需要时直接克隆
3. 游戏对象：复制游戏中的单位或物品
4. GUI编辑器：复制已有的图形元素