设计模式--抽象工厂模式

设计原则：

要依赖抽象，不要依赖具体类

目录

本文的结构如下：

• 什么是抽象工厂模式
• 为什么要用该模式
• 模式的结构
• 代码示例
• 优点和缺点
• 适用环境
• 模式应用
• 模式扩展
• 总结

一、前言

工厂方法模式通过引入工厂等级结构，解决了简单工厂模式中工厂类职责太重的问题，但由于工厂方法模式中的每个工厂只生产一类产品，可能会导致系统中存在大量的工厂类，势必会增加系统的开销。此时，我们可以考虑将一些相关的产品组成一个“产品族”，由同一个工厂来统一生产，这就是我们本文将要学习的抽象工厂模式的基本思想。

二、什么是抽象工厂模式

抽象工厂模式(Abstract Factory Pattern)：提供一个接口，用于创建一系列相关或相互依赖对象的家族，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。

三、为什么要用该模式

3.1、官方解释

在工厂方法模式中具体工厂负责生产具体的产品，每一个具体工厂对应一种具体产品，工厂方法也具有唯一性，一般情况下，一个具体工厂中只有一个工厂方法或者一组重载的工厂方法。但是有时候我们需要一个工厂可以提供多个产品对象，而不是单一的产品对象。

为了更清晰地理解工厂方法模式，需要先引入两个概念：

• 产品等级结构：产品等级结构即产品的继承结构，如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是其子类。
• 产品族：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中。

当系统所提供的工厂所需生产的具体产品并不是一个简单的对象，而是多个位于不同产品等级结构中属于不同类型的具体产品时需要使用抽象工厂模式。

抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态。

抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构，一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建。当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时，抽象工厂模式比工厂方法模式更为简单、有效率。

3.2、举个例子

你的蛋糕店卖得非常好，为了更好的提供效率，你决定为每个蛋糕店开设一个原料提供工厂，每个蛋糕店都有专门的原料工厂提供原料，比如水果蛋糕需要的鸡蛋和水果，但CenterCakeStore更多卖的是草莓类水果蛋糕，用的鸡蛋是一般的鸡蛋，而CollegeCakeStore更多卖的是菠萝类水果蛋糕，并且用的鸡蛋都是土鸡蛋，所以原料工厂提供的具体水果和鸡蛋是不一样的，代码怎么设计呢？

这次你没有请我，因为你足够聪明，你知道我肯定会这样写：

为每个原料建立一个抽象工厂类，提供抽象方法用于获取产品：

/**
 * Created by w1992wishes on 2017/11/1.
 */
public abstract class FruitFactory {
    public abstract Fruit provideFruit();
}
/**
 * Created by w1992wishes on 2017/11/1.
 */
public abstract class EggFactory {
    abstract Egg provideEgg();
}

然后为抽象工厂提供多个实现，每个子类工厂提供一种具体的原料：

/**
 * Created by w1992wishes on 2017/11/1.
 */
public class CenterFruitFactory extends FruitFactory {

    @Override
    public Fruit provideFruit() {
        return new StrawberryFruit();
    }
}
/**
 * Created by w1992wishes on 2017/11/1.
 */
public class CollegeFruitFactory extends FruitFactory{
    @Override
    public Fruit provideFruit() {
        return new MangoFruit();
    }
}
/**
 * Created by w1992wishes on 2017/11/1.
 */
public class CenterEggFactory extends EggFactory {
    @Override
    Egg provideEgg() {
        return new NormalEgg()();
    }
}
/**
 * Created by w1992wishes on 2017/11/1.
 */
public class CollegeEggFactory extends EggFactory{
    @Override
    Egg provideEgg() {
        return new SpecialEgg();
    }
}

接着还有一堆抽象原料，Egg，Fruit…
一堆具体原料，SpecialEgg，NormalEgg，MangoFruit…
还要在具体的Cake中用具体的原料：

/**
 * Created by w1992wishes on 2017/10/31.
 */
public class CenterFruitCake extends Cake {
    public CenterFruitCake(){
        name = "center fruit cake";
    }
    @Override
    public void prepare(){
        FruitFactory fruitFactory = new CenterFruitFactory();
        EggFactory eggFactory = new CenterEggFactory();
        fruit = fruitFactory.provideFruit();
        egg = eggFactory.provideEgg();
    }
}
/**
 * Created by w1992wishes on 2017/11/1.
 */
