目录(?)[+]

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

public abstract class Product {  
      
    public void method() { //产品类的公共方法，已经实现  
        //实现了公共的逻辑  
    }  
      
    public abstract void method2(); //非公共方法，需要子类具体实现  
}

具体产品类可以有多个，都继承与抽象类Product，如下：

 
    [java] 
    view plain
    copy

     
    
     
   
public class ConcreateProduct1 extends Product {  
      
    @Override  
    public void method2() {  
        //product1的业务逻辑  
    }  
}  
public class ConcreateProduct2 extends Product {  
  
    @Override  
    public void method2() {  
        //product2的业务逻辑  
    }  
}  

抽象工厂类负责定义产品对象的产生，代码如下：

 
    [java] 
    view plain
    copy

public abstract class Creator {  
    //创建一个产品对象，其输入参数类型可以自行设置  
    public abstract <T extends Product> T createProduct(Class<T> clazz);  
}

这里用的是泛型，传入的对象必须是Product抽象类的实现类。具体如何产生一个产品的对象，是由具体工厂类实现的，具体工厂类继承这个抽象工厂类：

 
    [java] 
    view plain
    copy

     
    
     
   
public class ConcreteCreator extends Creator {  
  
    @Override  
    public <T extends Product> T createProduct(Class<T> clazz) {  
        Product product = null;  
        try {  
            product = (Product) Class.forName(clazz.getName()).newInstance();  
        } catch (Exception e) { //异常处理  
            e.printStackTrace();  
        }  
        return (T) product;  
    }  
}  

通过这样的设计，我们就可以在测试类中随意生产产品了，看下面的测试类：

 
    [java] 
    view plain
    copy

     
    
     
   
public class FactoryTest {  
  
    public static void main(String[] args) {  
        Creator factory = new ConcreteCreator();  
        Product product1 = factory.createProduct(ConcreteProduct1.class); //通过不同的类创建不同的产品  
        Product product2 = factory.createProduct(ConcreteProduct2.class);  
         /* 
          * 下面继续其他业务处理 
          */  
     }  
}  

下面举个女娲造人的例子阐述一下工厂模式的实际应用。

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

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

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

 
    [java] 
    view plain
    copy

public interface Human {      
    public void getColor();//人有不同的颜色      
    public void talk(); //人会说话  
}

接下来对Human接口的不同实现：

 
    [java] 
    view plain
    copy

     
    
     
   
public class BlackHuman implements Human {// 黑种人  
  
    @Override  
    public void getColor() {  
        System.out.println("Black");  
    }  
    @Override  
    public void talk() {  
        System.out.println("Black man");  
    }  
}  
public class Human implements Human {   //黄种人  
  
    @Override  
    public void getColor() {  
        System.out.println("Yellow");  
    }  
    @Override  
    public void talk() {  
        System.out.println("Yellow man");  
    }  
}  
public class WhiteHuman implements Human {//白种人  
  
    @Override  
    public void getColor() {  
        System.out.println("White");  
    }  
    @Override  
    public void talk() {  
        System.out.println("White man");  
    }  
}  

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

 
    [java] 
    view plain
    copy

public abstract class AbstractHumanFactory{  
    public abstract <T extends Human> T createHuman(Class<T> clazz); //注意这里T必须是Human的实现类才行，因为要造Human嘛  
}

然后女娲开始具体实现这个八卦炉了……

 
    [java] 
    view plain
    copy

     
    
     
   
public class HumanFactory extends AbstractHumanFactory {  
  
    @Override  
    public <T extends Human> T createHuman(Class<T> clazz) {  
        Human human = null;  
        try {  
            human = (Product) Class.forName(clazz.getName()).newInstance();  
        } catch (Exception e) { //异常处理  
            System.out.println("人种产生错误");  
        }  
        return (T) human;  
    }  
}  

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

 
    [java] 
    view plain
    copy

     
    
     
   
public class FactoryTest {  
    public static void main(String[] args) {  
        AbstractHumanFactory bagualu = new HunmanFactory();  
        Human blackMan = bagualu.createHuman(BlackHuman.class); //黑人诞生了  
        Human yellowMan = bagualu.createHuman(YelloHuman.class); //黄人诞生了  
        Human whiteMan = bagualu.createHuman(WhiteHuman.class); //白人诞生了  
      }  
}  

女娲就是这么把人造出来的……这就是工厂模式！

3.工厂模式的扩展

3.1 静态工厂模式

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

 
    [java] 
    view plain
    copy

     
    
     
   
public class HumanFactory {  
  
    @Override  
    public static <T extends Human> T createHuman(Class<T> clazz) {  
        Human human = null;  
        try {  
            human = (Product) Class.forName(clazz.getName()).newInstance();  
        } catch (Exception e) { //异常处理  
            System.out.println("人种产生错误");  
        }  
        return (T) human;  
    }  
}  

