golang设计模式之工厂模式

1.简单工厂模式

通过参数的方式创建产品，在增加一个新的类型时，除了要增加新的类和方法之外，还需要修改工厂函数，在工厂函数中添加case，这一点违背了对修改关闭这个原则（开放-封闭原则）。

//抽象的产品
type SuperMarket interface {
	GetGoods()
}

//参数的方式创建产品
func  NewSupermarket( name string) SuperMarket {
	switch name {
	case "s":
		return &Snacks{}
	case "v":
		return &Vegetables{}
	default:
		return nil
	}
}

//产品1
type Snacks struct {}

func (s *Snacks)GetGoods()  {
	fmt.Println("snacks")
}

//产品2
type Vegetables struct {}
func (v *Vegetables)GetGoods()  {
	fmt.Println("vegetables")
}

2.工厂模式

定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。简单理解就是，创建对象的工作交给工厂即可，客户端不用关心对象怎么来的，直接从工厂获得即可。但是访问类的时候需要指定所要产品的具体类，比如要访问加法或者减法操作都需要实例化

//A X B
//AB操作数 X操作

//实际运行类接口
type Operator interface {
	SetLeft(int)
	SetRight(int)
	Result() int
}

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

//数据抽离
type OperatorBase struct {
	left,right int
}

func (o *OperatorBase)SetLeft(leftval int)  {
	o.left = leftval
}
func (o *OperatorBase)SetRight(rightVal int)  {
	o.right = rightVal
}

//操作的抽象 加法
type PlusOperFactory struct {}

//操作类中包含操作苏
type PlusOperator struct {
	*OperatorBase
}

//实际运行
func (o *PlusOperator)Result() int  {
	return o.left + o.right
}
func (PlusOperFactory)Create()  Operator {
	return &PlusOperator{&OperatorBase{}}
}

type SubOperatorFactory struct {
	
} 

type SubOperator struct {
	*OperatorBase
}

func (o *SubOperator)Result() int  {
	return o.left - o.right
}
func (SubOperatorFactory)Create()  Operator {
	return &SubOperator{&OperatorBase{}}
}

3.抽象工厂模式

提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

type OderInfo interface {
	queryOrderInfo()
}
type OderDetail interface {
	saveOrderDetail()
}
type OrderFactory interface {
	CreateOrderInfo() OderInfo
	CreateOrderDetail() OderDetail
} 

type SnackOrder struct{}

func (s *SnackOrder)queryOrderInfo()  {
	fmt.Println("snack orderInfo")
}

type SnackOrderDetai struct {}

func (s *SnackOrderDetai)saveOrderDetail()  {
	fmt.Println("snack saveOrderDetail")
}

type SnackFactory struct {}

func (s *SnackFactory) CreateOrderInfo() OderInfo{
	return &SnackOrder{}
}

func (s *SnackFactory) CreateOrderDetail() OderDetail {
	return &SnackOrderDetai{}
}