【java设计模式】之 工厂(Factory)模式-阿里云开发者社区

开发者社区> ghost丶桃子> 正文

【java设计模式】之 工厂(Factory)模式

简介:
+关注继续查看

目录(?)[+]

1.工厂模式的定义

        工厂模式使用的频率非常高,我们在开发中总能见到它们的身影。其定义为:Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.即定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。工厂方法模式的通用类图如下所示:


        如图所示,Product抽象类负责定义产品的共性,实现对事物最抽象的定义,Creator为抽象工厂类,具体如何创建产品类由具体的实现工厂ConcreteCreator来完成。我们来看一下通用的模板代码:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public abstract class Product {  
  2.       
  3.     public void method() { //产品类的公共方法,已经实现  
  4.         //实现了公共的逻辑  
  5.     }  
  6.       
  7.     public abstract void method2(); //非公共方法,需要子类具体实现  
  8. }  
        具体产品类可以有多个,都继承与抽象类Product,如下:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class ConcreateProduct1 extends Product {  
  2.       
  3.     @Override  
  4.     public void method2() {  
  5.         //product1的业务逻辑  
  6.     }  
  7. }  
  8. public class ConcreateProduct2 extends Product {  
  9.   
  10.     @Override  
  11.     public void method2() {  
  12.         //product2的业务逻辑  
  13.     }  
  14. }  
        抽象工厂类负责定义产品对象的产生,代码如下:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public abstract class Creator {  
  2.     //创建一个产品对象,其输入参数类型可以自行设置  
  3.     public abstract <T extends Product> T createProduct(Class<T> clazz);  
  4. }  
       这里用的是泛型,传入的对象必须是Product抽象类的实现类。具体如何产生一个产品的对象,是由具体工厂类实现的,具体工厂类继承这个抽象工厂类:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class ConcreteCreator extends Creator {  
  2.   
  3.     @Override  
  4.     public <T extends Product> T createProduct(Class<T> clazz) {  
  5.         Product product = null;  
  6.         try {  
  7.             product = (Product) Class.forName(clazz.getName()).newInstance();  
  8.         } catch (Exception e) { //异常处理  
  9.             e.printStackTrace();  
  10.         }  
  11.         return (T) product;  
  12.     }  
  13. }  
        通过这样的设计,我们就可以在测试类中随意生产产品了,看下面的测试类:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class FactoryTest {  
  2.   
  3.     public static void main(String[] args) {  
  4.         Creator factory = new ConcreteCreator();  
  5.         Product product1 = factory.createProduct(ConcreteProduct1.class); //通过不同的类创建不同的产品  
  6.         Product product2 = factory.createProduct(ConcreteProduct2.class);  
  7.          /* 
  8.           * 下面继续其他业务处理 
  9.           */  
  10.      }  
  11. }  
        下面举个女娲造人的例子阐述一下工厂模式的实际应用。

