关闭

工厂三兄弟之抽象工厂模式

标签: 抽象工厂模式设计模式
350人阅读 评论(0) 收藏 举报
分类:

 工厂方法模式通过引入工厂等级结构,解决了简单工厂模式中工厂类职责太重的问题,但由于工厂方法模式中的每个工厂只生产一类产品,可能会导致系统中存在大量的工厂类,势必会增加系统的开销。此时,我们可以考虑将一些相关的产品组成一个“产品族”,由同一个工厂来统一生产,这就是我们本文将要学习的抽象工厂模式的基本思想。

 

1 界面皮肤库的初始设计

       Sunny软件公司欲开发一套界面皮肤库,可以对Java桌面软件进行界面美化。为了保护版权,该皮肤库源代码不打算公开,而只向用户提供已打包为jar文件的class字节码文件。用户在使用时可以通过菜单来选择皮肤,不同的皮肤将提供视觉效果不同的按钮、文本框、组合框等界面元素,其结构示意图如图1所示:

界面皮肤库结构示意图

       该皮肤库需要具备良好的灵活性和可扩展性,用户可以自由选择不同的皮肤,开发人员可以在不修改既有代码的基础上增加新的皮肤。

       Sunny软件公司的开发人员针对上述要求,决定使用工厂方法模式进行系统的设计,为了保证系统的灵活性和可扩展性,提供一系列具体工厂来创建按钮、文本框、组合框等界面元素,客户端针对抽象工厂编程,初始结构如图2所示:

基于工厂方法模式的界面皮肤库初始结构图

       在图2中,提供了大量工厂来创建具体的界面组件,可以通过配置文件更换具体界面组件从而改变界面风格。但是,此设计方案存在如下问题:

       (1) 当需要增加新的皮肤时,虽然不要修改现有代码,但是需要增加大量类,针对每一个新增具体组件都需要增加一个具体工厂,类的个数成对增加,这无疑会导致系统越来越庞大,增加系统的维护成本和运行开销;

       (2) 由于同一种风格的具体界面组件通常要一起显示,因此需要为每个组件都选择一个具体工厂,用户在使用时必须逐个进行设置,如果某个具体工厂选择失误将会导致界面显示混乱,虽然我们可以适当增加一些约束语句,但客户端代码和配置文件都较为复杂。

       如何减少系统中类的个数并保证客户端每次始终只使用某一种风格的具体界面组件?这是Sunny公司开发人员所面临的两个问题,显然,工厂方法模式无法解决这两个问题,别着急,本文所介绍的抽象工厂模式可以让这些问题迎刃而解。


2 产品等级结构与产品族

       在工厂方法模式中具体工厂负责生产具体的产品,每一个具体工厂对应一种具体产品,工厂方法具有唯一性,一般情况下,一个具体工厂中只有一个或者一组重载的工厂方法。但是有时候我们希望一个工厂可以提供多个产品对象,而不是单一的产品对象,如一个电器工厂,它可以生产电视机、电冰箱、空调等多种电器,而不是只生产某一种电器。为了更好地理解抽象工厂模式,我们先引入两个概念:

       (1) 产品等级结构产品等级结构即产品的继承结构,如一个抽象类是电视机,其子类有海尔电视机、海信电视机、TCL电视机,则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构,抽象电视机是父类,而具体品牌的电视机是其子类。

       (2) 产品族:在抽象工厂模式中,产品族是指由同一个工厂生产的,位于不同产品等级结构中的一组产品,如海尔电器工厂生产的海尔电视机、海尔电冰箱,海尔电视机位于电视机产品等级结构中,海尔电冰箱位于电冰箱产品等级结构中,海尔电视机、海尔电冰箱构成了一个产品族。

       产品等级结构与产品族示意图如图3所示:

3  产品族与产品等级结构示意图

       在图3中,不同颜色的多个正方形、圆形和椭圆形分别构成了三个不同的产品等级结构,而相同颜色的正方形、圆形和椭圆形构成了一个产品族,每一个形状对象都位于某个产品族,并属于某个产品等级结构。图3中一共有五个产品族,分属于三个不同的产品等级结构。我们只要指明一个产品所处的产品族以及它所属的等级结构,就可以唯一确定这个产品。

       当系统所提供的工厂生产的具体产品并不是一个简单的对象,而是多个位于不同产品等级结构、属于不同类型的具体产品时就可以使用抽象工厂模式。抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形式。抽象工厂模式与工厂方法模式最大的区别在于,工厂方法模式针对的是一个产品等级结构,而抽象工厂模式需要面对多个产品等级结构,一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建。当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时,抽象工厂模式比工厂方法模式更为简单、更有效率。抽象工厂模式示意图如图4所示:


抽象工厂模式示意图

       在图4中,每一个具体工厂可以生产属于一个产品族的所有产品,例如生产颜色相同的正方形、圆形和椭圆形,所生产的产品又位于不同的产品等级结构中。如果使用工厂方法模式,图4所示结构需要提供15个具体工厂,而使用抽象工厂模式只需要提供5个具体工厂,极大减少了系统中类的个数


抽象工厂模式概述

       抽象工厂模式为创建一组对象提供了一种解决方案。与工厂方法模式相比,抽象工厂模式中的具体工厂不只是创建一种产品,它负责创建一族产品。抽象工厂模式定义如下:

       抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。抽象工厂模式又称为Kit模式,它是一种对象创建型模式。

       在抽象工厂模式中,每一个具体工厂都提供了多个工厂方法用于产生多种不同类型的产品,这些产品构成了一个产品族,抽象工厂模式结构如图5所示:


5  抽象工厂模式结构图

       在抽象工厂模式结构图中包含如下几个角色:

       ● AbstractFactory(抽象工厂):它声明了一组用于创建一族产品的方法,每一个方法对应一种产品。

       ● ConcreteFactory(具体工厂):它实现了在抽象工厂中声明的创建产品的方法,生成一组具体产品,这些产品构成了一个产品族,每一个产品都位于某个产品等级结构中。

       ● AbstractProduct(抽象产品):它为每种产品声明接口,在抽象产品中声明了产品所具有的业务方法。

        ConcreteProduct(具体产品):它定义具体工厂生产的具体产品对象,实现抽象产品接口中声明的业务方法。

       在抽象工厂中声明了多个工厂方法,用于创建不同类型的产品,抽象工厂可以是接口,也可以是抽象类或者具体类,其典型代码如下所示:

[java] view plaincopy
  1. abstract class AbstractFactory {  
  2. public abstract AbstractProductA createProductA(); //工厂方法一  
  3. public abstract AbstractProductB createProductB(); //工厂方法二  
  4. ……  
  5. }  

       具体工厂实现了抽象工厂,每一个具体的工厂方法可以返回一个特定的产品对象,而同一个具体工厂所创建的产品对象构成了一个产品族。对于每一个具体工厂类,其典型代码如下所示:

[java] view plaincopy
  1. class ConcreteFactory1 extends AbstractFactory {  
  2.     //工厂方法一  
  3. public AbstractProductA createProductA() {  
  4.     return new ConcreteProductA1();  
  5. }  
  6.   
  7. //工厂方法二  
  8. public AbstractProductB createProductB() {  
  9.     return new ConcreteProductB1();  
  10. }  
  11.   
  12. ……  
  13. }  

       与工厂方法模式一样,抽象工厂模式也可为每一种产品提供一组重载的工厂方法,以不同的方式对产品对象进行创建。

疑问

思考

       抽象工厂模式是否符合“开闭原则”?【从增加新的产品等级结构和增加新的产品族两方面进行思考。】




完整解决方案

       Sunny公司开发人员使用抽象工厂模式来重构界面皮肤库的设计,其基本结构如图6所示:


