创建者模式——抽象工厂模式（Abstract Factory）（3）

1.　概述
　　抽象工厂模式为一个产品家族提供了统一的创建接口。当需要这个产品家族的某一系列的时候，可以从抽象工厂中选出相对应的系列来创建一个具体的工厂类别。

2.　抽象工厂模式中的角色

 　　2.1 抽象工厂（AbstractFactory）：担任这个角色的是工厂方法模式的核心，它是与应用系统商业逻辑无关的。

 　　2.2 具体工厂（ConcreteFactory）：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。

 　　2.3 抽象产品（AbstractProduct）：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。

 　　2.4 具体产品（ConcreteProduct）：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西，其内部一定充满了应用系统的商业逻辑。

3.　实例：更换数据库。现有系统使用的是SqlServer数据库，它的Licence是付费的，有的客户想使用免费的数据库服务，如Access。有的客户拥有其它数据库服务商的Licence，他们也不想使用还要另付费的SqlServer。

 　　3.1 解决这个问题的根本是将应用程序与数据库解耦，使得应用程序不再依赖某一个具体的数据库。抽象工厂给我们提供了解决方案。

　　 3.2 实现类图

　　　　

　　3.3 实现代码

　　　　3.3.1 抽象工厂类，提供了创建一组相关或相互依赖的对象的接口。

    /// <summary>
    /// 抽象工厂类
    /// </summary>
    public interface IDatabaseFactory
    {

        IEmployee CreateEmployee();

        IUser CreateUser();
    }

　　　　3.3.2 具体工厂类，提供了创建SqlServer,或Access具体产品的实现

    /// <summary>
    /// 与SqlServer相关产品的实现
    /// </summary>
    public class SqlServerDatabaseFactory : IDatabaseFactory
    {

        public IEmployee CreateEmployee()
        {

            return new SqlEmployee();
        }

        public IUser CreateUser()
        {

            return new SqlUser();
        }

    }


    /// <summary>
    /// 与Access相关产品的实现
    /// </summary>
    public class AccessDatabaseFactory : IDatabaseFactory
    {

        public IEmployee CreateEmployee()
        {

            return new AccessEmployee();
        }

        public IUser CreateUser()
        {

            return new AccessUser();
        }

    }

　　　　3.3.3 两个抽象产品，分别是IUser和IEmployee

    /// <summary>
    /// 抽象产品
    /// </summary>
    public interface IUser 
    {
        User GetUser();

        bool SaveUser();
    }

    /// <summary>
    /// 抽象产品
    /// </summary>
    public interface IEmployee
    {

        Employee GetEmployee();

        bool SaveEmployee();
    }

　　3.3.4 具体产品的实现

    /// <summary>
    /// 与SqlServer相关的具体产品User
    /// </summary>
    public class SqlUser : IUser
    {
        public User GetUser()
        {

            return null;
        }

        public bool SaveUser()
        {

            return false;
        }

    }

    /// <summary>
    /// 与SqlServer相关的具体产品Employee
    /// </summary>
    public class SqlEmployee : IEmployee
    {

        public SqlEmployee()
        {

        }

        public Employee GetEmployee()
        {

            return null;
        }

        public bool SaveEmployee()
        {

            return false;
        }

    }

    /// <summary>
    /// 与Access相关的具体产品User
    /// </summary>
    public class AccessUser : IUser
    {

        public AccessUser()
        {

        }

        public User GetUser()
        {

            return null;
        }

        public bool SaveUser()
        {

            return false;
        }

    }

    /// <summary>
    /// 与Access相关的具体产品Employee
    /// </summary>
    public class AccessEmployee : IEmployee
    {

        public AccessEmployee()
        {

        }

        public Employee GetEmployee()
        {

            return null;
        }

        public bool SaveEmployee()
        {

            return false;
        }

    }

4.　模式总结

　　4.1 优点
　　　　4.1.1 具体产品从客户代码中被分离出来
　　　　4.1.2 容易改变产品的系列（如SqlServer产品系列，Access产品系列）
　　　　4.1.3 将一个系列的产品族统一到一起创建

　　4.2 缺点
　　　　在产品族中扩展新的产品是很困难的，它需要修改抽象工厂的接口，如增加一种产品Customer变得非常困难。

　　4.3 实用范围
　　　　4.3.1 一个系统要独立于它的产品的创建、组合和表示时。
　　　　4.3.2 一个系统要由多个产品系列中的一个来配置时。
　　　　4.3.3 当你要强调一系列相关的产品对象的设计以便进行联合使用时。
　　　　4.3.4 当你提供一个产品类库，而只想显示它们的接口而不是实现时。

