GoLang设计模式03 - 工厂方法模式

我们知道，开闭原则指的是对修改关闭，对扩展开放，而工厂方法就是为了解决这个问题，它提供一个工厂抽象接口，每一种产品的生产都会有自己的工厂，消费者从对应工厂获取产品即可，如果增加了一种产品，只需要增加对应的工厂即可，从而避免了修改，只是扩展。但是也会出现一个问题，那就是会出现大量的工厂类，代码量大。

 

package factorymethod

import "fmt"

//抽象层
type Fruit interface {
    show()
}
type Factory interface {
    create() Fruit
}

//实现层
type Apple struct {
    Fruit //方便理解为继承，可省略
}

func (a *Apple) show() {
    fmt.Println("i am Apple")
}

type Banana struct {
    Fruit //方便理解为继承，可省略
}

func (a *Banana) show() {
    fmt.Println("i am Banana")
}

type Pear struct {
    Fruit //方便理解为继承，可省略
}

func (a *Pear) show() {
    fmt.Println("i am Pear")
}

type AppleFactory struct {
    Factory
}

func (a *AppleFactory) create() Fruit {
    var fruit Fruit
    fruit = new(Apple)
    return fruit
}

type BananaFactory struct {
    Factory
}

func (a *BananaFactory) create() Fruit {
    var fruit Fruit
    fruit = new(Banana)
    return fruit
}

type PearFactory struct {
    Factory
}

func (a *PearFactory) create() Fruit {
    var fruit Fruit
    fruit = new(Pear)
    return fruit
}

//业务层
func main() {
    var appleFac Factory
    appleFac = new(AppleFactory)
    var apple Fruit
    apple = appleFac.create()
    apple.show()

    var pearFac Factory
    pearFac = new(PearFactory)
    pear := pearFac.create()
    pear.show()

    var bananaFac Factory
    bananaFac = new(BananaFactory)
    banana := bananaFac.create()
    banana.show()
}

 

优点

1. 你可以避免创建者和具体产品之间的紧密耦合。
2. 单一职责原则。 你可以将产品创建代码放在程序的单一位置， 从而使得代码更容易维护。
3. 开闭原则。 无需更改现有客户端代码， 你就可以在程序中引入新的产品类型。

缺点

1. 在添加新的产品的时候，会导致系统类的增加，从而增加了系统的复杂性和理解难度。
2. 为了系统的可扩展型，引入了抽象层，增加了系统的抽象性，和理解难度。