设计模式之美：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 发布于博客园的系列文章，任何未经作者本人同意的人为或爬虫转载均为耍流氓。