设计模式之简单工厂(Factory method)

1.参考文献：

http://chjavach.iteye.com/blog/800325

2.解析

在java编程中，我们要做到“面向接口编程”。下面回顾一些接口方面的知识：

（1）Java中接口的概念
　　在Java中接口是一种特殊的抽象类，跟一般的抽象类相比，接口里面的所有方法都是抽象方法（也因此，接口中的方法可以加abstract，也可以不加），接口里面的所有属性都是常量。也就是说，接口里面是只有方法定义而不会有任何方法实现。
（2）接口用来干什么
　　通常用接口来定义实现类的外观，也就是实现类的行为定义，用来约束实现类的行为。接口就相当于一份契约，根据外部应用需要的功能，约定了实现类应该要实现的功能，但是具体的实现类除了实现接口约定的功能外，还可以根据需要实现一些其它的功能，这是允许的，也就是说实现类的功能包含但不仅限于接口约束的功能。通过使用接口，可以实现不相关类的相同行为，而不需考虑这些类之间的层次关系，接口就是实现类对外的外观。
（3）接口的思想
　　根据接口的作用和用途，浓缩下来，接口的思想就是“封装隔离”。通常提到封装是指对数据的封装，但是这里的封装是指“对被隔离体的行为的封装”，或者是“对被隔离体的职责的封装”；而隔离指的是外部调用和内部实现，外部调用只能通过接口进行调用，而外部调用是不知道内部具体实现的，也就是说外部调用和内部实现是被接口隔离开的。
（4）使用接口的好处
　　由于外部调用和内部实现被接口隔离开了，那么只要接口不变，内部实现的变化就不会影响到外部应用，从而使得系统更灵活，具有更好的扩展性和可维护性，这也就是所谓“接口是系统可插拔性的保证”这句话的意思。
（5）接口和抽象类的选择
　　既然接口是一种特殊的抽象类，那么在开发中，何时选用接口，何时选用抽象类呢？对于它们的选择，在开发中是一个很重要的问题，特别总结两句话给大家：

• 优先选用接口
• 在如下情况应选择抽象类：既要定义子类的行为，又要为子类提供公共的功能。（可以参考博客：Java 接口和抽象类区别，里面有详细在讲述）。

3.实例

下面列举一个简单的面向接口编程的例子。

假设有一个接口叫Api，然后有一个实现类Impl实现了它，在客户端创建一个Impl的实例，把它赋值给一个Api接口类型的变量，然后客户端就可以通过这个变量来操作接口的功能了，此时具体的结构图如下图：

4.代码示例

首先定义接口Api

package edu.sjtu.erplab.yanmo.simplefactory;
public interface Api {
    public void print(String s);
}

然后定义接口的实现Impl

package edu.sjtu.erplab.yanmo.simplefactory;

public class Impl implements Api {

    @Override
    public void print(String s) {
        // TODO Auto-generated method stub
        System.out.println("this is in Impl:"+s);
    }
}

最后定义客户端Client

package edu.sjtu.erplab.yanmo.simplefactory;

public class Client {
    public static void main(String[] args) {
        //将Impl的实例赋值给Api接口类型的变量，然后客户端就可以使用Api接口类型的变量操作接口的功能。  
        Api api=new Impl();
        api.print("abc");
    }
}

上述面向接口编程的例子存在一些问题：

客户端不但知道了接口，同时还知道了具体的实现就是Impl。而接口的思想是“封装隔离”，那么Impl这个具体实现类，就应该是被接口Api封装并同客户端隔离开的，也就是说，客户端根本就不应该知道具体的实现类是Impl（也就是在Client中就不应该出现Impl）。那么应该如何解决这个问题呢？这就是下面需要将的工厂模式来实现。

5.简单工厂

5.1简单工厂定义：

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

5.2简单工厂结构：

Api： 定义客户所需要的功能接口
Impl：具体实现Api的实现类，可能会有多个
Factory：工厂，选择合适的实现类来创建Api接口对象
Client：客户端，通过Factory去获取Api接口对象，然后面向Api接口编程

6.传入参数的简单工厂代码实例

Api和Impl的实现如上面的代码实例，保持不变，下面给出Impl2、Factory和Client的实现

