浅析设计模式之抽象工厂模式-技术开发专区

浅析设计模式之抽象工厂模式

作者：IT168 横刀天笑编辑：赵建凯 2007-09-12 00:00 来源：IT168�

三、设计模式实例

    下面举一个网上非常流行的例子。

    带着你的女友去快餐店吃东西，比如麦当劳、肯德基，你走进快餐店只需要对服务员说“来份鸡腿”(统一的接口)，如果是麦当劳服务员就会用麦当劳专用的盘子装着麦当劳的鸡腿拿给你，走进肯德基也一样，你还是只需要说“来份鸡腿”，不需要改变你的用词，而且也不会出现麦当劳的盘子装着肯德基的(一系列相关类)鸡腿。

    在这里麦当劳、肯德基就是生产食品产品的工厂、盘子和鸡腿都是他们的产品。

    这个实例我用一个演进的过程来描述，首先我们按照Gof所描述的抽象工厂模式来完成这个示例的代码，然后，为了验证开闭原则（对添加打开，对修改关闭），假设本地新开了一家快餐厅，向系统的服务器层添加一个快餐厅（全聚德）来看看是否对系统造成修改的影响，在.net里我们可以利用反射功能将这个抽象工厂模式演进为一个反射工厂模式，利用反射后我们甚至可以去掉麦当劳和肯德基等餐厅的实现，但是如果女友想去别的餐厅吃的时候girlfriend类还是要改变，进一步我们可以利用配置文件来配置所要去的餐厅这样系统就稳定多了，当要添加餐厅并去新餐厅的时候只需要添加新的特性修改配置文件。

///代码清单
using System;
namespace Jurassic.Training.AbstractFactory
{
/// <summary>
/// 餐厅类抽象工厂
/// </summary>
  public abstract class Restaurant
{
/// <summary>
/// 创建一个盘子类
/// </summary>
/// <returns>盘子</returns>
      public abstract Plate CreatePlate();
/// <summary>
/// 创建一个鸡腿类
/// </summary>
/// <returns>鸡腿</returns>
      public abstract Drumstick CreateDrumstick();
}
}
using System;
namespace Jurassic.Training.AbstractFactory
{
/// <summary>
/// 肯德基餐厅
/// </summary>
  public class KFC : Restaurant
{
/// <summary>
/// 创建一个肯德基的盘子
/// </summary>
/// <returns>肯德基盘子</returns>
      public override Plate CreatePlate()
{
return new KFCPlate();
}
/// <summary>
/// 创建一个肯德基鸡腿
/// </summary>
/// <returns>肯德基鸡腿</returns>
        public override Drumstick CreateDrumstick()
{
return new KFCDrumstick();
}
}
}
using System;
namespace Jurassic.Training.AbstractFactory
{
/// <summary>
/// 麦当劳餐厅
/// </summary>
  public class MDL : Restaurant
{
/// <summary>
/// 创建一个麦当劳盘子
/// </summary>
/// <returns>麦当劳盘子</returns>
      public override Plate CreatePlate()
{
return new MDLPlate();
}
/// <summary>
/// 创建一个麦当劳鸡腿
/// </summary>
/// <returns>麦当劳鸡腿</returns>
        public override Drumstick CreateDrumstick()
{
return new MDLDrumstick();
}
}
}
using System;
namespace Jurassic.Training.AbstractFactory
{
/// <summary>
/// 盘子产品父类
/// </summary>
  public abstract class Plate
{
/// <summary>
/// 盘子装载方法
/// </summary>
/// <returns></returns>
    public abstract string Load();
}
}
using System;
namespace Jurassic.Training.AbstractFactory
{
/// <summary>
/// 肯德基的盘子
/// </summary>
  public class KFCPlate : Plate
{
public override string Load()
{
return "肯德基的盘子装";
}
}
}
using System;
namespace Jurassic.Training.AbstractFactory
{
/// <summary>
/// 麦当劳的盘子
/// </summary>
  public class MDLPlate : Plate
{
public override string Load()
{
return "麦当劳的盘子装";
}
}
}
using System;
namespace Jurassic.Training.AbstractFactory
{
/// <summary>
/// 鸡腿产品父类
/// </summary>
  public abstract class Drumstick
{
public abstract string Name{get;}
}
}
using System;
namespace Jurassic.Training.AbstractFactory
{
/// <summary>
/// 肯德基鸡腿
/// </summary>
  public class KFCDrumstick : Drumstick
{
public override string Name
{
get{ return "肯德基的鸡腿"; }
}
}
}
using System;
namespace Jurassic.Training.AbstractFactory
{
/// <summary>
/// 麦当劳鸡腿
/// </summary>
  public class MDLDrumstick : Drumstick
{
public override string Name
{
get { return "麦当劳的鸡腿"; }
}
}
}
using System;
namespace Jurassic.Training.AbstractFactory
{
/// <summary>
/// 女友，模拟客户类
/// </summary>
  public class Girlfriend
{
public static void Main()
{
//走进肯德基
        Restaurant restaurant = new KFC();
GoRestaurant(restaurant);
Console.ReadLine();
}
public static void GoRestaurant(Restaurant restaurant)
{
Plate p = restaurant.CreatePlate();
Drumstick d = restaurant.CreateDrumstick();
Console.WriteLine(p.Load() + d.Name);
}
}
}

现在我们向系统添加一个餐厅：全聚德餐厅。

