C++设计模式之简单工厂模式

  Iphone 6即将面世过程中，富士康集团正在为Iphone6的面世做着最后的冲刺，生产线上的工人正忙碌着为Iphone6进行各道流程的加工操作。作为代工工厂，富士康为世界上IT巨头，如：苹果，惠普等加工出各种产品。市场上看到的各种品牌电脑，绝大部分来在富士康这家代工厂。在设计模式中,也存在一个类似的模式，提供一个工厂，根据需要可以创建出各种不同类型的对象，该模式称之为简单工程模式。

1、简单工厂模式    

    简单工厂模式并不属于GoF 23个经典设计模式，但通常将它作为学习其他工厂模式的基础，它的设计思想很简单，其基本流程如下：

    首先将需要创建的各种不同对象的相关代码封装到不同的类中，这些类称为具体产品类，而将它们公共的代码进行抽象和提取后封装在一个抽象产品类中，每一个具体产品类都是抽象产品类的子类；然后提供一个工厂类用于创建各种产品，在工厂类中提供一个创建产品的工厂方法，该方法可以根据所传入的参数不同创建不同的具体产品对象；客户端只需调用工厂类的工厂方法并传入相应的参数即可得到一个产品对象。

    简单工厂模式定义如下：

       简单工厂模式(Simple Factory Pattern)：定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。因为在简单工厂模式中用于创建实例的方法是静态(static)方法，因此简单工厂模式又被称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。

        简单工厂模式的要点在于：当你需要什么，只需要传入一个正确的参数，就可以获取你所需要的对象，而无须知道其创建细节。简单工厂模式结构比较简单，其核心是工厂类的设计，其结构如图1所示：

图1  简单工厂模式结构图

    在简单工厂模式结构图中包含如下几个角色：

    Factory（工厂角色）：工厂角色即工厂类，它是简单工厂模式的核心，负责实现创建所有产品实例的内部逻辑；工厂类可以被外界直接调用，创建所需的产品对象；在工厂类中提供了静态的工厂方法factoryMethod()，它的返回类型为抽象产品类型Product。

    Product（抽象产品角色）：它是工厂类所创建的所有对象的父类，封装了各种产品对象的公有方法，它的引入将提高系统的灵活性，使得在工厂类中只需定义一个通用的工厂方法，因为所有创建的具体产品对象都是其子类对象。

    ConcreteProduct（具体产品角色）：它是简单工厂模式的创建目标，所有被创建的对象都充当这个角色的某个具体类的实例。每一个具体产品角色都继承了抽象产品角色，需要实现在抽象产品中声明的抽象方法。

    如果不使用简单工厂，而是直接在客户端通过多次使用new操作和创建多个具体对象（可以是不同类型的具体对象），客户端需要知道具体的类型，针对的是具体编程而不是针对接口编程，这违背了“针对接口编程而不是针对具体编程原则”，也违背了"迪米特法则，也就是最少朋友原则"（客户端需要知道具体类型，而具体类型不是客户类的直接朋友）。对象创建是一个变化的过程，因此应该封装变化。在简单工厂模式中，客户端通过工厂类来创建一个产品类的实例，而无须直接使用new关键字来创建对象，减少了客户端与具体对象之间的耦合，把对象的创建过程封装在了工厂中，对客户端而言，隐藏了对象创建的具体细节。

    在使用简单工厂模式时，首先需要对产品类进行重构，不能设计一个包罗万象的产品类，而需根据实际情况设计一个产品层次结构，将所有产品类公共的代码移至抽象产品类，并在抽象产品类中声明一些抽象方法，以供不同的具体产品类来实现。

2、OCR软件项目的开发与实现

    某OCR软件公司根据市场需求，欲开发银行卡识别、身份证识别、驾照识别项目。请为这些OCR识别项目开发一套统一的框架，要求能够具有扩展性。（身份证识别: 意思是把身份证图片传送给识别引擎，由引擎对图像进行处理，把处理之后的文本信息返回）

1.不适用模式实现方式一

    项目实现代码如下：

[cpp] view plaincopy

