golang中的设计模式（一）–创造型设计模式

Simple Factory Pattern（简单工厂模式）

在简单工厂模式中，可以根据参数的不同返回不同类的实例。
eg:

// AB interface
type AB interface {
	Say(name string) string
}

// A .
type A struct{}

// Say .
func (*A) Say(name string) string {
	return fmt.Sprintf("我是A实例, %s", name)
}

// B .
type B struct{}

// Say .
func (*B) Say(name string) string {
	return fmt.Sprintf("我是B实例, %s", name)
}

// NewAB 根据参数不同返回不同实例
func NewAB(t int) AB {
	if t == 1 {
		return &A{}
	}
	return &B{}
}

Factory Method Pattern 工厂模式方法

在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责产品类被实例化这种细节
eg:

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

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

// 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
}

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

// PlusOperator Operator 的实际加法实现
type PlusOperator struct {
	*OperatorBase
}

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

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

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

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

//Result 获取结果
func (o PlusOperator) Result() int {
	return o.a + o.b
}

//Result 获取结果
func (o MinusOperator) Result() int {
	return o.a - o.b
}

Abstract Factory 抽象工厂模式

当系统所提供的工厂所需生产的具体产品并不是一个简单的对象，而是多个位于不同产品等级结构中属于不同类型的具体产品时需要使用抽象工厂模式。

抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构。

// 工厂接口和产品接口
 type FactoryInterface interface {
   	CreatePigMeatBuns() ProductInterface // 创建猪肉馅产品
   	Create3SBuns() ProductInterface      // 创建三鲜馅产品
   }
   
   type ProductInterface interface {
   	Intro()
   }
   // 实现4种产品
   type GDPigMeatBuns struct {
  }

  func (p GDPigMeatBuns) Intro() {
      fmt.Println("广东猪肉馅包子")
  }
  .....
  // 实现工厂
  // 齐市包子铺 
  type QSFactory struct {
  }

  func (qs QSFactory) CreatePigMeatBuns() ProductInterface {
      return QSPigMeatBuns{}
  }

  func (qs QSFactory) Create3SBuns() ProductInterface {
      return QS3SBuns{}
  }
  // 广东包子铺
  type GDFactory struct {
  }

  func (gd GDFactory) CreatePigMeatBuns() ProductInterface {
      return GDPigMeatBuns{}
  }

  func (gd GDFactory) Create3SBuns() ProductInterface {
      return GD3SBuns{}
  }