go设计模式之工厂方法模式

Golang
109
0
0
2024-09-15

工厂方法模式

什么是工厂方法模式

工厂方法模式是一种创建型设计模式,它定义了一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类的实例化推迟到其子类。

这个接口就是工厂接口,子类就是具体工厂类,而需要创建的对象就是产品对象。客户端代码只需要调用工厂接口的方法,而无需关心具体的产品对象是如何创建的。

用于创建对象的过程中将实例化的逻辑封装在一个工厂方法中。

把被创建的对象称为“产品”,把创建产品的对象称为“工厂”。

在 Go 语言中,工厂方法模式经常被用于对象的创建和初始化。

工厂方法模式的主要优点有:

  • 用户无需关心产品的具体创建细节。用户只需要知道具体工厂的名称就可得到所要的产品,无须知道产品的具体创建过程(对创建过程复杂的对象很有作用);
  • 解耦。避免创建者和具体产品之间的紧密耦合。
  • 开闭原则。 无需更改现有客户端代码, 你就可以在程序中引入新的产品类型。;

其缺点是

  • 引入很多新的子类。应用工厂方法模式需要引入许多新的子类, 代码可能会因此变得更复杂。

角色

工厂方法模式包含四个主要角色:

  • 抽象产品类(Product)
  • 具体产品类(ConcreteProduct)
  • 抽象工厂接口(Creator)
  • 具体工厂类(ConcreteCreator)

抽象产品类定义产品功能接口。

具体产品类实现Product接口。

抽象工厂类声明工厂方法,定义了创建产品的接口。

具体工厂类实现Creator接口,返回ConcreteProduct。

工厂方法代码

工厂方法模式举例

场景:

创建狗子的案例:

创建狗子,狗子有泰迪、柴犬,以后可能会增加比熊。

注意这里就只有一种类型,就是狗子,没有猫子这个种类。

创建狗子的接口工厂IDogFactory(接口MakeDogs(),返回产品接口)

创建狗子具体工厂DogFactory(实现IDogFactory接口)

狗子接口IDog(sleep()、run(),定义产品功能)

泰迪Teddy、柴犬ChaiDog(具体的狗子)

抽象产品类:

// idog.go
type IDog interface {
	Sleep()
	Run()
}

具体产品类:

柴犬:

// caidog.go
// 柴犬
type ChaiDog struct {
}

func (c ChaiDog) Sleep() {
	fmt.Println("睡觉")
}

func (c ChaiDog) Run() {
	fmt.Println("奔跑")
}

泰迪:

// teddy.go
// 泰迪
type Teddy struct {
}

func (t Teddy) Sleep() {
	fmt.Println("睡觉")
}

func (t Teddy) Run() {
	fmt.Println("奔跑")
}

抽象工厂类(接口工厂):

创建狗子的抽象接口

// factory.go
type IDogFactory interface {
	MakeDogs(dogType string) IDog
}

具体工厂类:

// dogfactory.go
type DogFactory struct {
}

// 提供一个方法实例化工厂
func NewDogFactory() Factory {
	return &DogFactory{}
}

// 工厂方法,这是一个特殊的方法,用来创建不同的狗子
func (d *DogFactory) MakeDog(dogType string) IDog {
	switch dogType {
	case "teddy":
		return &Teddy{name: dogType,
			age: 2,
		}
	case "chaidog":
		return &ChaiDog{name: dogType,
			age: 2,
		}
	}
	return nil
}

场景类:

// client.go
func main() {
	// 创建一个工厂
	f := example.NewFactory()
    // 传入teddy,创建对应的狗子
	teddyDog := f.MakeDog("teddy")
	teddyDog.Sleep()
	teddyDog.Run()
    // 传入chaidog,创建对应的狗子
	cDog := f.MakeDog("chaidog")
	cDog.Sleep()
	cDog.Run()
}

当想加入一个新的产品,例如柯基,添加一个柯基产品子类, 然后重写其工厂方法即可。

简单工厂方法代码

缩小为简单工厂模式。

