设计模式之工厂模式

1.简单工厂方法模式

package main

import "fmt"

type Fruit interface{
   Plant()
   Crop()
}
type Apple struct {}
func (*Apple)Plant(){
   fmt.Println("种植苹果")
}
func (*Apple)Crop(){
   fmt.Println("收获苹果")
}

type Banana struct{}
func (*Banana)Plant(){
   fmt.Println("种植香蕉")
}
func (*Banana)Crop(){
   fmt.Println("收获香蕉")
}
func FruitFactory(t int)Fruit{

   switch t {
   case 1:
      return &Apple{}
   case 2:
      return &Banana{}
   }
   return nil 
}

func main() {
   a:=FruitFactory(1)
   a.Plant()
   a.Crop()

   b:=FruitFactory(2)
   b.Plant()
   b.Crop()
}

2抽象工厂

package main

import "fmt"

//订单接口
type Order interface {
   Order()
}
//详情接口
type Detail interface{
   Detail()
}
//抽象工厂接口
type AbFactory interface{
   CreateOrder() Order
   CreateDetail() Detail
}

//实现mysql 订单接口对象
type MysqlOrder struct {}
func (*MysqlOrder)Order(){
   fmt.Println("创建mysql订单")
}
//实现mysql详情接口对象
type MysqlDetail struct {}
func(*MysqlDetail)Detail(){
   fmt.Println("创建mysql订单详情")
}
//实现mysql抽象类工厂接口对象
type MysqlAbFactory struct {}
func (*MysqlAbFactory)CreateOrder()Order{
   return &MysqlOrder{}
}
func(*MysqlAbFactory)CreateDetail()Detail{
   return &MysqlDetail{}
}

//es订单实现对象
type EsOrder struct {}
func (*EsOrder)Order(){
   fmt.Println("创建es订单")
}
//es详情实现对象
type EsDetail struct {}
func (*EsDetail) Detail(){
   fmt.Println("创建es详情")
}
//实现抽象工厂对象
type EsAbFactory struct {}
func(*EsAbFactory) CreateOrder()Order{
   return &EsOrder{}
}
func(*EsAbFactory)CreateDetail()Detail{
   return &EsDetail{}
}

func main() {
   //抽象类接口
   var ab AbFactory
   //实现mysql抽象类接口
   ab = &MysqlAbFactory{}
   //使用mysql抽象的订单方法
   ab.CreateOrder().Order()
   //使用mysql抽象详情方法
   ab.CreateDetail().Detail()
   
   //抽象工厂接口
   var esAb AbFactory
   //实现es抽象接口
   esAb = &EsAbFactory{}
   //使用es抽象工厂订单
   esAb.CreateOrder().Order()
   //使用es抽象工厂详情
   esAb.CreateDetail().Detail()
}