設計模式之美：Abstract Factory（抽象工廠）

索引

• 別名
• 意圖
• 結構
• 參與者
• 適用性
• 缺點
• 效果
• 相關模式
• 命名約定
• 實現
  • 實現方式（一）：使用 Factory Method 來實現 Abstract Factory。
  • 實現方式（二）：使用 Prototype 來實現 Abstract Factory。
  • 實現方式（三）：定義可擴展的 Abstract Factory。
  • 實現方式（四）：使用模板以避免創建子類。

別名

• Kit

意圖

提供一個創建一系列相關或相互依賴對象的接口，而無需指定它們具體的類。

Provide an interface for creating families of related or dependent objects without specifying their concrete classes.

結構

參與者

AbstractFactory

• 聲明一個創建抽象產品對象的操作接口。

ConcreteFactory

• 實現創建具體產品對象的操作。

AbstractProduct

• 為一類產品對象聲明一個接口。

ConcreteProduct

• 定義一個將被相應的具體工廠創建的產品對象。
• 實現 AbstractProduct 接口。

Client

• 僅適用由 AbstractFactory 和 AbstractProduct 類聲明的接口。

適用性

在以下情況下可以使用 Abstract Factory 模式：

• 一個系統要獨立於它的產品的創建、組合和表示時。
• 一個系統要由多個產品系列中的一個來配置時。
• 當你要強調一系列相關的產品對象的設計以便進行聯合使用時。
• 當你提供一個產品類庫，而只想顯示它們的接口而不是實現時。

缺點

• 難以支持新種類的產品。支持新種類的產品就需要擴展 AbstractFactory 接口，這將引起所有子類的改變。

效果

• 它分離了具體的類。
• 它使得易於交換產品系列。
• 它有利於產品的一致性。

相關模式

• Abstract Factory 經常用 Factory Method 來實現。
• Abstract Factory 也可以用 Prototype 來實現。
• 一個具體的工廠可以是一個 Singleton。

命名約定

使用命名約定是一個好習慣，例如，總是聲明那些定義為抽象工廠的類為 XxxKit。

實現

實現方式（一）：使用 Factory Method 來實現 Abstract Factory。

一個具體的工廠將為每個產品重定義該工廠方法以指定產品。

namespace AbstractFactoryPattern.Implementation1
{
  public abstract class AbstractOrInterfaceOfFactoryKit
  {
    public abstract AbstractOrInterfaceOfProductA CreateProductA();
    public abstract AbstractOrInterfaceOfProductB CreateProductB();
  }

  public abstract class AbstractOrInterfaceOfProductA
  {
  }

  public abstract class AbstractOrInterfaceOfProductB
  {
  }

  public class ConcreteFactoryKit1 : AbstractOrInterfaceOfFactoryKit
  {
    public override AbstractOrInterfaceOfProductA CreateProductA()
    {
      return new ConcreteProductA();
    }

    public override AbstractOrInterfaceOfProductB CreateProductB()
    {
      return new ConcreteProductB();
    }
  }

  public class ConcreteProductA : AbstractOrInterfaceOfProductA
  {
  }

  public class ConcreteProductB : AbstractOrInterfaceOfProductB
  {
  }

  public class Client
  {
    public void TestCase1()
    {
      AbstractOrInterfaceOfFactoryKit kit = new ConcreteFactoryKit1();
      AbstractOrInterfaceOfProductA productA = kit.CreateProductA();
      AbstractOrInterfaceOfProductB productB = kit.CreateProductB();
    }
  }
}

實現方式（二）：使用 Prototype 來實現 Abstract Factory。

具體工廠使用產品系列中每一個產品的原型實例來初始化，且它通過復制它的原型來創建新的產品。

namespace AbstractFactoryPattern.Implementation2
{
  public abstract class AbstractOrInterfaceOfFactoryKit
  {
    public abstract AbstractOrInterfaceOfProductA CreateProductA();
    public abstract AbstractOrInterfaceOfProductB CreateProductB();
  }

  public abstract class AbstractOrInterfaceOfProductA
  {
    public abstract AbstractOrInterfaceOfProductA Clone();
  }

  public abstract class AbstractOrInterfaceOfProductB
  {
    public abstract AbstractOrInterfaceOfProductB Clone();
  }

  public class ConcreteFactoryKit1 : AbstractOrInterfaceOfFactoryKit
  {
    public override AbstractOrInterfaceOfProductA CreateProductA()
    {
      return new ConcreteProductA();
    }

    public override AbstractOrInterfaceOfProductB CreateProductB()
    {
      return new ConcreteProductB();
    }
  }

  public class ConcreteFactoryKit2 : AbstractOrInterfaceOfFactoryKit
  {
    private AbstractOrInterfaceOfProductA _prototypeOfProductA;
    private AbstractOrInterfaceOfProductB _prototypeOfProductB;

    public ConcreteFactoryKit2(
      AbstractOrInterfaceOfProductA prototypeOfProductA,
      AbstractOrInterfaceOfProductB prototypeOfProductB)
    {
      _prototypeOfProductA = prototypeOfProductA;
      _prototypeOfProductB = prototypeOfProductB;
    }

    public override AbstractOrInterfaceOfProductA CreateProductA()
    {
      return _prototypeOfProductA.Clone();
    }

    public override AbstractOrInterfaceOfProductB CreateProductB()
    {
      return _prototypeOfProductB.Clone();
    }
  }

