我的設計模式之旅，本節使用抽象工廠模式實現阿迪達斯、耐克品牌服飾生產，分別用C#跟Golang實現。對抽象方法模式進行了細緻的介紹。 ...

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

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

程式介紹

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

案例中 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語言高級編程》柴樹彬、曹春輝
《大話設計模式》程傑
《深入設計模式》亞歷山大·什韋茨
菜鳥教程

我的設計模式之旅、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 輸出

思考總結

什麼是抽象工廠模式

餓漢式單例模式

參考資料