缘起

最近复习设计模式
拜读谭勇德的<<设计模式就该这样学>>
本系列笔记拟采用golang练习之

抽象工厂

抽象工厂模式（Abstract Factory Pattern）指提供一个创建一系列相关或相互依赖对象的接口，无须指定它们具体的类。意思是客户端不必指定产品的具体类型，创建多个产品族中的产品对象。
_

抽象工厂vs工厂方法

  • 抽象工厂是创建一系列对象, 且这些对象之间可能存在相关性. 工厂方法通常是创建单一类别的对象

场景

  • 某智能家居场景, 需要通过app统一控制各种设备
  • 目前支持智能灯(ILight)和空调(IAirConditioner)
  • 不同厂家, 通过提供不同的抽象工厂实现, 接入系统, 提供各种设备的控制

设计

  • 定义ISmartDevice接口, 作为所有智能设备的基础接口
  • 定义ILight, 抽象智能灯的接口
  • 定义IAirConditioner, 抽象空调的接口
  • 定义ISmartFactory, 抽象工厂接口, 定义创建智能灯 - CreateLight, 和创建空调 - CreateAirConditioner的方法
  • 定义并实现IFactoryRegistry, 提供厂商标识符到抽象工厂实例的全局注册表
  • 创建”mijia”子目录, 接入”mijia”厂商的智能灯和空调
    • tMijiaLight, 实现ILight接口
    • tMijiaAirConditioner, 实现IAirConditioner接口
    • tMijiaFactory, 实现ISmartFactory接口, 并在init方法中注册到全局的工厂注册表
  • 创建”redmi”子目录, 接入”redmi”厂商的智能灯和空调

abstract_factory_test.go

单元测试

  1. package patterns
  3. import (
  4.     af "learning/gooop/creational_patterns/abstract_factory"
  5.     "testing"
  7.     // 引入并注册厂商"mijia"
  8.     _ "learning/gooop/creational_patterns/abstract_factory/mijia"
  10.     // 引入并注册厂商"redmi"
  11.     _ "learning/gooop/creational_patterns/abstract_factory/redmi"
  12. )
  14. func Test_AbstractFactory(t *testing.T) {
  15.     config := make([]*af.DeviceInfo, 0)
  16.     config = append(config, af.NewDeviceInfo(1, "客厅灯", af.DeviceTypeLight, "mijia", "ML-100"))
  17.     config = append(config, af.NewDeviceInfo(2, "餐厅灯", af.DeviceTypeLight, "redmi", "RL-45"))
  18.     config = append(config, af.NewDeviceInfo(11, "主卧空调", af.DeviceTypeAirConditioner, "mijia", "MA-15"))
  19.     config = append(config, af.NewDeviceInfo(12, "次卧空调", af.DeviceTypeAirConditioner, "redmi", "RA-10"))
  21.     for _,info := range config {
  22.         factory := af.DefaultFactoryRegistry.Get(info.Vendor())
  23.         if factory == nil {
  24.             t.Errorf("unsupported vendor: %s", info.Vendor())
  26.         } else {
  27.             switch info.GetType() {
  28.             case af.DeviceTypeLight:
  29.                 e,light := factory.CreateLight(info)
  30.                 if e != nil {
  31.                     t.Error(e.Error())
  32.                 } else {
  33.                     _ = light.Open()
  34.                     _,_ = light.GetLightMode()
  35.                     _ = light.SetLightMode(1)
  36.                     _,_ = light.GetLightMode()
  37.                     _ = light.Close()
  38.                 }
  39.                 break
  41.             case af.DeviceTypeAirConditioner:
  42.                 e,ac := factory.CreateAirConditioner(info)
  43.                 if e != nil {
  44.                     t.Error(e.Error())
  45.                 } else {
  46.                     _ = ac.Open()
  47.                     _,_ = ac.GetTemperature()
  48.                     _ = ac.SetTemperature(26.5)
  49.                     _,_ = ac.GetTemperature()
  50.                     _ = ac.Close()
  51.                 }
  52.                 break
  53.             }
  54.         }
  55.     }
  56. }

