抽象工厂模式（Abstract Factory Pattern）

前言

​ 在工厂方法模式中，我们使用一个工厂创建一个产品，也就是说一个具体的工厂对应一个具体的产品。但是有时候我们需要一个工厂能够提供多个产品对象，而不是单一的对象，这个时候我们就需要使用抽象工厂模式。

一些概念

​ 产品等级结构：也就是产品的继承结构。例如一个为电视的抽象类，它有长虹电视、乐视电视、康佳电视等一系列的子类，那么这个抽象类电视和他的子类就构成了一个产品等级结构。

​ 产品族：是在抽象工厂模式中的。在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。比如，乐视工厂生产乐视电视。乐视手机，那么乐视电视则位于电视产品族中。

​ 产品等级结构与产品族结构示意图如下：

概念

​ 抽象工厂模式（Abstract Factory Pattern） 抽象工厂模式提供一个接口，用于创建相关或者依赖对象的家族，而不需要明确指定具体类。

​ 抽象工厂允许客户端使用抽象的接口来创建一组相关的产品，而不需要关系实际产出的具体产品是什么。这样一来，客户就可以从具体的产品中被解耦。

类图

​

AbstractFactoy: 抽象工厂。抽象工厂定义了一个接口，所有的具体工厂都必须实现此接口，这个接口包含了一组方法用来生产产品。

ConcreteFactory：具体工厂。具体工厂是用于生产不同产品族。要创建一个产品，客户只需要使用其中一个工厂完全不需要实例化任何产品对象。(图中AbstractFactoryA和AbstractFactoryB应改为ComcreteFactoryA、ComcreteFactoryB)

AbstractProduct：抽象产品。这是一个产品家族，每一个具体工厂都能够生产一整组产品。

Product：具体产品。

设计模式的实现

场景说明

​ 在披萨店中，为了要保证每家加盟店都能够生产高质量的披萨，防止使用劣质的原料，我们打算建造一家生产原料的工厂，并将原料运送到各家加盟店。但是加盟店都位于不同的区域，比如纽约、芝加哥。纽约使用一组原料，芝加哥使用另一种原料。在这里我们可以这样理解，这些不同的区域组成了原料家族，每个区域实现了一个完整的原料家族。

代码实现

以下忽略了各种原料类代码。

package abstractFactory;

/**
 * <p>ClassName      PizzaIngredientFactory
 * <p>Description   原料工厂。该工厂为抽象工厂，负责创建所有的原料。
 * <p>Author         ChongLou
 * <p>Version
 * <p>Date           2017/8/15 0:12
 */
public interface PizzaIngredientFactory {
    /*
     * 在接口中，每个原料都有一个对应的方法创建该原料
     */
    public Dough createDough();

    public Sauce createSauce();

    public Cheese createCheese();

    public Veggies[] createVeggies();

    public Pepperoni createPepperoni();

    public Clams createClams();
}

package abstractFactory;

/**
 * <p>ClassName      NYPizzaIngredientFactory
 * <p>Description    原料工厂。该具体工厂只需要继承PizzaIngredientFactory
 * <p>Author         ChongLou
 * <p>Version
 * <p>Date           2017/8/15 0:15
 */
public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
    public Cheese createCheese() {
        return new ReggianoCheese();
    }

    public Clams createClams() {
        return new FreshClams();
    }

    public Dough createDough() {
        return new ThinCrustDough();
    }

    public Pepperoni createPepperoni() {
        return new SlicedPepperoni();
    }

    public Sauce createSauce() {
        return new MarinaraSauce();
    }

    public Veggies[] createVeggies() {
        Veggies veggies[] = {new Garlic(), new Onion(), new Mushroom(), new RefPepper()};
        return veggies;
    }

}

package abstractFactory;

/**
 * <p>ClassName      Pizza
 * <p>Description
 * <p>Author         ChongLou
 * <p>Version
 * <p>Date           2017/8/15 0:17
 */
public abstract class Pizza {
    /*
         * 每个披萨都持有一组在准备时会用到的原料
         */
    String    name;
    Dough     dough;
    Sauce     sauce;
    Veggies   veggies[];
    Cheese    cheese;
    Pepperoni pepperoni;
    Clams     clams;

