引言

前一篇文章总结了Builder建造者模式，在面对构造复杂对象的时候尤其是需要统一管理装配流程的时候，不失为一种良好的选择，但绝不会是唯一的选择，很多时候都应该结合实际的业务来选择对应的模式和结构，这篇文章讲述的就是另一种创建型设计模式——工厂方法模式Factory Method。

一、工厂模式概述

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。工厂模式专门负责将大量有共同接口的类实例化，工厂模式可以动态决定将哪一个类实例化，不必事先知道每次要实例化哪一个类。 工厂模式有三种形态：Simple Factory简单工厂模式、Factory Method工厂方法模式、Abstract Factory抽象工厂模式，前两者是类的创建模式，后者是对象的创建模式，这三种模式从上到下逐步抽象，并且更具一般性。（GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式与抽象工厂模式，将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。）

二、简单工厂模式

简单工厂（又被称为静态工厂）模式是最简单的工厂模式主要用于生产同一等级结构中的任意产品或者方案，但对于增加新的产品，就要修改原工厂类，符合单一职责原则，不符合开放-封闭原则。简单工厂模式是由一个工厂类根据传入的参量决定创建出哪一种产品类的实例，涉及工厂角色(Factory )、抽象产品(Product)角色及具体产品(Concrete Product)角色等三个角色。

这里写图片描述
以生产产品A、B、C为例，使用简单工厂模式实现：

1、抽象同一等级系列的产品共性，定义接口创建Product角色

package factory;
//也可以定义为抽象类。
public interface IProduct {
    void setLevel(String level);
}

2、实现接口创建具体的产品实体类

package factory;
public class ProductA implements IProduct {
    public void setLevel(String level) {
        ... 
    }
}

package factory;
public class ProductB implements IProduct {
    public void setLevel(String level) {
        ...
    }
}

package factory;

public class ProductC implements IProduct {

    public void setLevel(String level) {
        ...
    }
}

3、定义工厂角色，承担生产产品的角色

public class Factory {
    private static final String TYPE_A="a";
    private static final String TYPE_B="b";
    private static final String TYPE_C="c";
    
    public static IProduct create(String type){
        IProduct product=null;
        if(TYPE_A.equals(type)){
            product=new ProductA();
        }else if(TYPE_B.equals(type)){
            product=new ProductB();
        }else if(TYPE_C.equals(type)){
            product=new ProductC();
        }
        return product;
    }
}

测试

public class FactoryMain {
    public static void main(String[] args) {
        IProduct productA=Factory.create("a");//通过工厂创建产品A
        IProduct productB=Factory.create("b");//通过工作创建产品B
    }
}

使用简单工厂模式的时候，一般可以把工厂类当做是一个工具类，所以可以把方法设置为静态方法，工厂类本身构造方法可以设置为私有的防止不必要的调用，因此简单工厂模式又被叫为静态工厂。

三、工厂方法模式

工厂方法模式也是定义一个用于创建对象的接口，让子类决定实例化哪一个类且使一个类的实例化延迟到其子类，其实工厂方法模式是简单工厂模式的进一步抽象和推广，其基本思想是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。

这里写图片描述
还是以创建一产品系下的低等、中等、高等产品为例。

1、抽象同一等级系列的产品共性，定义接口创建IProduct角色

package factory;
//也可以定义为抽象类。
public interface IProduct {
    ...
}

2、实现接口创建具体的产品实体类

package factory;
public class ProductLow implements IProduct {
    ...
}

public class ProductMid implements IProduct {
    ...
}

3、定义抽象工厂和具体的工厂并继承抽象工厂承担实际生产产品的角色

//抽象工厂
public abstract class AbstractFactory{
    public abstract IProduct manufacture();
}

public class FactoryLow extends AbstractFactory{
    public IProduct manufacture(){
        return new ProductLow();
    }
}

public class FactoryMid extends AbstractFactory{
    public IProduct manufacture(){
        return new ProductMid();
    }
}

测试

public class Main {

