设计模式学习笔记（六）：抽象工厂模式

1 概述

1.1 引言

在了解抽象工厂模式之前，首先来了解一下两个术语：

• 产品等级结构
• 产品族

1.1.1 产品等级结构

产品等级结构也就是产品的继承结构，例如一个抽象类是电视机，子类有不同品牌的电视机，比如海尔电视机，海信电视机，TCL电视机，而抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是子类。

1.1.2 产品族

产品族是指由一个同一个工厂产生的位于不同产品等级结构中的一组产品，例如海尔电器工厂生产的海尔电视机，海尔电冰箱。海尔电视机位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中，海尔电视机与海尔电冰箱共同构成了一个产品族。

两者示意图如下：

抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式是针对一个产品等级结构，而抽象工厂模式需要面对多个产品等级结构，一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建。

每一个具体工厂可以生产属于一个产品族的所有产品，所生产的产品又位于不同的产品等级结构中，在上图的例子中，如果使用工厂方法模式需要12个具体工厂类，而使用抽象工厂模式只需要4个工厂类，大大减少了系统中类的个数。

1.2 定义

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。

抽象工厂模式又叫Kit模式，是一种对象创建型模式。

1.3 结构图

1.4 角色

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

2 典型实现

2.1 步骤

• 确定产品等级结构：也就是定义抽象产品，抽象产品的数量就是产品等级结构的数量，为抽象产品声明产品所具有的业务方法
• 确定产品族：也就是定义具体产品，对于每个抽象产品，有多少个子类就有多少个产品族，具体产品类实现或继承抽象产品，实现其中的业务方法
• 定义抽象工厂：定义为接口/抽象类，声明创建一族产品的方法，根据产品等级结构数量确定方法数量
• 定义具体工厂：实现/继承抽象工厂，实现其中的业务方法

2.2 抽象产品

这里简单定义两个抽象产品接口，也就是假设有两个产品等级结构（A与B）：

interface ProductA
{
    void methodA();
}

interface ProductB
{
    void methodB();
}

2.3 具体产品

声明四个具体产品，假设每种产品由分别两个工厂生产，也就是假设有两个产品族：

class ProductA1 implements ProductA
{
    public void methodA()
    {
        System.out.println("Product A1");
    }
}

class ProductA2 implements ProductA
{
    public void methodA()
    {
        System.out.println("Product A2");
    }
}

class ProductB1 implements ProductB
{
    public void methodB()
    {
        System.out.println("Product B1");
    }
}

class ProductB2 implements ProductB
{
    public void methodB()
    {
        System.out.println("Product B2");
    }
}

2.4 抽象工厂

由于只有两个产品等级结构（A与B），这里的抽象工厂只需要两个方法，分别表示生产这两种产品：

interface Factory
{
    ProductA getProductA();
    ProductB getProductB();
}

2.5 具体工厂

由于上面已经假设为两个产品族，因此这里需要两个具体工厂：

//产品族Factory1
class Factory1 implements Factory
{
    public ProductA getProductA()
    {
        return new ProductA1();
    }

    public ProductB getProductB()
    {
        return new ProductB1();
    }
}

//产品族Factory2
class Factory2 implements Factory
{
    public ProductA getProductA()
    {
        return new ProductA2();
    }

    public ProductB getProductB()
    {
        return new ProductB2();
    }
}

2.6 客户端

public static void main(String[] args) {
    Factory factory = new Factory1();
    ProductA productA = factory.getProductA();
    ProductB productB = factory.getProductB();
    productA.methodA();
    productB.methodB();

    factory = new Factory2();
    productA = factory.getProductA();
    productB = factory.getProductB();
    productA.methodA();
    productB.methodB();
}

客户端针对抽象工厂以及抽象产品编程，只需要知道工厂类名即可获取同一工厂（同一产品族）不同产品等级结构的产品。

3 实例

界面皮肤库设计：开发一套皮肤库，用户可以通过菜单选择皮肤，不同的皮肤提供视觉不同的按钮，文本框等UI元素，使用抽象工厂模式进行设计。

这里简单起见假设开发两套皮肤：

• 春季皮肤（SpringSkin）
• 夏季皮肤（SummerSkin）

