原型模式

模式动机

原型模式使对象能复制自身，并且暴露到接口中，使客户端面向接口编程时，不知道接口实际对象的情况下生成新的对象。

原型模式配合原型管理器使用，使得客户端在不知道具体类的情况下，通过接口管理器得到新的实例，并且包含部分预设定配置。

Go语言实现

prototype.go

  1. package prototype
  3. //Cloneable 是原型对象需要实现的接口
  4. type Cloneable interface {
  5.     Clone() Cloneable
  6. }
  8. type PrototypeManager struct {
  9.     prototypes map[string]Cloneable
  10. }
  12. func NewPrototypeManager() *PrototypeManager {
  13.     return &PrototypeManager{
  14.         prototypes: make(map[string]Cloneable),
  15.     }
  16. }
  18. func (p *PrototypeManager) Get(name string) Cloneable {
  19.     return p.prototypes[name]
  20. }
  22. func (p *PrototypeManager) Set(name string, prototype Cloneable) {
  23.     p.prototypes[name] = prototype
  24. }

prototype_test.go

  1. package prototype
  3. import "testing"
  5. var manager *PrototypeManager
  7. type Type1 struct {
  8.     name string
  9. }
  11. func (t *Type1) Clone() Cloneable {
  12.     tc := *t
  13.     return &tc
  14. }
  16. type Type2 struct {
  17.     name string
  18. }
  20. func (t *Type2) Clone() Cloneable {
  21.     tc := *t
  22.     return &tc
  23. }
  25. func TestClone(t *testing.T) {
  26.     t1 := manager.Get("t1")
  28.     t2 := t1.Clone()
  30.     if t1 == t2 {
  31.         t.Fatal("error! get clone not working")
  32.     }
  33. }
  35. func TestCloneFromManager(t *testing.T) {
  36.     c := manager.Get("t1").Clone()
  38.     t1 := c.(*Type1)
  39.     if t1.name != "type1" {
  40.         t.Fatal("error")
  41.     }
  43. }
  45. func init() {
  46.     manager = NewPrototypeManager()
  48.     t1 := &Type1{
  49.         name: "type1",
  50.     }
  51.     manager.Set("t1", t1)
  52. }