抽象工厂模式

转载 2012年03月28日 00:00:00

一、 抽象工厂(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卷:公共语言运行库》,中国电力出版社

More ++, Less C

近来在sdmagazine上面看到的一篇好文章,决定与大家共享。不过由于最近忙,就不翻译了^_^More ++, Less CStandard template libraries, abstract...
  • cber
  • cber
  • 2001-09-19 14:13:00
  • 1392

工厂模式,工厂方法模式,抽象工厂模式 详解

1. 工厂模式 1.1 定义 简单工厂模式是由一个工厂对象根据收到的消息决定要创建哪一个类的对象实例。 1.2 使用场景 工厂类负责创建的对象比较少,客户只需要传入工厂类参数,对于如何创建对象(逻辑)...
  • wfg18801733667
  • wfg18801733667
  • 2017-03-09 10:02:25
  • 2752

设计模式——抽象工厂模式详解

0.前言写在最前面,本人的设计模式类博文,建议先看博文前半部分的理论介绍,再看后半部分的实例分析,最后再返回来复习一遍理论介绍,这时候你就会发现我在重点处标红的用心,对于帮助你理解设计模式有奇效哦~无...
  • SEU_Calvin
  • SEU_Calvin
  • 2016-08-21 17:05:41
  • 11992

JAVA设计模式之抽象工厂模式

本文属于23种设计模式系列。 继续前面简单工厂模式和工厂方法模式的例子,以汽车配件制造介绍抽象工厂模式。...
  • jason0539
  • jason0539
  • 2015-04-11 08:26:32
  • 58238

Java 抽象工厂模式

抽象工厂模式(Abstract Factory Pattern)是工厂方法模式的进一步抽象,其英文原话"Provide an interface for creating families of re...
  • liruikqn
  • liruikqn
  • 2013-10-20 21:08:14
  • 22478

抽象工厂模式的优缺点

优点: 1、抽象工厂模式隔离了具体类的生产,使得客户并不需要知道什么被创建。 2、当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。 3、增加新的具体工厂...
  • tayanxunhua
  • tayanxunhua
  • 2012-12-01 11:13:10
  • 11753

抽象工厂模式实例与讲解

  • qq_25551295
  • qq_25551295
  • 2015-11-15 16:49:40
  • 302

JAVA设计模式之抽象工厂模式案例

  • 2017年07月09日 13:20
  • 14KB
  • 下载

简单工厂模式和抽象工厂模式的通俗理解

 以造汽车为例来通俗的说一下:(写的不好或有错误的地方欢迎大家指正)汽车制造商要造汽车卖给客户,那应该如可来做?看下面:     第一:汽车制造商要知道客户要什么样的汽车,即设计汽车;   第二:设计...
  • chenxsh2615
  • chenxsh2615
  • 2007-06-01 20:02:00
  • 3078

C#设计模式-抽象工厂模式源代码工程

  • 2017年02月19日 12:02
  • 37KB
  • 下载
收藏助手
不良信息举报
您举报文章:抽象工厂模式
举报原因:
原因补充:

(最多只允许输入30个字)