    public static void main(String[] args) {
        AbstractFact factory=new FactoryLow();
        factory.manufacture();//创建低等次的产品
        factory=new FactoryMid();
        factory.manufacture();//创建中等次的产品
    }
}

看到这不难看出，工厂方法模式和简单工厂的区别：工厂方法模式只是把简单工厂中的工厂实体类化为两层：抽象工厂类和实际产品的工厂实体类，更利于扩展。

四、抽象工厂模式

通常情况下，简单工厂、工厂方法模式都是单产品系的，而抽象工厂是多产品多系列的，但是从本质上来说工厂方法模式和抽象工厂模式的基本思想是一致的，不同之处在于由于抽象工厂模式是多产品系的所以Product角色会有多个，同样的AbstractFactory角色和对应的实体工厂也会有多个。
比如说需要生产两类产品家轿ICar和ISUV，其中两类产品下又分为中等和高等车，那么使用抽象工厂模式来实现是最合适不过的了，主要步骤都一致，第一步肯定是定义两类产品的Product角色，并且实现各自的中等、高等产品实体类（具体代码和工厂方法模式差不多），

1、再定义整体的抽象工厂类

有N个产品族，在抽象工厂类中就应该有N个创建方法。

//抽象工厂，
public abstract class AbstractFactory{
    public abstract ICar manufacture();//生产ICar
    public abstract ISUV manufacture();//生产ISUV
}

2、再实现各自产品系列对应的实体工厂类

有M个产品等级就应该有M个实现工厂类，在每个实现工厂中，实现不同产品族
的生产任务。

//中等工厂
public class FactoryMid extends AbstractFactory{
    public ICar manufacture(){
        return new MidCar();//生产中等Car
    }
    public ISUV manufacture(){
        return new MidSUV();//生产中等SUV
    }
}
...

五、结合泛型和反射实现自动选择工厂

public abstract class Product {
    //产品类的公共方法
    public void method1(){
    //业务逻辑处理
    }
    //抽象方法
    public abstract 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);//生成ConcreteProduct1对象
    }
}

六、工厂模式三种形态的对比

这里写图片描述

七、活用工厂模式实现的单例模式和延迟加载初始化

单例模式的核心要求就是在内存中只有一个对象，那么通过工厂模式也只要在内存中生产一个对象即可。

这里写图片描述

定义一个单例类

public class Singleton {
    //构造方法私有不允许通过new产生一个对象
    private Singleton(){
    }
}

工厂通过反射方式创建对象

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;
    }
}

2、延迟加载初始化

通过工厂方法模式创建了一个单例对象，该框架可以继续扩展，在一个项目中可以
产生一个单例构造器，所有需要产生单例的类都遵循一定的规则（比如构造方法是private），然
后通过扩展该框架，只要输入一个类型就可以获得唯一的一个实例。基于性能考虑，我们还可以考虑延迟初始化（Lazy initialization），即一个对象被消费完毕后，并不立刻释放，工厂类
保持其初始状态，等待再次被使用。同时延迟初始化也是工厂方法模式的一个扩展应用，其通用类UML类图如下

这里写图片描述
ProductFactory负责产品类对象的创建工作，并且通过prMap变量产生一个缓存，对需要
再次被重用的对象保留，通过定义一个Map容器，容纳所有产生的对象，如果在Map容器中已经有的对象，则直接取出返回；如果没有，则根据需要的类型产生一个对象并放入到Map容器中，以方便下次调用。

//Product和ConcreteProduct代码略，和普通工厂模式一致，Product定义产品共性，ConcreteProduct实现具体产品细节
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;
    }
}

小结

虽然结构上建造者模式和工厂方法模式都用于创建复杂对象，但两者的专注点不同，建造者模式最主要的功能是基本方法的调用顺序安排，通俗地说就是零件的装配，顺序不同产生的对象也不同；而工厂方法则重点是创建，创建零件是它的主要职责，组装顺序则不是它关心的。关注的是零件类型和装配顺序，不过设计模式在任何时候也不能生搬硬套，实际开发中常常只是借鉴他的思想灵活和结合各种模式，才是编程之道。