设计模式：工厂设计模式介绍及3种写法（简单工厂、工厂方法、抽象工厂）

0、介绍

给一个背景：一个pizza订购项目，pizza本身的种类要便于扩展和维护，那么种类很多、制作过程也不少、还要完成订购的功能。

按照一般的思路，类图设计如下：

其中：

1. Pizza类按照面向对象的设计思路，制作过程对应的方法在其中实现；
2. 由于需要不同的类型 Pizza，而在 prepare 步骤不同，所以 Pizza 做成抽象类，而两个不同类型的 Pizza 去继承 Pizza 类；
3. 还需要一个的 OrderPizza 类，接受预定类型，完成对应的pizza类订购操作；
4. 然后提供一个入口 PizzaStore 去调用 OrderPizza 类，相当于客户端。

代码如下：

/*
*  Pizza抽象类，让其他的继承
*/
public abstract class Pizza {
    protected String name;//pizza名
    //不同pizza准备不同，所以留给实现类去实现
    public abstract void prepare();
    public void bake(){
        System.out.println(name + " baking");
    }
    public void cut(){
        System.out.println(name + " cutting");
    }
    public void box(){
        System.out.println(name + " boxing");
    }
    public void setName(String name){
        this.name = name;
    }
}

/*
*  奶酪pizza
*/
public class CheesePizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("制作奶酪pizza准备材料ing");
    }
}

/*
*   希腊pizza
*/
public class GreekPizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("给希腊pizza准备原材料ing");
    }
}

/*
*  pizza订购类
*/
public class OrderPizza {
    //获取pizza订单
    private String getType(){
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type");
            String type = br.readLine();
            return type;
        }catch (IOException e){
            e.printStackTrace();
            return "";
        }
    }
    //构造器
    public OrderPizza() {
        Pizza pizza = null;
        String orderType;//订购类型
        do {
            orderType = getType();
            if (orderType.equals("greek")){
                pizza = new GreekPizza();
                pizza.setName("希腊pizza");
            }else if (orderType.equals("cheese")){
                pizza = new CheesePizza();
                pizza.setName("奶酪pizza");
            }else{
                break;
            }
            //方便调试，把制作过程打印
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while (true);
    }
}

/*
*  客户端
*/
public class PizzaStore {
    public static void main(String[] args) {
        new OrderPizza();
    }
}

这样我们的一个 pizza 线上商店就全部完成了，似乎是一个很完美的过程呢。

优点：
传统思路，便于理解
缺点：
违反了在设计模式七大原则里面说过的 ocp 原则，即对扩展开放，对修改关闭。

具体一些：Pizza 作为提供方，如果商店要增加一个种类，那么除了要增加一个 Pizza 类【提供方】之外，依赖的 Order 类也要增加对于新 Pizza 的处理【使用方】（甚至扩展起来，还有别的依赖于 Pizza 的使用方操作类，全部都要修改），而按照 Ocp 原则，使用方不应该修改，所以我们要避免这种情况。

一、简单工厂模式

对于上面的缺点，我们把创建 Pizza 的过程封装到一个类里，然后以这个类为中介进行创建，而不是再在Order里面直接创建。这样增加【提供方】 Pizza 的时候，修改这个类就可以了。

简单工厂模式（静态工厂模式）：

1. 属于创建型模式，是工厂模式的一种，由一个工厂对象来决定创造出哪一种产品类的实例。他是工厂模式家族里最简单实用的模式；
2. 简单工厂模式定义了一个创建对象的类，由这个类来封装实例化对象的行为；
3. 在实际开发中，如果会用到大量创建某种对象时，就会用到工厂模式。

/*
    简单工厂类，根据类型创建pizza对象并返回
*/
public class SimpleFactory {
    public Pizza createPizza(String orderType){
        System.out.println("使用简单工厂模式");
        Pizza pizza = null;
        if (orderType.equals("greek")){
            pizza = new GreekPizza();
            pizza.setName("希腊披萨");
        }else if (orderType.equals("cheese")){
            pizza = new CheesePizza();
            pizza.setName("奶酪披萨");
        }else if (orderType.equals("pepper")){
            pizza = new PepperPizza();
            pizza.setName("胡椒披萨");
        }
        return pizza;
    }
}

