浅析设计模式(三)——抽象工厂模式

抽象工厂模式（Abstract-Factory，创建型模式）

本文的结构：

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

一、抽象工厂模式的定义

　　提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

　　前面【浅析设计模式（四）——创建型模式之Simple-Factory(简单工厂方法，非设计模式)】中介绍的简单工厂方法，虽然已经对变化的部分进行了封装，但是这里只由一个对象负责所有的具体类的实例化，因此每次有新增对象类型时，都需要改变工厂的源码进行扩展。而【浅析设计模式（五）——创建型模式之Factory-Method(工厂方法模式)】中介绍的工厂方法模式，则对简单工厂方法进行了最直接的封装和抽象，把创建对象的具体操作进行了分离，便于扩展和维护。这两种做法都是用于创建单类对象。

　　从某种角度来看，抽象工厂模式也是类似的，都是把创建对象的动作进行了封装。但是抽象工厂模式意在创建相关或依赖对象的家族。从抽象工厂模式的实现来看，它通过组合委托给具体的工厂来实现，对象的创建被实现在工厂接口所暴露出来的方法中，通常用于创建产品家族或者相关集合。而这些工厂通常使用工厂方法来实现具体的产品创建。做个最简化，如果抽象工厂也只是创建一类产品，而不考虑后续的扩展之类的，是可以直接用工厂方法来实现的。

　　这里有必要对“相关或依赖对象的家族”做一个简单地说明，举个栗子，假如要创建的对象是台电脑，那么像键盘、鼠标、显示器、主机等等，就可以看成是“相关或依赖对象的家族”。下面要举的栗子也是类似的，也还是拿Pizza的例子，Pizza有各种原料，这里从简，只举出Cheese奶酪、Veggies蔬菜、Clams蛤等原料进行说明，这里的创建对象，实际上是创建了包含各类原料的Pizza，也即就是提到的“相关或依赖对象的家族”。

二、抽象工厂模式的参与者及其角色

1. AbstractFactory

• 声明一个创建抽象产品对象的操作接口

2. ConcreteFactory

• 实现创建具体产品对象的操作

3. AbstractProduct

• 为一类产品对象声明一个接口

4. ConcreteProduct

• 定义一个将被相应的具体工厂创建的产品对象
• 实现AbstractProduct接口

5. Client

• 仅使用由AbstractFactory和AbstractProduct类声明的接口。

三、抽象工厂模式的类图 

四、抽象工厂模式的示例

1. AbstractFactory：声明一个创建抽象产品对象的操作接口，用于创建相关或依赖对象的家族。

/**
 * 
 * <p>
 * Reference : Head-First-Design-Patterns
 *
 */
public interface PizzaIngredientFactory {
    public Cheese createCheese();
    public Veggies[] createVeggies();
    public Clams createClam();
}

2. ConcreteFactory：实现创建具体产品对象的操作，这里就是最简单的直接创建对象，

例1：

/**
 * 
 * <p>
 * Reference : Head-First-Design-Patterns
 *
 */
public class NYPizzaIngredientFactory implements PizzaIngredientFactory{
    
    @Override
    public Veggies[] createVeggies() {
        Veggies veggies[] = { new Garlic(), new Onion(), new Mushroom()};
        return veggies;
    }

    @Override
    public Clams createClam() {
        return new FreshClams();
    }

    @Override
    public Cheese createCheese() {
        return new ReggianoCheese();
    }
}

 例2

/**
 * 
 * <p>
 * Reference : Head-First-Design-Patterns
 *
 */
public class ChicagoPizzaIngredientFactory implements PizzaIngredientFactory{
    
    @Override
    public Cheese createCheese() {
        return new MozzarellaCheese();
    }
    @Override
    public Veggies[] createVeggies() {
        Veggies veggies[] = { new Onion(), new Garlic()};
        return veggies;
    }
    @Override
    public Clams createClam() {
        return new FrozenClams();
    }
}

 从这里可以看出，上面的具体工厂其实就是工厂方法的简化，不带任何判断就直接创建了具体的对象。当然也是可以像前面提到的工厂方法模式一样，带参数，然后根据参数进行具体对象的创建。

3. AbstractProduct：为一类产品对象声明一个接口，以上创建的“相关或依赖对象的家族”其实就是这里需要用到的。

/**
 * 
 * <p>
 * Reference : Head-First-Design-Patterns
 *
 */
public abstract class Pizza {
    String name;

    Veggies veggies[];
    Cheese cheese;
    Clams clam;

    abstract void prepare();

    void bake() {
        System.out.println("Bake for 25 minutes at 350");
    }

    void cut() {
        System.out.println("Cutting the pizza into diagonal slices");
    }

    void box() {
        System.out.println("Place pizza in official PizzaStore box");
    }

    void setName(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }

    public String toString() {
        StringBuffer result = new StringBuffer();
        result.append("---- " + name + " ----
");
        
        if (cheese != null) {
            result.append(cheese);
            result.append("
");
        }
        if (veggies != null) {
            for (int i = 0; i < veggies.length; i++) {
                result.append(veggies[i]);
                if (i < veggies.length-1) {
                    result.append(", ");
                }
            }
            result.append("
");
        }
        if (clam != null) {
            result.append(clam);
            result.append("
");
        }
        return result.toString();
    }
}

 4. ConcreteProduct：实现AbstractProduct接口，定义一个将被相应的具体工厂创建的产品对象。

这里简单地举个栗子即可，可以看到，这里组合使用了创建对象的工厂，然后根据需要由工厂创建具体的对象。

/**
 * 
 * <p>
 * Reference : Head-First-Design-Patterns
 *
 */
public class VeggiePizza extends Pizza{
    PizzaIngredientFactory ingredientFactory;
    
    public VeggiePizza(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
    }
 
    @Override
    void prepare() {
        System.out.println("Preparing " + name);
        cheese = ingredientFactory.createCheese();
        veggies = ingredientFactory.createVeggies();
    }
}

 类似的

/**
 * 
 * <p>
 * Reference : Head-First-Design-Patterns
 *
 */
public class ClamPizza extends Pizza{
    PizzaIngredientFactory ingredientFactory;
     
    public ClamPizza(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
    }
 
    void prepare() {
        System.out.println("Preparing " + name);
        cheese = ingredientFactory.createCheese();
        clam = ingredientFactory.createClam();
    }
}

 5. Client：仅使用由AbstractFactory和AbstractProduct类声明的接口。

　　这里的例子曲折了点，不过也可以大概说明要表达的意思。获取到具体Pizza的流程如下：

1. 首先创建一个纽约披萨店，即PizzaStore nyStore = new NYPizzaStore();
2. 通过披萨店下订单，即Pizza pizza = nyStore.orderPizza("cheese");
3. orderPizza("cheese")首先调用Pizza pizza = createPizza("cheese");
4. createPizza("cheese")中就涉及到了具体的工厂类，pizza = new CheesePizza(ingredientFactory);
5. 接下来就是具体的准备Pizza了，调用pizza.prepare()时，便是由工厂具体地创建所有对象家族了。如下

void prepare() {
    System.out.println("Preparing " + name);
    cheese = ingredientFactory.createCheese();
    //...其他的原料产品，如Veggies、Clams等，可能只需要一个，也可能全部都要。这里略去
}

 顺着这个思路走：

PizzaStore nyStore = new NYPizzaStore()　　→

　　　　Pizza pizza = nyStore.orderPizza("cheese")　　→

　　　　　　　　Pizza pizza = createPizza("cheese")　　→

　　　　　　　　　　　　pizza = new CheesePizza(ingredientFactory)　　→

　　　　　　　　　　　　　　　　pizza.prepare()　　→

　　　　　　　　　　　　　　　　　　　　ingredientFactory创建具体的产品。。。

测试用的主类和主函数：

/**
 * This is the test-main.
 * <p>
 * Reference : Head-First-Design-Patterns
 *
 */
public class PizzaTestApp {
    public static void main(String[] args) {
        PizzaStore nyStore = new NYPizzaStore();
        PizzaStore chicagoStore = new ChicagoPizzaStore();
 
        Pizza pizza = nyStore.orderPizza("cheese");
        System.out.println("Ethan ordered a " + pizza + "
");
 
        pizza = chicagoStore.orderPizza("cheese");
        System.out.println("Joel ordered a " + pizza + "
");

        pizza = nyStore.orderPizza("clam");
        System.out.println("Ethan ordered a " + pizza + "
");
 
        pizza = chicagoStore.orderPizza("clam");
        System.out.println("Joel ordered a " + pizza + "
");


        pizza = nyStore.orderPizza("veggie");
        System.out.println("Ethan ordered a " + pizza + "
");
 
        pizza = chicagoStore.orderPizza("veggie");
        System.out.println("Joel ordered a " + pizza + "
");
    }
}

 抽象类PizzaStore

/**
 * 
 * <p>
 * Reference : Head-First-Design-Patterns
 *
 */
public abstract class PizzaStore {
    protected 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;
    }
}

 继承抽象类PizzaStore的具体实现类NYPizzaStore。

/**
 * 
 * <p>
 * Reference : Head-First-Design-Patterns
 *
 */
public class NYPizzaStore extends PizzaStore{
    protected Pizza createPizza(String item) {
        Pizza pizza = null;
        PizzaIngredientFactory ingredientFactory = 
            new NYPizzaIngredientFactory();
 
        if (item.equals("cheese")) {
  
            pizza = new CheesePizza(ingredientFactory);
            pizza.setName("New York Style Cheese Pizza");
  
        } else if (item.equals("veggie")) {
 
            pizza = new VeggiePizza(ingredientFactory);
            pizza.setName("New York Style Veggie Pizza");
 
        } else if (item.equals("clam")) {
 
            pizza = new ClamPizza(ingredientFactory);
            pizza.setName("New York Style Clam Pizza");
 
        }
        return pizza;
    }
}

简单地总结，就是使用组合工厂类创建了包含一系列相关对象的具体产品对象。

 五、参考

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

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