2.用女蜗造人阐述工厂模式

        现在女娲要造人,她要造三种人:白种人、黄种人和黑种人。怎么造呢?她得有个能产生人类的工厂吧(类似于八卦炉的东西),这个工厂得让她生产出不同的人种。每个人都有两个属性:皮肤颜色和说话。那现在我们开始设计女蜗造人的程序,首先我们看一下造人的类图:


        抽象接口Human是人类,里面有两个方法,getColor获得皮肤颜色,talk交谈。下面三个具体Human的实现类,分别实现三个人种。根据工厂模式,应该有个抽象工厂,AbstractHumanFactory就担当了这个责任,里面有个抽象方法createHuman,那HumanFactory就是实现类了,实现抽象工厂里的方法。下面我们看看具体实现:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public interface Human {      
  2.     public void getColor();//人有不同的颜色      
  3.     public void talk(); //人会说话  
  4. }  
        接下来对Human接口的不同实现:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class BlackHuman implements Human {// 黑种人  
  2.   
  3.     @Override  
  4.     public void getColor() {  
  5.         System.out.println("Black");  
  6.     }  
  7.     @Override  
  8.     public void talk() {  
  9.         System.out.println("Black man");  
  10.     }  
  11. }  
  12. public class Human implements Human {   //黄种人  
  13.   
  14.     @Override  
  15.     public void getColor() {  
  16.         System.out.println("Yellow");  
  17.     }  
  18.     @Override  
  19.     public void talk() {  
  20.         System.out.println("Yellow man");  
  21.     }  
  22. }  
  23. public class WhiteHuman implements Human {//白种人  
  24.   
  25.     @Override  
  26.     public void getColor() {  
  27.         System.out.println("White");  
  28.     }  
  29.     @Override  
  30.     public void talk() {  
  31.         System.out.println("White man");  
  32.     }  
  33. }  

        好了,人的模子搞好了,现在女娲要开始搭建八卦炉了,于是女娲开始画八卦炉模型了:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public abstract class AbstractHumanFactory{  
  2.     public abstract <T extends Human> T createHuman(Class<T> clazz); //注意这里T必须是Human的实现类才行,因为要造Human嘛  
  3. }  
        然后女娲开始具体实现这个八卦炉了……

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class HumanFactory extends AbstractHumanFactory {  
  2.   
  3.     @Override  
  4.     public <T extends Human> T createHuman(Class<T> clazz) {  
  5.         Human human = null;  
  6.         try {  
  7.             human = (Product) Class.forName(clazz.getName()).newInstance();  
  8.         } catch (Exception e) { //异常处理  
  9.             System.out.println("人种产生错误");  
  10.         }  
  11.         return (T) human;  
  12.     }  
  13. }  

        好,现在人种也有了,八卦炉也有了,剩下的就是采集黄土,然后命令八卦炉开始生产了:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class FactoryTest {  
  2.     public static void main(String[] args) {  
  3.         AbstractHumanFactory bagualu = new HunmanFactory();  
  4.         Human blackMan = bagualu.createHuman(BlackHuman.class); //黑人诞生了  
  5.         Human yellowMan = bagualu.createHuman(YelloHuman.class); //黄人诞生了  
  6.         Human whiteMan = bagualu.createHuman(WhiteHuman.class); //白人诞生了  
  7.       }  
  8. }  
        女娲就是这么把人造出来的……这就是工厂模式!

3.工厂模式的扩展

3.1 静态工厂模式

        我们还用上面女娲造人的例子说明,现在女娲在思考一个问题:我现在只需要一个工厂就可以把人生产出来,我干嘛要具体的工厂对象呢?我只要使用静态方法就好了。这样一想,于是女娲就开始把AbstractHumanFactory抽象类去掉了,只保留了HumanFactory类,同时把createHuman方法设置成了static类型,搞定!

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class HumanFactory {  
  2.   
  3.     @Override  
  4.     public static <T extends Human> T createHuman(Class<T> clazz) {  
  5.         Human human = null;  
  6.         try {  
  7.             human = (Product) Class.forName(clazz.getName()).newInstance();  
  8.         } catch (Exception e) { //异常处理  
  9.             System.out.println("人种产生错误");  
  10.         }  
  11.         return (T) human;  
  12.     }  
  13. }  
        然后女娲造人的时候就不用new什么八卦炉了,直接用HumanFactory类调用就行了:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. Human blackMan = HumanFactory.createHuman(BlackHuman.class);  

        这就是静态工厂模式,在实际项目中,根据需求可以设置成静态工厂类,但是缺点是扩展比较困难,如果就一个工厂,不需要扩展,可以这么设计,仍然是很常用的。