每套皮肤具有以下UI元素：

• 按钮（Button）
• 文本框（TextField）
• 组合框（ComboBox）

具体设计如下：

• 抽象产品：Button+TextField+ComboBox
• 具体产品：SpringButton+SummerButton+SpringTextField+SummerTextField+SpringComboBox+SummerComboBox
• 抽象工厂：SkinFactory
• 具体工厂：SpringSkinFactory+SummerSkinFactory

先设计产品类：

//抽象产品
interface Button
{
    void display();
}

//具体产品
class SpringButton implements Button
{
    public void display()
    {
        System.out.println("春季皮肤按钮");
    }
}

//具体产品
class SummerButton implements Button
{
    public void display()
    {
        System.out.println("夏季皮肤按钮");
    }
}

//抽象产品
interface TextField
{
    void display();
}

//具体产品
class SpringTextField implements TextField
{
    public void display()
    {
        System.out.println("春季皮肤文本框");
    }
}

//具体产品
class SummerTextField implements TextField
{
    public void display()
    {
        System.out.println("夏季皮肤文本框");
    }
}

//抽象产品
interface ComboBox
{
    void display();
}

//具体产品
class SpringComboBox implements ComboBox
{
    public void display()
    {
        System.out.println("春季皮肤组合框");
    }
}

//具体产品
class SummerComboBox implements ComboBox
{
    public void display()
    {
        System.out.println("夏季皮肤组合框");
    }
}

接着是工厂类：

//抽象工厂
interface SkinFactory
{
    Button createButton();
    TextField createTextField();
    ComboBox createComboBox();
}

//具体工厂
class SpringSkinFactory implements SkinFactory
{
    public Button createButton()
    {
        return new SpringButton();
    }

    public TextField createTextField()
    {
        return new SpringTextField();
    }

    public ComboBox createComboBox()
    {
        return new SpringComboBox();
    }
}

//具体工厂
class SummerSkinFactory implements SkinFactory
{
    public Button createButton()
    {
        return new SummerButton();
    }

    public TextField createTextField()
    {
        return new SummerTextField();
    }

    public ComboBox createComboBox()
    {
        return new SummerComboBox();
    }
}

测试：

public class Test
{
    public static void main(String[] args) {
        SkinFactory factory = new SpringSkinFactory();
        factory.createButton().display();
        factory.createTextField().display();
        factory.createComboBox().display();
        
        factory = new SummerSkinFactory();
        factory.createButton().display();
        factory.createTextField().display();
        factory.createComboBox().display();
    }
}

4 有关OCP

虽然使用抽象工厂模式增加新的皮肤界面非常方便，但是如果增加一个UI元素，会修改大量的代码，需要修改抽象工厂以及每一个具体工厂类，也就是说，不能够在符合OCP（开放闭合原则）的前提下增加新的组件。

这是抽象工厂模式的最大缺点，尽管增加新的产品族（这里是皮肤）非常方便，但是增加新的产品等级结构（这里是UI元素）很麻烦。抽象工厂模式的这种性质叫做开闭原则的倾斜性。因此设计人员在设计之初需要全面考虑，否则新增产品结构会导致大量的代码修改。

5 主要优点

• 隔离：抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离更换一个具体工厂类变得很相对容易，所有的具体工厂都实现了在抽象工厂中声明的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为
• 同一产品族对象：当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象
• 增加产品族容易：增加新的产品族容易，无须修改已有系统，符合OCP

6 主要缺点

主要缺点是增加新的产品等级结构麻烦，需要对系统进行大量的修改，违背了OCP。

7 适用场景

• 一个系统不当应依赖与产品类实例如何被创建，组合和表达细节，这对于所有类型的工厂模式都是很重要的，用户无须关心对象的创建过程，将对象的创建以及使用解耦
• 系统中有多于一个的产品族，而每次只使用其中某一产品族
• 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。同一个产品族中的产品可以是没有任何关系的对象，但是它们都具有一些共同的约束。例如同一皮肤下的按钮以及文本框，按钮与文本框没有直接联系，但是都属于同一皮肤
• 产品等级结构稳定，设计完成后，不会向系统中增加新的产品等级结构或者删除已有的产品等级结构

8 总结