设计模式 -- 简单工厂模式

写在前面的话：读书破万卷，编码如有神
--------------------------------------------------------------------
主要内容包括：

1. 初识简单工厂模式，包括: 定义、结构
2. 体会简单工厂模式，包括: 场景问题、不用模式的解决方案、使用模式的解决方案
3. 理解简单工厂模式，包括: 典型疑问、认识简单工厂、简单工厂中方法的写法、可配置的简单工厂、简单工厂的优缺点
4. 思考简单工厂模式，包括: 简单工厂的本质、何时选用

参考内容：

1、《研磨设计模式》 一书，作者：陈臣、王斌

--------------------------------------------------------------------

1、初识简单工厂                                                                  　　

1.1、定义

　　提供一个创建对象实例的功能，而无须关心具体的实现。被创建的实例的类型可以是接口、抽象类，也可以是具体的类。

1.2、结构和说明

　　

说明:

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

--------------------------------------------------------------------

2、体会简单工厂模式                                                             

2.1、接口回顾

（1）Java中接口的概念

　　在Java中接口是一种特殊的抽象类，跟一般的抽象类相比，接口里面的所有方法都是抽象的，接口里面的所属属性都是常量。也就是说，接口里面只有方法定义而没有方法的实现。

（2）接口用来干什么

　　通常用接口来定义实现类的外观，也就是实现类的行为定义，用来约束实现类的行为，接口相当于一份契约，根据外部应用需要的功能，约定了实现类应该要实现的功能。

（3）接口的思想

　　根据接口的作用和用途，可以总结为 “封装隔离”。 通常提到的封装是指对数据的封装，但是这里的封装是指"对被隔离体的行为的封装"，或者是"对被隔离体的职责的封装"，而隔离指的是外部调用和内部实现，外部调用只能通过接口进行调用，外部调用是不知道内部具体实现的，也就是说外部调用和内部实现是被接口隔离开的。

（4）使用接口的好处

　　只要接口不变，内部实现的变化就不会影响到外部应用，从而使得系统更灵活，具有更好的扩展性和可维护性。

（5）接口和抽象类的选择

　　a. 优先选用接口

　　b. 在既要定义子类的行为，又要为子类提供公共的功能时应该选用抽象类

2.2、面向接口编程

面向接口编程是Java编程中一个重要规则，在Java程序设计里面，非常讲究层的划分和模块的划分。比如场景的三层结构：

在一个层内部的各个模块交互也要通过接口

既然在Java中需要面向接口编程，那么在程序中到底该如何使用接口，来做到真正的面向接口编程呢?

比如目前有接口: Api , 实现类: ImplA、ImplB  客户端:Client

画一个简单的类图:

2.3、不用模式的解决方案

(1)首先是接口的定义Api,如下：
/**
 * 某个接口（通用的、抽象的、非具体的功能）
 * @author Administrator
 *
 */
public interface Api {
    /**
     * 某个具体的方法定义
     * @param msg
     */
    public void operation(String msg);
}
(2)具体的实现类ImplA,如下:
/**
 * 具体的实现类A
 * @author Administrator
 *
 */
public class ImplA implements Api {

    @Override
    public void operation(String msg) {
        System.out.println("ImplA  , msg = " + msg);
    }
}
(3)具体的实现类ImplB,如下:
/**
 * 具体的实现类B
 * @author Administrator
 *
 */
public class ImplB implements Api {

    @Override
    public void operation(String msg) {
        System.out.println("ImplB  , msg = " + msg);
    }
}
(4)客户端,如下:
/**
 * 客户端
 * @author Administrator
 *
 */
public class Client {
    public static void main(String[] args) {
        Api api = new ImplA();
        api.operation("哈哈，嘻嘻");
        
        System.out.println("------------------");
        api = new ImplB();
        api.operation("嘿嘿，嘎嘎");
    }
}

运行结果:
ImplA , msg = 哈哈，嘻嘻
------------------
ImplB  , msg = 嘿嘿，嘎嘎

2.4、有何问题

重点看看客户端代码中的下面两行:

Api api = new ImplA();
api = new ImplB();

我们会发现在客户端调用的时候，客户端不但知道了接口，而且还知道具体的实现类:ImplA、ImplB。接口的思想是"封装隔离"，而实现类ImplA、ImplB应该是被接口Api封装并同客户端隔离开的，换句话说， 客户端根本就不应该知道具体的实现是ImplA、ImplB。

把这个问题描述一下：在Java编程中，出现只知接口而不知实现，该肿么办？

2.5、使用简单工厂来解决问题

/**
 * 某个接口（通用的、抽象的、非具体的功能）
 * @author Administrator
 *
 */
public interface Api {
    /**
     * 某个具体的方法定义
     * @param msg
     */
    public void operation(String msg);
}

/**
 * 具体的实现类A
 * @author Administrator
 *
 */
public class ImplA implements Api {

    @Override
    public void operation(String msg) {
        System.out.println("ImplA  , msg = " + msg);
    }
}

/**
 * 具体的实现类B
 * @author Administrator
 *
 */
public class ImplB implements Api {

