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.”

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

1.简单工厂模式

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

简单工厂模式角色分配:

  1. Creator(产品创建者) 简单工厂模式的核心,它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用,创建所需的产品对象。

  2. Product ( 产品抽象类) 简单工厂模式所创建的所有对象的父类,它负责描述所有实例所共有的公共接口。

  3. Concrete Product (具体产品) 是简单工厂模式的创建目标,所有创建的对象都是充当这个角色的某个具体类的实例。

简单的工厂模式UML图 简单工厂模式

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

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

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

1
2
3
4
5
6
7
8
9
10
11
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class PhoneFactory
{
public:
    Phone* createPhone(string phoneName)
    {
        if(phoneName == "AndroidPhone")
        {
            return new AndroidPhone();
        }else if(phoneName == "IosPhone")
        {
            return new IosPhone();
        }

        return NULL;
    }
};

客户端这样实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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代码。 但是工厂方法模式可以解决这个问题。

2.工厂方法模式

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

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

工厂方法模式UML图: 工厂方法模式

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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;}
};

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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不在像以前那样将所有的判断塞到里面。而是改由其子类来实现创建功能,这感觉就是权力下放。 客户端:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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进行任何修改,这样很好地符合了“开放-封闭“原则。

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

3.抽象工厂模式

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

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

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

抽象工厂模式的UML图: 抽象工厂模式

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//产品等级结构--手机  
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两个接口。

1
2
3
4
5
6
7
class MobileFactory
{
public:
    virtual ~MobileFactory(){};
    virtual Phone* createPhone() = 0;
    virtual Pad* createPad() = 0;
};

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

1
2
3
4
5
6
7
8
9
10
11
12
class AndroidFactory : public MobileFactory
{
public:
    Phone* createPhone()
    {
        return new AndroidPhone();
    }
    Pad* createPad()
    {
        return new AndroidPad();
    }
};

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

1
2
3
4
5
6
7
8
9
10
11
12
13
class IosFactory : public MobileFactory
{
public:
    Phone* createPhone()
    {
        return new IosPhone();
    }

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

最后客户端这样实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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。 工厂方法

github下载地址:https://github.com/BeyondVincent/ios_patterns/tree/master/FactoryMethodPattern

参考资料

备注:欢迎转载,但请一定注明出处! http://blog.wangruofeng007.com

Comments