使用Go实现23种设计模式——创建型模式

使用Go实现23种设计模式——创建型模式

单例模式

一个类只能生成一个实例，提供一个全局访问点供外部获取该实例

适用场景：

1. 只要求生成一个全局对象
2. 需要频繁实例化，而创建的对象又频繁被销毁

Go语言实现

type client struct{}

var (
  c    *client
	once sync.Once
)

func GetClient() *client {
	once.Do(func() {
		c = &client{}
	})
	return c
}

单例模式优点

1. 在内存中只有一个实例，减少了内存开销
2. 避免对资源的多重占用

单例模式缺点

1. 没有接口，无法继承，一定程度上违背了单一职责原则（一个类应该只关心内部逻辑，而不关心外面怎么样来实例化）

工厂模式

定义一个创建对象的接口，让子类决定实例化哪个类

适用场景

父工厂类中只有创建产品的抽象接口，将产品对象的实际创建工作推迟到具体子工厂类当中

Go语言实现

type Executor interface {
	Run()
}

type syncExecutor struct {
}

func (e *syncExecutor) Run() {
	fmt.Println("sync executor run")
}

type asyncExecutor struct {
}

func (e *asyncExecutor) Run() {
	fmt.Println("async executor run")
}

func GetExecutor(sync bool) Executor {
	if sync {
		return &syncExecutor{}
	} else {
		return &asyncExecutor{}
	}
}

工厂模式优点

1. 符合开闭原则，有很强的扩展性、弹性和可维护性，修改时只需要添加对应的工厂类即可
2. 使用了依赖倒置原则，依赖抽象而不是具体
3. 使用者只需要知道产品的具体工厂，无需知道工厂中产品的创建过程，甚至不需要知道产品的类名

工厂模式缺点

1. 每增加一个产品时，都需要一个具体类和一个具体创建者，使得类的个数成倍增加，导致系统复杂性增加

抽象工厂模式

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类

适用场景

系统中有多个产品类，但每次只使用其中的某一类产品

Go语言实现

type FactoryInterface interface {
	CreateAnimal() ProductInterface
}

type ProductInterface interface {
	Init()
}

type DogFactory struct {
}

type AnimalDog struct {
}

func (a *AnimalDog) Init() {
	fmt.Printf("Dog ...\n")
}

func (f *DogFactory) CreateAnimal() ProductInterface {
	return &AnimalDog{}
}

func main() {
	var f FactoryInterface
	f = new(DogFactory)
	a := f.CreateAnimal()
	a.Init()
}

抽象工厂模式优点

1. 隔离了具体类的生产，客户并不知道什么将被创建
2. 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象
3. 新增具体工厂和产品族方便

抽象工厂模式缺点

1. 增加新的产品等级结构复杂，需要修改抽象工厂及所有的具体工厂类

建造者模式

将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象（对复杂对象进行分模块创建）

适用场景

对象可以分模块初始化

Go语言实现

type Person struct {
	name, sex, address string
	age                int
}

func (p *Person) PrintInfo() {
	fmt.Printf("姓名: %s, 年龄: %d, 性别: %s, 住址: %s\n", p.name, p.age, p.sex, p.address)
}

type PersonBuilder struct {
	person *Person
}

func NewPersonBuilder() *PersonBuilder {
	return &PersonBuilder{person: &Person{}}
}

func (p *PersonBuilder) Name(name string) *PersonBuilder {
	p.person.name = name
	return p
}

func (p *PersonBuilder) Sex(sex string) *PersonBuilder {
	p.person.sex = sex
	return p
}

func (p *PersonBuilder) Address(address string) *PersonBuilder {
	p.person.address = address
	return p
}

func (p *PersonBuilder) Age(age int) *PersonBuilder {
	p.person.age = age
	return p
}

func (p *PersonBuilder) Build() *Person {
	return p.person
}

func main() {
	p := NewPersonBuilder().
		Name("张三").
		Age(18).
		Sex("男").
		Address("上海").
		Build()
	p.PrintInfo()
}

建造者模式优点

1. 封装性好
2. 扩展性好

建造者模式缺点

1. 增加类数量，产生多余的Builder对象
2. 如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大

原型模式

用原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象

适用场景

1. 不同对象之间相似度高
2. 创建对象比较麻烦，但复制比较简单

Go语言实现

type Student struct {
	name string
	age  int
	sex  string
}

func (s *Student) SetStudentInfo(name string, age int, sex string) {
	s.name = name
	s.age = age
	s.sex = sex
}

func (s *Student) SetName(name string) {
	s.name = name
}

func (s *Student) PrintInfo() {
	fmt.Printf("学生姓名: %s, 年龄: %d, 性别: %s\n", s.name, s.age, s.sex)
}

func (s *Student) Clone() *Student {
	return &Student{
		name: s.name,
		age:  s.age,
		sex:  s.sex,
	}
}

func main() {
	s1 := &Student{}
	s1.SetStudentInfo("张三", 18, "男")
	s1.PrintInfo()
	s2 := s1.Clone()
	s2.SetName("李四")
	s2.PrintInfo()
}

原型模式优点

1. 性能优良
2. 可以使用深克隆方式保存对象状态

原型模式缺点

1. 需要为每个类实现一个克隆方法，该方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违反了开闭原则
2. 深拷贝与浅拷贝的风险，容易出错