创建型模式分类

1. 工厂方法 ★★★

2. 抽象工厂 ★★★

3. 建造者模式（生成器模式） ★★★

4. 原型 ★★

5. 单例 ★★★

工厂方法模式 ★★★

1. 特点

• 工厂方法模式是一种创建型设计模式， 其在父类中提供一个创建对象的方法， 允许子类决定实例化对象的类型。
• 适合应用场景
  1. 当你在编写代码的过程中， 如果无法预知对象确切类别及其依赖关系时， 可使用工厂方法。
  2. 如果你希望用户能扩展你软件库或框架的内部组件， 可使用工厂方法。
  3. 如果你希望复用现有对象来节省系统资源， 而不是每次都重新创建对象， 可使用工厂方法。
• 优缺点
  • 优点
    1. 你可以避免创建者和具体产品之间的紧密耦合。
    2. 单一职责原则。 你可以将产品创建代码放在程序的单一位置， 从而使得代码更容易维护。
    3. 开闭原则。 无需更改现有客户端代码， 你就可以在程序中引入新的产品类型。
  • 缺点
    1. 应用工厂方法模式需要引入许多新的子类， 代码可能会因此变得更复杂。 最好的情况是将该模式引入创建者类的现有层次结构中。
• 与其他模式的关系
  1. 在许多设计工作的初期都会使用工厂方法模式 （较为简单， 而且可以更方便地通过子类进行定制）， 随后演化为使用抽象工厂模式、 原型模式或生成器模式 （更灵活但更加复杂）。
  2. 抽象工厂模式通常基于一组工厂方法， 但你也可以使用原型模式来生成这些类的方法。
  3. 你可以同时使用工厂方法和迭代器模式来让子类集合返回不同类型的迭代器， 并使得迭代器与集合相匹配。
  4. 原型并不基于继承， 因此没有继承的缺点。 另一方面， 原型需要对被复制对象进行复杂的初始化。 工厂方法基于继承， 但是它不需要初始化步骤。
  5. 工厂方法是模板方法模式的一种特殊形式。 同时， 工厂方法可以作为一个大型模板方法中的一个步骤。

2. 示例

package main

import "fmt"

// 产品接口
type IGun interface {
    setName(name string)
    setPower(power int)
    getName() string
    getPower() int
}

// 具体产品
type Gun struct {
    name  string
    power int
}

func (g *Gun) setName(name string) {
    g.name = name
}

func (g *Gun) getName() string {
    return g.name
}

func (g *Gun) setPower(power int) {
    g.power = power
}

func (g *Gun) getPower() int {
    return g.power
}

// 具体产品 ak47
type Ak47 struct {
    Gun
}

func newAk47() IGun {
    return &Ak47{
        Gun: Gun{
            name:  "AK47 gun",
            power: 4,
        },
    }
}

// 具体产品 火枪
type musket struct {
    Gun
}

func newMusket() IGun {
    return &musket{
        Gun: Gun{
            name:  "Musket gun",
            power: 1,
        },
    }
}

// 工厂

func getGun(gunType string) (IGun, error) {
    if gunType == "ak47" {
        return newAk47(), nil
    }
    if gunType == "musket" {
        return newMusket(), nil
    }
    return nil, fmt.Errorf("Wrong gun type passed")
}


// 主协程
func main() {
    ak47, _ := getGun("ak47")
    musket, _ := getGun("musket")

    printDetails(ak47)
    printDetails(musket)
}

func printDetails(g IGun) {
    fmt.Printf("Gun: %s", g.getName())
    fmt.Println()
    fmt.Printf("Power: %d", g.getPower())
    fmt.Println()
}

抽象工厂模式 ★★★

1. 特点

• 抽象工厂模式是一种创建型设计模式， 它能创建一系列相关的对象， 而无需指定其具体类。
• 适合应用场景
  • 如果代码需要与多个不同系列的相关产品交互， 但是由于无法提前获取相关信息， 或者出于对未来扩展性的考虑， 你不希望代码基于产品的具体类进行构建， 在这种情况下， 你可以使用抽象工厂。 抽象工厂为你提供了一个接口， 可用于创建每个系列产品的对象。 只要代码通过该接口创建对象， 那么你就不会生成与应用程序已生成的产品类型不一致的产品。