    @Override
    public void operation(String msg) {
        System.out.println("ImplB  , msg = " + msg);
    }
}

/**
 * 工厂类，用来创建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;
    }
}

/**
 * 客户端
 * @author Administrator
 *
 */
public class Client {
    public static void main(String[] args) {
        //重要改变，没有new Impl()了，取而代之Factory.createApi();
        Api api = Factory.createApi(1);
        api.operation("哈哈，嘻嘻");
        
        System.out.println("------------------");
        api = Factory.createApi(2);
        api.operation("嘿嘿，嘎嘎");
    }
}

运行结果:
ImplA  , msg = 哈哈，嘻嘻
------------------
ImplB  , msg = 嘿嘿，嘎嘎

--------------------------------------------------------------------

3、理解简单工厂                                                                  

3.1、典型疑问

　　可能会有人认为，上面示例中的简单工厂看起来不就是把客户端里面的"new ImplA()、new ImplB()"移动到简单工厂里面吗？ 不还是一样通过new一个实现类来得到接口吗? 把"new ImplA()、new ImplB()"放到客户端和放到简单工厂里面有什么不同吗?

ps: 理解这个问题的重点就在于理解简单工厂所处的位置。

简单工厂的位置是位于封装体内的，也就是简单工厂是跟接口和具体的实现在一起的，算是封装体内部的一类，所以简单工厂知道具体的实现类是没有关系的。重新整理一下简单工厂的结构图，如下图所示：

3.2、认识简单工厂

（1）简单工厂模式的功能

　　可以用来创建的接口、抽象类或者是普通类的实例。

（2）静态工厂

　　通常把简单工厂类实现成一个工具类，直接使用静态方法就可以了，也就是说简单工厂的方法通常都是静态的，所以也称为静态工厂。

（3）万能工厂

　　一个简单工厂可以包含很多用来构造东西的方法，这些方法可以创建不同的接口、抽象类或者是类实例。一个简单工厂理论上可以构造任何东西。所以又称之为“万能工厂”

（4）简单工厂创建对象的范围

　　虽然从理论上将，简单工厂什么都能创建，但对于简单工厂可创建对象的范围，通常不要太大，最好是控制在一个独立的组件级别或者一个模块级别。

（5）简单工厂的调用顺序示意图

3.3、简单工厂中方法的写法

　　仔细分析会发现，简单工厂方法的内部主要实现的功能是"选择合适的实现类"来创建实例对象，既然要实现选择，那么就需要选择的条件或者是选择的参数，选择条件或者是参数的来源通常有以下几种：

1. 来源于客户端，由Client来传入参数
2. 来源于配置文件，从配置文件获取用于判断的值
3. 来源于程序运行期间的某个值，比如从缓存中获取某个运行期的值

3.4、可配置的简单工厂

通过配置文件的方式来实现简单工厂

/**
 * 某个接口（通用的、抽象的、非具体的功能）
 * @author Administrator
 *
 */
public interface Api {
    /**
     * 某个具体的方法定义
     * @param msg
     */
    public void operation(String msg);
}


/**
 * 具体的实现类A
 * @author Administrator
 *
 */
public class ImplA implements Api {

    @Override
    public void operation(String msg) {
        System.out.println("ImplA  , msg = " + msg);
    }
}

/**
 * 具体的实现类B
 * @author Administrator
 *
 */
public class ImplB implements Api {

    @Override
    public void operation(String msg) {
        System.out.println("ImplB  , msg = " + msg);
    }
}


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

/**
 * 工厂类，用来创建Api对象
 */
public class Factory {

    /**
     * 具体创建Api对象的方法,根据配置文件的参数来创建接口
     * @return
     */
    public static Api createApi(){
        //直接读取配置文件来获取需要创建实例的类
        Properties p = new Properties();
        InputStream in = null;
        try{
            in = Factory.class.getResourceAsStream("factory.properties");
            p.load(in);
        }catch(IOException e){
            System.out.println("找不到配置文件!");
            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) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return api;
    }
}

/**
 * 客户端
 * @author Administrator
 *
 */
public class Client {
    public static void main(String[] args) {
        //重要改变，没有new Impl()了，取而代之Factory.createApi();
        Api api = Factory.createApi();
        api.operation("哈哈，嘻嘻");
    }
}

配置文件factory.properties
ImplClass=Factory.ImplA


运行结果:
ImplA  , msg = 哈哈，嘻嘻

--------------------------------------------------------------------

4、思考简单工厂模式                                                                   

4.1、简单工厂模式的本质：选择实现

4.2、简单工厂的优缺点

优点:

1. 帮助封装
2. 解耦

缺点:

1. 可能增加客户端使用的复杂度
2. 不方便扩展子工厂

4.3、何时选用简单工厂 

1. 如果想要完全封装隔离具体的实现，让让外部只能通过接口来操作封装体，那么可以选用简单工厂，让客户端通过工厂来获取相应的接口，而无须关系具体的实现
2. 如果想要把对外创建对象的职责集合管理和控制，可以选用简单工厂，一个简单工厂可以创建很多的、不相关的对象，可以把对外创建对象的职责集中到一个工厂来，从而实现集中管理和控制