一个模块仅需要一个工厂类,就没有必要把它实例化出来。java使用静态方法就可以了。

场景:

创建狗子的案例:

创建狗子,狗子有泰迪、柴犬,以后可能会增加比熊。

去掉了工厂接口。

创建狗子的具体工厂DogFactory

狗子接口IDog(sleep()、run(),定义产品功能)

泰迪Teddy、柴犬ChaiDog(具体的狗子)

抽象产品类:

// idog.go
type IDog interface {
	Sleep()
	Run()
}

具体产品类:

柴犬:

// caidog.go
// 柴犬
type ChaiDog struct {
}

func (c ChaiDog) Sleep() {
	fmt.Println("睡觉")
}

func (c ChaiDog) Run() {
	fmt.Println("奔跑")
}

泰迪:

// teddy.go
// 泰迪
type Teddy struct {
}

func (t Teddy) Sleep() {
	fmt.Println("睡觉")
}

func (t Teddy) Run() {
	fmt.Println("奔跑")
}

抽象工厂类(接口工厂):

去掉。

具体工厂类:

// dogfactory.go
// 工厂方法,这是一个特殊的方法,用来创建不同的狗子
func MakeDogs(dogType string) IDog {
	if dogType == "teddy" {
		return &Teddy{}
	}
	if dogType == "chaidog" {
		return &ChaiDog{}
	}
	return nil
}

场景类:

// client.go
func main() {
	teddyDog := example.MakeDog("teddy")
	teddyDog.Sleep()
	teddyDog.Run()
	cDog := example.MakeDog("chaidog")
	cDog.Sleep()
	cDog.Run()
}

工厂方法代码(升级)

升级为多个具体工厂类。

假如有1个产品类有5个具体实现,每个实现类的初始化方法都不相同,如果写在一个工厂方法中,会导致这个方法巨大无比。

为每一个产品定义一个ConcreteCreator。

创建狗子的案例:

创建狗子的接口工厂Factory(MakeDogs())

创建泰迪狗子的具体工厂ChaiDogFactory(实现接口Factory)

创建泰迪柴犬的具体工厂TeddyFactory(实现接口Factory)

狗子接口(sleep()、run())

泰迪、柴犬(具体的狗子)

接口工厂类:

// factory.go
type Factory interface {
	// 无需再传递参数了
	MakeDog() IDog
}

抽象产品类:

// idog.go
type IDog interface {
	Sleep()
	Run()
}

具体产品类:

柴犬:

// caidog.go
// 柴犬
type ChaiDog struct {
}

func (c ChaiDog) Sleep() {
	fmt.Println("睡觉")
}

func (c ChaiDog) Run() {
	fmt.Println("奔跑")
}

泰迪:

// teddy.go
// 泰迪
type Teddy struct {
}

func (t Teddy) Sleep() {
	fmt.Println("睡觉")
}

func (t Teddy) Run() {
	fmt.Println("奔跑")
}

具体工厂:

// teddyfactory.go
// 创建泰迪的具体工厂
type TeddyFactory struct {
}

func NewTeddyFactory() Factory {
	return &TeddyFactory{}
}

func (d *TeddyFactory) MakeDog() IDog {
	return &Teddy{name: "tom",
		age: 2,
	}
}

// caidogfactory.go
// 创建柴犬的具体工厂
type ChaiDogFactory struct {
}

func NewChaiDogFactory() Factory {
	return &ChaiDogFactory{}
}

func (d *ChaiDogFactory) MakeDog() IDog {
	return &ChaiDog{name: "kate",
		age: 2,
	}
}

场景类:

// client.go
func main() {
	cf := example.NewChaiDogFactory()
	teddyDog := cf.MakeDog()
	teddyDog.Sleep()
	teddyDog.Run()
	tf := example.NewTeddyFactory()
	caiDog := tf.MakeDog()
	caiDog.Sleep()
	caiDog.Run()
}

如果要扩展一个产品类,需要建立一个相应的工厂类,增加了扩展的难度。

在复杂的应用中一般才用多工厂的方法,然后再增加一个协调类,避免调用者与各个子工厂交流。