建站
咨詢
售后
建站咨詢
新聞中心
?01 介紹
工廠模式是一種創(chuàng)建型設計模式，包含三種類型，分別是簡單工廠、工廠方法和抽象工廠。
新邱網(wǎng)站制作公司哪家好，找創(chuàng)新互聯(lián)！從網(wǎng)頁設計、網(wǎng)站建設、微信開發(fā)、APP開發(fā)、成都響應式網(wǎng)站建設等網(wǎng)站項目制作，到程序開發(fā)，運營維護。創(chuàng)新互聯(lián)于2013年開始到現(xiàn)在10年的時間，我們擁有了豐富的建站經(jīng)驗和運維經(jīng)驗，來保證我們的工作的順利進行。專注于網(wǎng)站建設就選創(chuàng)新互聯(lián)。
在《設計模式》[1]一書中，因為 GoF[2] 認為簡單工廠是工廠方法的一種特例，所以 GoF 把工廠模式分為兩種類型，分別是工廠方法和抽象工廠。
本文我們使用第一種分類方式，分別介紹一下工廠模式的三種類型。
02 使用場景
在介紹工廠模式的使用場景之前，我們需要先簡單了解工廠模式的組成結(jié)構(gòu)，一般分為抽象產(chǎn)品、具體產(chǎn)品、抽象工廠和具體工廠。
注意：簡單工廠模式，不區(qū)分抽象工廠和具體工廠。
簡單工廠
簡單工廠適用于具體產(chǎn)品較少，且不會頻繁添加具體產(chǎn)品的場景。因為每多一個具體產(chǎn)品，在工廠中就多一個 if 分支。
工廠方法
工廠方法適用于具體產(chǎn)品較多，且需要頻繁添加具體產(chǎn)品的場景。使用工廠方法可以避免使用 if 分支，當我們需要添加具體產(chǎn)品時，只需創(chuàng)建新的具體產(chǎn)品和具體工廠，符合開閉原則和單一職責原則。
而且還可以將每個具體產(chǎn)品的創(chuàng)建邏輯拆分到不同的工廠中，避免使用一個工廠導致的代碼過于復雜。
注意：拆分多個工廠，則需要維護多個工廠的代碼。
抽象工廠
抽象工廠適用于一個具體工廠需要負責生產(chǎn)多個不同產(chǎn)品，并且工廠的職責不會繼續(xù)增加的場景（即抽象工廠定義的一組方法不會繼續(xù)增加）。
否則，不僅所有具體工廠都需要修改，抽象產(chǎn)品和具體產(chǎn)品也需要修改，違反開閉原則。
03 實現(xiàn)方式
簡單工廠
簡單工廠模式違反了開閉原則，嚴格意義上不算是一個設計模式，它主要包括三個結(jié)構(gòu)，分別是工廠、抽象產(chǎn)品和具體產(chǎn)品。
- 工廠 - 負責調(diào)用具體產(chǎn)品生產(chǎn)產(chǎn)品，返回值是抽象產(chǎn)品（接口）。
- 抽象產(chǎn)品 - 負責定義產(chǎn)品，接口類型，包含一組方法。
- 具體產(chǎn)品 - 負責被工廠調(diào)用，實現(xiàn)抽象產(chǎn)品（接口）。
工廠方法
工廠方法模式符合開閉原則，它相比簡單工廠模式，多了一個抽象工廠的結(jié)構(gòu)，總共包括四個結(jié)構(gòu)，分別是抽象工廠、具體工廠、抽象產(chǎn)品和具體產(chǎn)品。
- 抽象工廠（單個） - 負責定義工廠，接口類型，包含一組方法。
- 具體工廠（多個） - 負責通過實例化具體產(chǎn)品創(chuàng)建產(chǎn)品，實現(xiàn)抽象工廠（接口）。
- 抽象產(chǎn)品（單個） - 負責定義產(chǎn)品，接口類型，包含一組方法。
- 具體產(chǎn)品（多個） - 負責被具體工廠調(diào)用，實現(xiàn)抽象產(chǎn)品（接口）。
注意：此處“抽象工廠”是工廠方法模式中的一個結(jié)構(gòu)，不要與抽象工廠模式混淆。
抽象工廠
抽象工廠模式也是總共包括四個結(jié)構(gòu)，它與工廠方法模式不同，工廠方法模式中抽象產(chǎn)品只有一個，而抽象工廠模式抽象產(chǎn)品有多個。
但是，四個結(jié)構(gòu)的職責與工廠方法模式相同。
- 抽象工廠（單個）
- 具體工廠（多個）
- 抽象產(chǎn)品（多個）
- 具體產(chǎn)品（多個）
04 Go 實現(xiàn)
簡單工廠
// IDrink 抽象產(chǎn)品 - 飲料
type IDrink interface {
Kind() // 抽象方法 - 類別
Name() // 抽象方法 - 名稱
}
// CocaCola 具體產(chǎn)品 - 可口可樂
type CocaCola struct {
}
// Kind 具體方法
func (c *CocaCola) Kind() {
fmt.Println("carbonated drinks")
}
// Name 具體方法
func (c *CocaCola) Name() {
fmt.Println("CocaCola")
}
// Sprite 具體產(chǎn)品 - 雪碧
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 生產(chǎn) - 返回值（抽象產(chǎn)品）
func (s *SimpleFactory) Produce(name string) (drink IDrink) {
if name == "CocaCola" {
drink = new(CocaCola)
} else if name == "Sprite" {
drink = new(Sprite)
}
return
}
閱讀上面這段代碼，我們可以發(fā)現(xiàn)，我們通過代碼定義簡單工廠模式的三個結(jié)構(gòu)。
定義一個包含一組方法的 IDrink 接口，代表抽象產(chǎn)品；
定義一個 CocaCola? 結(jié)構(gòu)體和一個 Sprite? 結(jié)構(gòu)體，并都實現(xiàn) IDrink 接口，代表具體產(chǎn)品；
定義一個 SimpleFactory? 結(jié)構(gòu)體，并定義一個返回值是 IDrink? 的 Produce 方法，代表工廠。
工廠方法
// IDrink 抽象產(chǎn)品
type IDrink interface {
Kind() // 抽象方法
Name() // 抽象方法
}
// CocaCola 具體產(chǎn)品
type CocaCola struct {
}
// Kind 具體方法
func (c *CocaCola) Kind() {
fmt.Println("carbonated drinks")
}
// Name 具體方法
func (c *CocaCola) Name() {
fmt.Println("CocaCola")
}
// Sprite 具體產(chǎn)品
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
}
閱讀上面這段代碼，我們通過代碼定義工廠方法模式的四個結(jié)構(gòu)。
定義一個包含一組方法的 IDrink 接口，代表抽象產(chǎn)品；
定義一個 CocaCola? 結(jié)構(gòu)體和一個 Sprite? 結(jié)構(gòu)體，并都實現(xiàn) IDrink 接口，代表具體產(chǎn)品；
定義一個包含一組方法的 IFactory 接口，代表抽象工廠；
定義一個 CocaColaFactory? 結(jié)構(gòu)體和一個 SpriteFactory? 結(jié)構(gòu)體，并都實現(xiàn) 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 產(chǎn)品
type CocaBrandCola struct {
}
func (c *CocaBrandCola) ColaKind() {
fmt.Println("Coca Brand carbonated drinks")
}
func (c *CocaBrandCola) ColaName() {
fmt.Println("Coca Brand Cola")
}
// CocaBrandSprite 可口品牌 具體 Sprite 產(chǎn)品
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 產(chǎn)品
type PepsiBrandCola struct {
}
func (p *PepsiBrandCola) ColaKind() {
fmt.Println("Pepsi Brand carbonated drinks")
}
func (p *PepsiBrandCola) ColaName() {
fmt.Println("Pepsi Brand Cola")
}
// PepsiBrandSprite 百事品牌 具體 Sprite 產(chǎn)品
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
}
閱讀上面這段代碼，我們通過代碼定義抽象工廠模式的四個結(jié)構(gòu)。
定義一個包含一組方法的 AbstractCola? 接口，和一個包含一組方法的 AbstractSprite 接口，均代表抽象產(chǎn)品（多個抽象產(chǎn)品）；
定義一個 CocaBrandCola? 結(jié)構(gòu)體，實現(xiàn) AbstractCola? 接口；定義一個 CocaBrandSprite? 結(jié)構(gòu)體，實現(xiàn) AbstractSprite 接口；均代表具體產(chǎn)品（多個具體產(chǎn)品）；
定義一個包含一組方法的 AbstractFactory 接口，代表抽象工廠；
定義一個 CocaFactory? 結(jié)構(gòu)體，實現(xiàn) AbstractFactory? 接口；定義一個 PepsiFactory? 結(jié)構(gòu)體，實現(xiàn) AbstractFactory 接口；均代表具體工廠（多個具體工廠）；
05 總結(jié)
本文介紹的三種工廠模式中，簡單工廠和工廠方法比較常用，抽象工廠使用較少。
其中，簡單工廠適用于具體產(chǎn)品較少，且不會頻繁添加具體產(chǎn)品的場景；
工廠方法適用于具體產(chǎn)品較多，且需要頻繁添加具體產(chǎn)品的場景；
還有就是生產(chǎn)具體產(chǎn)品，代碼比較復雜，不只是實例化具體產(chǎn)品，還需要其他業(yè)務邏輯的場景；
或不希望代碼中使用一堆 if 分支的場景。
參考資料
?[1]《設計模式》: https://en.wikipedia.org/wiki/Design_Patterns
[2]GoF: http://wiki.c2.com/?GangOfFour
新聞標題：Go 語言實現(xiàn)創(chuàng)建型設計模式 - 工廠模式
URL標題：http://www.5511xx.com/article/cdhecop.html