3.2 多个工厂模式

        我们还以女娲造人为例,后来女娲想了想,,这人不可能就说话吧,还得有不同的属性杀的,如果在一个八卦炉里造,除了new一个人外,还得对不同的人设置不同的属性,这样的话,八卦炉有点吃不消阿……又有点乱啊……但是她想到了一个法子,每个人种弄个八卦炉,不同的八卦炉专门生产不同的人种,这样就结构清晰了,她在造人的时候自己选择与哪个八卦炉相关联就行了。示意图如下:


        这样的话AbstractHumanFactory抽象类我们就要改写了:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public abstract class AbstractHumanFactory {  
  2.     public abstract Human createHuman();  
  3. }  
        注意抽象方法中已经不需要再传递相关类的参数了,因为每个具体的工厂都已经非常明确自己的职责:创建自己负责的产品类对象。所以不同的工厂实现自己的createHuman方法即可:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class BlackHumanFactory extends AbstractHumanFactory {  
  2.     public Human createHuman() {  
  3.         return new BlackHuman();  
  4.     }  
  5. }  
  6. public class YellowHumanFactory extends AbstractHumanFactory {  
  7.     public Human createHuman() {  
  8.         return new YellowHuman();  
  9.     }  
  10. }  
  11. public class WhiteHumanFactory extends AbstractHumanFactory {  
  12.     public Human createHuman() {  
  13.         return new WhiteHuman();  
  14.     }  
  15. }  
        这样三个不同的工厂就产生了,每个工厂对应只生产自己对应的人种。所以现在女娲造人就可以不用一个八卦炉了,分工协作,各不影响了!

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class FactoryTest {  
  2.     public static void main(String[] args) {  
  3.         Human blackMan = new BlackHumanFactory().createHuman(); //黑人诞生了  
  4.         Human yellowMan = new YellowHumanFactory().createHuman(); //黄人诞生了  
  5.         Human whiteMan = new WhiteHumanFactory().createHuman(); //白人诞生了  
  6.       }  
  7. }  
        这种工厂模式的好处是职责清晰,结构简单,但是给扩扩展性和可维护性带来了一定的影响,因为如果要扩展一个产品类,就需要建立一个相应的工厂类,这样就增加了扩展的难度。因为工厂类和产品类的数量是相同的,维护时也需要考虑两个对象之间的关系。但是这种模式还是很常用的。

3.3 替代单例模式

        上一章介绍了单例模式,并且指出了单例和多例的一些缺点,但是我们是不是可以采用工厂模式来实现一个单例模式的功能呢?答案是肯定的,单例模式的核心要求就是在内存中只有一个对象,通过工厂方法模式也可以只在内存中生产一个对象。见下面:

Singleton类定义了一个private的无参构造方法,目的是不允许通过new的方式创建对象,另外,Singleton类也不自己定义一个Singleton对象了,因为它要通过工厂来获得。

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class Singleton {  
  2.     private Singleton() {  
  3.           
  4.     }  
  5.     public void doSomething() {  
  6.         //业务处理  
  7.     }  
  8. }  
        既然Singleton不能通过正常的渠道建立一个对象,那SingletonFactory如何建立一个单例对象呢?答案是通过反射方式创建:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class SingletonFactory {  
  2.     private static Singleton instance;  
  3.     static {  
  4.         try {         
  5.             Class clazz = Class.forName(Singleton.class.getName());  
  6.             //获取无参构造方法  
  7.             Constructor constructor = clazz.getDeclaredConstructor();  
  8.             //设置无参构造方法可访问  
  9.             constructor.setAccessible(true);  
  10.             //产生一个实例对象  
  11.             instance = (Singleton) constructor.newInstance();  
  12.         } catch (Exception e) {  
  13.             //异常处理  
  14.         }  
  15.     }  
  16.     public static Singleton getInstance() {  
  17.         return instance;  
  18.     }  
  19. }  
        以上通过工厂方法模式创建了一个单例对象,该框架可以继续扩展,在一个项目中可以产生一个单例构造器,所有需要产生单例的类都遵循一定的规则(构造方法是private),然后通过扩展该框架,只要输入一个类型就可以获得唯一的一个实例。

