?01 介紹
工廠模式是一種創建型設計模式，包含三種類型，分別是簡單工廠、工廠方法和抽象工廠。
在《設計模式》[1]一書中，因為 GoF[2] 認為簡單工廠是工廠方法的一種特例，所以 GoF 把工廠模式分為兩種類型，分別是工廠方法和抽象工廠。
本文我們使用第一種分類方式，分別介紹一下工廠模式的三種類型。
02 使用場景
在介紹工廠模式的使用場景之前，我們需要先簡單了解工廠模式的組成結構，一般分為抽象產品、具體產品、抽象工廠和具體工廠。
注意：簡單工廠模式，不區分抽象工廠和具體工廠。
簡單工廠
簡單工廠適用于具體產品較少，且不會頻繁添加具體產品的場景。因為每多一個具體產品，在工廠中就多一個 if 分支。
工廠方法
工廠方法適用于具體產品較多，且需要頻繁添加具體產品的場景。使用工廠方法可以避免使用 if 分支，當我們需要添加具體產品時，只需創建新的具體產品和具體工廠，符合開閉原則和單一職責原則。
而且還可以將每個具體產品的創建邏輯拆分到不同的工廠中，避免使用一個工廠導致的代碼過于復雜。
注意：拆分多個工廠，則需要維護多個工廠的代碼。
抽象工廠
抽象工廠適用于一個具體工廠需要負責生產多個不同產品，并且工廠的職責不會繼續增加的場景（即抽象工廠定義的一組方法不會繼續增加）。
否則，不僅所有具體工廠都需要修改，抽象產品和具體產品也需要修改，違反開閉原則。
03 實現方式
簡單工廠
簡單工廠模式違反了開閉原則，嚴格意義上不算是一個設計模式，它主要包括三個結構，分別是工廠、抽象產品和具體產品。
- 工廠 - 負責調用具體產品生產產品，返回值是抽象產品（接口）。
- 抽象產品 - 負責定義產品，接口類型，包含一組方法。
- 具體產品 - 負責被工廠調用，實現抽象產品（接口）。
工廠方法
工廠方法模式符合開閉原則，它相比簡單工廠模式，多了一個抽象工廠的結構，總共包括四個結構，分別是抽象工廠、具體工廠、抽象產品和具體產品。
- 抽象工廠（單個） - 負責定義工廠，接口類型，包含一組方法。
- 具體工廠（多個） - 負責通過實例化具體產品創建產品，實現抽象工廠（接口）。
- 抽象產品（單個） - 負責定義產品，接口類型，包含一組方法。
- 具體產品（多個） - 負責被具體工廠調用，實現抽象產品（接口）。
注意：此處“抽象工廠”是工廠方法模式中的一個結構，不要與抽象工廠模式混淆。
抽象工廠
抽象工廠模式也是總共包括四個結構，它與工廠方法模式不同，工廠方法模式中抽象產品只有一個，而抽象工廠模式抽象產品有多個。
但是，四個結構的職責與工廠方法模式相同。
- 抽象工廠（單個）
- 具體工廠（多個）
- 抽象產品（多個）
- 具體產品（多個）
04 Go 實現
簡單工廠
// IDrink 抽象產品 - 飲料
type IDrink interface {
Kind() // 抽象方法 - 類別
Name() // 抽象方法 - 名稱
}
// CocaCola 具體產品 - 可口可樂
type CocaCola struct {
}
// Kind 具體方法
func (c *CocaCola) Kind() {
fmt.Println("carbonated drinks")
}
// Name 具體方法
func (c *CocaCola) Name() {
fmt.Println("CocaCola")
}
// Sprite 具體產品 - 雪碧
type Sprite struct {
}
// Kind 具體方法
func (s *Sprite) Kind() {
fmt.Println("carbonated drinks")
}
// Name 具體方法
func (s *Sprite) Name() {
fmt.Println("Sprite")
}
// SimpleFactory 工廠
type SimpleFactory struct {
}
// Produce 生產 - 返回值（抽象產品）
func (s *SimpleFactory) Produce(name string) (drink IDrink) {
if name == "CocaCola" {
drink = new(CocaCola)
} else if name == "Sprite" {
drink = new(Sprite)
}
return
}
閱讀上面這段代碼，我們可以發現，我們通過代碼定義簡單工廠模式的三個結構。
定義一個包含一組方法的 IDrink 接口，代表抽象產品；
定義一個 CocaCola? 結構體和一個 Sprite? 結構體，并都實現 IDrink 接口，代表具體產品；
定義一個 SimpleFactory? 結構體，并定義一個返回值是 IDrink? 的 Produce 方法，代表工廠。
工廠方法
// IDrink 抽象產品
type IDrink interface {
Kind() // 抽象方法
Name() // 抽象方法
}
// CocaCola 具體產品
type CocaCola struct {
}
// Kind 具體方法
func (c *CocaCola) Kind() {
fmt.Println("carbonated drinks")
}
// Name 具體方法
func (c *CocaCola) Name() {
fmt.Println("CocaCola")
}
// Sprite 具體產品
type Sprite struct {
}
// Kind 具體方法
func (s *Sprite) Kind() {
fmt.Println("carbonated drinks")
}
// Name 具體方法
func (s *Sprite) Name() {
fmt.Println("Sprite")
}
// IFactory 抽象工廠
type IFactory interface {
Produce() IDrink // 抽象方法
}
// CocaColaFactory 具體工廠
type CocaColaFactory struct {
}
// Produce 具體方法
func (c *CocaColaFactory) Produce() (drink IDrink) {
drink = new(CocaCola)
return
}
// SpriteFactory 具體工廠
type SpriteFactory struct {
}
// Produce 具體方法
func (s *SpriteFactory) Produce() (drink IDrink) {
drink = new(Sprite)
return
}
閱讀上面這段代碼，我們通過代碼定義工廠方法模式的四個結構。
定義一個包含一組方法的 IDrink 接口，代表抽象產品；
定義一個 CocaCola? 結構體和一個 Sprite? 結構體，并都實現 IDrink 接口，代表具體產品；
定義一個包含一組方法的 IFactory 接口，代表抽象工廠；
定義一個 CocaColaFactory? 結構體和一個 SpriteFactory? 結構體，并都實現 IFactory 接口，代表具體工廠；
抽象工廠
// AbstractCola 抽象 Cola
type AbstractCola interface {
ColaKind() // 抽象方法
ColaName() // 抽象方法
}
// AbstractSprite 抽象 Sprite
type AbstractSprite interface {
SpriteKind() // 抽象方法
SpriteName() // 抽象方法
}
// AbstractFactory 抽象工廠
type AbstractFactory interface {
ProduceCola() AbstractCola // 抽象方法
ProduceSprite() AbstractSprite // 抽象方法
}
// CocaBrandCola 可口品牌 具體 Cola 產品
type CocaBrandCola struct {
}
func (c *CocaBrandCola) ColaKind() {
fmt.Println("Coca Brand carbonated drinks")
}
func (c *CocaBrandCola) ColaName() {
fmt.Println("Coca Brand Cola")
}
// CocaBrandSprite 可口品牌 具體 Sprite 產品
type CocaBrandSprite struct {
}
func (c *CocaBrandSprite) SpriteKind() {
fmt.Println("Coca Brand carbonated drinks")
}
func (c *CocaBrandSprite) SpriteName() {
fmt.Println("Coca Brand Sprite")
}
// CocaFactory 可口品牌 具體工廠
type CocaFactory struct {
}
func (c *CocaFactory) ProduceCola() (cola AbstractCola) {
cola = new(CocaBrandCola)
return
}
func (c *CocaFactory) ProduceSprite() (sprite AbstractSprite) {
sprite = new(CocaBrandSprite)
return
}
// PepsiBrandCola 百事品牌 具體 Cola 產品
type PepsiBrandCola struct {
}
func (p *PepsiBrandCola) ColaKind() {
fmt.Println("Pepsi Brand carbonated drinks")
}
func (p *PepsiBrandCola) ColaName() {
fmt.Println("Pepsi Brand Cola")
}
// PepsiBrandSprite 百事品牌 具體 Sprite 產品
type PepsiBrandSprite struct {
}
func (p *PepsiBrandSprite) SpriteKind() {
fmt.Println("Pepsi Brand carbonated drinks")
}
func (p *PepsiBrandSprite) SpriteName() {
fmt.Println("Pepsi Brand Sprite")
}
// PepsiFactory 百事品牌 具體工廠
type PepsiFactory struct {
}
func (p *PepsiFactory) ProduceCola() (cola AbstractCola) {
cola = new(PepsiBrandCola)
return
}
func (p *PepsiFactory) ProduceSprite() (sprite AbstractSprite) {
sprite = new(PepsiBrandSprite)
return
}
閱讀上面這段代碼，我們通過代碼定義抽象工廠模式的四個結構。
定義一個包含一組方法的 AbstractCola? 接口，和一個包含一組方法的 AbstractSprite 接口，均代表抽象產品（多個抽象產品）；
定義一個 CocaBrandCola? 結構體，實現 AbstractCola? 接口；定義一個 CocaBrandSprite? 結構體，實現 AbstractSprite 接口；均代表具體產品（多個具體產品）；
定義一個包含一組方法的 AbstractFactory 接口，代表抽象工廠；
定義一個 CocaFactory? 結構體，實現 AbstractFactory? 接口；定義一個 PepsiFactory? 結構體，實現 AbstractFactory 接口；均代表具體工廠（多個具體工廠）；
05 總結
本文介紹的三種工廠模式中，簡單工廠和工廠方法比較常用，抽象工廠使用較少。
其中，簡單工廠適用于具體產品較少，且不會頻繁添加具體產品的場景；
工廠方法適用于具體產品較多，且需要頻繁添加具體產品的場景；
還有就是生產具體產品，代碼比較復雜，不只是實例化具體產品，還需要其他業務邏輯的場景；
或不希望代碼中使用一堆 if 分支的場景。
參考資料
?[1]《設計模式》: https://en.wikipedia.org/wiki/Design_Patterns
[2]GoF: http://wiki.c2.com/?GangOfFour