  public class ConcreteProductA : AbstractOrInterfaceOfProductA
  {
    public override AbstractOrInterfaceOfProductA Clone()
    {
      return new ConcreteProductA();
    }
  }

  public class ConcreteProductB : AbstractOrInterfaceOfProductB
  {
    public override AbstractOrInterfaceOfProductB Clone()
    {
      return new ConcreteProductB();
    }
  }

  public class Client
  {
    public void TestCase2()
    {
      AbstractOrInterfaceOfFactoryKit kit1 = new ConcreteFactoryKit1();
      AbstractOrInterfaceOfProductA productA1 = kit1.CreateProductA();
      AbstractOrInterfaceOfProductB productB1 = kit1.CreateProductB();

      AbstractOrInterfaceOfFactoryKit kit2 = new ConcreteFactoryKit2(productA1, productB1);
      AbstractOrInterfaceOfProductA productA2 = kit2.CreateProductA();
      AbstractOrInterfaceOfProductB productB2 = kit2.CreateProductB();
    }
  }
}

實現方式（三）：定義可擴展的 Abstract Factory。

Abstract Factory 通常為每一種它可以生產的產品定義一個操作。產品的種類被編碼在操作型構中。

增加一種新的產品要求改變 Abstract Factory 的接口以及所有與它相關的類。

一個更靈活但不太安全的設計是給創建對象的操作增加一個參數。該參數指定了將被創建的對象的種類。

該參數可以是一個類標識符、一個整數、一個字符串，或其他任何可以標識這種產品的東西。

這樣改動之后，Abstract Factory 只需要一個 "Make" 操作和一個指示要創建對象的種類的參數。

namespace AbstractFactoryPattern.Implementation3
{
  public enum ProductCategory
  {
    ProductA,
    ProductB,
  }

  public abstract class AbstractOrInterfaceOfFactoryKit
  {
    public abstract object CreateProduct(ProductCategory category);
  }

  public abstract class AbstractOrInterfaceOfProductA
  {
  }

  public abstract class AbstractOrInterfaceOfProductB
  {
  }

  public class ConcreteFactoryKit1 : AbstractOrInterfaceOfFactoryKit
  {
    public override object CreateProduct(ProductCategory category)
    {
      switch (category)
      {
        case ProductCategory.ProductA:
          return new ConcreteProductA();
        case ProductCategory.ProductB:
          return new ConcreteProductB();
        default:
          throw new NotSupportedException();
      }
    }
  }

  public class ConcreteProductA : AbstractOrInterfaceOfProductA
  {
  }

  public class ConcreteProductB : AbstractOrInterfaceOfProductB
  {
  }

  public class Client
  {
    public void TestCase3()
    {
      AbstractOrInterfaceOfFactoryKit kit = new ConcreteFactoryKit1();
      AbstractOrInterfaceOfProductA productA = (AbstractOrInterfaceOfProductA)kit.CreateProduct(ProductCategory.ProductA);
      AbstractOrInterfaceOfProductB productB = (AbstractOrInterfaceOfProductB)kit.CreateProduct(ProductCategory.ProductB);
    }
  }
}

實現方式（四）：使用模板以避免創建子類。

使用C#中的泛型實現抽象工廠。

namespace AbstractFactoryPattern.Implementation4
{
  public abstract class AbstractOrInterfaceOfFactoryKit
  {
    public abstract AbstractOrInterfaceOfProductA CreateProductA();
    public abstract AbstractOrInterfaceOfProductB CreateProductB();
    public abstract AbstractOrInterfaceOfProductC CreateProductC<TC>()
      where TC : AbstractOrInterfaceOfProductC, new();
  }

  public abstract class AbstractOrInterfaceOfProductA
  {
  }

  public abstract class AbstractOrInterfaceOfProductB
  {
  }

  public abstract class AbstractOrInterfaceOfProductC
  {
  }

  public class ConcreteFactoryKit1<TA, TB> : AbstractOrInterfaceOfFactoryKit
    where TA : AbstractOrInterfaceOfProductA, new()
    where TB : AbstractOrInterfaceOfProductB, new()
  {
    public override AbstractOrInterfaceOfProductA CreateProductA()
    {
      return new TA();
    }

    public override AbstractOrInterfaceOfProductB CreateProductB()
    {
      return new TB();
    }

    public override AbstractOrInterfaceOfProductC CreateProductC<TC>()
    {
      return new TC();
    }
  }

  public class ConcreteProductA : AbstractOrInterfaceOfProductA
  {
  }

  public class ConcreteProductB : AbstractOrInterfaceOfProductB
  {
  }

  public class ConcreteProductC : AbstractOrInterfaceOfProductC
  {
  }

  public class Client
  {
    public void TestCase4()
    {
      AbstractOrInterfaceOfFactoryKit kit = new ConcreteFactoryKit1<ConcreteProductA, ConcreteProductB>();
      AbstractOrInterfaceOfProductA productA = kit.CreateProductA();
      AbstractOrInterfaceOfProductB productB = kit.CreateProductB();
      AbstractOrInterfaceOfProductC productC = kit.CreateProductC<ConcreteProductC>();
    }
  }
}

《設計模式之美》為 Dennis Gao 發布於博客園的系列文章，任何未經作者本人同意的人為或爬蟲轉載均為耍流氓。