public class CollegeFruitCake extends Cake {
    public CollegeFruitCake(){
        name = "college fruit cake";
    }
    @Override
    public void prepare(){
        FruitFactory fruitFactory = new CollegeFruitFactory();
        EggFactory eggFactory = new CollegeEggFactory();
        fruit = fruitFactory.provideFruit();
        egg = eggFactory.provideEgg();
    }
}

经过一堆复杂的类构建，最后才能订购，而且这还只是一种蛋糕，如果需要增加新的蛋糕时，虽然不要修改现有代码，但是需要增加大量类，针对每一个新增具体组件都需要增加一个具体工厂，类的个数成对增加，这无疑会导致系统越来越庞大，增加系统的维护成本和运行开销；

正是因为每一个具体工厂对应一种具体产品，如果产品族很多，会引入很多类，为了解决这个问题，所以有了抽象工厂模式。

四、模式的结构

抽象工厂模式结构和工厂方法模式结构差不多，只是多了产品族中其他的抽象产品和具体产品。

● Factory（抽象工厂）：它声明了一组用于创建一族产品的方法，每一个方法对应一种产品。
● ConcreteFactory（具体工厂）：它实现了在抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中。
● Product（抽象产品）：它为每种产品声明接口，在抽象产品中声明了产品所具有的业务方法。
● ConcreteProduct（具体产品）：它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法。

五、代码示例

先定义一个抽象原料工厂：

/**
 * Created by w1992wishes on 2017/11/1.
 */
public interface FoodFactory {
    Egg provideEgg();
    Fruit provideFruit();
}

每个蛋糕店对应的具体工厂：

/**
 * Created by w1992wishes on 2017/11/1.
 */
public class CenterFoodFactory implements FoodFactory {
    @Override
    public Egg provideEgg() {
        return new NormalEgg();
    }
    @Override
    public Fruit provideFruit() {
        return new StrawberryFruit();
    }
}

/**
 * Created by w1992wishes on 2017/11/1.
 */
public class CollegeFoodFactory implements FoodFactory {
    @Override
    public Egg provideEgg() {
        return new SpecialEgg();
    }
    @Override
    public Fruit provideFruit() {
        return new MongoFruit();
    }
}

具体的水果蛋糕类：

/**
 * Created by w1992wishes on 2017/11/01.
 */
public abstract class Cake {
    String name;
    Fruit fruit;
    Egg egg;

    abstract void prepare();
    void bake(){
        System.out.println("bake");
    }
    void box(){
        System.out.println("box");
    }

    public String getName() {
        return name;
    }
    public Fruit getFruit(){
        return fruit;
    }
    public Egg getEgg(){
        return egg;
    }
}

/**
 * Created by w1992wishes on 2017/10/31.
 */
public class CenterFruitCake extends Cake {
    public CenterFruitCake(){
        name = "center fruit cake";
    }
    @Override
    public void prepare(){
        FoodFactory foodFactory = new CenterFoodFactory();
        fruit = foodFactory.provideFruit();
        egg = foodFactory.provideEgg();
    }
}

/**
 * Created by w1992wishes on 2017/11/1.
 */
public class CollegeFruitCake extends Cake {
    public CollegeFruitCake(){
        name = "college fruit cake";
    }
    @Override
    public void prepare(){
        FoodFactory foodFactory = new CollegeFoodFactory();
        fruit = foodFactory.provideFruit();
        egg = foodFactory.provideEgg();
    }
}

蛋糕店的代码不变：

/**
 * Created by w1992wishes on 2017/11/1.
 */
public class CenterCakeStore extends CakeStore {
    @Override
    protected Cake createCake(String type) {
        Cake cake = null;
        if ("cheese".equals(type)) {
            cake = new CenterCheeseCake();
        } else if ("fruit".equals(type)) {
            cake = new CenterFruitCake();
        } else if ("cream".equals(type)) {
            cake = new CenterCreamCake();
        } 
        return cake;
    }
}

/**
 * Created by w1992wishes on 2017/11/1.
 */
public class CollegeCakeStore extends CakeStore {
    @Override
    protected Cake createCake(String type) {
        Cake cake = null;
        if ("cheese".equals(type)) {
            cake = new CollegeCheeseCake();
        } else if ("fruit".equals(type)) {
            cake = new CollegeFruitCake();
        } else if ("cream".equals(type)) {
            cake = new CollegeCreamCake();
        } 
        return cake;
    }
}

客户端代码不变：

/**
 * Created by w1992wishes on 2017/11/1.
 */
public class Client {
    public static void main(String[] args) {
        CakeStore cakeStore = new CollegeCakeStore();//这里可通过引入配置文件更改
        cakeStore.orderCake("fruit");
    }
}

