研磨设计模式之简单工厂模式-2

2  解决方案

1  简单工厂来解决

        用来解决上述问题的一个合理的解决方案就是简单工厂，那么什么是简单工厂呢？

1：简单工厂定义

2：应用简单工厂来解决的思路

分析上面的问题，虽然不能让模块外部知道模块内的具体实现，但是模块内部是可以知道实现类的，而且创建接口是需要具体实现类的。

那么干脆在模块内部新建一个类，在这个类里面来创建接口，然后把创建好的接口返回给客户端，这样外部应用就只需要根据这个类来获取相应的接口对象，然后就可以操作接口定义的方法了。把这样的对象称为简单工厂，就叫Factory吧。

这样一来，客户端就可以通过这个Factory来获取需要的接口对象，然后调用接口的方法来实现需要的功能，而且客户端也不用再关心具体实现了。

2.2简单工厂结构和说明

        简单工厂的结构如图5所示：

Api：

定义客户所需要的功能接口

Impl：

具体实现Api的实现类，可能会有多个

Factory：

工厂，选择合适的实现类来创建Api接口对象

Client：

客户端，通过Factory去获取Api接口对象，然后面向Api接口编程

（1）先看看Api的定义，示例代码如下：

/** 
 * 接口的定义，该接口可以通过简单工厂来创建 
 */  
public interface Api {  
    /** 
     * 示意，具体的功能方法的定义 
     * @param s 示意，需要的参数 
     */  
    public void operation(String s);  
}  

 （2）定义了接口，该来实现它了，ImplA的示例代码如下：

/** 
 * 接口的具体实现对象A  
 */  
public class ImplA implements Api{  
    public void operation(String s) {  
        //实现功能的代码，示意一下  
        System.out.println("ImplA s=="+s);  
    }  
}  

 ImplB的示意实现和ImplA基本一样，示例代码如下：

/** 
 * 接口的具体实现对象B  
 */  
public class ImplB implements Api{  
    public void operation(String s) {  
        //实现功能的代码，示意一下  
        System.out.println("ImplB s=="+s);  
    }  
}  

 （3）该来看看简单工厂的实现，示例代码如下：

/** 
 * 工厂类，用来创造Api对象 
 */  
public class Factory {  
    /** 
     * 具体的创造Api对象的方法 
     * @param condition 示意，从外部传入的选择条件 
     * @return 创造好的Api对象 
     */  
    public static Api createApi(int condition){  
        //应该根据某些条件去选择究竟创建哪一个具体的实现对象，  
        //这些条件可以从外部传入，也可以从其它途径获取。  
        //如果只有一个实现，可以省略条件，因为没有选择的必要。  
  
        //示意使用条件  
        Api api = null;  
        if(condition == 1){  
            api = new ImplA();  
        }else if(condition == 2){  
            api = new ImplB();  
        }  
        return api;  
    }  
}  

 （4）再来看看客户端的示意，示例代码如下：

/** 
 * 客户端，使用Api接口 
 */  
public class Client {  
    public static void main(String[] args) {  
        //通过简单工厂来获取接口对象  
        Api api = Factory.createApi(1);  
        api.operation("正在使用简单工厂");  
    }  
}  

2.4  使用简单工厂重写示例 

        要使用简单工厂来重写前面的示例，主要就是要创建一个简单工厂对象，让简单工厂来负责创建接口对象。然后让客户端通过工厂来获取接口对象，而不再由客户端自己去创建接口的对象了。        此时系统的结构如图6所示。

                      图6  使用简单工厂重写示例的结构示意图

 （1）接口Api和实现类Impl都和前面的示例一样，就不去赘述了。（2）新创建一个简单工厂的对象，示例代码如下：

/** 
 * 工厂类，用来创造Api对象 
 */  
public class Factory {  
    /** 
     * 具体的创造Api对象的方法 
     * @return 创造好的Api对象 
     */  
    public static Api createApi(){  
        //由于只有一个实现，就不用条件判断了  
        return new Impl();  
    }  
}  

（3）使用简单工厂         客户端如何使用简单工厂提供的功能呢？这个时候，客户端就不用再自己去创建接口的对象了，应该使用工厂来获取，经过改造，客户端代码如下：

/** 
* 客户端：测试使用Api接口 
*/  
public class Client {  
    public static void main(String[] args) {  
        //重要改变，没有new Impl()了，取而代之Factory.createApi()  
Api api = Factory.createApi();  
        api.test1("哈哈，不要紧张，只是个测试而已！");  
    }  
}  

         就如同上面的示例，客户端通过简单工厂创建了一个实现接口的对象，然后面向接口编程，从客户端来看，它根本就不知道具体的实现是什么，也不知道是如何实现的，它只知道通过工厂获得了一个接口对象，然后就能通过这个接口来获取想要的功能。         事实上，简单工厂能帮助我们真正开始面向接口编程，像以前的做法，其实只是用到了接口的多态那部分的功能，最重要的“封装隔离性”并没有体现出来。