/*
*  pizza订购类
*/
public class OrderPizza {
    SimpleFactory factory;
    Pizza pizza = null;
    //构造器
    public OrderPizza(SimpleFactory factory) {
        setFactory(factory);
    }
    //创建过程改为调用工厂类
    public void setFactory(SimpleFactory factory){
        String orderType = "";
        this.factory = factory;
        do {
            orderType = getType();
            pizza = this.factory.createPizza(orderType);
            //打印制作过程
            if (pizza != null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else{
                System.out.println("订购失败");
                break;
            }
        }while (true);
    }
    //获取pizza种类
    private String getType() {
            //和前面一样
    }
}

/*
*  客户端
*/
public class PizzaStore {
    public static void main(String[] args) {
//        new OrderPizza();
        //使用简单那工厂模式
        new OrderPizza(new SimpleFactory());
        System.out.println("结束");
    }
}

类图变成了这样：

可以看到，复杂的依赖关系基本消失，工厂类 负责了所有对象的产生，因此他和使用方OrderPizza 的关系是聚合关系。

这样一来，如果有新增的 Pizza 类，除了类的创建之外，就只用修改工厂类里面的新建方法，而对于使用方，OrderPizza、或者即将使用 Pizza 类的其他增加进来的使用方，代码都不用修改，因为他们都是调用工厂类进行对象的创建。

（其实就是为了方便扩展，多抽象出来一层的思想）

补充：

简单工厂模式之所以又叫静态工厂模式，就是因为可以直接把工厂类的 create 方法写成静态，这样的话，就不用 new 出工厂对象，而是只需要调用它的静态方法就可以。

public OrderPizzaviaStatic() {
    String orderType = "";
    do {
        orderType = getType();
        pizza = SimpleFactory.createPizza(orderType);//静态方法
        if (pizza != null){
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }else{
            System.out.println("订购失败");
            break;
        }
    }while (true);
}

使用静态与否，根据具体情况来修改。

二、工厂方法模式

工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类，工厂方法模式将对象的实例化推迟到子类。

思考这个问题：

如果新增了一个需求，对于pizza，每次要新加地域属性，比如现在还是3种pizza，但是有3个地方，各有这三种pizza。客户点单的时候也会输入地域属性。

• 解决方法：创建的时候利用简单工厂模式，新建不同地域的工厂，并且每个工厂里带上地域属性，其他不变，就可以实现扩展。
• 但是这种方法不是最优，如果不同工厂很多的话，会需要多个工厂类。

其实把工厂类单独作为普通类来考虑，我们能想到的改进思路就是，在他们基础上，再提取公共接口或者抽象类。事实上，工厂方法模式的确是基于这种思路的。

使用工厂方法模式，将实例化功能抽象成抽象方法（而不是像简单工厂模式那样直接实现），在不同地域点餐子类中实现抽象方法。

根据这个类图很容易看得出来，其实只是对于Order部分做了一个抽象，其他的和之前的一般写法没有区别。

虽然没有出现factory字样，但是其实两个Order子类充当了Factory的作用：

• Order 根据不同的 type 去调用不同的子 Order，做 create 的工作；
• 每个 Pizza 类里什么也不做。

所以和上面简单工厂的区别就是，这个根据地域分别写了 Order 类，将 OrderPizza 作为抽象类去组织这几个。

因此这一版代码，一个抽象 Pizza 类和4个子 Pizza 类完全没有变化，剩下三个类的写法如下：

/*
    orderPizza类，根据type调用不同的工厂
*/
public abstract class OrderPizza {
    //抽象方法，具体根据地域不同，让工厂子类去实现
    abstract Pizza createPizza(String orderType);
    //构造器
    public OrderPizza(){
        Pizza pizza = null;
        String orderType;
        do {
            orderType = getType();
            pizza = createPizza(orderType);//调用的是抽象方法
            if (pizza != null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else {
                System.out.println("订购失败");
                break;
            }
        }while (true);
    }

    private String getType() {
            //和之前一样
    }
}

/*
    北京pizza工厂类
*/
public class BJOrderPizza extends OrderPizza{
    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")){
            pizza = new BJCheesePizza();
            pizza.setName("北京奶酪pizza");
        }else if (orderType.equals("pepper")){
            pizza = new BJPepperPizza();
            pizza.setName("北京胡椒pizza");
        }
        return pizza;
    }
}