• 优缺点
  • 优点
    1. 可以确保同一工厂生成的产品相互匹配。
    2. 可以避免客户端和具体产品代码的耦合。
    3. 单一职责原则。 你可以将产品生成代码抽取到同一位置， 使得代码易于维护。
    4. 开闭原则。 向应用程序中引入新产品变体时， 你无需修改客户端代码。
  • 缺点
    • 由于采用该模式需要向应用中引入众多接口和类， 代码可能会比之前更加复杂。
• 与其他模式的关系
  1. 在许多设计工作的初期都会使用工厂方法模式 （较为简单， 而且可以更方便地通过子类进行定制）， 随后演化为使用抽象工厂模式、 原型模式或生成器模式 （更灵活但更加复杂）。
  2. 生成器重点关注如何分步生成复杂对象。 抽象工厂专门用于生产一系列相关对象。 抽象工厂会马上返回产品， 生成器则允许你在获取产品前执行一些额外构造步骤。
  3. 抽象工厂模式通常基于一组工厂方法， 但你也可以使用原型模式来生成这些类的方法。
  4. 当只需对客户端代码隐藏子系统创建对象的方式时， 你可以使用抽象工厂来代替外观模式。
  5. 你可以将抽象工厂和桥接模式搭配使用。 如果由桥接定义的抽象只能与特定实现合作， 这一模式搭配就非常有用。 在这种情况下， 抽象工厂可以对这些关系进行封装， 并且对客户端代码隐藏其复杂性。
  6. 抽象工厂、 生成器和原型都可以用单例模式来实现。

2. 示例

package main

import "fmt"


// 抽象工厂
type ISportsFactory interface {
	makeShoe() IShoe
	makeShirt() IShirt
}

func GetSportsFactory(brand string) (ISportsFactory, error) {
	if brand == "adidas" {
		return &Adidas{}, nil
	}

	if brand == "nike" {
		return &Nike{}, nil
	}

	return nil, fmt.Errorf("Wrong brand type passed")
}

// 具体工厂 adidas
type Adidas struct {
}

func (a *Adidas) makeShoe() IShoe {
	return &AdidasShoe{
		Shoe: Shoe{
			logo: "adidas",
			size: 14,
		},
	}
}

func (a *Adidas) makeShirt() IShirt {
	return &AdidasShirt{
		Shirt: Shirt{
			logo: "adidas",
			size: 14,
		},
	}
}
// 具体工厂 nike

type Nike struct {
}

func (n *Nike) makeShoe() IShoe {
	return &NikeShoe{
		Shoe: Shoe{
			logo: "nike",
			size: 14,
		},
	}
}

func (n *Nike) makeShirt() IShirt {
	return &NikeShirt{
		Shirt: Shirt{
			logo: "nike",
			size: 14,
		},
	}
}

// 抽象产品 shoe + Shirt

type IShoe interface {
	setLogo(logo string)
	setSize(size int)
	getLogo() string
	getSize() int
}

type Shoe struct {
	logo string
	size int
}

func (s *Shoe) setLogo(logo string) {
	s.logo = logo
}

func (s *Shoe) getLogo() string {
	return s.logo
}

func (s *Shoe) setSize(size int) {
	s.size = size
}

func (s *Shoe) getSize() int {
	return s.size
}


type IShirt interface {
	setLogo(logo string)
	setSize(size int)
	getLogo() string
	getSize() int
}

type Shirt struct {
	logo string
	size int
}

func (s *Shirt) setLogo(logo string) {
	s.logo = logo
}

func (s *Shirt) getLogo() string {
	return s.logo
}

func (s *Shirt) setSize(size int) {
	s.size = size
}

func (s *Shirt) getSize() int {
	return s.size
}


// 具体产品 Adidas 家 shoe + shirt
type AdidasShoe struct {
	Shoe
}

type AdidasShirt struct {
	Shirt
}
// 具体产品 nike 家 shoe + shirt
type NikeShirt struct {
	Shirt
}
type NikeShoe struct {
	Shoe
}

// main
func main() {
	adidasFactory, _ := GetSportsFactory("adidas")
	nikeFactory, _ := GetSportsFactory("nike")

	nikeShoe := nikeFactory.makeShoe()
	nikeShirt := nikeFactory.makeShirt()

	adidasShoe := adidasFactory.makeShoe()
	adidasShirt := adidasFactory.makeShirt()

	printShoeDetails(nikeShoe)
	printShirtDetails(nikeShirt)

	printShoeDetails(adidasShoe)
	printShirtDetails(adidasShirt)
}