1. #ifndef _DEVELOP_PRODUCT_H_  
2. #define _DEVELOP_PRODUCT_H_  
3.   
4. #include <iostream>  
5. #include <string>  
6. using namespace std;  
7.   
8. //开发产品类  
9. class DevelopProduct  
10. {  
11. private:  
12.     //产品名  
13.     string m_strProductName;  
14. public:  
15.     //根据参数类型创建具体产品，在这里为简单起见只是保存着项目名称操作  
16.     void CreateProduct(string strProdectName)  
17.     {  
18.         if( 0 == strcmp(strProdectName.c_str(), "银行卡识别项目") )  
19.         {  
20.             m_strProductName = "银行卡识别项目";  
21.         }  
22.         else if( 0 == strcmp(strProdectName.c_str(), "身份证识别项目") )  
23.         {  
24.             m_strProductName = "身份证识别项目";  
25.         }  
26.         else if( 0 == strcmp(strProdectName.c_str(), "驾驶证识别项目") )  
27.         {  
28.             m_strProductName = "驾驶证识别项目";  
29.         }  
30.     }  
31.   
32.     //显示创建的产品名称  
33.     void DisplayProduct()  
34.     {  
35.         cout << "项目名称: " << m_strProductName << endl;  
36.     }  
37. };  
38.   
39.   
40. #endif  

    DevelopProduct开发产品类，CreateProduct函数根据参数类型的不同，创建具体各个不同的识别产品。
    测试代码实现如下：

[cpp] view plaincopy

1. #include <iostream>  
2. #include "DevelopProduct.h"  
3. using namespace std;  
4.   
5. int main()  
6. {  
7.     DevelopProduct * pDevelopProduct = new DevelopProduct();  
8.       
9.     pDevelopProduct->CreateProduct("银行卡识别项目");  
10.     pDevelopProduct->DisplayProduct();  
11.       
12.     pDevelopProduct->CreateProduct("身份证识别项目");  
13.     pDevelopProduct->DisplayProduct();  
14.   
15.     pDevelopProduct->CreateProduct("驾驶证识别项目");  
16.     pDevelopProduct->DisplayProduct();  
17.   
18.     return 0;  
19. }  

    编译并运行，结果如下：

    仔细发现，DevelopProduct类的CreateProduct方法带有多个条件判断，根据每种类型的不同，创建不同的软件产品。整个类的代码相当冗长，代码越长，阅读难度、维护难度和测试难度也越大。如果需要再添加一个"火车票识别项目",得修改CreateProduct代码，违背了开放封闭原则。因此需要对此代码进行重构,把创建的过程封装起来。在重构代码之前，再来看一个没有使用模式的例子。

2.不适用模式实现方式二

   项目实现代码如下：

[cpp] view plaincopy

1. #ifndef _SOFT_PRODUCT_H_  
2. #define _SOFT_PRODUCT_H_  
3.   
4. #include <iostream>  
5. using namespace std;  
6.   
7. //抽象软件产品类  
8. class SoftProduct  
9. {  
10. public:  
11.     virtual void DisplayProduct() = 0;  
12. };  
13.   
14.   
15. //银行卡产品  
16. class BankCard : public SoftProduct  
17. {  
18. public:  
19.     void DisplayProduct()  
20.     {  
21.         cout << "项目名称: " << "银行卡识别项目" << endl;  
22.     }  
23. };  
24.   
25.   
26. //身份证产品  
27. class IdentityCard : public SoftProduct  
28. {  
29. public:  
30.     void DisplayProduct()  
31.     {  
32.         cout << "项目名称: " << "身份证识别项目" << endl;  
33.     }  
34. };  
35.   
36.   
37.   
38. //驾驶证产品  
39. class DriveLicense : public SoftProduct  
40. {  
41. public:  
42.     void DisplayProduct()  
43.     {  
44.         cout << "项目名称: " << "驾驶证识别项目" << endl;  
45.     }  
46. };  
47.   
48. #endif  

    SoftProduct为抽象的OCR软件产品类，包含一个显示方法，显示各个项目的名称。 BankCard银行卡类，IdentityCard身份证类，DriveLicense驾照类是SoftProduct的子类。

    测试代码如下：

[cpp] view plaincopy

