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