func printShoeDetails(s IShoe) {
	fmt.Printf("Logo: %s", s.getLogo())
	fmt.Println()
	fmt.Printf("Size: %d", s.getSize())
	fmt.Println()
}

func printShirtDetails(s IShirt) {
	fmt.Printf("Logo: %s", s.getLogo())
	fmt.Println()
	fmt.Printf("Size: %d", s.getSize())
	fmt.Println()
}

建造者模式 ★★★

1. 特点

• 建造者模式是一种创建型设计模式，使你能够分步骤创建复杂对象。该模式允许你使用相同的创建代码生成不同类型和形式的对象。
• 适用场景
  • 使 用 生 成 器 模 式 可 避 免 “重 叠 构 造 函 数 （telescoping constructor）”的出现。
  • 当你希望使用代码创建不同形式的产品（例如石头或木头房 屋）时， 可使用生成器模式。
  • 使用生成器构造组合树或其他复杂对象。
• 优缺点
  • 优点
    1. 你可以分步创建对象， 暂缓创建步骤或递归运行创建步骤。
    2. 生成不同形式的产品时， 你可以复用相同的制造代码。
    3. 单一职责原则。 你可以将复杂构造代码从产品的业务逻辑中 分离出来。
  • 缺点
    1. 由于该模式需要新增多个类， 因此代码整体复杂程度会有所 增加。
• 和其他设计模式的关系
  • 在许多设计工作的初期都会使用工厂方法（较为简单， 而且可以更方便地通过子类进行定制）， 随后演化为使用抽象工 厂、原型或生成器（更灵活但更加复杂）。
  • 生成器重点关注如何分步生成复杂对象。 抽象工厂专门用于 生产一系列相关对象。 抽象工厂会马上返回产品， 生成器则 允许你在获取产品前执行一些额外构造步骤。
  • 你可以在创建复杂组合树时使用生成器， 因为这可使其构造 步骤以递归的方式运行。
  • 你可以结合使用生成器和桥接模式：主管类负责抽象工作，各种不同的生成器负责实现工作。
  • 抽象工厂、生成器和原型都可以用单例来实现。

2. 示例

// 接口
package main

type IBuilder interface {
    setWindowType()
    setDoorType()
    setNumFloor()
    getHouse() House
}

func getBuilder(builderType string) IBuilder {
    if builderType == "normal" {
        return newNormalBuilder()
    }

    if builderType == "igloo" {
        return newIglooBuilder()
    }
    return nil
}

// 具体生成器


type IglooBuilder struct {
    windowType string
    doorType   string
    floor      int
}

func newIglooBuilder() *IglooBuilder {
    return &IglooBuilder{}
}

func (b *IglooBuilder) setWindowType() {
    b.windowType = "Snow Window"
}

func (b *IglooBuilder) setDoorType() {
    b.doorType = "Snow Door"
}

func (b *IglooBuilder) setNumFloor() {
    b.floor = 1
}

func (b *IglooBuilder) getHouse() House {
    return House{
        doorType:   b.doorType,
        windowType: b.windowType,
        floor:      b.floor,
    }
}

// 产品
package main

type House struct {
    windowType string
    doorType   string
    floor      int
}

// 主管
package main

type Director struct {
    builder IBuilder
}

func newDirector(b IBuilder) *Director {
    return &Director{
        builder: b,
    }
}

func (d *Director) setBuilder(b IBuilder) {
    d.builder = b
}

func (d *Director) buildHouse() House {
    d.builder.setDoorType()
    d.builder.setWindowType()
    d.builder.setNumFloor()
    return d.builder.getHouse()
}
//main

func main() {
    normalBuilder := getBuilder("normal")
    iglooBuilder := getBuilder("igloo")

    director := newDirector(normalBuilder)
    normalHouse := director.buildHouse()

    fmt.Printf("Normal House Door Type: %s\n", normalHouse.doorType)
    fmt.Printf("Normal House Window Type: %s\n", normalHouse.windowType)
    fmt.Printf("Normal House Num Floor: %d\n", normalHouse.floor)

    director.setBuilder(iglooBuilder)
    iglooHouse := director.buildHouse()

    fmt.Printf("\nIgloo House Door Type: %s\n", iglooHouse.doorType)
    fmt.Printf("Igloo House Window Type: %s\n", iglooHouse.windowType)
    fmt.Printf("Igloo House Num Floor: %d\n", iglooHouse.floor)

}

