1.简单工厂模式

代码

package simplefactory

import "fmt"

type API interface {
    Say(name string) string
}

func NewAPI(t int) API {
    if t == 1 {
        return &readAPI{}
    } else if t == 2 {
        return &writerAPI{}
    }
    return nil
}

type readAPI struct{}

func (*readAPI) Say(name string) string {
    return fmt.Sprintf("read, %s", name)
}

type writerAPI struct{}

func (*writerAPI) Say(name string) string {
    return fmt.Sprintf("writer, %s", name)
}

测试用例

package simplefactory

import "testing"

func TestType1(t *testing.T) {
    api := NewAPI(1)
    s := api.Say("Tom")
    if s != "read, Tom" {
        t.Fatal("Type1 test fail")
    }
}

func TestType2(t *testing.T) {
    api := NewAPI(2)
    s := api.Say("Tom")
    if s != "writer, Tom" {
        t.Fatal("Type2 test fail")
    }
}

// 执行结果：
// === RUN   TestType1
// --- PASS: TestType1 (0.00s)
// PASS

2.工厂模式

代码

package factorymethod

// Operator 是被封装的实际类接口
type Operator interface {
    SetA(int)
    SetB(int)
    Result() int
}

// OperatorBase 是Operator 接口实现的基类，封装公用方法
type OperatorBase struct {
    a, b int
}

// SetA 设置 A
func (o *OperatorBase) SetA(a int) {
    o.a = a
}

// SetB 设置 B
func (o *OperatorBase) SetB(b int) {
    o.b = b
}

// PlusOperator Operator 的实际加法实现
// 结构体嵌套实现“继承”
type PlusOperator struct {
    OperatorBase
}

func (o *PlusOperator) Result() int {
    return o.a + o.b
}

// OperatorFactory 是工厂接口
type OperatorFactory interface {
    Create() Operator
}

// PlusOperatorFactory 是 PlusOperator 的工厂类
type PlusOperatorFactory struct{}

func (PlusOperatorFactory) Create() Operator {
    return &PlusOperator{OperatorBase{}}
}

// MinusOperator Operator 的实际减法实现
type MinusOperator struct {
    OperatorBase
}

func (o *MinusOperator) Result() int {
    return o.a - o.b
}

// MinusOperatorFactory 是 PlusOperator 的工厂类
type MinusOperatorFactory struct{}

func (MinusOperatorFactory) Create() Operator {
    return &MinusOperator{OperatorBase{}}
}

测试用例

package factorymethod

import "testing"

func compute(factory OperatorFactory, a, b int) int {
    op := factory.Create()
    op.SetA(a)
    op.SetB(b)
    return op.Result()
}

func TestOperator(t *testing.T) {
    var (
        factory OperatorFactory
    )

    factory = PlusOperatorFactory{}
    if compute(factory, 1, 2) != 3 {
        t.Fatal("error with factory method pattern")
    }

    factory = MinusOperatorFactory{}
    if compute(factory, 4, 2) != 2 {
        t.Fatal("error with factory method pattern")
    }
}

// 测试结果：
// === RUN   TestOperator
// --- PASS: TestOperator (0.00s)
// PASS

3.抽象工厂模式

代码

package abstractfactory

import "fmt"

// OrderMainDAO 为订单主记录
type OrderMainDAO interface {
    SaveOrderMain()
}

// OrderDetailDAO 为订单详情纪录
type OrderDetailDAO interface {
    SaveOrderDetail()
}

// RDBMainDAP 为关系型数据库的 OrderMainDAO 实现
type RDBMainDAO struct{}

//  RDBMainDAO 类型实现接口 OrderMainDAO
func (RDBMainDAO) SaveOrderMain() {
    fmt.Print("rdb main save\n")
}

// RDBDetailDAO 为关系型数据库的 OrderDetailDAO 实现
type RDBDetailDAO struct{}

// RDBDetailDAO 类型实现接口 OrderDetailDAO
func (RDBDetailDAO) SaveOrderDetail() {
    fmt.Print("rdb detail save\n")
}

// DAOFactory DAO 抽象模式工厂接口
type DAOFactory interface {
    CreateOrderMainDAO() OrderMainDAO
    CreateOrderDetailDAO() OrderDetailDAO
}

// RDBDAOFactory 是RDB 抽象工厂实现
type RDBDAOFactory struct{}

func (*RDBDAOFactory) CreateOrderMainDAO() OrderMainDAO {
    return &RDBMainDAO{}
}

func (*RDBDAOFactory) CreateOrderDetailDAO() OrderDetailDAO {
    return &RDBDetailDAO{}
}

// XMLMainDAO XML存储
type XMLMainDAO struct{}

//  XMLMainDAO 类型实现接口 OrderMainDAO.
func (XMLMainDAO) SaveOrderMain() {
    fmt.Print("xml main save\n")
}

// XMLDetailDAO XML存储
type XMLDetailDAO struct{}

//  XMLDetailDAO 类型实现接口 OrderDetailDAO.
func (XMLDetailDAO) SaveOrderDetail() {
    fmt.Print("xml detail save")
}

//XMLDAOFactory 是RDB 抽象工厂实现
type XMLDAOFactory struct{}

func (*XMLDAOFactory) CreateOrderMainDAO() OrderMainDAO {
    return &XMLMainDAO{}
}

func (*XMLDAOFactory) CreateOrderDetailDAO() OrderDetailDAO {
    return &XMLDetailDAO{}
}

测试用例

package abstractfactory

func getMainAndDetail(factory DAOFactory) {
    factory.CreateOrderMainDAO().SaveOrderMain()
    factory.CreateOrderDetailDAO().SaveOrderDetail()
}

func ExampleRdbFactory() {
    var factory DAOFactory
    factory = &RDBDAOFactory{}
    getMainAndDetail(factory)
    // Output:
    // rdb main save
    // rdb detail save
}

func ExampleXmlFactory() {
    var factory DAOFactory
    factory = &XMLDAOFactory{}
    getMainAndDetail(factory)
    // Output:
    // xml main save
    // xml detail save
}

// === RUN   ExampleRdbFactory
// --- PASS: ExampleRdbFactory (0.00s)
// === RUN   ExampleXmlFactory
// --- PASS: ExampleXmlFactory (0.00s)
// PASS