    /*
     * prepare()方法声明为抽象方法。在这个方法中，我们需要收集披萨所需要的原料，而这些原料都是来自原料工厂
     */
    abstract void prepare();

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

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

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

    public String getName() {
        return name;
    }

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


}

package abstractFactory;

/**
 * <p>ClassName      CheesePizza
 * <p>Description    所生产的原料依赖所使用的工厂，Pizza类根本不关心这些原料，
 *                  它只需要知道如何制作披萨即可。这里，Pizza和区域原料之间被解耦
 * <p>Author         ChongLou
 * <p>Version
 * <p>Date           2017/8/15 0:18
 */
public class CheesePizza extends Pizza {
    PizzaIngredientFactory ingredientFactory;

    /*
     * 要制作披萨必须要有制作披萨的原料，而这些原料是从原料工厂运来的
     */
    public CheesePizza(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
        prepare();
    }

    /**
     * 实现prepare方法
     * prepare 方法一步一步地创建芝士比萨，每当需要原料时，就跟工厂要
     */
    void prepare() {
        System.out.println( "Prepareing " + name );
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
    }
}

/**
 * <p>ClassName      ClamPizza
 * <p>Description    所生产的原料依赖所使用的工厂，Pizza类根本不关心这些原料，它只需要知道如何制作披萨*即可。这里，Pizza和区域原料之间被解耦。
 * <p>Author         ChongLou
 * <p>Version
 * <p>Date           2017/8/15 0:17
 */
public class ClamPizza extends Pizza{  
    PizzaIngredientFactory ingredientFactory;  

    public ClamPizza(PizzaIngredientFactory ingredientFactory){  
        this.ingredientFactory = ingredientFactory;  
    }  

    @Override  
    void prepare() {  
        System.out.println("Prepare " + name);  
        dough = ingredientFactory.createDough();  
        sauce = ingredientFactory.createSauce();  
        cheese = ingredientFactory.createCheese();  
        clams = ingredientFactory.createClams();        
    }  

}  

package abstractFactory;

/**
 * <p>ClassName      PizzaStore
 * <p>Description    披萨店类，在此其中披萨店和本地的原料工厂关联起来
 * <p>Author         ChongLou
 * <p>Version
 * <p>Date           2017/8/15 0:21
 */
public abstract class PizzaStore {
    public Pizza orderPizza(String type){
        Pizza pizza;
        pizza = createPizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }

    /*
    * 创建pizza的方法交给子类去实现
     */
    abstract Pizza createPizza(String type);
}

package abstractFactory;

/**
 * <p>ClassName      CheesePizza
 * <p>Description    所生产的原料依赖所使用的工厂，Pizza类根本不关心这些原料，
 *                  它只需要知道如何制作披萨即可。这里，Pizza和区域原料之间被解耦
 * <p>Author         ChongLou
 * <p>Version
 * <p>Date           2017/8/15 0:18
 */
public class CheesePizza extends Pizza {
    PizzaIngredientFactory ingredientFactory;

    /*
     * 要制作披萨必须要有制作披萨的原料，而这些原料是从原料工厂运来的
     */
    public CheesePizza(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
        prepare();
    }

    /**
     * 实现prepare方法
     * prepare 方法一步一步地创建芝士比萨，每当需要原料时，就跟工厂要
     */
    void prepare() {
        System.out.println( "Prepareing " + name );
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
    }
}

​ 其中PizzaIngredientFactory是抽象的披萨原料工厂接口，它定义了如何生产一个相关产品的家族。这个家族包含了所有制作披萨的原料。

​ NYPizzaIngredientFactory和ChicagoPizzaIngredientFactory是两个具体披萨工厂类，他们负责生产相应的披萨原料。

​ NYPizzaStore是抽象工厂的客户端。

总结

​ 抽象工厂隔离了具体类的生成，是的客户端不需要知道什么被创建。所有的具体工厂都实现了抽象工厂中定义的公共接口，因此只需要改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。但是，添加新的行为时比较麻烦。如果需要添加一个新产品族对象时，需要更改接口及其下所有子类，这必然会带来很大的麻烦。

​ 关于抽象工厂模式，还有很多不是很了解，有待补充。