原型模式 ★

1. 特点

• 原型模式是一种创建型设计模式， 使你能够复制已有对象， 而又无需使代码依赖它们所属的类。

  原型模式将克隆过程委派给被克隆的实际对象。 模式为所有支持克隆的对象声明了一个通用接口， 该接口让你能够克隆对象， 同时又无需将代码和对象所属类耦合。 通常情况下， 这样的接口中仅包含一个 克隆方法。

  所有的类对 克隆方法的实现都非常相似。 该方法会创建一个当前类的对象， 然后将原始对象所有的成员变量值复制到新建的类中。 你甚至可以复制私有成员变量， 因为绝大部分编程语言都允许对象访问其同类对象的私有成员变量。

• 适用场景

  • 如果你需要复制一些对象， 同时又希望代码独立于这些对象所属的具体类， 可以使用原型模式。
  • 如果子类的区别仅在于其对象的初始化方式， 那么你可以使用该模式来减少子类的数量。 别人创建这些子类的目的可能是为了创建特定类型的对象。

• 优缺点

  • 优点
    1. 你可以克隆对象， 而无需与它们所属的具体类相耦合。
    2. 你可以克隆预生成原型， 避免反复运行初始化代码。
    3. 你可以更方便地生成复杂对象。
    4. 你可以用继承以外的方式来处理复杂对象的不同配置。
  • 缺点
    1. 克隆包含循环引用的复杂对象可能会非常麻烦。

• 与其他模式的关系

  • 在许多设计工作的初期都会使用工厂方法模式 （较为简单， 而且可以更方便地通过子类进行定制）， 随后演化为使用抽象工厂模式、 原型模式或生成器模式 （更灵活但更加复杂）。
  • 抽象工厂模式通常基于一组工厂方法， 但你也可以使用原型模式来生成这些类的方法。
  • 原型可用于保存命令模式的历史记录。
  • 大量使用组合模式和装饰模式的设计通常可从对于原型的使用中获益。 你可以通过该模式来复制复杂结构， 而非从零开始重新构造。
  • 原型并不基于继承， 因此没有继承的缺点。 另一方面， 原型需要对被复制对象进行复杂的初始化。 工厂方法基于继承， 但是它不需要初始化步骤。
  • 有时候原型可以作为备忘录模式的一个简化版本， 其条件是你需要在历史记录中存储的对象的状态比较简单， 不需要链接其他外部资源， 或者链接可以方便地重建。
  • 抽象工厂、 生成器和原型都可以用单例模式来实现。

2. 示例

 // inode.go: 原型接口
package main

type Inode interface {
    print(string)
    clone() Inode
}
 // file.go: 具体原型
package main

import "fmt"

type File struct {
    name string
}

func (f *File) print(indentation string) {
    fmt.Println(indentation + f.name)
}

func (f *File) clone() Inode {
    return &File{name: f.name + "_clone"}
}
 // folder.go: 具体原型
package main

import "fmt"

type Folder struct {
    children []Inode
    name     string
}

func (f *Folder) print(indentation string) {
    fmt.Println(indentation + f.name)
    for _, i := range f.children {
        i.print(indentation + indentation)
    }
}

func (f *Folder) clone() Inode {
    cloneFolder := &Folder{name: f.name + "_clone"}
    var tempChildren []Inode
    for _, i := range f.children {
        copy := i.clone()
        tempChildren = append(tempChildren, copy)
    }
    cloneFolder.children = tempChildren
    return cloneFolder
}
 // main.go: 客户端代码
package main

import "fmt"

func main() {
    file1 := &File{name: "File1"}
    file2 := &File{name: "File2"}
    file3 := &File{name: "File3"}

    folder1 := &Folder{
        children: []Inode{file1},
        name:     "Folder1",
    }

    folder2 := &Folder{
        children: []Inode{folder1, file2, file3},
        name:     "Folder2",
    }
    fmt.Println("\nPrinting hierarchy for Folder2")
    folder2.print("  ")

    cloneFolder := folder2.clone()
    fmt.Println("\nPrinting hierarchy for clone Folder")
    cloneFolder.print("  ")
}

单例模式 ★★★

1. 特点