测试输出

  1. $ go test -v abstract_factory_test.go 
  2. === RUN   Test_AbstractFactory
  3. tMijiaLight.Open, &{1 客厅灯 Light mijia ML-100}
  4. tMijiaLight.GetLightMode, 0
  5. tMijiaLight.SetLightMode, 1
  6. tMijiaLight.GetLightMode, 1
  7. tMijiaLight.Close, &{1 客厅灯 Light mijia ML-100}
  8. tRedmiLight.Open, &{2 餐厅灯 Light redmi RL-45}
  9. tRedmiLight.GetLightMode, 0
  10. tRedmiLight.SetLightMode, 1
  11. tRedmiLight.GetLightMode, 1
  12. tRedmiLight.Close, &{2 餐厅灯 Light redmi RL-45}
  13. tMijiaLight.Open, &{11 主卧空调 AirConditioner mijia MA-15}
  14. tMijiaAirConditioner.GetTemperature, 0
  15. tMijiaAirConditioner.SetTemperature, 26.5
  16. tMijiaAirConditioner.GetTemperature, 26.5
  17. tMijiaLight.Close, &{11 主卧空调 AirConditioner mijia MA-15}
  18. tRedmiAirConditioner.Open, &{12 次卧空调 AirConditioner redmi RA-10}
  19. tRedmiAirConditioner.GetTemperature, 0
  20. tRedmiAirConditioner.SetTemperature, 26.5
  21. tRedmiAirConditioner.GetTemperature, 26.5
  22. tRedmiAirConditioner.Close, &{12 次卧空调 AirConditioner redmi RA-10}
  23. --- PASS: Test_AbstractFactory (0.00s)
  24. PASS
  25. ok      command-line-arguments  0.002s

ISmartDevice.go

抽象智能设备的基础接口

  1. package abstract_factory
  3. type ISmartDevice interface {
  4.     ID() int
  5.     Name() string
  7.     Open() error
  8.     Close() error
  9. }

ILight.go

抽象智能灯的接口, 继承ISmartDevice接口, 并添加灯光模式的控制方法

  1. package abstract_factory
  3. type ILight interface {
  4.     ISmartDevice
  6.     GetLightMode() (error, int)
  7.     SetLightMode(mode int) error
  8. }

IAirConditioner.go

抽象空调的接口, 继承ISmartDevice接口, 并添加温度控制的方法

  1. package abstract_factory
  3. type IAirConditioner interface {
  4.     ISmartDevice
  6.     GetTemperature() (error, float64)
  7.     SetTemperature(t float64) error
  8. }

DeviceInfo.go

智能设备的配置信息

  1. package abstract_factory
  3. type DeviceInfo struct {
  4.     iID int
  5.     sName string
  6.     sType DeviceType
  7.     sVendor string
  8.     sModel string
  9. }
  11. type DeviceType string
  12. const DeviceTypeLight DeviceType = "Light"
  13. const DeviceTypeAirConditioner DeviceType = "AirConditioner"
  15. func NewDeviceInfo(id int, name string, devType DeviceType, vendor string, model string) *DeviceInfo {
  16.     return &DeviceInfo{
  17.         id, name, devType, vendor, model,
  18.     }
  19. }
  21. func (me *DeviceInfo) ID() int {
  22.     return me.iID
  23. }
  25. func (me *DeviceInfo) Name() string {
  26.     return me.sName
  27. }
  29. func (me *DeviceInfo) Vendor() string {
  30.     return me.sVendor
  31. }
  33. func (me *DeviceInfo) GetType() DeviceType {
  34.     return me.sType
  35. }

FactoryRegistry.go

从工厂标识符到抽象工厂实例的全局注册表

  1. package abstract_factory
  4. var DefaultFactoryRegistry = newFactoryRegistry()
  7. type IFactoryRegistry interface {
  8.     Set(vendor string, factory ISmartFactory)
  9.     Get(vendor string) ISmartFactory
  10. }
  12. type tSimpleFactoryRegistry struct {
  13.     mFactoryMap map[string]ISmartFactory
  14. }
  16. func newFactoryRegistry() IFactoryRegistry {
  17.     return &tSimpleFactoryRegistry{
  18.         mFactoryMap: make(map[string]ISmartFactory, 0),
  19.     }
  20. }
  22. func (me *tSimpleFactoryRegistry) Set(vendor string, factory ISmartFactory) {
  23.     me.mFactoryMap[vendor] = factory
  24. }
  26. func (me *tSimpleFactoryRegistry) Get(vendor string) ISmartFactory {
  27.     it,ok := me.mFactoryMap[vendor]
  28.     if ok {
  29.         return it
  30.     }
  31.     return nil
  32. }