3.4 延迟初始化

        何为延迟初始化(Lazy initialization)?即一个对象被使用完毕后,并不立刻释放,工厂类保持其初始状态,等待再次被使用。延迟初始化是工厂模式的一个扩展应用,其通用类表示如下:


        ProductFactory负责产品类对象的创建工作,并且通过prMap变量产生一个缓存,对需要再次被重用的对象保留:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class ProductFactory {  
  2.     private static final Map<String, Product> prMap = new HashMap();  
  3.     public static synchronized Product createProduct(String type) throws Exception {  
  4.         Product product = null;  
  5.         //如果Map中已经有这个对象  
  6.         if(prMap.containsKey(type)) {  
  7.             product = prMap.get(type);  
  8.         } else {  
  9.             if(type.equals("Product1")) {  
  10.                 product = new ConcreteProduct1();  
  11.             }  
  12.             else {  
  13.                 product = new ConcreteProduct2();  
  14.             }  
  15.             prMap.put(type, product);  
  16.         }  
  17.         return product;  
  18.     }  
  19. }  

        代码比较简单,通过定义一个Map容器,容纳所有产生的对象,每次在new一个对象的时候先判断Map中有没有,有就不用再new了,直接取。另外,每次new过一个对象后,也将其放入Map中方便下次调用。

        延迟加载时很有用的,比如JDBC连接数据库,会要求设置一个MaxConnections最大连接数量,该数量就是内存中最大实例化的数量。

4. 工厂模式的应用

    优点:

        1. 工厂模式具有良好的封装性,代码结构清晰,也有利于扩展。在增加产品类的情况下,只需要适当地修改具体的工厂类或扩展一个工厂类,就可以完成“拥抱变化”。

        2. 工厂模式可以屏蔽产品类。这一点非常重要,产品类的实现如何变化,调用者都不用关系,只需要关心产品的接口,只要接口保持不变,系统的上层模块就不需要发生变化。

        3. 工厂模式是典型的解耦框架。高层模块只需要知道产品的抽象类,其他的实现类都不用关心。

       工厂模式就介绍这么多吧,如果错误之处,欢迎留言指正~

       相关阅读:http://blog.csdn.net/column/details/des-pattern.html

_____________________________________________________________________________________________________________________________________________________

-----乐于分享,共同进步!

-----更多文章请看:http://blog.csdn.net/eson_15

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
设计模式之三(工厂方法模式)
原文:设计模式之三(工厂方法模式) 前言 工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化那一个类。工厂方法使一个类的实例化延迟到其子类。 简单工厂模式(http://www.cnblogs.com/aehyok/archive/2013/05/10/3072008.html)的最大优点在于工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖。
747 0
Java描述设计模式(02):简单工厂模式
一、生活场景简介 1、引入场景 订餐流程简单描述 1)、食品抽象类,规定食品的基础属性操作 2)、鱼类,鸡肉类食品类扩展 3)、订餐流程类,根据食品名称,加工指定类型食品 4)、模拟客户端预定操作 2、源代码实现 1)、关系图谱 2)、代码实现 /** * 简单工厂模式引入场景 */ publ...
547 0
自动调整速率的Actor设计模式
问题背景 与数据库或者存储系统交互是所有应用软件都必不可少的功能之一,akka开发的系统也不例外。但akka特殊的地方在于,会尽可能的将所有的功能都设计成异步的,以避免Actor阻塞,然而无法避免IO这类的阻塞操作。
972 0
反射与工厂设计模式 | 带你学《Java语言高级特性》之八十三
通过案例逐步掌握工厂设计模式,通过工厂类获取指定接口的实例化对象。
630 0
1955
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
文娱运维技术
立即下载
《SaaS模式云原生数据仓库应用场景实践》
立即下载
《看见新力量:二》电子书
立即下载