浅析设计模式(二)——工厂方法模式

工厂方法模式（Factory-Method，创建型模式）

本文的结构：

• 一、工厂方法模式的定义
• 二、工厂方法模式的参与者及其角色
• 三、工厂方法模式的类图
• 四、工厂方法模式的示例
• 五、参考

一、工厂方法模式的定义

　　定义一个用于创建对象的接口，让子类决定将哪一个类实例化。Factory Method使一个类的实例化延迟到子类。

　　从工厂方法的实现来看，它通过继承来实现，委托子类把创建对象的方法具体化，通常用于创建单个产品。

　　上一篇【浅析设计模式（四）——创建型模式之Simple-Factory(简单工厂方法，非设计模式)】中介绍的简单工厂方法，虽然已经对变化的部分进行了封装，但是这里只由一个对象负责所有的具体类的实例化，因此每次有新增对象类型时，都需要改变工厂的源码进行扩展。

　　如果把实例化部分(即上面创建对象的createPizza方法)进行抽象，而且挪到PizzaStore(改为抽象类，即由抽象类定义上层接口)里面，然后由子类负责具体实现，那就可以使用一群子类来负责实例化了，而不用改变原有的子类实现及其实例化方式，比较容易进行扩展，当然，缺点就是需要维护一群子类，每次有新的类型时，在不修改原有实现的基础上，只能通过新增子类来进行实现；另外一点就是需要在运行时根据实际情况进行选择和确认具体类。简单工厂方法可以看成是工厂方法模式退化后的一种特例，即在确定需要实例化的对象基本不会变化、而且可控的情况下，将抽象的工厂方法与具体的工厂方法进行合并，始终由单一的具体工厂直接负责对象的实例化。

二、工厂方法模式的参与者及其角色

1. Product

• 定义工厂方法要创建的对象的接口

2. ConcreteProduct

• 实现Product接口，即具体的对象

3. Creator

• 声明工厂方法，该方法返回一个Product类型的对象。Creator也可以定义一个工厂方法的缺省实现，他返回一个缺省的ConcreteProduct对象。

4. ConcreteCreator

• 重定义工厂方法以返回一个ConcreteProduct对象。

三、工厂方法模式的类图 

四、工厂方法模式的示例

1. Creator：这个是工厂方法的上层接口，定义了创建对象的接口方法，也即对创建对象的方法进行了抽象化。

　　这里还是从创建Pizza开涮。可以看出与简单工厂方法的差别，这里又把创建对象的方法搬回来了，只是抽象化了，没有具体实现，目的是要让子类类确认实例化的具体实现。其他的流程还是可以保持一致的。

/**
 * This is the factory.
 * <p>
 * Reference : Head-First-Design-Patterns
 *
 */
public abstract class PizzaStore {
    public abstract Pizza createPizza(String item);
     
