设计模式--抽象工厂模式(Go语言描述)

设计模式–抽象工厂模式(Go语言描述)

UML


class.png

抽象工厂模式中通常包含以下几种角色:

  1. Factory(抽象工厂): 与工厂方法模式不同的是,抽象工厂声明了一族产品的生产方法,每一个方法都对应于一种产品。
  2. ConcreteFactory(具体工厂): 实现了抽象工厂中声明的方法。每个具体工厂负责生产一族产品。
  3. Product(抽象产品): 与工厂方法模式相同,都定义了一类产品所应实现的方法。
  4. Concrete(具体产品): 实现了抽象产品定义的业务方法,对应于一种具体的产品。


class.png

图片来源于这里



另外,因为在抽象工厂模式中,工厂不再满足于只生产一种类型的产品,而引入了产品族产品等级结构的概念:

  1. 产品族: 由同一个具体工厂生产,归属于不同产品等级结构的一组产品。如BMW工厂生产的轮胎、发动机。
  2. 产品等级结构: 产品的继承关系,具体产品继承于同一个抽象产品,属于同一个产品等级结构。如抽象产品是轮胎,那么其具体产品有BMW工厂生产的轮胎,也有Audi工厂生产的轮胎,轮胎和各工厂生产的轮胎之间构成一个产品的等级结构。

示例

package main

import "fmt"

// 抽象工厂:定义接口
type AbstractFactory interface {
    WheelMethod() Wheel
    EngineMethod() Engine
}

// BMW具体工厂,生产一族产品
type BMWFactory struct{}

func (f *BMWFactory) WheelMethod() Wheel {
    return &BMWWheel{}
}

func (f *BMWFactory) EngineMethod() Engine {
    return &BMWEngine{}
}

// Audi具体工厂,生产一族产品
type AudiFactory struct{}

func (f *AudiFactory) WheelMethod() Wheel {
    return &AudiWheel{}
}

func (f *AudiFactory) EngineMethod() Engine {
    return &AudiEngine{}
}

/* ----------------------------------------- */
// 引擎抽象产品
type Engine interface {
    Start()
}

// BMW引擎
type BMWEngine struct{}

func (b *BMWEngine) Start() {
    fmt.Printf("BMW's Engine\n")
}

// Audi引擎
type AudiEngine struct{}

func (a *AudiEngine) Start() {
    fmt.Printf("Audi's Engine\n")
}

/* ----------------------------------------- */
// 轮胎抽象产品
type Wheel interface {
    Run()
}

// BMW轮胎
type BMWWheel struct{}

func (b *BMWWheel) Run() {
    fmt.Printf("BMW's Wheel\n")
}

// Audi轮胎
type AudiWheel struct{}

func (a *AudiWheel) Run() {
    fmt.Printf("Audi's Wheel\n")
}

func main() {
    bmwFactory := &BMWFactory{}
    wheel := bmwFactory.WheelMethod()
    wheel.Run()
    // output: BMW's Wheel
    engine := bmwFactory.EngineMethod()
    engine.Start()
    // output: BMW's Engine

    audiFactory := &AudiFactory{}
    wheel = audiFactory.WheelMethod()
    wheel.Run()
    // output: Audi's Wheel
    engine = audiFactory.EngineMethod()
    engine.Start()
    // output: Audi's Engine
}

小结

抽象工厂模式中,工厂类不再局限于生产一类产品,而是可以生产一族产品,当只有一种产品等级结构时,抽象工厂模式会退化成工厂方法模式。
在抽象工厂模式中,接口与实现进行了分离,客户端只需要面对接口编程,而不需要知道具体的产品实现。在不同之间的产品族进行切换,只需要通过配置文件动态地切换具体工厂。
增加一族产品只需要增加具体产品及其对应的工厂即可,对已有的代码不需要进行任何修改;而增加一种新的产品等级接口,却需要修改抽象工厂及其全部的子类工厂,增加新产品的生产方法,违背了”开闭原则“。

参考:

  1. 设计模式Java版

本文使用CC BY-NA-SA 4.0协议许可
本文链接:http://404-notfound.com/abstractFactory/