30分钟学透设计模式4-最简单的面向接口编程-简单工厂模式

设计模式系列：
30分钟学透设计模式1-单例模式的前世今生
 30分钟学透设计模式2-随处可见的Builder模式
 30分钟学透设计模式3-使用最多的Iterator模式
 30分钟学透设计模式4-最简单的面向接口编程-简单工厂模式
 30分钟学透设计模式5-从代理模式到AOP

一、概述

1、定义

简单工厂：提供一个创建对象实例的功能，而无需关心其具体实现。被创建实例的类型可以是接口、抽象类或具体的实现类。

通俗地讲，需要创建的对象叫做产品，创建对象的地方叫做工厂，你只管使用产品，不用想它是怎么生产出来的。

2、模式构成

Factory： 工厂角色，负责实现创建所有实例的内部逻辑
Product： 抽象产品角色，是所创建的所有对象的父类，负责描述所有实例所共有的公共接口
ConcreteProduct： 具体实现Product接口的实现类，可能会有多个

简单的说，Factory可以理解为富士康，Product为手机。具体的ConcreteProduct可以是苹果、小米等等。
用户只管从“工厂”买手机，然后使用手机，不需要关心手机是怎么组装起来的。

二、实现一个简单工厂

1、定义一个接口类：Phone

public interface Phone {
    void call(String s);
}

2、定义一个类Impl，用来实现接口Phone

public class Impl implements Phone {
    public void call(String s) {
        System.out.println("impl call: " + s);
    }
}

接口有了，实现类有了，我们通常是怎么用的呢？

Phone p = new Impl();

但是，这样使用者需要提前知道具体实现类impl，接口和实现类并没有解耦。我们只需在二者中间加个工厂即可。

3、定义一个工厂类Factory，其内部用来调用Impl

public class Factory {
    public static Phone createPhone() {
        return new Impl();
    }
}

至此，简单工厂的三大角色凑齐了，可以召唤神龙了。我们来看看怎么使用呢？

4、实现一个测试类，用来使用简单工厂

public class Client {
    public static void main(String[] args) {
        Phone phone = Factory.createPhone();
        phone.call("hello world");
    }
}

三、模式分析

简单工厂的本质可以理解为客户端对实现类的选择实现，只是这种选择被工厂类所持有，但具体的实现逻辑仍由实现类实现。
把创建和对象业务处理分离，可以降低系统耦合度，使两者的修改都相对容易
Factory它是一个具体的类，非接口或者抽象类。有一个重要的create()方法。如果生产不同的手机，需要利用if或者 switch创建产品并返回。
create()方法通常是静态的，所以也称之为静态工厂。

1、模式优缺点

优点：
封装与解耦：简单工厂通过封装组件，使得外部可以通过接口进行访问。并且实现了客户端和实现类的解耦。
缺点：增加了系统的复杂度和代码的可阅读性。

2、模式使用场景

解耦：如果想要完全封装实现类，让外部只能通过接口来操作，则可以选用简单工厂。客户端只需通过工厂来调用相关接口，而无需关心具体实现。
统一管理：把对外创建对象的职责集中管理，可以选用简单工厂。一个简单工厂可以创建很多的、不相关的对象，从而实现集中管理和控制。简单的理解，如果一个对象不能直接使用new来创建，其中的构造参数过于复杂，则可以考虑简单工厂。

四、简单工厂的其他实现

1、升级多种实现类

上面的例子中我们的Factory只提供了一种类的实现，这在使用当中是很少遇到的。如果Factory需要提供多种实现类的话，常见的做法是什么呢？

public static Phone createPhone(int type) {
    if (type == 1) {
        return new Impl();
    } else if (type == 2) {
        return new Impl1();
    } else {
        return null;
    }
 }

因此，可以通过一些判断来选择工厂返回的实现类。

2、通过反射选择工厂实现类

前面说到的，通过类型选择工厂的实现类，过于死板。Client需要提前知道每种类型的对应的实现类，并且增加新的实现类时，需要修改工厂代码。我们可以通过反射将ClassName 传递给Factory。

public static <T extends Phone> T createPhone(Class<T> clz) throws Exception {
    return (T) Class.forName(clz.getName()).newInstance();
}

其客户端使用方式：

Phone phone = Factory.createPhone(Impl.class);
phone.call("hello world");

不幸的的是，针对含有参数的构造，这两种方法似乎不是那么友好。

3、多方法式工厂

顾名思义，这种方式是工厂种含有多个构造方法。每个方法对应不同的实现类。看上去，很简单，我们以线程池的Executors为例，看看这种方式。

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>(),
                                    threadFactory));
    }

这种方法的好处是：工厂为不同的产品提供不同的生产方法。使用时需要哪个则调用哪个。简单上手。

那上面的例子我们同样可以改成这种：

    public static Phone createPhone() {
        return new Impl();
    }

    public static Phone createPhone1() {
        return new Impl1();
    }