创建式设计模式---工厂模式
目录导航
1)什么是工厂模式
工厂模式(Factory Method Pattern)是一种设计模式，旨在创建对象时，将对象的创建与使用进行分离。通过定义一个工厂类，这个类具有创建不同具体产品对象的方法。用户只需与工厂类交互，告诉工厂自己想要什么类型的产品，工厂就会负责创建并返回相应的产品对象。这样做的好处是使得系统的架构更加清晰、灵活，方便扩展和维护产品的种类，同时也降低了代码之间耦合度。简单来说，就是有个专门负责生产对象的"地方"，根据需求生产出对应的对象。
其uml类图
由图可知，工厂方法模式的角色组成如下
- 工厂(Factory)：声明返回的产品对象的工厂方法的接口。该方法返回的对象类型必须与产品接口类型相匹配。
- 具体工厂(ConCreateFactory):实现工厂接口的类，会重写基础工厂方法，使其返回不同类型的产品
- 产品(Product):声明产品方法的接口。对于所有由具体工厂类及其子类构建的对象，该接口是通用的。
- 具体产品(ConcreateProduct):实现产品接口的类
2)使用场景
- 在程序开发过程中，如果开发者无法预知对象的具体类型及其依赖关系，则可以使用工厂方法模式。工厂方法模式将创建产品的工厂代码与产品代码分离，从而降低代码之间的耦合度。例如，如果需要添加一种新产品，则只需创建一个新的具体工厂类，然后重写其工厂方法。
- 如果开发者希望其他开发者可以扩展软件库或框架的内部组件，则可以使用工厂模式。
- 如果一个类需要通过子类指定其创建的对象，则可以使用工厂模式
3)实现方式
go
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进行测试
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
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产品类
go
package example
// 生产Nike鞋子的产品类
type Nike struct {
shoes
}
func newNike() TShoes {
return &Nike{
shoes: shoes{
name: "Nike shoes",
size: 37,
},
}
}定义Adidas产品类
go
package example
// 生产Adidas鞋子产品
type Adidas struct {
shoes
}
func newAdidas() TShoes {
return &Adidas{
shoes: shoes{
name: "Adidas shoes",
size: 38,
},
}
}3.main.go进行测试
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个或多个类，则可以单独测试每个类的功能实现
缺点：
- 系统里的类的数量会大幅度成对增加，从而提高该系统的复杂性。工厂模式的实现会导致集成类的数量大量增加，因为每个具体的产品类都需要一个具体的工厂类。尽管工厂模式有利于软件的扩展，但是会增加工作量。如果要扩展工厂模式的产品系列，则必须要调整工厂接口和相应的具体工厂类。因此，针对所需产品类型提前进行可靠规划是非常重要的。
- 随着抽象层的引入，提高了开发者对系统的理解难度。如果下一个人要接着上一个人的进度，需要阅读和理解抽象层的代码。