1. #include <iostream>  
2. #include "SoftProduct.h"  
3. using namespace std;  
4.   
5. int main()  
6. {  
7.     SoftProduct * pSoftProduct = NULL;  
8.   
9.     //创建银行卡识别项目  
10.     pSoftProduct = new BankCard();  
11.     pSoftProduct->DisplayProduct();  
12.     delete pSoftProduct;  
13.     pSoftProduct = NULL;  
14.   
15.     //创建身份证识别项目  
16.     pSoftProduct = new IdentityCard();  
17.     pSoftProduct->DisplayProduct();  
18.     delete pSoftProduct;  
19.     pSoftProduct = NULL;  
20.   
21.     //创建驾驶证识别项目  
22.     pSoftProduct = new DriveLicense();  
23.     pSoftProduct->DisplayProduct();  
24.     delete pSoftProduct;  
25.     pSoftProduct = NULL;  
26.   
27.     return 0;  
28. }  

    编译并执行，结果如下：

    使用继承的方式，可以根据需要进行扩展。如果需要添加一个"火车票识别项目",则只需要定义一个火车票识别项目类，继承于抽象产品类SoftProduct就可以了，不需要对原有代码进行修改，满足开放封闭原则。

    但需要创建具体的软件项目产品时，客户端得知道具体的软件产品类型。上面程序，客户端得知道BankCard银行卡类，IdentityCard身份证类，DriveLicense驾照类这三个具体类型。也就是说客户端针对具体进行编程而不是针对抽象进行编程，违背了针对抽象进行编程原则。同时客户端知道这些具体的类型，增加了类间的耦合性，也违背了迪米特法则，也就是最小朋友原则（那些具体的类型不是客户端的直接朋友，客户端只需要认识抽象产品类SoftProduct就可以了）。因此，发现问题后得重构上述代码，把对象的具体创建细节封装起来，对客户端隐藏创建的具体细节。

3、使用模式的实现方式

    软件产品类的实现代码如下：

[cpp] view plaincopy

1. #ifndef _SOFT_PRODUCT_H_  
2. #define _SOFT_PRODUCT_H_  
3.   
4. #include <iostream>  
5. using namespace std;  
6.   
7. //抽象软件产品类  
8. class SoftProduct  
9. {  
10. public:  
11.     virtual void DisplayProduct() = 0;  
12. };  
13.   
14.   
15. //银行卡产品  
16. class BankCard : public SoftProduct  
17. {  
18. public:  
19.     void DisplayProduct()  
20.     {  
21.         cout << "项目名称: " << "银行卡识别项目" << endl;  
22.     }  
23. };  
24.   
25.   
26.   
27. //身份证产品  
28. class IdentityCard : public SoftProduct  
29. {  
30. public:  
31.     void DisplayProduct()  
32.     {  
33.         cout << "项目名称: " << "身份证识别项目" << endl;  
34.     }  
35. };  
36.   
37.   
38.   
39.   
40. //驾驶证产品  
41. class DriveLicense : public SoftProduct  
42. {  
43. public:  
44.     void DisplayProduct()  
45.     {  
46.         cout << "项目名称: " << "驾驶证识别项目" << endl;  
47.     }  
48. };  
49.   
50.   
51. #endif  

    产品工厂的实现代码如下：

[cpp] view plaincopy

1. #ifndef _PRODUCT_FACTORY_H_  
2. #define _PRODUCT_FACTORY_H_  
3.   
4. #include <iostream>  
5. #include <string>  
6. #include "SoftProduct.h"  
7.   
8. using namespace std;  
9.   
10.   
11. //产品工厂  
12. class ProductFactory  
13. {  
14.   
15. public:  
16.     //静态方法，根据类型创建具体产品  
17.     static SoftProduct * CreateProduct(string strProductName)  
18.     {  
19.         SoftProduct * pSoftProduct = NULL;  
20.   
21.         if( 0 == strcmp(strProductName.c_str(), "银行卡识别项目") )  
22.         {  
23.             pSoftProduct = new BankCard();  
24.         }  
25.         else if( 0 == strcmp(strProductName.c_str(), "身份证识别项目") )  
26.         {  
27.             pSoftProduct = new IdentityCard();  
28.         }  
29.         else if( 0 == strcmp(strProductName.c_str(), "驾驶证识别项目") )  
30.         {  
31.             pSoftProduct = new DriveLicense();  
32.         }  
33.   
34.         return pSoftProduct;  
35.     }  
36. };  
37.   
38. #endif  

    添加了一个产品工厂类ProductFactory，该类有一个静态CreateProduct方法，根据参数类型的不同创建不同的具体软件项目产品。CreateProduct内部封装了具体对象的创建细节，对客户端而言，不再需要具体的对象类型了，客户端完全针对接口进行编程，对客户端隐藏了对象创建的细节。
    测试程序实现代码如下：

