一個菜鳥的設計模式之旅，文章可能會有不對的地方，懇請大佬指出錯誤，

編程旅途是漫長遙遠的，在不同時刻有不同的感悟，本文會一直更新下去，

程式介紹

你想要購買一組運動裝備，比如一雙鞋與一件襯衫這樣由兩種不同產品組合而成的套裝，相信你會想去購買同一品牌的商品，這樣商品之間能夠互相搭配起來，如果把這樣的行為轉換成代碼的話，幫助創建此類產品組的工具就是抽象工廠，便于產品之間能夠相互匹配，

案例中 Shoe、Shirt 是兩個抽象產品，具體產品NikeShirt、NikeShoe、AdidasShirt、AdidasShoe 是對兩個抽象產品的具體分類的實作，ISportsFactory\IAbstractFactory 是抽象工廠介面，里面包含所有產品創建的抽象方法，客戶端用的都是抽象產品介面，沒有出現任何一個具體產品了字樣，達到了解耦的目的！

最大的好處是易于交換產品系列，只需要修改具體的工廠實體！

阿迪達斯工廠正在生產襯衫
阿迪達斯工廠正在生產襯衫
阿迪達斯工廠正在生產鞋子
耐克工廠正在生產襯衫
耐克工廠正在生產襯衫
耐克工廠正在生產鞋子
襯衫 品牌 阿迪達斯 大小 14	
襯衫 品牌 阿迪達斯 大小 14
襯衫 品牌 耐克 大小 12
襯衫 品牌 耐克 大小 12
鞋子 品牌 阿迪達斯 大小 10
鞋子 品牌 耐克 大小 12

程式代碼、抽象工廠模式 Golang

iShirt.go 產品介面類

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
}

iShoe.go 產品介面類

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
}

adidas.go 阿迪達斯工廠

package main

type Adidas struct {
}

type AdidasShirt struct {
	Shirt
}

type AdidasShoe struct {
	Shoe
}

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 NikeShirt struct {
	Shirt
}

type NikeShoe struct {
	Shoe
}

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,
		},
	}
}

iSportsFactory.go 抽象工廠介面、簡單工廠

package main

import "fmt"

// 這個是抽象工廠介面
type ISportsFactory interface {
	makeShoe() IShoe
	makeShirt() IShirt
}

// 這里是簡單工廠，根據brand生成特定工廠實體
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")
}

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()
}

Console 輸出

Logo: nike
Size: 14
Logo: nike
Size: 14
Logo: adidas
Size: 14
Logo: adidas
Size: 14

程式代碼、抽象工廠模式 C#

Shirt.cs 產品類

namespace 抽象工廠;

public abstract class Shirt
{
    public string Logo { get; private set; }
    public int Size { get; private set; }

    protected Shirt(string logo, int size)
    {
        Logo = logo;
        Size = size;
    }
}

public class AdidasShirt : Shirt
{
    public AdidasShirt(int size) : base("阿迪達斯", size)
    {
    }
}

public class NikeShirt : Shirt
{
    public NikeShirt(int size) : base("耐克", size)
    {
    }
}

Shoe.cs 產品類

namespace 抽象工廠;

public abstract class Shoe
{
    public string Logo { get; private set; }
    public int Size { get; private set; }

    protected Shoe(string logo, int size)
    {
        Logo = logo;
        Size = size;
    }
}

public class AdidasShoe : Shoe
{
    public AdidasShoe(int size) : base("阿迪達斯", size)
    {
    }
}

public class NikeShoe : Shoe
{
    public NikeShoe(int size) : base("耐克", size)
    {
    }
}

AbstractFactory.cs 抽象工廠類

namespace 抽象工廠;

public interface IAbstractFactory
{
    Shoe createShoe(int size);
    Shirt createShirt(int size);
}

