创建式设计模式—工厂模式

1)什么是工厂模式

工厂模式(Factory Method Pattern)是一种设计模式，旨在创建对象时，将对象的创建与使用进行分离。通过定义一个工厂类，这个类具有创建不同具体产品对象的方法。用户只需与工厂类交互，告诉工厂自己想要什么类型的产品，工厂就会负责创建并返回相应的产品对象。这样做的好处是使得系统的架构更加清晰、灵活，方便扩展和维护产品的种类，同时也降低了代码之间耦合度。简单来说，就是有个专门负责生产对象的“地方”，根据需求生产出对应的对象。

其uml类图

由图可知，工厂方法模式的角色组成如下

• 工厂(Factory)：声明返回的产品对象的工厂方法的接口。该方法返回的对象类型必须与产品接口类型相匹配。
• 具体工厂(ConCreateFactory):实现工厂接口的类，会重写基础工厂方法，使其返回不同类型的产品
• 产品(Product):声明产品方法的接口。对于所有由具体工厂类及其子类构建的对象，该接口是通用的。
• 具体产品(ConcreateProduct):实现产品接口的类

2)使用场景

• 在程序开发过程中，如果开发者无法预知对象的具体类型及其依赖关系，则可以使用工厂方法模式。工厂方法模式将创建产品的工厂代码与产品代码分离，从而降低代码之间的耦合度。例如，如果需要添加一种新产品，则只需创建一个新的具体工厂类，然后重写其工厂方法。
• 如果开发者希望其他开发者可以扩展软件库或框架的内部组件，则可以使用工厂模式。
• 如果一个类需要通过子类指定其创建的对象，则可以使用工厂模式

3)实现方式

package modes

import "fmt"

// 定义工厂接口
type Factory interface {
	//定义一个工厂方法，返回Product
	FacMethod(user string) Product
}
// 定义一个具体的工厂类
type ConcreateFactory struct {
}
// 再实现接口的方法
func (cf *ConcreateFactory) FacMethod(user string) Product {
	p := &ConcreateFactory{} //创建一个具体的工厂实例
	return p
}
// 定义一个产品接口
type Product interface {
	Use()
}
//具体的产品类
type ConcreateProduct struct {
}
func (cf *ConcreateFactory) Use() {
	//TODO implement me
	fmt.Println("生产一个产品")
}

调用main.go进行测试

package main

import "factoryMode/modes"

func main() {
	factory := modes.ConcreateFactory{}
	//生产相关的产品
	product := factory.FacMethod("fac1")
	product.Use()
}

4)实践案例

使用工厂模式演示生产两种不同品牌的鞋子(以生产出Nike和aidas为例子吧)

1.定义一个产品接口TShoes,该接口有两个私有方法–setName()和setSize()，以及两个公共方法----GetName()和GetSize()

再定义一个shoes产品类，以及方法用于实现接口的方法,MakeShoes()则是根据shoes品牌的不同生成不同的产品对象并返回：

shoes.go

package example

import "fmt"

// 定义鞋子产品接口
type TShoes interface {
	SetName(name string)
	SetSize(size int)
	GetName() string
	GetSize() int
}

// 定义一个shoes类
type shoes struct {
	name string
	size int
}

func (c *shoes) SetName(name string) {
	c.name = name
}
func (c *shoes) GetName() string {
	return c.name
}

func (c *shoes) SetSize(size int) {
	c.size = size
}
func (c *shoes) GetSize() int {
	return c.size
}

func MakeShoes(shoesType string) (TShoes, error) {
	if shoesType == "Nike" {
		return newNike(), nil
	}
	if shoesType == "Adidas" {
		return newAdidas(), nil
	}
	return nil, fmt.Errorf("鞋子类型不对")
}

2.顶一个Nike产品类

package example

// 生产Nike鞋子的产品类
type Nike struct {
	shoes
}

func newNike() TShoes {
	return &Nike{
		shoes: shoes{
			name: "Nike shoes",
			size: 37,
		},
	}
}

定义Adidas产品类

package example

// 生产Adidas鞋子产品
type Adidas struct {
	shoes
}

func newAdidas() TShoes {
	return &Adidas{
		shoes: shoes{
			name: "Adidas shoes",
			size: 38,
		},
	}
}

3.main.go进行测试

package main

import (
	"factoryMode/example"
	"fmt"
)

func main() {
    //创建一个Nike产品对象
	Nike, _ := example.MakeShoes("Nike")
    //创建一个Adidas产品对象
	Adidas, _ := example.MakeShoes("Adidas")
	PrintInformations(Nike)
	fmt.Println("----------")
	PrintInformations(Adidas)

} 

// 此方法用于输出相关鞋子产品的信息，比如名字和尺码
func PrintInformations(s example.TShoes) {
	fmt.Printf("Shoes:%s", s.GetName())
	fmt.Println()
	fmt.Printf("Size:%d", s.GetSize())
}

//输出结果为，

Shoes:Nike shoes
Size:37---------- 
Shoes:Adidas shoes
Size:38     

5)优缺点分析

优点：

• 应用程序具有可扩展性。在工厂模式中，调用一个方法与新类的实现是完全分离的。这种情况对如何扩展软件有特殊的影响：工厂模式具有高度的自治性，开发者在添加新类后，无须以任何方式更改程序。
• 工厂组件具有单独可测试性。eg:如果工厂模式实现了4个或多个类，则可以单独测试每个类的功能实现

缺点：

• 系统里的类的数量会大幅度成对增加，从而提高该系统的复杂性。工厂模式的实现会导致集成类的数量大量增加，因为每个具体的产品类都需要一个具体的工厂类。尽管工厂模式有利于软件的扩展，但是会增加工作量。如果要扩展工厂模式的产品系列，则必须要调整工厂接口和相应的具体工厂类。因此，针对所需产品类型提前进行可靠规划是非常重要的。

• 工厂组件具有单独可测试性。eg:如果工厂模式实现了4个或多个类，则可以单独测试每个类的功能实现

缺点：

• 系统里的类的数量会大幅度成对增加，从而提高该系统的复杂性。工厂模式的实现会导致集成类的数量大量增加，因为每个具体的产品类都需要一个具体的工厂类。尽管工厂模式有利于软件的扩展，但是会增加工作量。如果要扩展工厂模式的产品系列，则必须要调整工厂接口和相应的具体工厂类。因此，针对所需产品类型提前进行可靠规划是非常重要的。
• 随着抽象层的引入，提高了开发者对系统的理解难度。如果下一个人要接着上一个人的进度，需要阅读和理解抽象层的代码。