Impl2.java

package edu.sjtu.erplab.yanmo.simplefactory;

public class Impl2 implements Api {

    @Override
    public void print(String s) {
        System.out.println("this is in Impl2:"+s);
    }
}

Factory.java

package edu.sjtu.erplab.yanmo.simplefactory;

public class Factory {
    public static Api createApi(int type)
    {
        Api api=null;
        if(type==1)
            api=new Impl();
        else if(type==2)
            api=new Impl2();
        return api;
    }
}

Client.java

package edu.sjtu.erplab.yanmo.simplefactory;

public class Client {

    public static void main(String[] args) {
        //将Impl的实例赋值给Api接口类型的变量，然后客户端就可以使用Api接口类型的变量操作接口的功能。  
//        Api api=new Impl();
//        api.print("abc");
        //传入参数决定需要创建什么类型的Api实现
        Api api=Factory.createApi(1);
        api.print("abc");
    }
}

简单工厂分析

　　为什么将new Impl()放在工厂类里面就算是封装完全了呢。这是因为工厂类是存在于模块内部的。接口是用来封装隔离具体的实现的，目标就是不要让客户端知道封装体内部的具体实现。简单工厂的位置是位于封装体内的，也就是简单工厂是跟接口和具体的实现在一起的，算是封装体内部的一个类，所以简单工厂知道具体的实现类是没有关系的。整理一下简单工厂的结构图，如图所示：

图中虚线框，就好比是一个组件的包装边界，表示接口、实现类和工厂类组合成了一个组件，在这个封装体里面，只有接口和工厂是对外的，也就是让外部知道并使用的，所以故意漏了一些在虚线框外，而具体的实现类是不对外的，被完全包含在虚线框内。对于客户端而言，只是知道了接口Api和简单工厂Factory，通过Factory就可以获得Api了，这样就达到了让Client在不知道具体实现类的情况下获取接口Api。所以看似简单的把“new Impl()”这句话从客户端里面移动到了简单工厂里面，其实是有了质的变化的。

　　虽然说简单工厂的方法多是用来造接口的，但是仔细分析就会发现，真正能实现功能的是具体的实现类，这些实现类（Impl和Impl2这里两个类）是已经做好的，并不是真的靠简单工厂来创造出来的，简单工厂的方法无外乎就是：实现了选择一个合适的实现类来使用。所以简单工厂方法的内部主要实现的功能是“选择合适的实现类”来创建实例对象。既然要实现选择，那么就需要选择的条件或者是选择的参数，选择条件或者是参数的来源通常又有几种：

1. 来源于客户端，由Client来传入参数。上面的实例中的参数内容1跟2就是来自于客户端。
2. 来源于配置文件，从配置文件获取用于判断的值。
3. 来源于程序运行期的某个值，比如从缓存中获取某个运行期的值。

7.可配置的简单工厂实例

Api和Impl与实例6没有变化，只是Factory发生了变化，新的Factory1如下所示：

package edu.sjtu.erplab.yanmo.simplefactory;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

//可配置工厂
public class Factory1 {
    public static Api createApi(){
        Properties p=new Properties();//配置文件
        InputStream in=null;//输入流
        try{
            //Finds a resource with a given name
            in=Factory1.class.getResourceAsStream("FactoryTest.properties");//从此类所在的包下取资源
            //Finds a resource with a given name
            p.load(in);//从输入流中加载配置文件
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try{
                in.close();
            }catch(IOException e){
                e.printStackTrace();
            }
        }
        //使用反射创建对象实例
        Api api=null;
        try{
            //根据配置文件中的内容来创建一个实例
            api=(Api)Class.forName(p.getProperty("ImplClass")).newInstance();
        }catch(InstantiationException e){
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return api;
    }

}

在Factory1的相同目录下创建一个配置文件，命名为：FactoryTest.properties。配置文件内容如下：

ImplClass=edu.sjtu.erplab.yanmo.simplefactory.Impl2

Client发生了一些小变换，不在需要传入参数，Client的代码实现如下：

package edu.sjtu.erplab.yanmo.simplefactory;

public class Client1 {
    public static void main(String[] args) {
        Api api=Factory1.createApi();
        api.print("12312");
    }
}