public class AdidasFactory : IAbstractFactory
{
    public Shoe createShoe(int size)
    {
        Console.WriteLine("阿迪達斯工廠正在生產鞋子");
        return new AdidasShoe(size);
    }

    public Shirt createShirt(int size)
    {
        Console.WriteLine("阿迪達斯工廠正在生產襯衫");
        return new AdidasShirt(size);
    }
}
public class NikeFactory : IAbstractFactory
{
    public Shoe createShoe(int size)
    {
        Console.WriteLine("耐克工廠正在生產鞋子");
        return new NikeShoe(size);
    }

    public Shirt createShirt(int size)
    {
        Console.WriteLine("耐克工廠正在生產襯衫");
        return new NikeShirt(size);
    }
}

// 一個類用于存放工廠單例物件，使用餓漢式單例類
public sealed class AbstractFactorySingleton
{
    public static readonly IAbstractFactory Adidas = new AdidasFactory();
    public static readonly IAbstractFactory Nike = new NikeFactory();
    
    // 常規寫法應該提供一個全域訪問點，這里為了方便省略
}

Program.cs

// See https://aka.ms/new-console-template for more information

using 抽象工廠;

// 產品的庫存
List<Shoe> shoes = new();
List<Shirt> shirts = new();

IAbstractFactory factory = AbstractFactorySingleton.Adidas;
Shirt s1 = factory.createShirt(14);
Shirt s2 = factory.createShirt(14);
shirts.Add(s1);
shirts.Add(s2);
Shoe s3 = factory.createShoe(10);
shoes.Add(s3);

factory = AbstractFactorySingleton.Nike;
s1 = factory.createShirt(12);
s2 = factory.createShirt(12);
shirts.Add(s1);
shirts.Add(s2);
s3 = factory.createShoe(12);
shoes.Add(s3);

foreach (var shirt in shirts)
{
    Console.WriteLine($"襯衫 品牌 {shirt.Logo} 大小 {shirt.Size}");
}

foreach (var shoe in shoes)
{
    Console.WriteLine($"鞋子 品牌 {shoe.Logo} 大小 {shoe.Size}");
}

Console 輸出

阿迪達斯工廠正在生產襯衫
阿迪達斯工廠正在生產襯衫
阿迪達斯工廠正在生產鞋子
耐克工廠正在生產襯衫
耐克工廠正在生產襯衫
耐克工廠正在生產鞋子
襯衫 品牌 阿迪達斯 大小 14
襯衫 品牌 阿迪達斯 大小 14
襯衫 品牌 耐克 大小 12
襯衫 品牌 耐克 大小 12
鞋子 品牌 阿迪達斯 大小 10
鞋子 品牌 耐克 大小 12

思考總結

注：把不同的產品變體、產品族理解為不同的產品系列，如現代風格家具類、北約風格家具類，

什么是抽象工廠模式

抽象工廠模式：創建型設計模式，提供一個創建一系列相關或相互依賴物件的介面，而無需指定它們具體的類，

何時使用：系統的產品有多于一個的產品族，而系統只消費其中某一族的產品，

如何解決：

為系列中的每件產品明確宣告介面，確保所有產品變體都繼承這些介面，
我們需要宣告抽象工廠——包含系列中所有產品構造方法的介面，
這些方法必須回傳抽象產品型別，每個工廠類都只能回傳特定類別的產品，

關鍵代碼：在一個工廠里聚合多個同類產品，

應用場景：

代碼需要與多個不同系列的相關產品互動，但是由于無法提前獲取相關資訊，或出于對未來擴展性的考慮，
如果你有一個基于一組抽象方法的類，且其主要功能因此變得不明確，那么在這種情況下可以考慮使用抽象工廠模式，
設計良好的程式中，每個類僅負責一件事，如果一個類與多種型別產品互動，就可以考慮將工廠方法抽取到獨立的工廠類或具備完整功能的抽象工廠類

實作步驟：

