工厂模式详解

3 种工厂模式

概述：工厂模式是个系列，分为简单工厂模式，工厂方法模式，抽象工厂模式，这三种模式也非常常用。这些模式最最经典的就例子就是设计计算器。

Factory Method (工厂方法模式)
Abstract Factory (抽象工厂模式）
Simple Factory（简单工厂模式）

参考 GoF《Design Patterns》一书 GOF 是这样描述工厂模式的：

“Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.”

在基类中定义创建对象的一个接口，让子类决定实例化哪个类。工厂方法让一个类的实例化延迟到子类中进行。

简单工厂模式

严格的说，简单工厂模式并不是 23 种常用的设计模式之一，它只算工厂模式的一个特殊实现。简单工厂模式在实际中的应用相对于其他 2 个工厂模式用的还是相对少得多，因为它只适应很多简单的情况，最最重要的是它违背了我们在概述中说的开放-封闭原则。因为每次你要新添加一个功能，都需要在生 switch-case 语句（或者 if-else 语句）中去修改代码，添加分支条件

简单工厂模式角色分配：

Creator（产品创建者）
简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
Product （产品抽象类）
简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
Concrete Product （具体产品）
是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

简单的工厂模式 UML 图

考虑下面一个事例：加入你是一个商人，你做的的是手机生意。现在你生产 android 手机和 iphone 等，考虑到以后你可能还会生产其他手机例如 ubuntu 手机。假定你选择了简单工厂模式来实现。那么显然，我们需要所有产品的抽象基类（Product）即是 Phone 类：

class Phone   
{  
public:  
    virtual ~Phone(){};//在删除的时候防止内存泄露  
    virtual void call(string number) = 0;  
};

然后我们需要具体的产品类 Concrete Product： AndroidPhone 和 iOSPhone

class AndroidPhone : public Phone   
{  
public:  
    void call(string number){ cout<<"AndroidPhone is calling..."<<endl;}  
};  

class IosPhone : public Phone  
{  
public:  
    void call(string number) { cout<<"IosPhone is calling..."<<endl;}  
};

最后我们需要 Creator

class PhoneFactory  
{  
public:  
    Phone* createPhone(string phoneName)  
    {  
        if(phoneName == "AndroidPhone")  
        {  
            return new AndroidPhone();  
        }else if(phoneName == "IosPhone")  
        {  
            return new IosPhone();  
        }  

        return NULL;  
    }  
};

客户端这样实现：

void main()  
{  
    PhoneFactor factory;  
    Phone* myAndroid = factory.createPhone("AndroidPhone");  
    Phone* myIPhone = factory.createPhone("iOSPhone");  
    if(myAndroid)  
    {  
        myAndroid->call("123");  
        delete myAndroid;  
        myAndroid = NULL;  
    }  

    if(myIPhone)  
    {  
        myIPhone->call("123");  
        delete  myIPhone;  
        myIPhone = NULL;  
    }  
}

这就是简单工厂方法，把所有的创建交给 creator,creator 通过 switch-case(或者 if-else)语句来选择具体创建的对象。简单明了。但是就如上面所说，它最致命的问题的违背了开放-封闭原则。每次你要新添加一个功能，都要修改 factor 里面的 createPhone 代码。但是工厂方法模式可以解决这个问题。

工厂方法模式

个人觉得工厂方法模式在工厂模式家族中是用的最多模式。上面说过了，如果简单工厂模式，要添加一个新功能，比如我现在要增加 WinPhone 的生产，那么我要修改 PhoneFactory 中的 createPhone 中的分支判断条件。这违背了开放-封闭原则，那为什么不能将创建方法放到子类中呢？
工厂方法的定义就是：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。

工厂方法模式角色：

抽象工厂(Creator)角色：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
具体工厂(Concrete Creator)角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。
抽象产品(Product)角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。
具体产品(Concrete Product)角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应

工厂方法模式 UML 图：

看定义看的晕乎乎的？那么我们来看代码：产品接口，以及其相应的子类。

class Phone   
{  
public:  
    virtual ~Phone(){};//在删除的时候防止内存泄露  
    virtual void call(string number) = 0;  
};  

class AndroidPhone : public Phone   
{  
public:  
    void call(string number){ cout<<"AndroidPhone is calling..."<<endl;}  
};  

class iOSPhone : public Phone  
{  
public:  
    void call(string number) { cout<<"iOSPhone is calling..."<<endl;}  
};

上面这个和简单工厂方法还是一样的。接下来不一样的来了…

class PhoneFactory  
{  
public:  
    virtual ~PhoneFactory(){};  
    virtual Phone* createPhone() = 0;  
};  

class AndroidPhoneFactory : public PhoneFactory  
{  
public:  
    virtual Phone* createPhone()  
    {  
        return new AndroidPhone();  
    }  
};  

class IosPhoneFactory : public PhoneFactory  
{  
public:  
    virtual Phone* createPhone()  
    {  
        return new IosPhone();  
    }  
};

工厂方法将 PhoneFactory 抽象成了基类，PhoneFactory 的 createPhone 不在像以前那样将所有的判断塞到里面。而是改由其子类来实现创建功能，这感觉就是权力下放。
客户端：

void main()  
{  
    PhoneFactory*  androidCreator = new AndroidPhoneFactory();  
    PhoneFactory*  iosCreator = new IosPhoneFactory();  
    Phone*  myAndroid = androidCreator->createPhone();  
    Phone* myIPhone = iosCreator->createPhone();  
    if(myAndroid)  
    {  
        myAndroid->call("123");  
        delete myAndroid;  
        myAndroid = NULL;  
    }  

    if(myIPhone)  
    {  
        myIPhone->call("123");  
        delete  myIPhone;  
        myIPhone = NULL;  
    }  

    delete androidCreator;  
    delete iosCreator;  
}

在工厂方法模式中，核心工厂类不在负责产品的创建，而是将具体的创建工作交给子类去完成。也就是后所这个核心工厂仅仅只是提供创建的接口，具体实现方法交给继承它的子类去完成。当我们的系统需要增加其他新功能时，只需要继承 PhoneFactory 这个类，并且实现 createPhone 接口。不需要对原工厂 PhoneFactory 进行任何修改，这样很好地符合了“开放-封闭“原则。

虽然工厂方法模式满足了”开放-封闭”原则，但是这个模式也仍然有缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，是的系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

抽象工厂模式

在工厂方法模式中，其实我们有一个潜在意识的意识。那就是我们生产的都是同一类产品，例如我们生产的都是手机！那么现在假如现在我们又要生产平板了了呢？那么就要用到抽象工厂模式。我抽象工厂模式也用的比较多在工厂模式家族中，仅次于工厂方法模式。在了解抽象工厂模式之前，还是老生常谈的理清下产品等级结构和产品簇的概念。下面的图还是老图。但是我讲讲我的理解：

产品等级结构：产品的等级结构也就是产品的继承结构。我理解就是同一类产品，比如手机是一个系列，有 android 手机，ios 手机，win 手机，那么这个抽象类手机和他的子类就构成了一个产品等级结构。那其他的平板显然不是和手机一个系列的，一个平板，一个是手机，所以他们是不同的产品等级结构。

产品族: 在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。比如分为 android 产品，和 ios 产品。其中一个 ios 产品包含 ios 手机和 ios 平板。显然 ios 手机和 ios 平板不是同一个产品等级结构的，因为一个是手机，一个是平板。但他们是同一个产品簇—都是 ios 产品。
希望大家通过上面的例子大家明白了这两个概念。

抽象工厂模式的 UML 图：

接着上面的话题，现在假如我要增加对平板的支持，那么我们肯定先添加两个产品等级结构，一个是手机，一个是平板：

//产品等级结构--手机  
class Phone   
{  
public:  
    virtual ~Phone(){};//在删除的时候防止内存泄露  
    virtual void call(string number) = 0;  
};  

class AndroidPhone : public Phone   
{  
public:  
    void call(string number){ cout<<"AndroidPhone is calling..."<<endl; }  
};  

class IosPhone : public Phone  
{  
public:  
    void call(string number) { cout<<"IosPhone is calling..."<<endl; }  
};  

//产品等级结构--平板  
class Pad  
{  
public:  
    virtual ~Pad(){};  
    virtual void playMovie() = 0;  
};  

class AndroidPad : public Pad  
{  
public:  
    virtual void playMovie(){ cout<<"AndriodPad is playing movie..."<<endl; }  
};  

class IosPad : public Pad  
{  
public:  
    virtual void playMovie(){ cout<<"IosPad is playing movie..."<<endl; }  
};

然后具体的工厂我们整个工厂是生产移动设备的所以我们取名为 MobileFactory,然后工厂可以生产平板和手机，故有了 createPhone 和 createPad 两个接口。

class MobileFactory  
{  
public:  
    virtual ~MobileFactory(){};  
    virtual Phone* createPhone() = 0;  
    virtual Pad* createPad() = 0;  
};

接着是 android 产品簇的工厂类，负责生产 android 的手机和平板：

class AndroidFactory : public MobileFactory  
{  
public:  
    Phone* createPhone()  
    {  
        return new AndroidPhone();  
    }  
    Pad* createPad()  
    {  
        return new AndroidPad();  
    }  
};

接着是 ios 的产品簇的工厂类，负责生产 ios 的手机和平板：

class IosFactory : public MobileFactory  
{  
public:  
    Phone* createPhone()  
    {  
        return new IosPhone();  
    }  

    Pad* createPad()  
    {  
        return new IosPad();  
    }  
};

最后客户端这样实现：

void main()  
{  
    MobileFactory*  androidCreator = new AndroidFactory();  
    MobileFactory*  iosCreator = new IosFactory();  
    Phone*  myAndroidPhone = androidCreator->createPhone();  
    Pad* myAndroidPad = androidCreator->createPad();  
    Phone* myIosPhone = iosCreator->createPhone();  
    Pad* myIosPad = iosCreator->createPad();  

    myAndroidPhone->call("123");  
    myAndroidPad->playMovie();  

    myIosPhone->call("123");  
    myIosPad->playMovie();  
    //这里没有做释放和判断，请自己判断和释放  
}

总结：
抽象工厂模式适用于那些有多种产品的产品簇，并且每次使用其中的某一产品簇的产品。
缺点：抽象工厂模式的添加新功能也非常麻烦，比工厂方法模式都还要复杂的多。
优点：当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象

主要用途

工厂方法要解决的问题是对象的创建时机，它提供了一种扩展的策略，很好地符合了开放封闭原则。工厂方法也叫做虚构造器（Virtual Constructor）。

什么时候使用工厂方法

当是如下情况是，可以使用工厂方法：一个类不知道它所必须创建的对象的类时，一个类希望有它的子类决定所创建的对象时。

更多关于工厂方法的介绍，可以参考本文最后给出的参考内容。下面我们就来看看在 iOS 中工厂方法的一种实现方法。

iOS 中工厂方法的实现实例

如下有一个类图，该图描述了下面即将实现的工厂方法（利用工厂方法，创建出不同的形状）。其中 BVShapeFactory 为工厂方法的基类，BVShape 为形状的基类，BVClient 通过 BVShapeFactory，利用 BVShapeFactory 的子类（BVCircleShapeFactory 和 BVSquareShapeFactory）分别创建出 BVCircleShape 和 BVSquareShape。