创建型模式之--简单工厂模式+工厂方法模式

1、女蜗造人

女蜗通过八卦炉烧制三种不同的人种。
对造人过程进行分析，该过程设计三个对象：女蜗、八卦炉、三种不同肤色的人。

• 女蜗：可以使用场景类表示，负者模拟场景，执行相关任务。
• 八卦炉：类似工厂，负者制造产品（三种人）。
• 三种人：他们都是同一接口下的不同实现类，是八卦炉的产品。

类图：
AbstractHumanFactory是一个抽象类，定义了一个八卦炉具有的整体功能，HumanFactory为实现类，完成具体的任务——创建人类；
Human接口是人类的总称，其三个实现类分别为三类人种；
NvWa类是一个场景类，负责模拟这个场景，执行相关的任务。

人类的抽象类：

public interface Human {
    //每个人种的皮肤都有相应的颜色
    public void getColor();
    //人类会说话
    public void talk();
}

三种肤色的人，都实现Human接口：

public class BlackHuman implements Human {
    public void getColor(){
        System.out.println("黑色人种的皮肤颜色是黑色的！");
    }
    public void talk() {
        System.out.println("黑人会说话，一般人听不懂。");
    }
}

public class YellowHuman implements Human {
    public void getColor(){
        System.out.println("黄色人种的皮肤颜色是黄色的！");
    }
    public void talk() {
        System.out.println("黄色人种会说话，一般说的都是双字节。");
    }
}

public class WhiteHuman implements Human {
    public void getColor(){
        System.out.println("白色人种的皮肤颜色是白色的！");
    }
    public void talk() {
        System.out.println("白色人种会说话，一般都是但是单字节。");
    }
}

八卦炉（抽象人类创建工厂）：
女娲（调用者）只要告诉工厂，它需要什么三种肤色人就行了，工厂就应该生成一个相应类的对象传过去，所以 createHuman(Class c) 方法的参数的 Class 类型。

public abstract class AbstractHumanFactory {
    public abstract <T extends Human> T createHuman(Class<T> c);
}

注意，我们在这里采用了泛型（Generic），通过定义泛型对createHuman的输入参数产生两层限制：

• 必须是Class类型
• 必须是Human的实现类

目前女娲只有一个八卦炉，人类创建工厂，需要继承AbstractHumanFactory 抽象类：

public class HumanFactory extends AbstractHumanFactory {
    public <T extends Human> T createHuman(Class<T> c){
        //定义一个生产的人种
        Human human=null;
        try {
            //产生相应肤色的一个人种
            human = (T)Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("人种生成错误！");
        }
        return (T)human;
    }
}

女娲造人场景：

public class NvWa {
    public static void main(String[] args) {
        //声明阴阳八卦炉
        AbstractHumanFactory YinYangLu = new HumanFactory();

        //女娲第一次造人，火候不足，于是白人产生了
        System.out.println("--造出的第一批人是白色人种--");
        Human whiteHuman = YinYangLu.createHuman(WhiteHuman.class);
        whiteHuman.getColor();
        whiteHuman.talk();
        //女娲第二次造人，火候过足，于是黑人产生了
        System.out.println("\n--造出的第二批人是黑色人种--");
        Human blackHuman = YinYangLu.createHuman(BlackHuman.class);
        blackHuman.getColor();
        blackHuman.talk();
    }
}

2、工厂方法模式定义

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完成的。

代码：

抽象产品类：

public abstract class Product {
    //产品类的公共方法
    public void method1(){
        //业务逻辑处理
    }
    //抽象方法
    public abstract void method2();
}

具体的产品类可以有多个，都继承于抽象产品类：

public class ConcreteProduct1 extends Product {
    public void method2() {
        //业务逻辑处理
    }
}

public class ConcreteProduct2 extends Product {
    public void method2() {
        //业务逻辑处理
    }
}

抽象工厂类负责定义产品对象的产生：

public abstract class Creator {
    /*
    * 创建一个产品对象，其输入参数类型可以自行设置
    * 通常为String、Enum、Class等，当然也可以为空
    */
    public abstract <T extends Product> T createProduct(Class<T> c);
}

具体工厂类：

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

场景类的调用：

public class Client {
    public static void main(String[] args) {
        Creator creator = new ConcreteCreator();
        Product product = creator.createProduct(ConcreteProduct1.class);
        /*
        * 继续业务处理
        */
    }
}

3、工厂方法模式的应用

优点：

• 良好的封装性，代码结构清晰。调用者，只需要知道产品的类名，就可以通过工厂得到想要的类的对象，而不需要知道对象创建的过程。
• 扩展性优秀。当需要增加一个可生产的新产品的时候，只需要增加一个产品的实现类即可；当生产方式需要改变是，只需要增加一个工厂实现类即可。
• 屏蔽产品类。调用者只需关系调用接口，而不用关心产品类如何变化。如JDBC连接数据库，需要改动的只是切换数据库名称，而不用知道具体产品实现细节。
• 是典型的解耦框架。接口和实现分离。