工厂模式,简单工厂模式,抽象工厂模式三者有什么区别

工厂方法模式：                                                                                        抽象工厂模式：

一个抽象产品类，可以派生出多个具体产品类。                                      多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。                                     一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类只能创建一个具体产品类的实例。          每个具体工厂类可以创建多个具体产品类的实例。

区别：

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。

工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

一、 抽象工厂（Abstract Factory）模式

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。

为了方便引进抽象工厂模式，引进一个新概念：产品族（Product Family）。所谓产品族，是指位于不同产品等级结构，功能相关联的产品组成的家族。如图：

 

图中一共有四个产品族，分布于三个不同的产品等级结构中。只要指明一个产品所处的产品族以及它所属的等级结构，就可以唯一的确定这个产品。

引进抽象工厂模式

所谓的抽象工厂是指一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象。如果用图来描述的话，如下图：

 

二、 Abstract Factory模式的结构：

 

图中描述的东西用产品族描述如下：

 

抽象工厂（Abstract Factory）角色：担任这个角色的是工厂方法模式的核心，它是与应用系统商业逻辑无关的。

具体工厂（Concrete Factory）角色：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。

抽象产品（Abstract Product）角色：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。

具体产品（Concrete Product）角色：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西，其内部一定充满了应用系统的商业逻辑。

三、 程序举例：

该程序演示了抽象工厂的结构，本身不具有任何实际价值。

//  Abstract Factory pattern -- Structural example  
using  System;

//  "AbstractFactory"
abstract   class  AbstractFactory
{
  // Methods
  abstract public AbstractProductA CreateProductA();
  abstract public AbstractProductB CreateProductB();
}

//  "ConcreteFactory1"
class  ConcreteFactory1 : AbstractFactory
{
  // Methods
  override public AbstractProductA CreateProductA()
  {
    return new ProductA1();
  }
  override public AbstractProductB CreateProductB()
  {
    return new ProductB1();
  }
}

//  "ConcreteFactory2"
class  ConcreteFactory2 : AbstractFactory
{
  // Methods
  override public AbstractProductA CreateProductA()
  {
    return new ProductA2();
  }

  override public AbstractProductB CreateProductB()
  {
    return new ProductB2();
  }
}

//  "AbstractProductA"
abstract   class  AbstractProductA
{
}

//  "AbstractProductB"
abstract   class  AbstractProductB
{
  // Methods
  abstract public void Interact( AbstractProductA a );
}

//  "ProductA1"
class  ProductA1 : AbstractProductA
{
}

//  "ProductB1"
class  ProductB1 : AbstractProductB
{
  // Methods
  override public void Interact( AbstractProductA a )
  {
    Console.WriteLine( this + " interacts with " + a );
  }
}

//  "ProductA2"
class  ProductA2 : AbstractProductA
{
}

//  "ProductB2"
class  ProductB2 : AbstractProductB
{
  // Methods
  override public void Interact( AbstractProductA a )
  {
    Console.WriteLine( this + " interacts with " + a );
  }
}

//  "Client" - the interaction environment of the products
class  Environment
{
  // Fields
  private AbstractProductA AbstractProductA;
  private AbstractProductB AbstractProductB;

  // Constructors
  public Environment( AbstractFactory factory )
  {
    AbstractProductB = factory.CreateProductB();
    AbstractProductA = factory.CreateProductA();
  }
 
  // Methods
  public void Run()
  {
    AbstractProductB.Interact( AbstractProductA );
  }
}

/// <summary>
/// ClientApp test environment
/// </summary>
class  ClientApp
{
  public static void Main(string[] args)
  {
    AbstractFactory factory1 = new ConcreteFactory1();
    Environment e1 = new Environment( factory1 );
    e1.Run();

    AbstractFactory factory2 = new ConcreteFactory2();
    Environment e2 = new Environment( factory2 );
    e2.Run();
  }
}

 

四、 在什么情形下使用抽象工厂模式：

在以下情况下应当考虑使用抽象工厂模式：

• 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。
• 这个系统有多于一个的产品族，而系统只消费其中某一产品族。
• 同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。
• 系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。
  
  

五、 抽象工厂的起源

据说最早的应用是用来创建在不同操作系统的视窗环境下都能够运行的系统。比如在Windows与Unix系统下都有视窗环境的构件，在每一个操作系统中，都有一个视窗构件组成的构件家族。我们可以通过一个抽象角色给出功能描述，而由具体子类给出不同操作系统下的具体实现，如图：

 