• 单例模式是一种创建型设计模式， 让你能够保证一个类只有一个实例， 并提供一个访问该实例的全局节点。单例模式指的是全局只有一个实例，并且它负责创建自己的对象。单例模式不仅有利于减少内存开支，还有减少系统性能开销、防止多个实例产生冲突等优点。
• 适用场景
  • 如果程序中的某个类对于所有客户端只有一个可用的实例， 可以使用单例模式。
  • 如果你需要更加严格地控制全局变量， 可以使用单例模式。
• 优缺点
  • 优点
    1. 你可以保证一个类只有一个实例。
    2. 你获得了一个指向该实例的全局访问节点。
    3. 仅在首次请求单例对象时对其进行初始化。
  • 缺点
    1. 违反了单一职责原则。 该模式同时解决了两个问题。
    2. 单例模式可能掩盖不良设计， 比如程序各组件之间相互了解过多等。
    3. 该模式在多线程环境下需要进行特殊处理， 避免多个线程多次创建单例对象。
    4. 单例的客户端代码单元测试可能会比较困难， 因为许多测试框架以基于继承的方式创建模拟对象。 由于单例类的构造函数是私有的， 而且绝大部分语言无法重写静态方法， 所以你需要想出仔细考虑模拟单例的方法。 要么干脆不编写测试代码， 或者不使用单例模式。
• 与其他模式的关系
  • 外观模式类通常可以转换为单例模式类， 因为在大部分情况下一个外观对象就足够了。
  • 如果你能将对象的所有共享状态简化为一个享元对象， 那么享元模式就和单例类似了。 但这两个模式有两个根本性的不同。
  • 只会有一个单例实体， 但是享元类可以有多个实体， 各实体的内在状态也可以不同。
  • 单例对象可以是可变的。 享元对象是不可变的。
  • 抽象工厂模式、 生成器模式和原型模式都可以用单例来实现。

2. 示例

2.1 饿汉模式 ★

懒汉方式指全局的单例实例在第一次被使用时创建。因为实例是在包被导入时初始化的，所以如果初始化耗时，会导致程序加载时间比较长。

• 实现方式

  package singleton
  
  type singleton struct {
  }
  
  var ins *singleton = &singleton{}
  
  func GetInsOr() *singleton {
      return ins
  }
  

• 饿汉模式可以将问题及早暴露，懒汉式虽然支持延迟加载，但是这只是把冷启动时间放到了第一次使用的时候，并没有本质上解决问题，并且为了实现懒汉式还不可避免的需要加锁

2.2 懒汉模式 ★★

懒汉方式真正使用的时候才会创建实例，运用较广，但它的缺点是非并发安全，在实际使用时需要加锁。

• 代码实现

  package singleton
  
  type singleton struct {
  }
  
  var ins *singleton
  
  func GetInsOr() *singleton {
      if ins == nil {
          ins = &singleton{}
      }
      
      return ins
  }
  

• 非并发安全，在实际使用时需要加锁。

2.3 双重锁定 ★★★

双重锁检查是在懒汉模式的基础上加锁实现，保证并发安全

• 代码实现

  package singleton
  
  import "sync"
  
  type singleton struct {
  }
  
  var ins *singleton
  var mu sync.Mutex
  
  func GetIns() *singleton {
  	if ins == nil {
  		mu.Lock()
  		defer mu.Unlock()
  		ins = &singleton{}
  	}
  	return ins
  }
  

• sync.Once 就是基于双重锁定的封装

  • 代码实现

    package singleton
    
    import (
        "sync"
    )
    
    type singleton struct {
    }
    
    var ins *singleton
    var once sync.Once
    
    func GetInsOr() *singleton {
        once.Do(func() {
            ins = &singleton{}
        })
        return ins
    }
    

  • 实现原理

    package sync
    
    import (
    	"sync/atomic"
    )
    
    type Once struct {
    	done uint32
    	m    Mutex
    }
    
    func (o *Once) Do(f func()) {
    	if atomic.LoadUint32(&o.done) == 0 {
    		// Outlined slow-path to allow inlining of the fast-path.
    		o.doSlow(f)
    	}
    }
    
    func (o *Once) doSlow(f func()) {
    	o.m.Lock()
    	defer o.m.Unlock()
    	if o.done == 0 {
    		defer atomic.StoreUint32(&o.done, 1)
    		f()
    	}
    }