使用场景：

• new 一个对象的替代品，但是增加代码复杂度。
• 需要灵活的、可扩展的框架时，可以考虑使用工厂方法模式。
• 用在异构项目中。

4、简单工厂模式

将工厂方法模式改为，只有一个工厂类（不用再抽象出一个父类），将工厂方法改为静态方法，通过工厂类类名直接调用。
该模式是工厂方法模式的弱化，因为调用更简单，所以称为简单工厂模式（Simple Factory Pattern），也叫做静态工厂模式。

女蜗造人类图如：

在女蜗造人中变更的源码仅仅是HumanFactory和NvWa类：

public class HumanFactory {
    public static <T extends Human> T createHuman(Class<T> c){
         //定义一个生产出的人种
        Human human=null;
        try {
            //产生一个人种
            human = (Human)Class.forName(c.getName()).newInstance();
        } catch (Exception e) {
            System.out.println("人种生成错误！");
        }
        return (T)human;
    }
}

public class NvWa {
    public static void main(String[] args) {
        //女娲第一次造人，火候不足，于是白色人种产生了
        System.out.println("--造出的第一批人是白色人种--");
        Human whiteHuman = HumanFactory.createHuman(WhiteHuman.class);//直接通过工厂类名调用
        whiteHuman.getColor();
        whiteHuman.talk();
        //女娲第二次造人，火候过足，于是黑色人种产生了
        System.out.println("\n--造出的第二批人是黑色人种--");
        Human blackHuman = HumanFactory.createHuman(BlackHuman.class);
        blackHuman.getColor();
        blackHuman.talk()
    }
}

5、多个工厂类的工厂方法模式

每个产品类的具体初始化方式不同（不仅仅是new，要设置不同的初始值），要为每个产品定义一个工厂的实现类，由调用者自己去选择与哪个工厂方法关联。

女蜗造人中，每个人种（具体的产品类）都对应了一个创建者，每个创建者都独立负责创建对应的产
品对象：

多工厂模式的抽象工厂类：

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

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

黑色人种的创建工厂实现：

public class BlackHumanFactory extends AbstractHumanFactory {
    public Human createHuman() {
        return new BlackHuman();
    }
}

黄色人种的创建工厂和白色人种的创建工厂 与此类似。

场景类NvWa修改后：

public class NvWa {
    public static void main(String[] args) {
        //女娲第一次造人，火候不足，于是白色人种产生了
        System.out.println("--造出的第一批人是白色人种--");
        Human whiteHuman = (new WhiteHumanFactory()).createHuman();
        whiteHuman.getColor();
        whiteHuman.talk();
        //女娲第二次造人，火候过足，于是黑色人种产生了
        System.out.println("\n--造出的第二批人是黑色人种--");
        Human blackHuman = (new BlackHumanFactory()).createHuman();
        blackHuman.getColor();
        blackHuman.talk();
    }
}

每一个产品类都对应了一个创建类，好处就是创建类的职责清晰，而且结构简单，但是给可扩展性和可维护性带来了一定的影响。为什么这么说呢？如果要扩展一个产品类，就需要建立一个相应的工厂类，这样就增加了扩展的难度。因为工厂类和产品类的数量相同，维护时需要考虑两个对象之间的关系。
当然，在复杂的应用中一般采用多工厂的方法，然后再增加一个协调类，避免调用者与各个子工厂交流，协调类的作用是封装子工厂类，对高层模块提供统一的访问接口。

6、替代单例模式

简单工厂模式或工厂方法模式也可以实现单例模式的功能。单例模式的核心要求就是在内存中只有一个对象，通过工厂方法模式也可以只在内存中生产一个对象。

单例类：

public class Singleton {
    //不允许通过new产生一个对象
    private Singleton(){
    }
    public void doSomething(){
    //业务处理
    }
}

Singleton保证不能通过正常的渠道建立一个对象，那SingletonFactory如何建立一个单例对象呢？答案是通过反射方式创建（感觉 强行被实例化了）：
在 静态代码块中 实例化，在类的初始化的时候就 单例对象就产生了，相当于饿汉式，获取对象时速度快。

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

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

7、延迟初始化

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

延迟加载的工厂类：

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容器，容纳所有产生的对象，如果在Map容器中已经有的对象，则直接取出返回；如果没有，则根据需要的类型产生一个对象并放入到Map容器中，以方便下次调用。

延迟加载框架是可以扩展的，例如限制某一个产品类的最大实例化数量，可以通过判断Map中已有的对象数量来实现，这样的处理是非常有意义的，例如JDBC连接数据库，都会要求设置一个MaxConnections最大连接数量，该数量就是内存中最大实例化的数量。

延迟加载还可以用在对象初始化比较复杂的情况下，例如硬件访问，涉及多方面的交互，则可以通过延迟加载降低对象的产生和销毁带来的复杂性。

参考资料：
【1】《设计模式之禅》-秦小波