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