界面皮肤库结构图

       在图6中,SkinFactory接口充当抽象工厂,其子类SpringSkinFactorySummerSkinFactory充当具体工厂,接口ButtonTextFieldComboBox充当抽象产品,其子类SpringButtonSpringTextFieldSpringComboBoxSummerButtonSummerTextFieldSummerComboBox充当具体产品。完整代码如下所示:

[java] view plaincopy
  1. //在本实例中我们对代码进行了大量简化,实际使用时,界面组件的初始化代码较为复杂,还需要使用JDK中一些已有类,为了突出核心代码,在此只提供框架代码和演示输出。  
  2. //按钮接口:抽象产品  
  3. interface Button {  
  4.     public void display();  
  5. }  
  6.   
  7. //Spring按钮类:具体产品  
  8. class SpringButton implements Button {  
  9.     public void display() {  
  10.         System.out.println("显示浅绿色按钮。");  
  11.     }  
  12. }  
  13.   
  14. //Summer按钮类:具体产品  
  15. class SummerButton implements Button {  
  16.     public void display() {  
  17.         System.out.println("显示浅蓝色按钮。");  
  18.     }     
  19. }  
  20.   
  21. //文本框接口:抽象产品  
  22. interface TextField {  
  23.     public void display();  
  24. }  
  25.   
  26. //Spring文本框类:具体产品  
  27. class SpringTextField implements TextField {  
  28.     public void display() {  
  29.         System.out.println("显示绿色边框文本框。");  
  30.     }  
  31. }  
  32.   
  33. //Summer文本框类:具体产品  
  34. class SummerTextField implements TextField {  
  35.     public void display() {  
  36.         System.out.println("显示蓝色边框文本框。");  
  37.     }     
  38. }  
  39.   
  40. //组合框接口:抽象产品  
  41. interface ComboBox {  
  42.     public void display();  
  43. }  
  44.   
  45. //Spring组合框类:具体产品  
  46. class SpringComboBox implements ComboBox {  
  47.     public void display() {  
  48.         System.out.println("显示绿色边框组合框。");  
  49.     }  
  50. }  
  51.   
  52. //Summer组合框类:具体产品  
  53. class SummerComboBox implements ComboBox {  
  54.     public void display() {  
  55.         System.out.println("显示蓝色边框组合框。");  
  56.     }     
  57. }  
  58.   
  59. //界面皮肤工厂接口:抽象工厂  
  60. interface SkinFactory {  
  61.     public Button createButton();  
  62.     public TextField createTextField();  
  63.     public ComboBox createComboBox();  
  64. }  
  65.   
  66. //Spring皮肤工厂:具体工厂  
  67. class SpringSkinFactory implements SkinFactory {  
  68.     public Button createButton() {  
  69.         return new SpringButton();  
  70.     }  
  71.   
  72.     public TextField createTextField() {  
  73.         return new SpringTextField();  
  74.     }  
  75.   
  76.     public ComboBox createComboBox() {  
  77.         return new SpringComboBox();  
  78.     }  
  79. }  
  80.   
  81. //Summer皮肤工厂:具体工厂  
  82. class SummerSkinFactory implements SkinFactory {  
  83.     public Button createButton() {  
  84.         return new SummerButton();  
  85.     }  
  86.   
  87.     public TextField createTextField() {  
  88.         return new SummerTextField();  
  89.     }  
  90.   
  91.     public ComboBox createComboBox() {  
  92.         return new SummerComboBox();  
  93.     }  
  94. }  

       为了让系统具备良好的灵活性和可扩展性,我们引入了工具类XMLUtil和配置文件,其中,XMLUtil类的代码如下所示:

