动易6.8网站头深圳网站建设微信开发

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

1)什么是工厂模式

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

其uml类图

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

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

2)使用场景

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

3)实现方式

package modesimport "fmt"// 定义工厂接口
type Factory interface {//定义一个工厂方法，返回ProductFacMethod(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 mefmt.Println("生产一个产品")
}

调用main.go进行测试

package mainimport "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 exampleimport "fmt"// 定义鞋子产品接口
type TShoes interface {SetName(name string)SetSize(size int)GetName() stringGetSize() int
}// 定义一个shoes类
type shoes struct {name stringsize 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 mainimport ("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个或多个类，则可以单独测试每个类的功能实现

缺点：

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