可以发现上面产品类图有两个产品等级结构，分别是Button与Text；同时有两个产品族：Unix产品族与Windows产品族。

 

系统对产品对象的创建要求由一个工厂的等级结构满足。其中有两个具体工厂角色，即UnixFactory和WinFactory。UnixFactory对象负责创建Unix产品族中的产品，而WinFactory负责创建Windows产品族中的产品。

 

显然一个系统只能够在某一个操作系统的视窗环境下运行，而不能同时在不同的操作系统上运行。所以，系统实际上只能消费属于同一个产品族的产品。

在现代的应用中，抽象工厂模式的使用范围已经大大扩大了，不再要求系统只能消费某一个产品族了。

六、 Abstract Factory模式在实际系统中的实现

Herbivore：草食动物
Carnivore：食肉动物
Bison：['baisn]，美洲或欧洲的野牛

下面实际代码演示了一个电脑游戏中创建不同动物的抽象工厂。尽管在不同大陆下动物物种是不一样的，但动物间的关系仍然保留了下来。

//  Abstract Factory pattern -- Real World example  
using  System;

//  "AbstractFactory"
abstract   class  ContinentFactory
{
  // Methods
  abstract public Herbivore CreateHerbivore();
  abstract public Carnivore CreateCarnivore();
}

//  "ConcreteFactory1"
class  AfricaFactory : ContinentFactory
{
  // Methods
  override public Herbivore CreateHerbivore()
  { return new Wildebeest(); }

  override public Carnivore CreateCarnivore()
  { return new Lion(); }
}

//  "ConcreteFactory2"
class  AmericaFactory : ContinentFactory
{
  // Methods
  override public Herbivore CreateHerbivore()
  { return new Bison(); }

  override public Carnivore CreateCarnivore()
  { return new Wolf(); }
}

//  "AbstractProductA"
abstract   class  Herbivore
{
}

//  "AbstractProductB"
abstract   class  Carnivore
{
  // Methods
  abstract public void Eat( Herbivore h );
}

//  "ProductA1"
class  Wildebeest : Herbivore
{
}

//  "ProductB1"
class  Lion : Carnivore
{
  // Methods
  override public void Eat( Herbivore h )
  {
    // eat wildebeest
    Console.WriteLine( this + " eats " + h );
  }
}

//  "ProductA2"
class  Bison : Herbivore
{
}

//  "ProductB2"
class  Wolf : Carnivore
{
  // Methods
  override public void Eat( Herbivore h )
  {
    // Eat bison
    Console.WriteLine( this + " eats " + h );
  }
}

//  "Client"
class  AnimalWorld
{
  // Fields
  private Herbivore herbivore;
  private Carnivore carnivore;

  // Constructors
  public AnimalWorld( ContinentFactory factory )
  {
    carnivore = factory.CreateCarnivore();
    herbivore = factory.CreateHerbivore();
  }

  // Methods
  public void RunFoodChain()
  { carnivore.Eat(herbivore); }
}

/// <summary>
///  GameApp test class
/// </summary>
class  GameApp
{
  public static void Main( string[] args )
  {
    // Create and run the Africa animal world
    ContinentFactory africa = new AfricaFactory();
    AnimalWorld world = new AnimalWorld( africa );
    world.RunFoodChain();

    // Create and run the America animal world
    ContinentFactory america = new AmericaFactory();
    world = new AnimalWorld( america );
    world.RunFoodChain();
  }
}

抽象工厂的另外一个例子：

如何设计抽象类工厂留作思考。

七、 "开放－封闭"原则

"开放－封闭"原则要求系统对扩展开放，对修改封闭。通过扩展达到增强其功能的目的。对于涉及到多个产品族与多个产品等级结构的系统，其功能增强包括两方面：

增加产品族：Abstract Factory很好的支持了"开放－封闭"原则。

增加新产品的等级结构：需要修改所有的工厂角色，没有很好支持"开放－封闭"原则。

综合起来，抽象工厂模式以一种倾斜的方式支持增加新的产品，它为新产品族的增加提供方便，而不能为新的产品等级结构的增加提供这样的方便。

 

---

 

参考文献：
阎宏，《Java与模式》，电子工业出版社
[美]James W. Cooper，《C#设计模式》，电子工业出版社
[美]Alan Shalloway  James R. Trott，《Design Patterns Explained》，中国电力出版社
[美]Robert C. Martin，《敏捷软件开发－原则、模式与实践》，清华大学出版社
[美]Don Box, Chris Sells，《.NET本质论 第1卷：公共语言运行库》，中国电力出版社