mijia/MijiaFactory.go

“mijia”厂商实现的工厂类, 在init方法中自动注册到全局注册表

  1. package mijia
  3. import (af "learning/gooop/creational_patterns/abstract_factory")
  5. func init() {
  6.     af.DefaultFactoryRegistry.Set("mijia", newMijiaFactory())
  7. }
  9. type tMijiaFactory struct {
  10. }
  12. func newMijiaFactory() af.ISmartFactory {
  13.     return &tMijiaFactory{}
  14. }
  16. func (me *tMijiaFactory) CreateLight(info *af.DeviceInfo) (error, af.ILight) {
  17.     return nil, newMijiaLight(info)
  18. }
  20. func (me *tMijiaFactory) CreateAirConditioner(info *af.DeviceInfo) (error, af.IAirConditioner) {
  21.     return nil, newMijiaAirConditioner(info)
  22. }

mijia/MijiaLight.go

“mijia”厂商的智能灯实现类

  1. package mijia
  3. import (
  4.     "fmt"
  5.     af "learning/gooop/creational_patterns/abstract_factory"
  6. )
  8. type tMijiaLight struct {
  9.     af.DeviceInfo
  10.     iMode int
  11. }
  14. func newMijiaLight(info *af.DeviceInfo) *tMijiaLight {
  15.     return &tMijiaLight{
  16.         *info, 0,
  17.     }
  18. }
  20. func (me *tMijiaLight) Open() error {
  21.     fmt.Printf("tMijiaLight.Open, %v\n", &me.DeviceInfo)
  22.     return nil
  23. }
  25. func (me *tMijiaLight) Close() error {
  26.     fmt.Printf("tMijiaLight.Close, %v\n", &me.DeviceInfo)
  27.     return nil
  28. }
  30. func (me *tMijiaLight) GetLightMode() (error, int) {
  31.     fmt.Printf("tMijiaLight.GetLightMode, %v\n", me.iMode)
  32.     return nil, me.iMode
  33. }
  35. func (me *tMijiaLight) SetLightMode(mode int) error {
  36.     fmt.Printf("tMijiaLight.SetLightMode, %v\n", mode)
  37.     me.iMode = mode
  38.     return nil
  39. }

mijia/MijiaAirConditioner

“mijia”厂商的空调实现类

  1. package mijia
  3. import (
  4.     "fmt"
  5.     af "learning/gooop/creational_patterns/abstract_factory"
  6. )
  8. type tMijiaAirConditioner struct {
  9.     af.DeviceInfo
  11.     fTemperature float64
  12. }
  15. func newMijiaAirConditioner(info *af.DeviceInfo) *tMijiaAirConditioner {
  16.     return &tMijiaAirConditioner{
  17.         *info, 0,
  18.     }
  19. }
  21. func (me *tMijiaAirConditioner) Open() error {
  22.     fmt.Printf("tMijiaLight.Open, %v\n", &me.DeviceInfo)
  23.     return nil
  24. }
  26. func (me *tMijiaAirConditioner) Close() error {
  27.     fmt.Printf("tMijiaLight.Close, %v\n", &me.DeviceInfo)
  28.     return nil
  29. }
  31. func (me *tMijiaAirConditioner) GetTemperature() (error, float64) {
  32.     fmt.Printf("tMijiaAirConditioner.GetTemperature, %v\n", me.fTemperature)
  33.     return nil, me.fTemperature
  34. }
  36. func (me *tMijiaAirConditioner) SetTemperature(t float64) error {
  37.     me.fTemperature = t
  38.     fmt.Printf("tMijiaAirConditioner.SetTemperature, %v\n", me.fTemperature)
  39.     return nil
  40. }

redmi/RedmiFactory.go

“redmi”厂商实现的工厂类, 在init方法中自动注册到全局注册表. 代码略

redmi/RedmiLight.go

“redmi”厂商的智能灯实现类. 代码略.

redmin/RedmiAirConditioner.go

“redmin”厂商的空调实现类. 代码略.

抽象工厂模式小结

抽象工厂模式的优点
（1）当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品族。
（2）抽象工厂增强了程序的可扩展性，对于新产品族的增加，只需实现一个新的具体工厂即可，不需要对已有代码进行修改，符合开闭原则。
抽象工厂模式的缺点
（1）规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口。
（2）增加了系统的抽象性和理解难度。
_
(end)