以不同的產品型別與產品變體為維度繪制矩陣，
為所有產品宣告抽象產品介面，然后讓所有具體產品類實作這些介面，
宣告抽象工廠介面，并且在介面中為所有抽象產品提供一組構建方法，
為每種產品變體實作一個具體工廠類，
在應用程式中開發初始化代碼，該代碼根據應用程式配置或當前環境，對特定具體工廠類進行初始化，然后將該工廠對象傳遞給所有需要創建產品的類，
找出代碼中所有對產品建構式的直接呼叫，將其替換為對工廠物件中相應構建方法的呼叫，

優點：

當一個產品族中的多個物件被設計成一起作業時，它能保證客戶端始終只使用同一個產品族中的物件，
確保同一工廠生成的產品相互匹配，
避免客戶端和具體產品代碼的耦合，
單一職責原則，你可以將產品生成代碼抽取到同一位置，使得代碼易于維護，
開閉原則，向應用程式中引入新產品變體時，你無需修改客戶端代碼，

缺點：

產品族擴展非常困難，要增加一個系列的某一產品，既要在介面里加代碼，又要在具體類里面加代碼，

使用場景：

QQ 換皮膚，一整套一起換，
生成不同作業系統的程式，
跨平臺UI元素

注意事項：

產品系列難擴展，具體產品易擴展，
一般情況下，應用程式會在初始化階段創建具體工廠物件，而在此之前，應用程式必須根據組態檔或環境設定選擇工廠類別，

與其他模式的關系：

在許多設計作業的初期都會使用工廠方法（較為簡單，而且可以更方便地通過子類進行定制），隨后演化為使用抽象工廠、原型或生成器（更靈活但更加復雜），
生成器（建造者模式）重點關注如何分步生成復雜物件，抽象工廠專門用于生產一系列相關物件，抽象工廠會馬上回傳產品，生成器則允許你在獲取產品前執行一些額外構造步驟，
抽象工廠模式通常基于一組工廠方法，但你也可以使用原型模式來生成這些類的方法，
當只需對客戶端代碼隱藏子系統創建物件的方式時，你可以使用抽象工廠來代替外觀，
你可以將抽象工廠和橋接搭配使用，如果由橋接定義的抽象只能與特定實作合作，這一模式搭配就非常有用，在這種情況下，抽象工廠可以對這些關系進行封裝，并且對客戶端代碼隱藏其復雜性，
抽象工廠、生成器和原型都可以用單例來實作，

餓漢式單例模式

在c#的例子中使用了餓漢式單例模式來生成各個工廠實體，這是C#與公告語言運行庫提供的一種靜態初始化方法，這種方法不需要開發人員顯式地撰寫執行緒安全代碼，即可解決多執行緒環境下它是不安全的問題，這種靜態初始化的方式是在自己被加載時就將自己實體化，所以被稱為懶漢式單例類，

更多參考：我的設計模式之旅、02 單例模式 - 小能日記 - 博客園

參考資料

《Go語言核心編程》李文塔
《Go語言高級編程》柴樹彬、曹春輝
《大話設計模式》程杰
《深入設計模式》亞歷山大·什韋茨
菜鳥教程

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/508895.html

標籤：其他

上一篇：微服務設計（二）---springCloud基礎及注冊中心

下一篇：如何優化好UITableView，值得思考

我的設計模式之旅、10 抽象工廠

程式介紹

程式代碼、抽象工廠模式 Golang

iShirt.go 產品介面類

iShoe.go 產品介面類

adidas.go 阿迪達斯工廠

nike.go 耐克生產工廠

iSportsFactory.go 抽象工廠介面、簡單工廠

main.go

Console 輸出

程式代碼、抽象工廠模式 C#

Shirt.cs 產品類

Shoe.cs 產品類

AbstractFactory.cs 抽象工廠類

Program.cs

Console 輸出

思考總結

什么是抽象工廠模式

餓漢式單例模式

參考資料