    public Pizza orderPizza(String type) {
        Pizza pizza = createPizza(type);
        System.out.println("--- Making a " + pizza.getName() + " ---");
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

 

2. ConcreteCreator：Creator的实现类，在这些实现子类中进行了具体的实现，也即实际创建对象的动作在这里发生。

实现类1：纽约风味的PizzaStore

/**
 * This is the concrete factory-method.
 * <p>
 * Reference : Head-First-Design-Patterns
 *
 */
public class NYPizzaStore extends PizzaStore {

    // Here is the concrete creator.
    @Override
    public Pizza createPizza(String item) {
        if (item.equals("cheese")) {
            return new NYStyleCheesePizza();
        } else if (item.equals("veggie")) {
            return new NYStyleVeggiePizza();
        } else if (item.equals("clam")) {
            return new NYStyleClamPizza();
        } else if (item.equals("pepperoni")) {
            return new NYStylePepperoniPizza();
        } else
            return null;
    }

}

 

实现类2：芝加哥风味的PizzaStore

/**
 * This is the concrete factory-method.
 * <p>
 * Reference : Head-First-Design-Patterns
 *
 */
public class ChicagoPizzaStore extends PizzaStore {

    // Here is the concrete creator.
    @Override
    public Pizza createPizza(String item) {
        if (item.equals("cheese")) {
            return new ChicagoStyleCheesePizza();
        } else if (item.equals("veggie")) {
            return new ChicagoStyleVeggiePizza();
        } else if (item.equals("clam")) {
            return new ChicagoStyleClamPizza();
        } else if (item.equals("pepperoni")) {
            return new ChicagoStylePepperoniPizza();
        } else
            return null;
    }

}

 

当然还可以添加南加州风味、洛杉矶风味等等的PizzaStore。

3. Product：需要创建的对象的父类。

　　实际上，要创建的是一类对象，并不是单纯的某一个对象，因此，这里的抽象化也是很有必要的，而且后续的维护、扩展等也是基于抽象类来开展，进行实际的定制化、具体化。

import java.util.ArrayList;

/**
 * This is the abstract product.
 * <p>
 * Reference : Head-First-Design-Patterns
 *
 */
public abstract class Pizza {
    String name;
    String dough;
    String sauce;
    ArrayList<String> toppings = new ArrayList<String>();
 
    void prepare() {
        System.out.println("Prepare " + name);
        System.out.println("Tossing dough...");
        System.out.println("Adding sauce...");
        System.out.println("Adding toppings: ");
        for (String topping : toppings) {
            System.out.println("   " + topping);
        }
    }
  
    void bake() {
        System.out.println("Bake for 25 minutes at 350");
    }
 
    void cut() {
        System.out.println("Cut the pizza into diagonal slices");
    }
  
    void box() {
        System.out.println("Place pizza in official PizzaStore box");
    }
 
    public String getName() {
        return name;
    }

    public String toString() {
        StringBuffer display = new StringBuffer();
        display.append("---- " + name + " ----\n");
        display.append(dough + "\n");
        display.append(sauce + "\n");
        for (String topping : toppings) {
            display.append(topping + "\n");
        }
        return display.toString();
    }
}

 

4. ConcreteProduct：需要创建的具体对象，后续需要扩展新的对象，实现Pizza类即可。

示例1：

/**
 * This is the concrete product.
 * <p>
 * Reference : Head-First-Design-Patterns
 *
 */
public class NYStyleCheesePizza extends Pizza{
    public NYStyleCheesePizza() { 
        name = "NY Style Sauce and Cheese Pizza";
        dough = "Thin Crust Dough";
        sauce = "Marinara Sauce";
 
        toppings.add("Grated Reggiano Cheese");
    }
}

 示例2：

/**
 * This is the concrete product.
 * <p>
 * Reference : Head-First-Design-Patterns
 *
 */
public class ChicagoStyleCheesePizza extends Pizza{
    public ChicagoStyleCheesePizza() { 
        name = "Chicago Style Deep Dish Cheese Pizza";
        dough = "Extra Thick Crust Dough";
        sauce = "Plum Tomato Sauce";
 
        toppings.add("Shredded Mozzarella Cheese");
    }
 
    void cut() {
        System.out.println("Cutting the pizza into square slices");
    }
}

 其他的就省略了，具体可看后面的参考。。。。

5. 测试

　　主要是使用上面的具体PizzaStore来创建各类Pizza。

/**
 * This is the test-main.
 * <p>
 * Reference : Head-First-Design-Patterns
 *
 */
public class PizzaTestApp {
    public static void main(String[] args) {
        
        //2 concrete factory
        PizzaStore nyStore = new NYPizzaStore();
        PizzaStore chicagoStore = new ChicagoPizzaStore();

        Pizza pizza = nyStore.orderPizza("cheese");
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza("cheese");
        System.out.println("Joel ordered a " + pizza.getName() + "\n");

        pizza = nyStore.orderPizza("clam");
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza("clam");
        System.out.println("Joel ordered a " + pizza.getName() + "\n");

        pizza = nyStore.orderPizza("pepperoni");
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza("pepperoni");
        System.out.println("Joel ordered a " + pizza.getName() + "\n");

        pizza = nyStore.orderPizza("veggie");
        System.out.println("Ethan ordered a " + pizza.getName() + "\n");

        pizza = chicagoStore.orderPizza("veggie");
        System.out.println("Joel ordered a " + pizza.getName() + "\n");
    }
}

 

五、参考

1、参考《Head First设计模式》和GoF《设计模式：可复用面向对象软件的基础》

2、代码可参考【github传送门】、UML类图参考【github传送门】