[cpp] view plaincopy

1. #include <iostream>  
2. #include "SoftProduct.h"  
3. #include "ProductFactory.h"  
4. using namespace std;  
5.   
6. int main()  
7. {  
8.     SoftProduct * pSoftProduct = NULL;  
9.       
10.     //创建银行卡识别项目  
11.     pSoftProduct = ProductFactory::CreateProduct("银行卡识别项目");  
12.     pSoftProduct->DisplayProduct();  
13.     delete pSoftProduct;  
14.     pSoftProduct = NULL;  
15.   
16.     //创建身份证识别项目  
17.     pSoftProduct = ProductFactory::CreateProduct("身份证识别项目");  
18.     pSoftProduct->DisplayProduct();  
19.     delete pSoftProduct;  
20.     pSoftProduct = NULL;  
21.   
22.     //创建驾驶证识别项目  
23.     pSoftProduct = ProductFactory::CreateProduct("驾驶证识别项目");  
24.     pSoftProduct->DisplayProduct();  
25.     delete pSoftProduct;  
26.     pSoftProduct = NULL;  
27.   
28.     return 0;  
29. }  

    编译并运行，结果如下：

3、简单工厂模式总结

    简单工厂模式提供了专门的工厂类用于创建对象，将对象的创建和对象的使用分离开，它作为一种最简单的工厂模式在软件开发中得到了较为广泛的应用。

1.主要优点

    简单工厂模式的主要优点如下：

    (1) 工厂类包含必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的职责，而仅仅“消费”产品，简单工厂模式实现了对象创建和使用的分离。也就是说工厂类封装了变化，封装了对象创建的具体细节，对客户端隐藏对象创建的细节，使得客户类针对接口进行编程。满足"针对接口编程而不是针对具体编程原则"。

    (2) 客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以在一定程度减少使用者的记忆量。满足"迪米特法则，也就是和直接朋友通信原则"。

    (3) 具体对象创建是一个变化过程，因此把对象的创建封装起来，体现了"封装变化原则"。

2.主要缺点

       简单工厂模式的主要缺点如下：

       (1) 由于工厂类集中了所有产品的创建逻辑，职责过重，一旦不能正常工作，整个系统都要受到影响，违背"单一原则"。

       (2)使用简单工厂模式势必会增加系统中类的个数（引入了新的工厂类），增加了系统的复杂度和理解难度。

       (3)系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护。违背"开发封闭原则"。

       (4)简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。

3.简单工程模式具体应用

       (1)通常在使用word办公软件的时候，会根据需要绘制出饼状图，柱状图，折线图等图形。可以提供一个工厂类，根据用户的选择创建出不同类型的图形。

    (2)QQ空间背景样式，博客背景样式等都提供了各种风格的样式。提供一个工厂，根据用户选择的具体风格样式，创建出各个不同的背景风格，用来装饰QQ空间。

    (3)网页下载工具的开发: 根据需要可以下载新浪网页、腾讯网页、搜狐网页等。根据用户的选择，把网页类型传进工厂，将下载该类型的网页内容。

    (4)淘宝购物最后一个支付环节，可以选择货到付款、网上银行、支付宝等类型支付。用户可以选择具体的支付方式完成订单,这也是简单工厂模式的一种应用。

    (5)电影院打折算法: VIP5折、学生票5折、成人票正常收费等打折算法。

    (6)多功能计算器的开发:封装加减乘除等运算操作(大话设计模式的例子)

    (7)在很多游戏场合，游戏角色可以选择各种各样的武器，如:手枪、AK47、步枪、大刀等。

    (8)如果电脑上装有QQ输入法、搜狗输入法、微软拼音输入法，用户可以设置使用哪种类型的输入法。类似的还可以设置IE浏览器、谷歌浏览器、火狐浏览器。可以设置word2003或者金山的WPS。这些都可以理解为简单工厂模式的一种运用。

    (9)软件公司决策是否开发哪一种产品，银行卡识别、身份证识别还是驾驶证识别。

    (10)生活中也有很多类似的工厂: 富士康代工工厂；安踏加工厂；咖啡生产基地；沃尔玛等超市提供各种产品供用户使用；肯德基马当劳等。