手撸golang 创建型设计模式 工厂方法
缘起
最近复习设计模式
拜读谭勇德的<<设计模式就该这样学>>
该书以java语言演绎了常见设计模式
本系列笔记拟采用golang练习之
工厂方法
工厂方法模式（Factory Method Pattern）又叫作多态性工厂模式，指定义一个创建对象的接口，但由实现这个接口的类来决定实例化哪个类，工厂方法把类的实例化推迟到子类中进行。
在工厂方法模式中，不再由单一的工厂类生产产品，而是由工厂类的子类实现具体产品的创建。因此，当增加一个产品时，只需增加一个相应的工厂类的子类, 以解决简单工厂生产太多产品导致其内部代码臃肿（switch … case分支过多）的问题。
场景
- 某智能家居场景, 需要通过app统一控制智能照明灯的开关
- 智能灯可以打开 - Open(), 或关闭 - Close()
- 智能灯可能来自不同厂商, 控制驱动不一样, 具体信息保存在配置文件中
- 当智能灯的品种越来越多以后, 简单工厂方法迅速膨胀, 变得难以维护, 因此需要改造为工厂方法
设计
- 定义ILight接口, 表示智能灯
- 定义ILightFactory接口, 表示创建智能灯的抽象工厂
- 定义LightInfo类, 保存不同灯的配置信息
- 定义FactoryRegistry类, 用于接受不同厂商的工厂子类
- 不同厂商各自实现抽象工厂和抽象产品
factory_method_test.go
单元测试
package patterns
import (
fm "learning/gooop/creational_patterns/factory_method"
"testing"
// 引入mijia并自动注册
_ "learning/gooop/creational_patterns/factory_method/mijia"
// 引入redmi并自动注册
_ "learning/gooop/creational_patterns/factory_method/redmi"
)
func Test_FactoryMethod(t *testing.T) {
config := make([]*fm.LightInfo, 0)
config = append(config, fm.NewLightInfo(1, "客厅灯", "mijia", "L-100"))
config = append(config, fm.NewLightInfo(2, "餐厅灯", "redmi", "L-45"))
for _,info := range config {
factory := fm.DefaultFactoryRegistry.Get(info.Vendor())
if factory == nil {
t.Errorf("unsupported vendor: %s", info.Vendor())
} else {
e, light := factory.Create(info)
if e != nil {
t.Error(e.Error())
} else {
_ = light.Open()
_ = light.Close()
}
}
}
}
测试输出
$ go test -v factory_method_test.go
=== RUN Test_FactoryMethod
tMijiaLight.open, &{1 客厅灯 mijia L-100}
tMijiaLight.Close, &{1 客厅灯 mijia L-100}
tRedmiLight.open, &{2 餐厅灯 redmi L-45}
tRedmiLight.Close, &{2 餐厅灯 redmi L-45}
--- PASS: Test_FactoryMethod (0.00s)
PASS
ok command-line-arguments 0.002s
ILight.go
定义智能灯的接口
package factory_method
type ILight interface {
ID() int
Name() string
Open() error
Close() error
}
ILightFactory.go
定义智能灯工厂的接口
package factory_method
type ILightFactory interface {
Create(info *LightInfo) (error, ILight)
}
_
LightInfo.go
封装智能灯的配置信息
package factory_method
type LightInfo struct {
iID int
sName string
sVendor string
sModel string
}
func NewLightInfo(id int, name string, vendor string, model string) *LightInfo {
return &LightInfo{
id, name, vendor, model,
}
}
func (me *LightInfo) ID() int {
return me.iID
}
func (me *LightInfo) Name() string {
return me.sName
}
func (me *LightInfo) Vendor() string {
return me.sVendor
}
FactoryRegistry.go
提供从厂商名称到该厂商的智能灯工厂实例的注册表
package factory_method
var DefaultFactoryRegistry = newFactoryRegistry()
type IFactoryRegistry interface {
Set(vendor string, factory ILightFactory)
Get(vendor string) ILightFactory
}
type tSimpleFactoryRegistry struct {
mFactoryMap map[string]ILightFactory
}
func newFactoryRegistry() IFactoryRegistry {
return &tSimpleFactoryRegistry{
mFactoryMap: make(map[string]ILightFactory, 0),
}
}
func (me *tSimpleFactoryRegistry) Set(vendor string, factory ILightFactory) {
me.mFactoryMap[vendor] = factory
}
func (me *tSimpleFactoryRegistry) Get(vendor string) ILightFactory {
it,ok := me.mFactoryMap[vendor]
if ok {
return it
}
return nil
}
MijiaLightFactory.go
位于"mijia"子目录, 实现ILightFactory接口, 提供对"mijia"产品的创建
package mijia
import (fm "learning/gooop/creational_patterns/factory_method")
func init() {
fm.DefaultFactoryRegistry.Set("mijia", newMijiaLightFactory())
}
type tMijiaLightFactory struct {
}
func newMijiaLightFactory() fm.ILightFactory {
return &tMijiaLightFactory{}
}
func (me *tMijiaLightFactory) Create(info *fm.LightInfo) (error, fm.ILight) {
return nil, NewMijiaLight(info)
}
MijiaLight.go
位于"mijia"子目录, 实现ILight接口, 提供对"mijia"智能灯的实现
package mijia
import "fmt"
import (fm "learning/gooop/creational_patterns/factory_method")
type tMijiaLight struct {
fm.LightInfo
}
func NewMijiaLight(info *fm.LightInfo) *tMijiaLight {
return &tMijiaLight{
*info,
}
}
func (me *tMijiaLight) Open() error {
fmt.Printf("tMijiaLight.open, %v\n", &me.LightInfo)
return nil
}
func (me *tMijiaLight) Close() error {
fmt.Printf("tMijiaLight.Close, %v\n", &me.LightInfo)
return nil
}
RedmiLightFactory.go
位于"redmi"子目录, 实现ILightFactory接口, 提供对"redmi"产品的创建
package redmi
import (fm "learning/gooop/creational_patterns/factory_method")
func init() {
fm.DefaultFactoryRegistry.Set("redmi", newRedmiLightFactory())
}
type tRedmiLightFactory struct {
}
func newRedmiLightFactory() fm.ILightFactory {
return &tRedmiLightFactory{}
}
func (me *tRedmiLightFactory) Create(info *fm.LightInfo) (error, fm.ILight) {
return nil, newRedmiLight(info)
}
RedmiLight.go
位于"redmi"子目录, 实现ILight接口, 提供对"redmi"智能灯的实现
package redmi
import "fmt"
import (fm "learning/gooop/creational_patterns/factory_method")
type tRedmiLight struct {
fm.LightInfo
}
func newRedmiLight(info *fm.LightInfo) *tRedmiLight {
return &tRedmiLight{
*info,
}
}
func (me *tRedmiLight) Open() error {
fmt.Printf("tRedmiLight.open, %v\n", &me.LightInfo)
return nil
}
func (me *tRedmiLight) Close() error {
fmt.Printf("tRedmiLight.Close, %v\n", &me.LightInfo)
return nil
}
小结
工厂方法模式的优点
（1）灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
（2）典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。
工厂方法模式的缺点
（1）类的个数容易过多，增加复杂度。
（2）增加了系统的抽象性和理解难度。
（3）抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。