[java] view plaincopy
  1. import javax.xml.parsers.*;  
  2. import org.w3c.dom.*;  
  3. import org.xml.sax.SAXException;  
  4. import java.io.*;  
  5.   
  6. public class XMLUtil {  
  7. //该方法用于从XML配置文件中提取具体类类名,并返回一个实例对象  
  8.     public static Object getBean() {  
  9.         try {  
  10.             //创建文档对象  
  11.             DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();  
  12.             DocumentBuilder builder = dFactory.newDocumentBuilder();  
  13.             Document doc;                             
  14.             doc = builder.parse(new File("config.xml"));   
  15.           
  16.             //获取包含类名的文本节点  
  17.             NodeList nl = doc.getElementsByTagName("className");  
  18.             Node classNode=nl.item(0).getFirstChild();  
  19.             String cName=classNode.getNodeValue();  
  20.               
  21.             //通过类名生成实例对象并将其返回  
  22.             Class c=Class.forName(cName);  
  23.             Object obj=c.newInstance();  
  24.             return obj;  
  25.         }     
  26.         catch(Exception e) {  
  27.             e.printStackTrace();  
  28.             return null;  
  29.         }  
  30.     }  
  31. }  

       配置文件config.xml中存储了具体工厂类的类名,代码如下所示:

[java] view plaincopy
  1. <?xml version="1.0"?>  
  2. <config>  
  3.     <className>SpringSkinFactory</className>  
  4. </config>  

       编写如下客户端测试代码:

[java] view plaincopy
  1. class Client {  
  2.     public static void main(String args[]) {  
  3.         //使用抽象层定义  
  4.         SkinFactory factory;  
  5.         Button bt;  
  6.         TextField tf;  
  7.         ComboBox cb;  
  8.         factory = (SkinFactory)XMLUtil.getBean();  
  9.         bt = factory.createButton();  
  10.         tf = factory.createTextField();  
  11.         cb = factory.createComboBox();  
  12.         bt.display();  
  13.         tf.display();  
  14.         cb.display();  
  15.     }  
  16. }  

       编译并运行程序,输出结果如下:

显示浅绿色按钮。

显示绿色边框文本框。

显示绿色边框组合框。

       如果需要更换皮肤,只需修改配置文件即可,在实际环境中,我们可以提供可视化界面,例如菜单或者窗口来修改配置文件,用户无须直接修改配置文件。如果需要增加新的皮肤,只需增加一族新的具体组件并对应提供一个新的具体工厂,修改配置文件即可使用新的皮肤,原有代码无须修改,符合“开闭原则”。

  疑问    

扩展

       在真实项目开发中,我们通常会为配置文件提供一个可视化的编辑界面,类似Struts框架中的struts.xml编辑器,大家可以自行开发一个简单的图形化工具来修改配置文件,实现真正的纯界面操作。




5 “开闭原则”的倾斜性

       Sunny公司使用抽象工厂模式设计了界面皮肤库,该皮肤库可以较为方便地增加新的皮肤,但是现在遇到一个非常严重的问题:由于设计时考虑不全面,忘记为单选按钮(RadioButton)提供不同皮肤的风格化显示,导致无论选择哪种皮肤,单选按钮都显得那么“格格不入”。Sunny公司的设计人员决定向系统中增加单选按钮,但是发现原有系统居然不能够在符合“开闭原则”的前提下增加新的组件,原因是抽象工厂SkinFactory中根本没有提供创建单选按钮的方法,如果需要增加单选按钮,首先需要修改抽象工厂接口SkinFactory,在其中新增声明创建单选按钮的方法,然后逐个修改具体工厂类,增加相应方法以实现在不同的皮肤中创建单选按钮,此外还需要修改客户端,否则单选按钮无法应用于现有系统。

       怎么办?答案是抽象工厂模式无法解决该问题,这也是抽象工厂模式最大的缺点在抽象工厂模式中,增加新的产品族很方便,但是增加新的产品等级结构很麻烦,抽象工厂模式的这种性质称为“开闭原则”的倾斜性。“开闭原则”要求系统对扩展开放,对修改封闭,通过扩展达到增强其功能的目的,对于涉及到多个产品族与多个产品等级结构的系统,其功能增强包括两方面:

       (1) 增加产品族:对于增加新的产品族,抽象工厂模式很好地支持了“开闭原则”,只需要增加具体产品并对应增加一个新的具体工厂,对已有代码无须做任何修改

       (2) 增加新的产品等级结构:对于增加新的产品等级结构,需要修改所有的工厂角色,包括抽象工厂类,在所有的工厂类中都需要增加生产新产品的方法,违背了“开闭原则”。

       正因为抽象工厂模式存在“开闭原则”的倾斜性,它以一种倾斜的方式来满足“开闭原则”,为增加新产品族提供方便,但不能为增加新产品结构提供这样的方便,因此要求设计人员在设计之初就能够全面考虑,不会在设计完成之后向系统中增加新的产品等级结构,也不会删除已有的产品等级结构,否则将会导致系统出现较大的修改,为后续维护工作带来诸多麻烦。



