快捷導(dǎo)航

Golang設(shè)計模式中抽象工廠模式詳細(xì)講解

更新時間：2023年01月11日 15:24:48 作者：Ch3n

抽象工廠模式用于生成產(chǎn)品族的工廠，所生成的對象是有關(guān)聯(lián)的。如果抽象工廠退化成生成的對象無關(guān)聯(lián)則成為工廠函數(shù)模式。比如本例子中使用RDB和XML存儲訂單信息，抽象工廠分別能生成相關(guān)的主訂單信息和訂單詳情信息

抽象工廠模式

抽象工廠模式是一種創(chuàng)建型設(shè)計模式，它能創(chuàng)建一系列相關(guān)的對象，而無需指定其具體類。

抽象工廠定義了用于創(chuàng)建不同產(chǎn)品的接口，但將實(shí)際的創(chuàng)建工作留給了具體工廠類。每個工廠類型都對應(yīng)一個特定的產(chǎn)品變體。

在創(chuàng)建產(chǎn)品時，客戶端代碼調(diào)用的是工廠對象的構(gòu)建方法，而不是直接調(diào)用構(gòu)造函數(shù) （new操作符）。由于一個工廠對應(yīng)一種產(chǎn)品變體，因此它創(chuàng)建的所有產(chǎn)品都可相互兼容。

客戶端代碼僅通過其抽象接口與工廠和產(chǎn)品進(jìn)行交互。該接口允許同一客戶端代碼與不同產(chǎn)品進(jìn)行交互。你只需創(chuàng)建一個具體工廠類并將其傳遞給客戶端代碼即可。

概念示例

讓我們假設(shè)一下，如果你想要購買一組運(yùn)動裝備，比如一雙鞋與一件襯衫這樣由兩種不同產(chǎn)品組合而成的套裝。相信你會想去購買同一品牌的商品，這樣商品之間能夠互相搭配起來。

如果我們把這樣的行為轉(zhuǎn)換成代碼的話，幫助我們創(chuàng)建此類產(chǎn)品組的工具就是抽象工廠，便于產(chǎn)品之間能夠相互匹配。

iSportsFactory.go: 抽象工廠接口

package main
import "fmt"
type ISportsFactory interface {
    makeShoe() IShoe
    makeShirt() IShirt
}
func GetSportsFactory(brand string) (ISportsFactory, error) {
    if brand == "adidas" {
        return &Adidas{}, nil
    }
    if brand == "nike" {
        return &Nike{}, nil
    }
    return nil, fmt.Errorf("Wrong brand type passed")
}

adidas.go: 具體工廠

package main
type Adidas struct {
}
func (a *Adidas) makeShoe() IShoe {
    return &AdidasShoe{
        Shoe: Shoe{
            logo: "adidas",
            size: 14,
        },
    }
}
func (a *Adidas) makeShirt() IShirt {
    return &AdidasShirt{
        Shirt: Shirt{
            logo: "adidas",
            size: 14,
        },
    }
}

nike.go: 具體工廠

package main
type Nike struct {
}
func (n *Nike) makeShoe() IShoe {
    return &NikeShoe{
        Shoe: Shoe{
            logo: "nike",
            size: 14,
        },
    }
}
func (n *Nike) makeShirt() IShirt {
    return &NikeShirt{
        Shirt: Shirt{
            logo: "nike",
            size: 14,
        },
    }
}

iShoe.go: 抽象產(chǎn)品

package main
type IShoe interface {
    setLogo(logo string)
    setSize(size int)
    getLogo() string
    getSize() int
}
type Shoe struct {
    logo string
    size int
}
func (s *Shoe) setLogo(logo string) {
    s.logo = logo
}
func (s *Shoe) getLogo() string {
    return s.logo
}
func (s *Shoe) setSize(size int) {
    s.size = size
}
func (s *Shoe) getSize() int {
    return s.size
}

adidasShoe.go: 具體產(chǎn)品

package main
type AdidasShoe struct {
    Shoe
}

nikeShoe.go: 具體產(chǎn)品

package main
type NikeShoe struct {
    Shoe
}

iShirt.go: 抽象產(chǎn)品

package main
type IShirt interface {
    setLogo(logo string)
    setSize(size int)
    getLogo() string
    getSize() int
}
type Shirt struct {
    logo string
    size int
}
func (s *Shirt) setLogo(logo string) {
    s.logo = logo
}
func (s *Shirt) getLogo() string {
    return s.logo
}
func (s *Shirt) setSize(size int) {
    s.size = size
}
func (s *Shirt) getSize() int {
    return s.size
}

adidasShirt.go: 具體產(chǎn)品

package main
type AdidasShirt struct {
    Shirt
}

nikeShirt.go: 具體產(chǎn)品

package main
type NikeShirt struct {
    Shirt
}

main.go: 客戶端代碼

package main
import "fmt"
func main() {
    adidasFactory, _ := GetSportsFactory("adidas")
    nikeFactory, _ := GetSportsFactory("nike")
    nikeShoe := nikeFactory.makeShoe()
    nikeShirt := nikeFactory.makeShirt()
    adidasShoe := adidasFactory.makeShoe()
    adidasShirt := adidasFactory.makeShirt()
    printShoeDetails(nikeShoe)
    printShirtDetails(nikeShirt)
    printShoeDetails(adidasShoe)
    printShirtDetails(adidasShirt)
}
func printShoeDetails(s IShoe) {
    fmt.Printf("Logo: %s", s.getLogo())
    fmt.Println()
    fmt.Printf("Size: %d", s.getSize())
    fmt.Println()
}
func printShirtDetails(s IShirt) {
    fmt.Printf("Logo: %s", s.getLogo())
    fmt.Println()
    fmt.Printf("Size: %d", s.getSize())
    fmt.Println()
}

output.txt: 執(zhí)行結(jié)果