手撸golang 建立型设计模式 简单工厂

手撸golang 建立型设计模式 简单工厂

缘起

最近复习设计模式
拜读谭勇德的<<设计模式就该这样学>>
该书以java语言演绎了常见设计模式
本系列笔记拟采用golang练习之

简单工厂

简单工厂模式（Simple Factory Pattern）又叫做静态工厂方法模式（Static Factory Method Pattern），简单来讲，简单工厂模式有一个具体的工厂类，能够生成多个不一样的产品，属于建立型设计模式。
_

场景

• 某智能家居场景, 须要经过app统一控制智能照明灯的开关
• 智能灯能够打开 - Open(), 或关闭 - Close()
• 智能灯可能来自不一样厂商, 控制驱动不同, 具体信息保存在配置文件中

设计

• 定义ILight接口, 表示智能灯
• 定义ILightFactory接口, 表示建立智能灯的简单工厂
• 定义LightInfo类, 保存不一样灯的配置信息
• 定义LightFactory类, 根据配置信息, 建立具体的智能灯实例

simple_factory_test.go

单元测试

package patterns_test

import "testing"
import (sf "learning/gooop/creational_patterns/simple_factory")

func Test_SimpleFactory(t *testing.T) {
    config := make([]*sf.LightInfo, 0)
    config = append(config, sf.NewLightInfo(1, "客厅灯", "mijia", "L-100"))
    config = append(config, sf.NewLightInfo(2, "餐厅灯", "redmi", "L-45"))

    factory := sf.DefaultLightFactory
    for _,info := range config {
        e, light := factory.Create(info)
        if e != nil {
            t.Error(e.Error())
        } else {
            _ = light.Open()
            _ = light.Close()
        }
    }
}

测试输出

$ go test -v simple_factory_test.go 
=== RUN   Test_SimpleFactory
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_SimpleFactory (0.00s)
PASS
ok      command-line-arguments  0.004s

ILight.go

定义智能灯的统一接口

package simple_factory

type ILight interface {
    ID() int
    Name() string

    Open() error
    Close() error
}

ILightFactory.go

定义智能灯的建立工厂

package simple_factory

type ILightFactory interface {
    Create(info *LightInfo) (error, ILight)
}

LightInfo.go

封装智能灯的配置信息

package simple_factory

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
}

LightFactory.go

tLightFactory是实现ILightFactory的简单工厂, 经过输入参数建立不一样的ILight实例

package simple_factory

import (
    "errors"
    "fmt"
    "strings"
)

var DefaultLightFactory = newLightFactory()

type tLightFactory struct {
}

func newLightFactory() ILightFactory {
    return &tLightFactory{}
}

func (me *tLightFactory) Create(info *LightInfo) (error, ILight) {
    switch strings.ToLower(info.sVendor) {
    case "mijia":
        return nil, newMijiaLight(info)
    case "redmi":
        return nil, newRedmiLight(info)
    default:
        return errors.New(fmt.Sprintf("unsupported vendor: %s", info.sVendor)), nil
    }
}

MijiaLight.go

适配厂商为"mijia"的智能灯的控制

package simple_factory

import "fmt"

type tMijiaLight struct {
    LightInfo
}


func newMijiaLight(info *LightInfo) *tMijiaLight {
    return &tMijiaLight{
        *info,
    }
}

func (me *tMijiaLight) Open() error {
    fmt.Printf("MijiaLight.open, %v\n", &me.LightInfo)
    return nil
}

func (me *tMijiaLight) Close() error {
    fmt.Printf("MijiaLight.Close, %v\n", &me.LightInfo)
    return nil
}

RedmiLight.go

适配厂商为"redmi"的智能灯的控制

package simple_factory

import "fmt"

type tRedmiLight struct {
    LightInfo
}

func newRedmiLight(info *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
}

小结

简单工厂模式主要包含3个角色。
（1）简单工厂（SimpleFactory x 1）：是简单工厂模式的核心，负责实现建立全部实例的内部逻辑。工厂类的建立产品类的方法能够被外界直接调用，建立所需的产品对象。
（2）抽象产品（IProduct x 1）：是简单工厂建立的全部对象的父类，负责描述全部实例共有的公共接口。
（3）具体产品（ConcreteProduct x N）：是简单工厂模式的建立目标。