工厂方法模式通过引入工厂等级结构，解决了简单工厂模式中工厂类职责太重的问题，但由于工厂方法模式中的每个工厂只生产一类产品，可能会导致系统中存在大量的工厂类，势必会增加系统的开销。因此，可以考虑将一些相关的产品组成一个“产品族”，由同一个工厂来统一生产，这就是本文将要学习的抽象工厂模式的基本思想。
抽象工厂方法模式的实现代码
package main
import "fmt"
// ======= 抽象层 =========
type AbstractApple interface {
ShowApple()
}
type AbstractBanana interface {
ShowBanana()
}
type AbstractPear interface {
ShowPear()
}
//抽象工厂
type AbstractFactory interface {
CreateApple() AbstractApple
CreateBanana() AbstractBanana
CreatePear() AbstractPear
}
// ======== 实现层 =========
/* 中国产品族 */
type ChinaApple struct {}
func (ca *ChinaApple) ShowApple() {
fmt.Println("中国苹果")
}
type ChinaBanana struct {}
func (cb *ChinaBanana) ShowBanana() {
fmt.Println("中国香蕉")
}
type ChinaPear struct {}
func (cp *ChinaPear) ShowPear() {
fmt.Println("中国梨")
}
type ChinaFactory struct {}
func (cf *ChinaFactory) CreateApple() AbstractApple {
apple := new(ChinaApple)
return apple
}
func (cf *ChinaFactory) CreateBanana() AbstractBanana {
banana := new(ChinaBanana)
return banana
}
func (cf *ChinaFactory) CreatePear() AbstractPear {
pear := new(ChinaPear)
return pear
}
/* 日本产品族 */
type JapanApple struct {}
func (ja *JapanApple) ShowApple() {
fmt.Println("日本苹果")
}
type JapanBanana struct {}
func (jb *JapanBanana) ShowBanana() {
fmt.Println("日本香蕉")
}
type JapanPear struct {}
func (cp *JapanPear) ShowPear() {
fmt.Println("日本梨")
}
type JapanFactory struct {}
func (jf *JapanFactory) CreateApple() AbstractApple {
apple := new(JapanApple)
return apple
}
func (jf *JapanFactory) CreateBanana() AbstractBanana {
banana := new(JapanBanana)
return banana
}
func (cf *JapanFactory) CreatePear() AbstractPear {
pear := new(JapanPear)
return pear
}
/* 美国产品族 */
type AmericanApple struct {}
func (aa *AmericanApple) ShowApple() {
fmt.Println("美国苹果")
}
type AmericanBanana struct {}
func (ab *AmericanBanana) ShowBanana() {
fmt.Println("美国香蕉")
}
type AmericanPear struct {}
func (ap *AmericanPear) ShowPear() {
fmt.Println("美国梨")
}
type AmericanFactory struct {}
func (af *AmericanFactory) CreateApple() AbstractApple {
apple := new(AmericanApple)
return apple
}
func (af *AmericanFactory) CreateBanana() AbstractBanana {
banana := new(AmericanBanana)
return banana
}
func (af *AmericanFactory) CreatePear() AbstractPear {
pear := new(AmericanPear)
return pear
}
// ======== 业务逻辑层 =======
func main() {
//需求1: 需要美国的苹果、香蕉、梨 等对象
//1-创建一个美国工
aFac := new(AmericanFactory)
//2-生产美国苹果
aApple := aFac.CreateApple()
aApple.ShowApple()
//3-生产美国香蕉
aBanana := aFac.CreateBanana()
aBanana.ShowBanana()
//4-生产美国梨
aPear := aFac.CreatePear()
aPear.ShowPear()
//需求2: 需要中国的苹果、香蕉
//1-创建一个中国工厂
cFac := new(ChinaFactory)
//2-生产中国苹果
cApple := cFac.CreateApple()
cApple.ShowApple()
//3-生产中国香蕉
cBanana := cFac.CreateBanana()
cBanana.ShowBanana()
}
终端输出
代码解析
func new(Type) *Type
// 内建函数new分配内存。其第一个实参为类型，而非值。其返回值为指向该类型的新分配的零值的指针。
工厂方法模式的代码拆分
1.项目的准备工作
找到 go 的 GOPATH
$ go env //可以查看 GOPATH
在 GOPATH 目录下创建3个文件夹
1.bin文件夹 -- 存放编译后的二进制文件
2.pkg文件夹 -- 存放编译后的库文件
3.src文件夹 -- 存放源码文件
2.创建文件夹
-- 在项目文件夹 abstruct_fac 里创建新文件夹
unify -- 统一，用于存放接口文件
module -- 模块，用于存放结构体文件
-- 在 module 文件夹里创建
china -- 存储与中国相关的结构体
japan -- 存储与日本相关的结构体
american -- 存储与美国相关的结构体
3.接口文件 -- unify文件夹
文件1 -- abstractapple.go
package unify
type AbstractApple interface {
ShowApple()
}
文件2 -- abstractbanana.go
package unify
type AbstractBanana interface {
ShowBanana()
}
文件3 -- abstractpear.go
package unify
type AbstractPear interface {
ShowPear()
}
4.结构体文件 -- module文件夹
1.中国包 -- china 文件夹
文件1 -- chinaapple.go
package china
import "fmt"
/* 中国产品族 */
type ChinaApple struct {}
func (ca *ChinaApple) ShowApple() {
fmt.Println("中国苹果")
}
文件2 -- chinabanana.go
package china
import "fmt"
type ChinaBanana struct {}
func (cb *ChinaBanana) ShowBanana() {
fmt.Println("中国香蕉")
}
文件3 -- chinapear.go
package china
import "fmt"
type ChinaPear struct {}
func (cp *ChinaPear) ShowPear() {
fmt.Println("中国梨")
}
文件1 -- chinafactory.go
package china
import (
"design/abstract_fac/unify"
)
type ChinaFactory struct {}
func (cf *ChinaFactory) CreateApple() unify.AbstractApple {
apple := new(ChinaApple)
return apple
}
func (cf *ChinaFactory) CreateBanana() unify.AbstractBanana {
banana := new(ChinaBanana)
return banana
}
func (cf *ChinaFactory) CreatePear() unify.AbstractPear {
pear := new(ChinaPear)
return pear
}
2.日本包 -- japan 文件夹
文件1 -- japanapple.go
package japan
import "fmt"
/* 日本产品族 */
type JapanApple struct {}
func (ja *JapanApple) ShowApple() {
fmt.Println("日本苹果")
}
文件2 -- japanbanana.go
package japan
import "fmt"
type JapanBanana struct {}
func (jb *JapanBanana) ShowBanana() {
fmt.Println("日本香蕉")
}
文件3 -- japanpear.go
package japan
import "fmt"
type JapanPear struct {}
func (jp *JapanPear) ShowPear() {
fmt.Println("日本梨")
}
文件1 -- japanfactory.go
package japan
import (
"design/abstract_fac/unify"
)
type JapanFactory struct {}
func (jf *JapanFactory) CreateApple() unify.AbstractApple {
apple := new(JapanApple)
return apple
}
func (jf *JapanFactory) CreateBanana() unify.AbstractBanana {
banana := new(JapanBanana)
return banana
}
func (cf *JapanFactory) CreatePear() unify.AbstractPear {
pear := new(JapanPear)
return pear
}
3.美国包 -- american 文件夹
文件1 -- americanapple.go
package american
import "fmt"
/* 美国产品族 */
type AmericanApple struct {}
func (aa *AmericanApple) ShowApple() {
fmt.Println("美国苹果")
}
文件2 -- americanbanana.go
package american
import "fmt"
type AmericanBanana struct {}
func (ab *AmericanBanana) ShowBanana() {
fmt.Println("美国香蕉")
}
文件3 -- americanpear.go
package american
import "fmt"
type AmericanPear struct {}
func (ap *AmericanPear) ShowPear() {
fmt.Println("美国梨")
}
文件1 -- americanfactory.go
package american
import (
"design/abstract_fac/unify"
)
type AmericanFactory struct {}
func (af *AmericanFactory) CreateApple() unify.AbstractApple {
apple := new(AmericanApple)
return apple
}
func (af *AmericanFactory) CreateBanana() unify.AbstractBanana {
banana := new(AmericanBanana)
return banana
}
func (af *AmericanFactory) CreatePear() unify.AbstractPear {
pear := new(AmericanPear)
return pear
}
5.主文件 -- main.go 在项目文件夹
package main
import (
"design/abstract_fac/module/china"
"design/abstract_fac/module/japan"
"design/abstract_fac/module/american"
)
func main() {
//需求1: 需要中国的苹果、香蕉、梨
//1-创建一个中国工厂
cFac := new(china.ChinaFactory)
//2-生产中国苹果
cApple := cFac.CreateApple()
cApple.ShowApple()
//3-生产中国香蕉
cBanana := cFac.CreateBanana()
cBanana.ShowBanana()
//4-生产中国梨
cPear := cFac.CreatePear()
cPear.ShowPear()
//需求2: 需要日本的苹果、香蕉、梨
//1-创建一个日本工厂
jFac := new(japan.JapanFactory)
//2-生产日本苹果
jApple := jFac.CreateApple()
jApple.ShowApple()
//3-生产日本香蕉
jBanana := jFac.CreateBanana()
jBanana.ShowBanana()
//4-生产日本梨
jPear := jFac.CreatePear()
jPear.ShowPear()
//需求3: 需要美国的苹果、香蕉、梨
//1-创建一个美国工厂
aFac := new(american.AmericanFactory)
//2-生产美国苹果
aApple := aFac.CreateApple()
aApple.ShowApple()
//3-生产美国香蕉
aBanana := aFac.CreateBanana()
aBanana.ShowBanana()
//4-生产美国梨
aPear := aFac.CreatePear()
aPear.ShowPear()
}
终端输出
6.全部文件图
