`
leeleeleelee
  • 浏览: 21008 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

工厂方法模式和抽象工厂模式的区别

阅读更多 

抽象工厂的方法经常以工厂方法的方式实现，两者很容易混淆。他们的工作都是负责创建对象。不同的是工厂方法用的方法是继承过来的，而抽象工厂是通过对象组合。其实整个工厂方法模式，只不过就是通过子类来创建对象。只需知道超类型就可以了，具体的类型由子类负责。在这一点上，抽象工厂表示毫无压力，但是做法不同。抽象工厂提供一个用来创建一个产品家族的抽象类型，这个类型的子类定义了产品被产生的方法。要想使用这个工厂，必须先实例化它（产品家族的抽象类型，通过组合而来）。它的优点是可以把一群相关的产品集合起来，缺点是如果有新产品加入需要修改接口代码，这会涉及到所有子类接口的更改，是一个很繁琐的工作。而工厂方法有点相反，它只是创建一个产品，不需要很大的接口，一个方法就可以了。如果你目前还不知道将来需要实例化哪些类时，也可以使用工厂方法，只要继承它，实现工厂方法就可以了。

工厂模式是：定义一个用于创建对象的接口，让子类决定实例化哪一个类，使一个类的实例化延迟到子类。 
它有个特点，就是通常工厂的类层次与产品的类层次几乎是一样的树。如果说工厂是你的影子，你就是产品了。在你平时未用到模式的时候，你需要什么就new一个，这种情况就好比你躺在地上，人影合一了。那什么时候需要工厂模式呢。看看定义：“使一个类的实例化延迟到子类”，这个是关键，当你有必要延迟实例化的时候才需要用工厂模式。那什么情况下要延迟呢，在单例模式中有惰性单例（就是单例那个静态属性）……等等，就是一开始你还不适合立刻就创建该对象，你还需要一些资源或其它准备工作。整个系统的运行不像单个程序那样，系统需要很多资源和多方面的协同工作。 

抽象工厂是：提供一个创建一系列相关或相互依赖对象的接口，而无虚指定他们的具体类。 
抽象工厂比工厂模式复杂的多。如果楼主说他们像可能是他们都叫工厂，都生成产品，都是接口型设计模式。但是我觉得他们是两个不同的设计模式。首先他们的目的是不同的。工厂是为了“延迟创建”，而抽象工厂是提供一系列的接口，是为了组织创建对象的灵活性，避免重复，避免耦合低内聚。 
设计模式本身语言晦涩难懂，这个抽象工厂我也是没次都看着头昏眼花^_^,举个运用他的场景： 
1。你有两台单色打印机，一台黑白墨的，一台彩墨的。 
2。你有两种文件要打，一种讲演搞，一种图片 

3。要求是讲演稿如果是有图就打黑白的，没图打彩色的，照片有字的就打黑白的，没字就打彩色的。

Java代码   收藏代码
  1. class Print{  
  2. ……  
  3.     void doTalk(){  
  4.        if(flag)  
  5.            //color            1  
  6.        else  
  7.            //non-color        2  
  8.    }  
  9.   
  10.    void doPicture(){  
  11.        if(flag)  
  12.           //color             3  
  13.        else  
  14.           //non-color         4  
  15.    }  
  16. ……  
  17. }  


上面的这个场景就是可以运用抽象工厂来重构的。 

public abstract class AbsFactory{ 
    abstract TalkPrint getTalkPrint(); //打讲演稿 
    abatract PicPrint getPicPrint();   //打图片的 
} 

public class ColorFactory extends AbsFactory{ 
    TalkPrint getTalkPrint(){ 
       //彩色讲演稿打印 
    } 

    PicPrint getPicPrint(){ 
       //彩色图片打印 
    } 
} 

public class NonColorFactory extends AbsFactory{ 
    TalkPrint getTalkPrint(){ 
         //黑白讲演稿打印 
    } 

    PicPrint getPicPrint(){ 
         //黑白图片打印 
    }  
} 

public abstract class TalkPrint{ 
   //抽象的讲演稿打印 
} 

public class colorTalkPrint extends TalkPrint{ 
   //彩色讲演稿打印 
} 

public class noncolorTalkPrint extends TalkPrint{ 
   //黑白讲演稿打印 
} 

public abstract class PicPrint{ 
   //抽象的图片打印 
} 


public class colorPicPrint extends PicPrint{ 
   //彩色图片打印 
} 

public class noncolorPicPrint extends PicPrint{ 
   //黑白图片打印 
} 

进一步解释这个场景，就是当你做相似的工作又多种选择的时候，可以考虑用抽象工厂。 

这里你要打印各种文件是一组相似的工作，打印有彩色、黑白等针对打印的不同要求。 


这里仅仅举了一个方面的例子。 

我们可以看出，虽然抽象工厂和工厂在代码形式上很相似，甚至抽象工作可以有工厂来拓展，但是他们的出发点是不一样的。 

在搞单例模式的时候我们针对多线程拓展了为“双重检查模式”，那是同一个场景同一个任务，跟这里是不一样的。 

关于单例模式，我有笔记留在我的博客，欢迎大家来一起讨论： 

http://zhaipuhong.iteye.com/blog/214675 


 

2008年8月06日 11:48
00

一楼很善于google嘛。。。

2008年8月06日 08:57
00

工厂模式和抽象工厂模式的区别： 

楼主不妨可以这么理解，抽象工厂模式就是ioc之后的工厂模式 
呵呵，也就是说抽象工厂模式就是在工厂模式的基础上添加啦spring框架 

具体就是这个意思，抽象工厂模式是让工厂和依赖工厂的子类全部依赖一个接口或者抽象类，因为抽象代表这稳定，这样可以很容易的遵循oo中比较著名的开放关闭原则，设计出来的系统、框架或者程序很富有弹性和扩展能力 

不知道这么说楼主明白否？

2008年8月06日 08:54
00

工厂模式定义:提供创建对象的接口. 

为何使用? 
工厂模式是我们最常用的模式了,著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。 

为什么工厂模式是如此常用？因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑实用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。 

我们以类Sample为例， 如果我们要创建Sample的实例对象: 

Sample sample=new Sample(); 

可是，实际情况是，通常我们都要在创建sample实例时做点初始化的工作,比如赋值 查询数据库等。 

首先，我们想到的是，可以使用Sample的构造函数，这样生成实例就写成: 

Sample sample=new Sample(参数); 

但是，如果创建sample实例时所做的初始化工作不是象赋值这样简单的事，可能是很长一段代码，如果也写入构造函数中，那你的代码很难看了（就需要Refactor重整）。 

为什么说代码很难看，初学者可能没有这种感觉，我们分析如下，初始化工作如果是很长一段代码，说明要做的工作很多，将很多工作装入一个方法中，相当于将很多鸡蛋放在一个篮子里，是很危险的，这也是有背于Java 面向对象的原则，面向对象的封装(Encapsulation)和分派(Delegation)告诉我们，尽量将长的代码分派“切割”成每段，将每段再“ 封装”起来(减少段和段之间偶合联系性)，这样，就会将风险分散，以后如果需要修改，只要更改每段，不会再发生牵一动百的事情。 

在本例中，首先，我们需要将创建实例的工作与使用实例的工作分开, 也就是说，让创建实例所需要的大量初始化工作从Sample的构造函数中分离出去。 

这时我们就需要Factory工厂模式来生成对象了，不能再用上面简单new Sample(参数)。还有,如果Sample有个继承如MySample, 按照面向接口编程,我们需要将Sample抽象成一个接口.现在Sample是接口,有两个子类MySample 和HisSample .我们要实例化他们时,如下: 

Sample mysample=new MySample(); 
Sample hissample=new HisSample(); 

随着项目的深入,Sample可能还会"生出很多儿子出来", 那么我们要对这些儿子一个个实例化,更糟糕的是,可能还要对以前的代码进行修改:加入后来生出儿子的实例.这在传统程序中是无法避免的. 

但如果你一开始就有意识使用了工厂模式,这些麻烦就没有了. 

工厂方法 
你会建立一个专门生产Sample实例的工厂:

Java代码   收藏代码
  1. public class Factory{  
  2.   
  3. 　　public static Sample creator(int which){  
  4.   
  5. 　　//getClass 产生Sample 一般可使用动态类装载装入类。  
  6. 　　if (which==1)  
  7. 　　　　return new SampleA();  
  8. 　　else if (which==2)  
  9. 　　　　return new SampleB();  
  10.   
  11. 　　}  
  12.   
  13. }  

那么在你的程序中,如果要实例化Sample时.就使用 

Sample sampleA=Factory.creator(1); 

这样, 在整个就不涉及到Sample的具体子类,达到封装效果,也就减少错误修改的机会,这个原理可以用很通俗的话来比喻:就是具体事情做得越多,越容易范错误.这每个做过具体工作的人都深有体会,相反,官做得越高,说出的话越抽象越笼统,范错误可能性就越少.好象我们从编程序中也能悟出人生道理?呵呵. 

使用工厂方法 要注意几个角色，首先你要定义产品接口，如上面的Sample,产品接口下有Sample接口的实现类,如SampleA,其次要有一个factory类，用来生成产品Sample，如下图，最右边是生产的对象Sample： 
 
进一步稍微复杂一点，就是在工厂类上进行拓展，工厂类也有继承它的实现类concreteFactory了。 

抽象工厂 
工厂模式中有: 工厂方法(Factory Method) 抽象工厂(Abstract Factory). 

这两个模式区别在于需要创建对象的复杂程度上。如果我们创建对象的方法变得复杂了,如上面工厂方法中是创建一个对象Sample,如果我们还有新的产品接口Sample2. 

这里假设：Sample有两个concrete类SampleA和SamleB，而Sample2也有两个concrete类Sample2A和SampleB2 

那么，我们就将上例中Factory变成抽象类,将共同部分封装在抽象类中,不同部分使用子类实现，下面就是将上例中的Factory拓展成抽象工厂: 

Java代码   收藏代码
  1. public abstract class Factory{  
  2.   
  3. 　　public abstract Sample creator();  
  4.   
  5. 　　public abstract Sample2 creator(String name);  
  6.   
  7. }  
  8.   
  9. public class SimpleFactory extends Factory{  
  10.   
  11. 　　public Sample creator(){  
  12. 　　　　.........  
  13. 　　　　return new SampleA  
  14. 　　}  
  15.   
  16. 　　public Sample2 creator(String name){  
  17. 　　　　.........  
  18. 　　　　return new Sample2A  
  19. 　　}  
  20.   
  21. }  
  22.   
  23. public class BombFactory extends Factory{  
  24.   
  25. 　　public Sample creator(){  
  26. 　　　　......  
  27. 　　　　return new SampleB  
  28. 　　}  
  29.   
  30. 　　public Sample2 creator(String name){  
  31. 　　　　......  
  32. 　　　　return new Sample2B  
  33. 　　}  
  34.   
  35. }  




从上面看到两个工厂各自生产出一套Sample和Sample2,也许你会疑问，为什么我不可以使用两个工厂方法来分别生产Sample和Sample2? 

抽象工厂还有另外一个关键要点，是因为 SimpleFactory内，生产Sample和生产Sample2的方法之间有一定联系，所以才要将这两个方法捆绑在一个类中，这个工厂类有其本身特征，也许制造过程是统一的，比如：制造工艺比较简单，所以名称叫SimpleFactory。 

在实际应用中，工厂方法用得比较多一些，而且是和动态类装入器组合在一起应用， 

举例 

我们以Jive的ForumFactory为例，这个例子在前面的Singleton模式中我们讨论过，现在再讨论其工厂模式: 

Java代码   收藏代码
  1. public abstract class ForumFactory {  
  2.   
  3. 　　private static Object initLock = new Object();  
  4. 　　private static String className = "com.jivesoftware.forum.database.DbForumFactory";  
  5. 　　private static ForumFactory factory = null;  
  6.   
  7. 　　public static ForumFactory getInstance(Authorization authorization) {  
  8. 　　　　//If no valid authorization passed in, return null.  
  9. 　　　　if (authorization == null) {  
  10. 　　　　　　return null;  
  11. 　　　　}  
  12. 　　　　//以下使用了Singleton 单态模式  
  13. 　　　　if (factory == null) {  
  14. 　　　　　　synchronized(initLock) {  
  15. 　　　　　　　　if (factory == null) {  
  16. 　　　　　　　　　　　　......  
  17.   
  18. 　　　　　　　　　　try {  
  19. 　　　　　　　　　　　　　　//动态转载类  
  20. 　　　　　　　　　　　　　　Class c = Class.forName(className);  
  21. 　　　　　　　　　　　　　　factory = (ForumFactory)c.newInstance();  
  22. 　　　　　　　　　　}  
  23. 　　　　　　　　　　catch (Exception e) {  
  24. 　　　　　　　　　　　　　　return null;  
  25. 　　　　　　　　　　}  
  26. 　　　　　　　　}  
  27. 　　　　　　}  
  28. 　　　　}  
  29.   
  30. 　　　　//Now, 返回 proxy.用来限制授权对forum的访问  
  31. 　　　　return new ForumFactoryProxy(authorization, factory,  
  32. 　　　　　　　　　　　　　　　　　　　　factory.getPermissions(authorization));  
  33. 　　}  
  34.   
  35. 　　//真正创建forum的方法由继承forumfactory的子类去完成.  
  36. 　　public abstract Forum createForum(String name, String description)  
  37. 　　throws UnauthorizedException, ForumAlreadyExistsException;  
  38.   
  39. 　　....  
  40.   
  41. }  






因为现在的Jive是通过数据库系统存放论坛帖子等内容数据,如果希望更改为通过文件系统实现,这个工厂方法ForumFactory就提供了提供动态接口: 

Java代码   收藏代码
  1. private static String className = "com.jivesoftware.forum.database.DbForumFactory";  


你可以使用自己开发的创建forum的方法代替com.jivesoftware.forum.database.DbForumFactory就可以. 

在上面的一段代码中一共用了三种模式,除了工厂模式外,还有Singleton单态模式,以及proxy模式,proxy模式主要用来授权用户对forum的访问,因为访问forum有两种人:一个是注册用户 一个是游客guest,那么那么相应的权限就不一样,而且这个权限是贯穿整个系统的,因此建立一个proxy,类似网关的概念,可以很好的达到这个效果.  

看看Java宠物店中的CatalogDAOFactory: 
Java代码   收藏代码
  1. public class CatalogDAOFactory {  
  2.   
  3. 　　/** 
  4.  
  5. 　　* 本方法制定一个特别的子类来实现DAO模式。 
  6. 　　* 具体子类定义是在J2EE的部署描述器中。 
  7. 　　*/  
  8.   
  9. 　　public static CatalogDAO getDAO() throws CatalogDAOSysException {  
  10.   
  11. 　　　　CatalogDAO catDao = null;  
  12.   
  13. 　　　　try {  
  14.   
  15. 　　　　　　InitialContext ic = new InitialContext();  
  16. 　　　　　　//动态装入CATALOG_DAO_CLASS  
  17. 　　　　　　//可以定义自己的CATALOG_DAO_CLASS，从而在无需变更太多代码  
  18. 　　　　　　//的前提下，完成系统的巨大变更。  
  19.   
  20. 　　　　　　String className =(String) ic.lookup(JNDINames.CATALOG_DAO_CLASS);  
  21.   
  22. 　　　　　　catDao = (CatalogDAO) Class.forName(className).newInstance();  
  23.   
  24. 　　　　} catch (NamingException ne) {  
  25.   
  26. 　　　　　　throw new CatalogDAOSysException("  
  27. 　　　　　　　　CatalogDAOFactory.getDAO: NamingException while  
  28. 　　　　　　　　　　getting DAO type : \n" + ne.getMessage());  
  29.   
  30. 　　　　} catch (Exception se) {  
  31.   
  32. 　　　　　　throw new CatalogDAOSysException("  
  33. 　　　　　　　　CatalogDAOFactory.getDAO: Exception while getting  
  34. 　　　　　　　　　　DAO type : \n" + se.getMessage());  
  35.   
  36. 　　　　}  
  37.   
  38. 　　　　return catDao;  
  39.   
  40. 　　}  
  41.   
  42. }  



CatalogDAOFactory是典型的工厂方法，catDao 是通过动态类装入器className获得CatalogDAOFactory具体实现子类，这个实现子类在Java宠物店是用来操作catalog数据库，用户可以根据数据库的类型不同，定制自己的具体实现子类，将自己的子类名给与CATALOG_DAO_CLASS变量就可以。 

由此可见，工厂方法确实为系统结构提供了非常灵活强大的动态扩展机制，只要我们更换一下具体的工厂方法，系统其他地方无需一点变换，就有可能将系统功能进行改头换面的变化。
分享到：
| filter和拦截器的区别和执行顺序
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics