开发之路（设计模式四：工厂模式上）

本期我们要介绍一个能让你烘烤自己的OO设计的一种模式，工厂模式        

---

请问除了使用new以外，你还有其他创造对象的方法吗？如果你说没有，那么和我一起好好学习下这个模式吧。你会认识到往往实例化不应该总是公开进行，也会认识到初始化经常造成的“耦合”问题。

---

在之前的模式当中，我有介绍过一个原则，我们不应该针对实现编程。但当看到“new”时，就会想到“具体”，无论是 A a=new A()还是 A a=new B()，都其实在实例化一个具体类，所以的确用的是实现，而不是接口，或者再比如在之前“模拟鸭子”当中
Duck d = new MallardDuck(); Duck是一个接口，但MallardDuck还是得建立具体类呀，OK若这样想那么至少明白了，代码与具体类“捆绑”是耦合，缺少弹性一种表现。

那这时就有小伙伴说了：“但总要有创建对象的时候把，Java中只提供了new关键字键对象，还能有别的吗？” 当然new关键字本身没有问题，这是Java原生部分，其实阻碍我们的是“改变”，针对接口编程，可以隔离掉当“改变”来了以后的许多问题，如果代码是针对接口（这里我在此强调，接口是一个大概念，不单单interface是接口，抽象类，类也能是一个“接口”）而写，那么通过多态，它可以与任何新类实现该接口。但是我个人也觉得似乎有问题：当代码大量使用具体类时，会自找麻烦，因为当一旦要求增加某些内容时，就必须改变代码。也就是说这样代码也不是“对修改关闭”（前期内容）了，想要新的具体类型来拓展代码，必须重新修改并覆盖它。

说了那么多，具体咋写代码呢，不能纸上谈兵把？OK，我具体来写个实例。假设你有家披萨店。

注：设计模式需要反复多次练习，方可灵活运用，前期可以先模仿。

一开始这样写(这里我引用书中笔记)

当然我们还要传入类型来制作不同口味的披萨，如下图

但是你知道吗？这样设计是会有很大压力的，比如你要添加新的口味披萨，或者取出掉某些卖的不好风味的披萨的话。要这么写，无论增加新披萨或者删除掉原有披萨你都要到这里操作，上面部分会进行修改，而下面部分准备原料，烘烤，切片，装盘，操作都是不改变的，只有上面打算做什么口味披萨的这个动作会改变。

注：请区别出哪些是会改变的，哪些不会改变

我们做的改进，封装创建对象的代码，要把创建披萨的代码转移到另一个对象中，由这个对象专职创建披萨，这个新对象只干这一件事，如图

没错，我们称呼为它“工厂”。
在JavaWeb当中有个持久层框架Hibernate，其一个核心接口“工厂”（SessionFactory）就是用到工厂模式，负责初始化hibernate，是数据源的代理，负责创建Session对象，一个数据库对象只需配置一个SessionFactory，若有多个也可以配置多个。

工厂（factory）处理创建对象的细节，一旦有了Factory，orderPizza()就变成了，此对象的客户。当需要什么类型披萨时，就叫披萨工厂做一个。现在orderPizza()方法只关心从工厂得到一个披萨，而这个披萨实现了Pizza接口，所以可以调用准备材料，烘烤，切片，装盘方法。

那我们来创建个简单工厂。

可能有小伙伴提问：“感觉只是把之前会被大量修改的问题移到另一个对象里而已”
注：SimlePizzaFactory会有很多客户，目前我们看到orderPizza()方法是它客户，但是，可能还有PizzaShopMenu(披萨店菜单),xxxxPizzaShop(各种不同风格披萨店)等等会利用这个工厂来取得披萨里的内容，总而言之，SimlePizzaFactory会有许多客户。所以，把创建披萨的代码包装进一个类，当以后实现改变时，只需修改此类即可。我正要把具体实例化的过程，在客户代码中删除。

此时我们写一个披萨“工厂”的客户类（PizzaStore）

以上就是简单工厂模式的内容了，
注：简单工程严格来说不是一个设计模式，更像是一种编程习惯，但由于经常被使用，所以有时候很多开发人员误认为“工厂模式”。

下面是简单工程的类图。（请注意理解）

注：
再次提醒：所谓的“实现一个接口”并不一定表示“写一个（interface）类，然后利用implements关键词来实现某个Java接口”。“实现一个接口”泛指“实现某个超类型（可以是类或接口）的某个方法”。

你以为这篇文章写道这里就结束了？哈哈，别忘了我的口号是啥~~

既然我们有了自己的披萨店，我们当然希望将它做大做强，我们开始加盟披萨店。

这里我们创建对应的“工厂”对象。

但这又有一个问题了，难道你能放任加盟店不管吗？这样各个加盟店就按照自己的方式，烘烤的做法不同，不要切片，使用其他厂商的盒子，如果能够建立一个框架，把加盟店和创建披萨捆绑在一起的同时又保持一定的弹性。

有个做法可以把披萨制作活动局限在客户（PizzaStore）类中，而同时又能让这些加盟店依然可以自由的创建该区域披萨，就是将createPizza方法放回PizzaStore内，将其设置为“抽象方法”，让后每个区域的加盟店创建它的子类，就是说两者之间形成依赖关系。

让我们详细一点。

从orderPizza()方法观点来看，此方法在抽象父类PizzaStore里定义，但具体实现还是在不同子类中。面对每个不同子类，父类的orderPizza()方法其实并不知道哪个子类将实际上制作披萨。

orderPizza()方法对Pizza对象指向，（准备材料，烘烤，切片，装盒）但由于Pizza对象是抽象的，orderPizza()对象也并不知道哪些实际参与的具体类，换句话说，这就是解耦。（WTF？这就是解耦，很多时候往往初学设计模式的人还不能做到很敏感，包括我自己，需要长时间不断学习）

OK，我们这时候开一家加盟店咯。

注：超类（父类）PizzaStore中orderPizza()方法，并不知道正要创建什么披萨，它只知道制作披萨有四个步骤。。。

现在我们创建工厂方法，之前都是new，对象负责具体类的实例化，现在我们通过PizzaStore做一个小转变（其实在这里，我个人感觉说他是工厂方法感觉怪怪的）

我们再来巩固下工厂方法（这里我放出我的笔记截图）

我们来写下购买披萨流程
1：首先，客户们需要取得披萨店实例。客户需要实例化一个NYStylePizzaStore或ChicagoStylePizzaStore
2：有了各自的PizzaStore订单，客户们分别调用orderPizza()方法，并传入他们所喜爱的比萨类型（芝士，素食）。
3：orderPizza调用createPizza()创建披萨，纽约风味披萨（NYStylePizzaStore）或者芝加哥风味披萨（ChicagoStylePizzaStore）。
4：orderPizza()并不知道具体创建的是哪一种披萨，只知道这是一个披萨，能够准备原料，烘烤，切片，被打包装盒，然后送出给顾客。

定义工厂方式模式：工厂模式定义了一个创建对象的接口，不在直接使用new了，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类了。
注：工厂方法模式能够封装具体类型的实例化。工厂方法让子类决定要实例化的类是哪一个。所谓“决定”，并不是指模式允许子类本身在运行时做决定，而是指在编写创建者类时，不需要知道实际创建的产品是哪一个。选择了哪个子类，自然就决定了实际创建的东西是什么（可能有点难以理解。。。）

下图是工厂方法模式类图

好的说这么多，下面就是具体实现的时候了，由于此例子量稍多，但是量大不代表我会偷工减料的，嘿嘿嘿~~~

这是参考的Java工程class图

代码开始

PizzaStore（工厂类）

package Store;

import Pizza.Pizza;

/**
 * PizzaStore相当于客户(工厂类)， 往后会有很多类似此类进行拓展
 * 
 * 在这里orderPizza()方法对pizz对象做了很多事（createPizza，prepare，bake，cut，box）
 * 但是由于Pizza对象是抽象的（接口），
 * orderPizza()并不知道具体哪些实际类参与进来了（相当于实现Pizza接口的实现类有哪些orderPizza()方法并不知道）
 * 换句话说，这就是解耦，减少相互依赖
 * 
 * 同理createPizza()方法中也不知道创建的具体是什么披萨 只知道披萨可以被准备，被烘烤，被切片，被装盒行为而已
 * 
 */
// 披萨店
public abstract class PizzaStore {

    // 点单
    public Pizza orderPizza(String type) {
        // createPizza()方法从工厂对象中取出,
        // 并且方法也不再这里实现，定义为抽象类，谁需要在拿走方法去具体实现
        Pizza pizza = createPizza(type);
        System.out.println("----制作一个" + pizza);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }

    // 把工厂对象移到这个方法里,并封装
    // 现在工厂方法为抽象的,子类必须实现这个抽象方法
    public abstract Pizza createPizza(String item);
}

下面是“工厂”具体实现
纽约风格披萨店(分店)

package Store;

import Pizza.NYStyleCheesePizza;
import Pizza.NYStyleClamPizza;
import Pizza.NYStylePepperoniPizza;
import Pizza.NYStyleVeggiePizza;
import Pizza.Pizza;

/**
 * 此时NYStylePizzaStore所封装的是关于如何制作纽约风格的比萨
 * 
 * @author Joy
 * 
 */

// 纽约风格披萨店(分店)
public class NYStylePizzaStore extends PizzaStore {

    // 根据披萨的不同，创建不同披萨(具体实现类)
    @Override
    public Pizza createPizza(String item) {
        if (item.equals("芝士")) {
            return new NYStyleCheesePizza();
        } else if (item.equals("素食")) {
            return new NYStyleVeggiePizza();
        } else if (item.equals("海鲜")) {
            return new NYStyleClamPizza();

        } else if (item.equals("香肠")) {
            return new NYStylePepperoniPizza();
        }
        return null;
    }
}

芝加哥披萨店(分店)

package Store;

import Pizza.ChicagoStyleCheesePizza;
import Pizza.ChicagoStyleClamPizza;
import Pizza.ChicagoStylePepperoniPizza;
import Pizza.ChicagoStyleVeggiePizza;
import Pizza.Pizza;

/**
 * 此时ChicagoStylePizzaStore所封装的是关于如何制作芝加哥风格的比萨
 * 
 * @author Joy
 * 
 */
// 芝加哥披萨店(分店)
public class ChicagoStylePizzaStore extends PizzaStore {

    @Override
    public Pizza createPizza(String item) {
        if (item.equals("芝士")) {
            return new ChicagoStyleCheesePizza();
        } else if (item.equals("素食")) {
            return new ChicagoStyleVeggiePizza();
        } else if (item.equals("海鲜")) {
            return new ChicagoStyleClamPizza();
        } else if (item.equals("香肠")) {
            return new ChicagoStylePepperoniPizza();
        }
        return null;
    }
}

Pizza类
（相当于各个“产品”的接口）

package Pizza;

import java.util.ArrayList;

public abstract class Pizza {
    String name;// 披萨名称
    String dough;// 面团类型
    String sauce;// 酱料
    ArrayList toppings = new ArrayList();// 一套佐料

    public void prepare() {
        System.out.println("准备:" + name);
        System.out.println("添加面团");
        System.out.println("添加酱料");
        System.out.println("添加佐料如下：");
        for (int i = 0; i < toppings.size(); i++) {
            System.out.print(toppings.get(i) + "   ");
        }
    }

    public void bake() {
        System.out.println("\n" + "披萨正在烘烤,需烘烤25分钟。。。");
    }

    public void cut() {
        System.out.println("制作完成，给披萨切片。。。");
    }

    public void box() {
        System.out.println("给披萨打包装盒。。。");
    }

    public String getName() {
        return name;
    }

    // 输出客人点的披萨信息
    @Override
    public String toString() {
        StringBuffer display = new StringBuffer();
        display.append(name + " ----\n");
        display.append(dough + "\n");
        display.append(sauce + "\n");
        for (int i = 0; i < toppings.size(); i++) {
            display.append((String) toppings.get(i) + "\n");
        }
        return display.toString();
    }

}

下面是各种披萨具体实现类

package Pizza;

//加州披萨店的芝士披萨
public class ChicagoStyleCheesePizza extends Pizza {
    public ChicagoStyleCheesePizza() {
        name="加州芝士披萨";
        dough="厚饼";
        sauce="番茄酱";
        toppings.add("干碎奶酪");                
    }
    @Override
    public void cut() {    
        System.out.println("将披萨切成方形");
    }

}

package Pizza;

//加州披萨店的海鲜披萨
public class ChicagoStyleClamPizza extends Pizza {

    public ChicagoStyleClamPizza() {
        name = "加州海鲜披萨";
        dough = "厚饼";
        sauce = "番茄酱";
        toppings.add("干碎奶酪");
        toppings.add("蟹黄");
        toppings.add("龙虾");
        toppings.add("各种海鲜");
    }
    
    @Override
    public void cut() {    
        System.out.println("将披萨切成三角形");
    }    

}

package Pizza;

//加州披萨店里的香肠披萨
public class ChicagoStylePepperoniPizza extends Pizza {

    public ChicagoStylePepperoniPizza() {
        name = "加州香肠披萨";
        dough = "厚饼";
        sauce = "番茄酱";

        toppings.add("干碎奶酪");
        toppings.add("黑胡椒");
        toppings.add("菠菜");
        toppings.add("茄子");
        toppings.add("香肠切片");
    }

    @Override
    public void cut() {
        System.out.println("切成方形薄披萨");
    }

}

package Pizza;

//加州披萨店里的素披萨
public class ChicagoStyleVeggiePizza extends Pizza {

    public ChicagoStyleVeggiePizza() {
        name = "加州素披萨";
        dough = "厚饼";
        sauce = "番茄酱";
        toppings.add("干碎奶酪");
        toppings.add("圣女果");
        toppings.add("黑胡椒粉");
        toppings.add("红辣椒");
        toppings.add("甜玉米粒");
        toppings.add("色拉");
    }

    @Override
    public void cut() {
        System.out.println("切成方形薄披萨");
    }
}

package Pizza;


//纽约披萨店里的芝士披萨
public class NYStyleCheesePizza extends Pizza {

    public NYStyleCheesePizza() {
        name="纽约芝士披萨";
        dough="薄饼";
        sauce="番茄酱";
        toppings.add("干奶酪");    
    }    
}

package Pizza;

//纽约披萨店里的河鲜披萨
public class NYStyleClamPizza extends Pizza {

    public NYStyleClamPizza() {
        name = "纽约海鲜披萨";
        dough="薄饼";
        sauce="番茄酱";
        toppings.add("巴马干奶酪");
        toppings.add("蟹黄");
        toppings.add("龙虾");
    }
}

package Pizza;




//纽约披萨店里的香肠披萨
public class NYStylePepperoniPizza extends Pizza {

    public NYStylePepperoniPizza() {
        name = "纽约香肠披萨";
        dough="薄饼";
        sauce="番茄酱";
        toppings.add("巴马干酪奶酪");
        toppings.add("意大利香肠切片");
        toppings.add("大蒜");
        toppings.add("洋葱");
        toppings.add("香菇");
        toppings.add("红辣椒");
    }
}

package Pizza;

//纽约披萨店里的素披萨
public class NYStyleVeggiePizza extends Pizza {

    public NYStyleVeggiePizza() {
        name = "纽约素食披萨";
        dough = "薄饼";
        sauce = "番茄酱";
        toppings.add("巴马干酪奶酪");
        toppings.add("洋葱");
        toppings.add("各种蔬菜");
    }
}

测试类

package TestMain;

import Pizza.Pizza;
import Store.ChicagoStylePizzaStore;
import Store.NYStylePizzaStore;
import Store.PizzaStore;

public class TestMain {
    public static void main(String[] args) {
        PizzaStore nyStore = new NYStylePizzaStore();
        PizzaStore chicagoStore = new ChicagoStylePizzaStore();
        // System.out.println("====================================");
        // Pizza pizza1 = nyStore.orderPizza("芝士");
        // System.out.println("Joy点了一个" + pizza1.getName());
        // System.out.println("====================================");
        // Pizza pizza2 = nyStore.orderPizza("素食");
        // System.out.println("Joy点了一个" + pizza2.getName());
        System.out.println("====================================");
        Pizza pizza3 = nyStore.orderPizza("海鲜");
        System.out.println("Joy点了一个" + pizza3.getName() + " ,正在送出");
        // System.out.println("====================================");
        // Pizza pizza4 = nyStore.orderPizza("香肠");
        // System.out.println("Joy点了一个" + pizza4.getName());
        System.out.println("====================================");
        Pizza pizza11 = chicagoStore.orderPizza("芝士");
        System.out.println("Joy点了一个" + pizza11.getName() + " ,正在送出");
        // System.out.println("====================================");
        // Pizza pizza22 = chicagoStore.orderPizza("素食");
        // System.out.println("Joy点了一个" + pizza22.getName());
        // System.out.println("====================================");
        // Pizza pizza33 = chicagoStore.orderPizza("海鲜");
        // System.out.println("Joy点了一个" + pizza33.getName());
        // System.out.println("====================================");
        // Pizza pizza44 = chicagoStore.orderPizza("香肠");
        // System.out.println("Joy点了一个" + pizza44.getName());

    }
}

效果如下：

这个模式是个很有用的模式，让我更加能封装变化了，模拟代码已经全部放出，注释也写的比较清楚，若有不理解欢迎留言。

感谢你看到这里，工厂模式上部分结束，但工厂模式内容还没完全结束 本人文笔随便，若有不足或错误之处望给予指点，90度弯腰~~~很快我会补全完这个内容。 生命不息，编程不止！

参考书籍：《Head First 设计模式》