【寒江雪】Go实现工厂模式

简单工厂

  简单工厂的实现思想，即创建一个工厂，将产品的实现逻辑集中在这个工厂中。

/***
 *  Simple Factory
 */
type FoodFactory struct {
}

func (ff FoodFactory) CreateFood(name string) Food {
    var s Food;
    switch name {
    case "Meat":
        s = new(Meat);
    case "Hamberger":
        s = new(Hamberger)
    }
    return s;
}

type Food interface {
    Eat()
}

type Meat struct {
}

type Hamberger struct {
}

func (m Meat) Eat() {
    fmt.Println("Eat meat.")
}

func (h Hamberger) Eat() {
    fmt.Println("Eat Hamberger.")
}

func main(){

    // Simple Factory
    f := FoodFactory{}
    f.CreateFood("Meat").Eat()
    f.CreateFood("Hamberger").Eat()
}

工厂方法

  工厂方法用于弥补简单工厂的不足之处:

• 当新增一种产品的时候，需要修改工厂逻辑
  
• 简单工厂没有继承的结构
  
• 一旦工厂瘫痪，整个系统都瘫痪
  

  工厂方法将产品的创建逻辑写在子类之中,代码如下

/***
 *  Factory Method
 */
type Factory interface {
    Create() Food
}

type MeatFactory struct {
}

func (mf MeatFactory) Create() Food {
    m := Meat{}
    return m
}

type HambergerFactory struct{

}

func (hf HambergerFactory) Create() Food {
    h := Hamberger{}
    return h
}

type Food interface {
    Eat()
}

type Meat struct {
}

type Hamberger struct {
}

func (m Meat) Eat() {
    fmt.Println("Eat meat.")
}

func (h Hamberger) Eat() {
    fmt.Println("Eat Hamberger.")
}

func main(){
    // Factory Method
    mf := MeatFactory{}
    mf.Create().Eat()
    hf := HambergerFactory{}
    hf.Create().Eat()
}

抽象工厂

  抽象工厂是针对一个产品族而言的.

  产品族就好像套餐.一个套餐包含了好几种食品，而每一种食品都是一种类型的食物。举个例子.

  一个套餐定义为食品和饮料.而有一家餐馆的食品包括肉和汉堡，饮料包括CoCo和茶.这家餐馆不想单独出售某种食品和饮料，只卖套餐.

  于是老板定义:

• 套餐A:肉和CoCo
  
• 套餐B:汉堡和茶
  

  定好了之后,把套餐A外包给工厂A负责生产，套餐B外包给工厂B负责生产。两个工厂根据这家店的需求，实习那了生产食品和生产饮料的方法。A工厂就负责A套餐，那么他就需要实现生产肉的逻辑和生产CoCo的逻辑即可.而B工厂只需要实现生产汉堡和生产茶的逻辑即可.

  这样以来，来到店里的客人，只需要订购套餐，服务员通知工厂生产并送达即可。假设一个客人要套餐A，服务员通知工厂A，先生产一个肉，再来一杯CoCo，服务员负责把这些产品递给客人食用即可。

/***
 *  Abstract Factory
 */

type HJXFactory interface{
    CreateFood()Food
    CreateDrink()Drink
}

type FactoryA struct {

}

func (af FactoryA)CreateFood()Food{
    f := Meat{}
    return f
}

func (af FactoryA)CreateDrink()Drink{
    d := CoCo{}
    return d
}

type FactoryB struct {

}

func (bf FactoryB)CreateFood()Food{
    f := Hamberger{}
    return f
}

func (bf FactoryB)CreateDrink()Drink{
    d := Tea{}
    return d
}
type Food interface {
    Eat()
}

type Meat struct {
}

type Hamberger struct {
}

func (m Meat) Eat() {
    fmt.Println("Eat meat.")
}

func (h Hamberger) Eat() {
    fmt.Println("Eat Hamberger.")
}

type Drink interface{
    Drink()
}

type CoCo struct{

}

func (cc CoCo)Drink(){
    fmt.Println("Drink CoCo")
}

type Tea struct{

}

func (t Tea)Drink(){
    fmt.Println("Drink Tea")
}
func main(){
    // Abstract Factory
    fa := FactoryA{}
    fa.CreateFood().Eat()
    fa.CreateDrink().Drink()

    fb := FactoryB{}
    fb.CreateFood().Eat()
    fb.CreateDrink().Drink()
}

Author: 寒江雪
Date:2018-03-08