然后女娲造人的时候就不用new什么八卦炉了，直接用HumanFactory类调用就行了：

 
    [java] 
    view plain
    copy

Human blackMan = HumanFactory.createHuman(BlackHuman.class);

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

3.2 多个工厂模式

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

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

 
    [java] 
    view plain
    copy

public abstract class AbstractHumanFactory {  
    public abstract Human createHuman();  
}

注意抽象方法中已经不需要再传递相关类的参数了，因为每个具体的工厂都已经非常明确自己的职责：创建自己负责的产品类对象。所以不同的工厂实现自己的createHuman方法即可：

 
    [java] 
    view plain
    copy

     
    
     
   
public class BlackHumanFactory extends AbstractHumanFactory {  
    public Human createHuman() {  
        return new BlackHuman();  
    }  
}  
public class YellowHumanFactory extends AbstractHumanFactory {  
    public Human createHuman() {  
        return new YellowHuman();  
    }  
}  
public class WhiteHumanFactory extends AbstractHumanFactory {  
    public Human createHuman() {  
        return new WhiteHuman();  
    }  
}  

这样三个不同的工厂就产生了，每个工厂对应只生产自己对应的人种。所以现在女娲造人就可以不用一个八卦炉了，分工协作，各不影响了！

 
    [java] 
    view plain
    copy

     
    
     
   
public class FactoryTest {  
    public static void main(String[] args) {  
        Human blackMan = new BlackHumanFactory().createHuman(); //黑人诞生了  
        Human yellowMan = new YellowHumanFactory().createHuman(); //黄人诞生了  
        Human whiteMan = new WhiteHumanFactory().createHuman(); //白人诞生了  
      }  
}  

这种工厂模式的好处是职责清晰，结构简单，但是给扩扩展性和可维护性带来了一定的影响，因为如果要扩展一个产品类，就需要建立一个相应的工厂类，这样就增加了扩展的难度。因为工厂类和产品类的数量是相同的，维护时也需要考虑两个对象之间的关系。但是这种模式还是很常用的。

3.3 替代单例模式

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

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

 
    [java] 
    view plain
    copy

public class Singleton {  
    private Singleton() {  
          
    }  
    public void doSomething() {  
        //业务处理  
    }  
}

既然Singleton不能通过正常的渠道建立一个对象，那SingletonFactory如何建立一个单例对象呢？答案是通过反射方式创建：

 
    [java] 
    view plain
    copy

     
    
     
   
public class SingletonFactory {  
    private static Singleton instance;  
    static {  
        try {         
            Class clazz = Class.forName(Singleton.class.getName());  
            //获取无参构造方法  
            Constructor constructor = clazz.getDeclaredConstructor();  
            //设置无参构造方法可访问  
            constructor.setAccessible(true);  
            //产生一个实例对象  
            instance = (Singleton) constructor.newInstance();  
        } catch (Exception e) {  
            //异常处理  
        }  
    }  
    public static Singleton getInstance() {  
        return instance;  
    }  
}  

以上通过工厂方法模式创建了一个单例对象，该框架可以继续扩展，在一个项目中可以产生一个单例构造器，所有需要产生单例的类都遵循一定的规则（构造方法是private），然后通过扩展该框架，只要输入一个类型就可以获得唯一的一个实例。

3.4 延迟初始化

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

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

 
    [java] 
    view plain
    copy

     
    
     
   
public class ProductFactory {  
    private static final Map<String, Product> prMap = new HashMap();  
    public static synchronized Product createProduct(String type) throws Exception {  
        Product product = null;  
        //如果Map中已经有这个对象  
        if(prMap.containsKey(type)) {  
            product = prMap.get(type);  
        } else {  
            if(type.equals("Product1")) {  
                product = new ConcreteProduct1();  
            }  
            else {  
                product = new ConcreteProduct2();  
            }  
            prMap.put(type, product);  
        }  
        return product;  
    }  
}  

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

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

4. 工厂模式的应用

优点：

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

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

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

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

_____________________________________________________________________________________________________________________________________________________

-----乐于分享，共同进步！

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

【java设计模式】之工厂（Factory）模式

1.工厂模式的定义

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

3.工厂模式的扩展

3.1 静态工厂模式

3.2 多个工厂模式

3.3 替代单例模式

3.4 延迟初始化

4. 工厂模式的应用

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【java设计模式】之 工厂（Factory）模式

1.工厂模式的定义

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

3.工厂模式的扩展

3.1 静态工厂模式

3.2 多个工厂模式

3.3 替代单例模式

3.4 延迟初始化

4. 工厂模式的应用

热门文章

最新文章

相关课程

相关电子书

相关实验场景

【java设计模式】之工厂（Factory）模式