/*
    上海pizza工厂类
*/
public class SHOrderPizza extends OrderPizza {
    @Override
    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")){
            pizza = new SHCheesePizza();
            pizza.setName("上海奶酪pizza");
        }else if (orderType.equals("pepper")){
            pizza = new SHPepperPizza();
            pizza.setName("上海胡椒pizza");
        }
        return pizza;
    }
}

最后，我们还是用一个 PizzaStore 类模拟一下客户端，接受不同的输入，来调用不同的 Order 类就可以。

三、抽象工厂模式

抽象工厂模式：

1. 定义一个 interface 用于创建相关或有依赖关系的对象簇，而无需指明具体的类；
2. 将简单工厂模式和工厂方法模式进行整合，其实相当于将简单工厂模式再网上抽象一层；
3. 包含AbstractFactory（抽象工厂）和具体实现工厂子类，根据需要的类型使用对应的子类，这样简单工厂类变成了工厂簇，更有助于代码维护。

这种实现方式的类图是这样的：

相比上面的工厂方法模式，抽象模式抽象出来一个Factory接口，两个实现类分别作为具体的工厂去实现接口的方法，然后聚合到Order类上，整体思路和上一种是一样的。

代码层面：

所有Pizza的内容都一样，BJFactory 和 SHFactory 和上面所说的，用工厂方法模式写的代码也一样，不过改成实现接口 AbstractFactory，而不是实现order抽象类。

AbstractFactory：

/*
    抽象工厂模式的抽象层：接口
*/
public interface AbstractFactory {
    //让下面子类实现具体
    public Pizza createPizza(String orderType);
}

OrderPizza 类和第二种模式的 OrderPizza 类基本是一样的；
区别就在于，不是根据传入的 Pizza 的 type 直接 create，而是去调用 Factory 实现类，所以是和第一种模式代码一样。

/*
    聚合的order类，和工厂接口交互
*/
public class OrderPizza {
    AbstractFactory factory;
    //构造器
    public OrderPizza(AbstractFactory factory){
        setFactory(factory);
    }
    //根据不同实现类进行构造
    private void setFactory(AbstractFactory factory){
        Pizza pizza = null;
        String orderType = "";
        this.factory = factory;
        do {
            orderType = getType();
            //factory是接受的不同factory，取决于不同实现类
            pizza = factory.createPizza(orderType);
            if (pizza != null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else{
                System.out.println("订购失败");
                break;
            }
        }while (true);
    }

    private String getType() {
    }
}

最后，我们写上 Store类就可以，根据输入的不同，new出 Order 类，并且传入不同地域的工厂参数。

总结一下可以发现，这三种工厂模式，大同小异，就是对于简单工厂模式的不同程度的抽象。

四、工厂模式在JDK的应用

jdk 的 Canlendar类中，使用的就是 简单工厂模式

当我们写下这行代码：

Calendar calendar = Calendar.getInstance();//静态方法

的时候，getInstance 方法去调用了

createCalendar 方法，返回一个 Canlendar 实例。

而在创建的方法里面如下：

做一系列判断，看里面获取的各种参数，相当于这个工厂根据不同的情况去决定选择哪一种（具体在这个类里是时区、地理位置之类的），最后将创建好的 calendar 返回。

也就是对应我们说的工厂模式第一种，简单工厂模式。

五、总结

工厂模式的意义：

将实例化对象的代码提取出来，放到一个类里面统一管理和维护，达到各种依赖关系的解耦，从而提高项目的可扩展性和可维护性。（最后是达到设计模式的 ocp 原则）

工厂模式分为三种：

1. 简单工厂模式：如果要创建一种对象的行为比较多，将所有的工作放到一个工厂类里，每次调用这个类的方法就可以。
2. 工厂方法模式：如果创建的对象种类要增加，那就分类多写几个工厂类，让他们实现一个抽象方法，这样能够做了区分后调用不同的工厂类。
3. 抽象工厂模式：再加一层抽象工厂层，那么操作层面就只和固定的抽象工厂类交互，不用管有几种工厂实现类。

工厂模式体现的编码技巧：

• 创建对象实例的时候不要直接 new 类，而是要把这个动作交给一个工厂的方法里，并且返回。
• 不要让类直接继承具体的类，而是继承抽象类或者实现接口。
• 不要覆盖基类中已经实现的方法。