using System;
namespace Jurassic.Training.AbstractFactory
{
/// <summary>
/// 全聚德餐厅
/// </summary>
  public class QJD : Restaurant
{
/// <summary>
/// 创建全聚德盘子
/// </summary>
/// <returns></returns>
      public override Plate CreatePlate()
{
return new QJDPlate();
}
/// <summary>
/// 创建全聚德鸡腿
/// </summary>
/// <returns></returns>
        public override Drumstick CreateDrumstick()
{
return new QJDDrumstick();
}
}
}
using System;
namespace Jurassic.Training.AbstractFactory
{
/// <summary>
/// 全聚德盘子
/// </summary>
    public class QJDPlate : Plate
{
public override string Load()
{
return "全聚德的盘子装";
}
}
}
using System;
namespace Jurassic.Training.AbstractFactory
{
/// <summary>
/// 全聚德鸡腿
/// </summary>
    public class QJDDrumstick : Drumstick
{
public override string Name
{
get{return "全聚德鸡腿";}
}
}
}

为了可以进全聚德吃鸡腿我们需要对客户类进行修改：

using System;
namespace Jurassic.Training.AbstractFactory
{
public class Girlfriend
{
public static void Main()
{
//走进肯德基
//Restaurant restaurant = new KFC();
//GoRestaurant(restaurant);
//走进麦当劳
//Restaurant restaurant = new MDL();
//GoRestaurant(restaurant);
//走进全聚德
        Restaurant restaurant = new QJD();
GoRestaurant(restaurant);
Console.ReadLine();
}
public static void GoRestaurant(Restaurant restaurant)
{
Plate p = restaurant.CreatePlate();
Drumstick d = restaurant.CreateDrumstick();
Console.WriteLine(p.Load() + d.Name);
}
}
}

    但是整个过程我们并没有对系统的基础框架进行修改，只是添加了新的特性，符合开－闭原则。

    仔细审视了工厂部分的实现，我们发现几个餐厅的实现部分都很雷同，我们请来了.net的反射，将几个餐厅实现部分都去除了，代码大大减少。

    要使用.net的反射我们将餐厅的抽象类修改为如下所示：

using System;
using System.Reflection;
namespace Jurassic.Training.AbstractFactory
{
public class Restaurant
{
private string _plateFile;
private string _drumstickFile;
private string _plate;
private string _drumstick;
public Restaurant(string type)
{
_plateFile = string.Format("{0}Plate.dll",type);
_drumstickFile = string.Format("{0}Drumstick.dll",type);
_plate = string.Format("Jurassic.Training.AbstractFactory.{0}Plate",type);
_drumstick = string.Format("Jurassic.Training.AbstractFactory.{0}Drumstick",type);
}
public Plate CreatePlate()
{
Plate plate = Helper(_plateFile,_plate) as Plate;
return plate;
}
public Drumstick CreateDrumstick()
{
Drumstick drumstick = Helper(_drumstickFile,_drumstick) as Drumstick;
return drumstick;
}
/// <summary>
/// 根据程序集文件名称和类型实例化类型
/// </summary>
/// <param name="fileName"></param>
/// <param name="type"></param>
/// <returns></returns>
      private object Helper(string fileName,string type)
{
Assembly asm = Assembly.LoadFrom(fileName);
object o = asm.CreateInstance (type);
return o;
}
}
}

这样我们可以把KFC.cs,MDL.cs,QJD.cs全部去掉了，要调用新的反射工厂模式的实现需要修改girlfriend如下：

using System;
namespace Jurassic.Training.AbstractFactory
{
public class Girlfriend
{
public static void Main()
{
//走进全聚德
        Restaurant restaurant = new Restaurant("QJD");
GoRestaurant(restaurant);
Console.ReadLine();
}
public static void GoRestaurant(Restaurant restaurant)
{
Plate p = restaurant.CreatePlate();
Drumstick d = restaurant.CreateDrumstick();
Console.WriteLine(p.Load() + d.Name);
}
}
}

虽说代码减少不少，但是如果我们要更换就餐的餐厅还是要修改girlfriend类，然后重新编译，这个时候我们想到把这个变化存储在应用程序之外，.net里的配置文件就是存储这个东西的好地方。

代码进一步演进，如下：

using System;
using System.Configuration;
namespace Jurassic.Training.AbstractFactory
{
public class Girlfriend
{
public static void Main()
{
//走进全聚德，从配置文件里获取信息
        Restaurant restaurant = new Restaurant(ConfigurationManager.AppSettings["type"]);
GoRestaurant(restaurant);
Console.ReadLine();
}
public static void GoRestaurant(Restaurant restaurant)
{
Plate p = restaurant.CreatePlate();
Drumstick d = restaurant.CreateDrumstick();
Console.WriteLine(p.Load() + d.Name);
}
}
}
加上配置文件
Girlfriend.exe.config
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<appSettings>
<add key="type" value="KFC"/>
</appSettings>
</configuration>

上面这个例子从Gof原版的抽象工厂模式说起，演进到.net里面抽象工厂模式的变化，最后用反射和配置文件构造出一个非常松耦合的系统。

四、现实中的抽象工厂模式

微软推出.net的时候，为了和Java相比较，针对Java的PetStore推出了PetShop 3.0，Petshop是一个经典的三层架构实例，它提供了两种数据库支持：SQL Server,Oracle，提供多数据库支持的时候就是使用的.net中抽象工厂模式的变体：反射工厂模式

第1页：设计模式定义、来历第2页：抽象工厂模式的使用场景第3页：设计模式实例

关注我们