6 抽象工厂模式总结


       抽象工厂模式是工厂方法模式的进一步延伸,由于它提供了功能更为强大的工厂类并且具备较好的可扩展性,在软件开发中得以广泛应用,尤其是在一些框架和API类库的设计中,例如在Java语言的AWT(抽象窗口工具包)中就使用了抽象工厂模式,它使用抽象工厂模式来实现在不同的操作系统中应用程序呈现与所在操作系统一致的外观界面。抽象工厂模式也是在软件开发中最常用的设计模式之一。

 

       1. 主要优点

       抽象工厂模式的主要优点如下:

       (1) 抽象工厂模式隔离了具体类的生成,使得客户并不需要知道什么被创建。由于这种隔离,更换一个具体工厂就变得相对容易,所有的具体工厂都实现了抽象工厂中定义的那些公共接口,因此只需改变具体工厂的实例,就可以在某种程度上改变整个软件系统的行为。

       (2) 当一个产品族中的多个对象被设计成一起工作时,它能够保证客户端始终只使用同一个产品族中的对象。

       (3) 增加新的产品族很方便,无须修改已有系统,符合“开闭原则”。

 

       2. 主要缺点

       抽象工厂模式的主要缺点如下:

       增加新的产品等级结构麻烦,需要对原有系统进行较大的修改,甚至需要修改抽象层代码,这显然会带来较大的不便,违背了“开闭原则”。

 

       3. 适用场景

       在以下情况下可以考虑使用抽象工厂模式:

       (1) 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节,这对于所有类型的工厂模式都是很重要的,用户无须关心对象的创建过程,将对象的创建和使用解耦。

       (2) 系统中有多于一个的产品族,而每次只使用其中某一产品族。可以通过配置文件等方式来使得用户可以动态改变产品族,也可以很方便地增加新的产品族。

       (3) 属于同一个产品族的产品将在一起使用,这一约束必须在系统的设计中体现出来。同一个产品族中的产品可以是没有任何关系的对象,但是它们都具有一些共同的约束,如同一操作系统下的按钮和文本框,按钮与文本框之间没有直接关系,但它们都是属于某一操作系统的,此时具有一个共同的约束条件:操作系统的类型。

       (4) 产品等级结构稳定,设计完成之后,不会向系统中增加新的产品等级结构或者删除已有的产品等级结构。

疑问

练习

Sunny软件公司欲推出一款新的手机游戏软件,该软件能够支持SymbianAndroidWindows Mobile等多个智能手机操作系统平台,针对不同的手机操作系统,该游戏软件提供了不同的游戏操作控制(OperationController)类和游戏界面控制(InterfaceController)类,并提供相应的工厂类来封装这些类的初始化过程。软件要求具有较好的扩展性以支持新的操作系统平台,为了满足上述需求,试采用抽象工厂模式对其进行设计。

  

【作者:刘伟 http://blog.csdn.net/lovelion



0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:275541次
    • 积分:4276
    • 等级:
    • 排名:第8004名
    • 原创:150篇
    • 转载:93篇
    • 译文:0篇
    • 评论:37条
    最新评论
    我的小窝