GoLang设计模式02 - 简单工厂模式

简单工厂模式是一种创建型模式，也是最常用的设计模式之一。调用方通过工厂产出并获取对象，可以不必关注对象创建的细节和构建逻辑。

在简单工厂模式下，调用方只和工厂进行交互，并告诉工厂具体获取哪种类型的对象。工厂负责和相应的struct交互，并返回需要的对象。

如下是工厂模式的UML类图：

接下来是一个工厂模式的范例，在这个例子中：

• 提供了一个接口iGun，定义了一把枪应该有的各种方法
• 提供了一个名为 gun 的类，并实现了iGun接口
• 两个具体类 ak47 和 maverick (卡宾枪，一种突击步枪)，两者都组装了gun struct，实现了iGun的的各种方法，因此它们也可以说是iGun的子类，
• 核心是名为gunFactory的struct(或者只是个函数)，它可以产出 ak47 和 maverick的实例。
• 最后，是main.go文件及其中的main()方法，可以被视为是调用方，它依赖了gunFactory(或者只是个函数) 来创建 ak47 和 maverick的实例，并应用这两个实例。

这里是这个例子对应的类图：

具体代码如下：

package main
 
type iGun interface {
    setName(name string)
    setPower(power int)
    getName() string
    getPower() int
}

type gun struct {
    name  string
    power int
}
 
func (g *gun) setName(name string) {
    g.name = name
}
 
func (g *gun) getName() string {
    return g.name
}
 
func (g *gun) setPower(power int) {
    g.power = power
}
 
func (g *gun) getPower() int {
    return g.power
}

type ak47 struct {
    gun
}
 
func newAk47() iGun {
    return &ak47{
        gun: gun{
            name:  "AK47 gun",
            power: 4,
        },
    }
}

type maverick struct {
    gun
}
 
func newMaverick() iGun {
    return &maverick{
        gun: gun{
            name:  "Maverick gun",
            power: 5,
        },
    }
}

//不符合开闭原则(对修改关闭，对扩展开放)
func getGun(gunType string) (iGun, error) {
    if gunType == "ak47" {
        return newAk47(), nil
    }
    if gunType == "maverick" {
        return newMaverick(), nil
    }
    return nil, fmt.Errorf("Wrong gun type passed")
}

func main() {
    ak47, _ := getGun("ak47")
    maverick, _ := getGun("maverick")
    printDetails(ak47)
    printDetails(maverick)
}
 
func printDetails(g iGun) {
    fmt.Printf("Gun: %s", g.getName())
    fmt.Println()
    fmt.Printf("Power: %d", g.getPower())
    fmt.Println()
}