設計模式之美：Product Trader（操盤手）

索引

• 意圖
• 結構
• 參與者
• 適用性
• 效果
• 相關模式
• 實現
  • 實現方式（一）：Product Trader 的示例實現。

意圖

使客戶程序可以通過命名抽象超類和給定規約來創建對象。

Product Trader 讓客戶程序與 Product 類解耦，從而使得類的層級結構、框架和應用程序易於改寫、配置和演進。

Let clients create objects by naming an abstract superclass and by providing a specification.

A Product Trader decouples the client from the product and thereby eases the adaption, configuration and evolution of class hierarchies, frameworks and applications.

結構

參與者

Client

• 為 ConcreteProduct 類創建 Specification。
• 為 Product Trader 提供 Specification 以初始話構建過程。

Product

• 定義類層次的接口。

ConcreteProduct

• Product 抽象類的具體類。
• 提供足夠的信息以判定是否滿足 Specification。

ProductTrader

• 從 Client 接收一個 ConcreteProduct 對應的 Specification。
• 映射 Specification 和 Creator。
• 提供映射配置機制。
• 調用 Creator 以生成符合 Specification 的 ConcreteProduct。

Creator

• 定義創建 ConcreteProduct 實例的接口。
• 知道如何根據 Specification 創建合適的 ConcreteProduct。

Specification

• 一個 Specification 代表着一個 ConcreteProduct 類。
• 作為映射和查詢 Creator 的條件參數。

適用性

當以下情況成立時可以使用 Product Trader 模式：

• 當你想讓客戶程序完全獨立於 Product 實體類的實現時。
• 你需要在運行時根據可用的規約條件動態的生成 Product 對象時。
• 你需要為給定的規約條件配置相應的 Product 類對象。
• 你需要在不影響客戶代碼的條件下修改和演進 Product 類的層次。

效果

• Client 程序完全獨立於 ConcreteProduct 類層次。
• 可以在運行時決定 Product 的具體類。
• 可以根據特定的領域對 Product 進行配置。
• Product 類層次更易於演進。
• 衍生新的 ConcreteProduct 更加方便。
• Product 類可以是負責的組件。

相關模式

• 可以嘗試在 Factory Method 模式無法工作或不太適合時，嘗試使用 Product Trader。Factory Method 常使 Product 和 Creator 之間形成循環依賴。

實現

實現方式（一）：Product Trader 的示例實現。

namespace ProductTraderPattern.Implementation1
{
  public class Specification
  {
    public string Criteria { get; set; }

    public bool IsSatisfiedBy(Product product)
    {
      return product.Criteria == this.Criteria;
    }

    public override int GetHashCode()
    {
      return Criteria.GetHashCode();
    }

    public override bool Equals(object obj)
    {
      return GetHashCode().Equals(obj.GetHashCode());
    }
  }

  public abstract class Product
  {
    public abstract string Criteria { get; }
  }

  public class ConcreteProductA : Product
  {
    public override string Criteria
    {
      get
      {
        return "SpecForConreteProductA";
      }
    }
  }

  public class ConcreteProductB : Product
  {
    public override string Criteria
    {
      get
      {
        return "SpecForConreteProductB";
      }
    }
  }

  public abstract class ProductCreator
  {
    public abstract Product Create(Specification spec);
  }

  public class ConcreteProductCreator : ProductCreator
  {
    public override Product Create(Specification spec)
    {
      if (spec.Criteria == "SpecForConreteProductA")
      {
        return new ConcreteProductA();
      }
      else if (spec.Criteria == "SpecForConreteProductB")
      {
        return new ConcreteProductB();
      }

      // any factory you can use here
      throw new NotSupportedException();
    }
  }

  public class ProductTrader
  {
    private Dictionary<Specification, ProductCreator> _dict
      = new Dictionary<Specification, ProductCreator>();

    public Product CreateFor(Specification spec)
    {
      ProductCreator creator = LookupCreator(spec);
      Product product = creator.Create(spec);
      return product;
    }

    public ProductCreator LookupCreator(Specification spec)
    {
      return _dict[spec];
    }

    public void AddCreator(Specification spec, ProductCreator creator)
    {
      _dict.Add(spec, creator);
    }

    public void RemoveCreator(Specification spec, ProductCreator creator)
    {
      _dict.Remove(spec);
    }

    public void SubstituteCreator(Specification spec, ProductCreator creator)
    {
      _dict[spec] = creator;
    }
  }

  public class Client
  {
    public void TestCase1()
    {
      Specification spec1 = new Specification();
      spec1.Criteria = "SpecForConreteProductA";

      Specification spec2 = new Specification();
      spec2.Criteria = "SpecForConreteProductA";

      ProductCreator creator = new ConcreteProductCreator();

      ProductTrader trader = new ProductTrader();
      trader.AddCreator(spec1, creator);
      trader.AddCreator(spec2, creator);

      Specification spec3 = new Specification();
      spec3.Criteria = "SpecForConreteProductA";

      Product product = trader.CreateFor(spec3);
    }
  }
}

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