看这段代码可能有点疑惑，建议不用管蛋糕店，直接看制作蛋糕的原料那块，是抽象工厂模式的真正实现代码。

相对于工厂方法模式，抽象工厂方法，即没有破坏“开闭原则”，同时又解决了前者引入大量工厂类的弊端，是前者更高层次的抽象。

六、优点和缺点

6.1、优点

• 抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用。
• 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说，是一种非常实用的设计模式。
• 增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。

6.2、缺点

• 在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是因为在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对该接口进行扩展，而这将涉及到对抽象工厂角色及其所有子类的修改，显然会带来较大的不便。
• 开闭原则的倾斜性。
  (1) 增加产品族：对于增加新的产品族，抽象工厂模式很好地支持了“开闭原则”，只需要增加具体产品并对应增加一个新的具体工厂，对已有代码无须做任何修改。
  (2) 增加新的产品等级结构：对于增加新的产品等级结构，需要修改所有的工厂角色，包括抽象工厂类，在所有的工厂类中都需要增加生产新产品的方法，违背了“开闭原则”。

正因为抽象工厂模式存在“开闭原则”的倾斜性，它以一种倾斜的方式来满足“开闭原则”，为增加新产品族提供方便，但不能为增加新产品结构提供这样的方便，因此要求设计人员在设计之初就能够全面考虑，不会在设计完成之后向系统中增加新的产品等级结构，也不会删除已有的产品等级结构，否则将会导致系统出现较大的修改，为后续维护工作带来诸多麻烦。

七、适用环境

在以下情况下可以考虑使用抽象工厂模式：

• 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是很重要的，用户无须关心对象的创建过程，将对象的创建和使用解耦。
• 系统中有多于一个的产品族，而每次只使用其中某一产品族。可以通过配置文件等方式来使得用户可以动态改变产品族，也可以很方便地增加新的产品族。
• 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。同一个产品族中的产品可以是没有任何关系的对象，但是它们都具有一些共同的约束，如同一制作水果蛋糕用的水果–草莓和芒果，草莓和芒果之间没有直接关系，但它们都是属于水果。
• 产品等级结构稳定，设计完成之后，不会向系统中增加新的产品等级结构或者删除已有的产品等级结构。

八、模式应用

在很多软件系统中需要更换界面主题，要求界面中的按钮、文本框、背景色等一起发生改变时，可以使用抽象工厂模式进行设计。

九、模式扩展

“开闭原则”的倾斜性

在介绍抽象工厂方法模式的缺点已经提到，这里再重复啰嗦一下。

“开闭原则”要求系统对扩展开放，对修改封闭，通过扩展达到增强其功能的目的。对于涉及到多个产品族与多个产品等级结构的系统，其功能增强包括两方面：

• 增加产品族：对于增加新的产品族，工厂方法模式很好的支持了“开闭原则”，对于新增加的产品族，只需要对应增加一个新的具体工厂即可，对已有代码无须做任何修改。
• 增加新的产品等级结构：对于增加新的产品等级结构，需要修改所有的工厂角色，包括抽象工厂类，在所有的工厂类中都需要增加生产新产品的方法，不能很好地支持“开闭原则”。

工厂模式的退化

当抽象工厂模式中每一个具体工厂类只创建一个产品对象，也就是只存在一个产品等级结构时，抽象工厂模式退化成工厂方法模式；当工厂方法模式中抽象工厂与具体工厂合并，提供一个统一的工厂来创建产品对象，并将创建对象的工厂方法设计为静态方法时，工厂方法模式退化成简单工厂模式。

十、总结

• 抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。
• 抽象工厂模式包含四个角色：抽象工厂用于声明生成抽象产品的方法；具体工厂实现了抽象工厂声明的生成抽象产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中；抽象产品为每种产品声明接口，在抽象产品中定义了产品的抽象业务方法；具体产品定义具体工厂生产的具体产品对象，实现抽象产品接口中定义的业务方法。
• 抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构。
• 抽象工厂模式的主要优点是隔离了具体类的生成，使得客户并不需要知道什么被创建，而且每次可以通过具体工厂类创建一个产品族中的多个对象，增加或者替换产品族比较方便，增加新的具体工厂和产品族很方便；主要缺点在于增加新的产品等级结构很复杂，需要修改抽象工厂和所有的具体工厂类，对“开闭原则”的支持呈现倾斜性。
• 抽象工厂模式适用情况包括：一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节；系统中有多于一个的产品族，而每次只使用其中某一产品族；属于同一个产品族的产品将在一起使用；系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。