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
网友评论