工厂模式 2022-03-11

工厂模式

简单工厂模式

简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，属于类创建型模式
简单工厂模式专门定义一个工厂类来负责创建其他类的实例，可以根据参数的不同返回不同类的实例
注意：被创建的具体实例是有共性的，通常具有共同的父类，或是实现了同一个接口

// You can edit this code!
// Click here and start typing.
package main

// 牛排工厂
type SteakFactory struct{}

func (f *SteakFactory) NewSteak(typ string) Steak {
    var s Steak
    if typ == "A" {
        s = &SteakA{}
    } else if typ == "B" {
        s = &SteakB{}
    }
    // 工厂也可以额外包装好
    s.prepare()
    s.bake()
    s.pack()
    return s
}

// 牛排产品 接口
type Steak interface {
    prepare() error
    bake() error
    pack() error
    delivery() error
}

// A类牛排
type SteakA struct{}

func (a *SteakA) prepare() error {
    // ...
    return nil
}

func (a *SteakA) bake() error {
    // ...
    return nil
}

func (a *SteakA) pack() error {
    // ...
    return nil
}

func (a *SteakA) delivery() error {
    // ...
    return nil
}

// B类牛排
type SteakB struct{}

func (b *SteakB) prepare() error {
    // ...
    return nil
}

func (b *SteakB) bake() error {
    // ...
    return nil
}

func (b *SteakB) pack() error {
    // ...
    return nil
}

func (b *SteakB) delivery() error {
    // ...
    return nil
}

func main() {
    // 创建工厂
    f := SteakFactory{}
    // 生产牛排
    a := f.NewSteak("A")
    b := f.NewSteak("B")
    // 派送牛排
    a.delivery()
    b.delivery()
}

// see: https://go.dev/play/p/tOomWNfU1C0

工厂方法模式

现在牛排的总类越来越多，成千上万种牛排丢到一个工厂生产，那这个工厂的实现必然非常臃肿
于是，需要将原来的工厂“拆”成很多个具体的小工厂，分别负责若干种牛排的精细化生产。比如生产甜牛排要一个工厂，生产咸牛排又是另一个工厂
这时，原来工厂创建对象的具体方法就可以抽象成为一个创建对象的接口（即工厂方法）而不是具体的实现了

// You can edit this code!
// Click here and start typing.
package main

// ---------
// 牛排工厂 接口
type SteakFactory interface {
    NewSteak(typ string) Steak
}

// 牛排产品 接口
type Steak interface {
    prepare() error
    bake() error
    pack() error
    delivery() error
}

// ---------

// 具体的牛排工厂实现,只生产AB类牛排，AB类都是咸牛排
type ABSteakFactory struct{}

func (f *ABSteakFactory) NewSteak(typ string) Steak {
    var s Steak
    if typ == "A" {
        s = &SteakA{}
    } else if typ == "B" {
        s = &SteakB{}
    }
    // 工厂也可以额外包装好
    s.prepare()
    s.bake()
    s.pack()
    return s
}

// A类牛排
type SteakA struct{}

func (a *SteakA) prepare() error {
    // ...
    return nil
}

func (a *SteakA) bake() error {
    // ...
    return nil
}

func (a *SteakA) pack() error {
    // ...
    return nil
}

func (a *SteakA) delivery() error {
    // ...
    return nil
}

// B类牛排
type SteakB struct{}

func (b *SteakB) prepare() error {
    // ...
    return nil
}

func (b *SteakB) bake() error {
    // ...
    return nil
}

func (b *SteakB) pack() error {
    // ...
    return nil
}

func (b *SteakB) delivery() error {
    // ...
    return nil
}

func main() {
    // 创建工厂
    f := ABSteakFactory{}
    // 生产牛排
    a := f.NewSteak("A")
    b := f.NewSteak("B")
    // 派送牛排
    a.delivery()
    b.delivery()
}

// see: https://go.dev/play/p/i7prWABFR2C

抽象工厂模式

现在工厂发现，可以做牛排，也可以做羊排猪排。于是工厂开始拓展业务
但是，受限于设备和原料，咸牛排工厂只能做咸羊排猪排，甜牛排工厂也只能做甜羊排猪排
我们说，一个工厂生产出的肉排，其同味道的。牛排、羊排和猪排在味道上是相关的

抽象工厂模式，提供【创建一系列相关的、或者有相互依赖关系的对象】的若干接口
抽象工厂模式中，不但工厂是抽象的，产品也是抽象的，而且有多个产品需要创建。因此，这个抽象工厂会对应到多个实际工厂，每个实际工厂负责创建多个实际产品。我们定义好工厂的接口和产品的接口，由每个具体的工厂去决定它们生产什么具体产品

// You can edit this code!
// Click here and start typing.
package main

// ---------工厂是抽象的，产品也是抽象的----
// 肉食工厂 接口
type MeetFactory interface {
    NewSteak(typ string) Steak
    NewPork(typ string) Pork
    NewLambChop(typ string) LambChop
}

// 牛排产品 接口
type Steak interface {
    prepareSteak() error
    bakeSteak() error
    packSteak() error
    deliverySteak() error
}

// 猪排产品 接口
type Pork interface {
    preparePork() error
    bakePork() error
    packPork() error
    deliveryPork() error
}

// 羊排产品 接口
type LambChop interface {
    prepareLambChop() error
    bakeLambChop() error
    packLambChop() error
    deliveryLambChop() error
}

// ---------以下是工厂和产品的具体实现

// 具体的工厂实现: 甜肉食工厂
type SweetMeetFactory struct{}

func (f *SweetMeetFactory) NewSteak(typ string) Steak {
    var s Steak
    // ...
    return s
}

func (f *SweetMeetFactory) NewPork(typ string) Pork {
    var p Pork
    // ...
    return p
}

func (f *SweetMeetFactory) NewLambChop(typ string) LambChop {
    var ls LambChop
    // ...
    return ls
}

// 具体的牛排实现: 甜A牛排
type SteakA struct{}

func (a *SteakA) prepare() error {
    // ...
    return nil
}

func (a *SteakA) bake() error {
    // ...
    return nil
}

func (a *SteakA) pack() error {
    // ...
    return nil
}

func (a *SteakA) delivery() error {
    // ...
    return nil
}

// 甜猪排实现

// 甜羊排实现

}