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