【设计模式】工厂模式

阅读量：4947 次

发布时间：2019-06-11

本文共 11234 字，大约阅读时间需要 37 分钟。

1、工厂模式概述

　　工厂方法模式使用的频率非常高，在我们日常的开发中总能见到它的身影。

　　工厂方法解决的问题是可以让你轻松方便的构造对象实例，而不必不必关心构造对象实例的细节和复杂过程。

　　在我们日常生活中经常遇到的有三种工厂模式：简单工厂模式，工厂模式，抽象工厂模式。

2、简单工厂模式

2.1 应用

　　例如部署多种数据库的情况，可能在不同的地方要使用不同的数据库，此时只需要在配置文件中设定数据库的类型，每次再根据类型生成实例，这样，不管下面的数据库类型怎么变化，在客户端看来都是只有一个AbstractProduct，使用的时候根本无需修改代码。提供的类型也可以用比较便于识别的字符串，这样不用记很长的类名，还可以保存为配置文件。

　　这样，每次只需要修改配置文件和添加新的产品子类即可。

　　所以简单工厂模式一般应用于多种同类型类的情况，将这些类隐藏起来，再提供统一的接口，便于维护和修改。

2.2 类图

2.3 代码

2.3.1 产品类

//AbstractProduct.h #ifndef _ABSTRACTPRODUCT_H_#define _ABSTRACTPRODUCT_H_#include 
     
      class AbstractProduct{public:    AbstractProduct();    virtual ~AbstractProduct();    public:    virtual void operation() = 0;};class ProductA:public AbstractProduct{public:    ProductA();    virtual ~ProductA();    public:    void operation();};class ProductB:public AbstractProduct{public:    ProductB();    ~ProductB();    public:    void operation();};#endif

//AbstractProduct.cpp#include "AbstractProduct.h"AbstractProduct::AbstractProduct(){}AbstractProduct::~AbstractProduct(){}ProductA::ProductA(){}ProductA::~ProductA(){}void ProductA::operation(){    fprintf(stderr,"productA operation!\n");}ProductB::ProductB(){}ProductB::~ProductB(){}void ProductB::operation(){    fprintf(stderr,"productB operation!\n");}

2.3.2 工厂类

//SimpleFactory.h#ifndef _SIMPLEFACTORY_H_#define _SIMPLEFACTROY_H_#include 
     
      #include "AbstractProduct.h"class AbstractFactory{public:    AbstractFactory();    virtual ~AbstractFactory();    public:    virtual AbstractProduct* createProduct(int type) = 0;    };class SimpleFactory:public AbstractFactory{public:    SimpleFactory();    ~SimpleFactory();    public:    AbstractProduct* createProduct(int type);};#endif

//SimpleFactory.cpp#include "SimpleFactory.h"AbstractFactory::AbstractFactory(){}AbstractFactory::~AbstractFactory(){}SimpleFactory::SimpleFactory(){}SimpleFactory::~SimpleFactory(){}AbstractProduct* SimpleFactory::createProduct(int type){    AbstractProduct* temp = NULL;    switch(type)    {    case 1:        temp = new ProductA();        break;    case 2:        temp = new ProductB();        break;    default:        break;    }    return temp;}

2.3.3 调用

//client.cpp#include "SimpleFactory.h"int main() {    AbstractFactory* factory = new SimpleFactory();    AbstractProduct* product = factory->createProduct(1);    product->operation();    delete product;    product = NULL;        product = factory->createProduct(2);    product->operation();    delete product;    product = NULL;    return 0;}

2.4 优缺点

2.4.1 优点

　　1.隐藏了对象创建的细节，将产品的实例化推迟到子类中实现。

　　2.客户端基本不用关心使用的是哪个产品，只需要知道用哪个工厂就行了，提供的类型也可以用比较便于识别的字符串。

　　3.方便添加新的产品子类，每次只需要修改工厂类传递的类型值就行了。

　　4.遵循了依赖倒转原则。

2.4.2 缺点

　　1.要求产品子类的类型差不多，使用的方法名都相同，如果类比较多，而所有的类又必须要添加一种方法，则会是非常麻烦的事情。或者是一种类另一种类有几种方法不相同，客户端无法知道是哪一个产品子类，也就无法调用这几个不相同的方法。

　　2.每添加一个产品子类，都必须在工厂类中添加一个判断分支，这违背了开放-封闭原则。

3、工厂模式

3.1 工厂模式定义

　　Define an interface for creating an object,but let subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses.（定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。）

　　工厂模式基本与简单工厂模式差不多，上面也说了，每次添加一个产品子类都必须在工厂类中添加一个判断分支，这样违背了开放-封闭原则，因此，工厂模式就是为了解决这个问题而产生的。

　　既然每次都要判断，那我就把这些判断都生成一个工厂子类，这样，每次添加产品子类的时候，只需再添加一个工厂子类就可以了。这样就完美的遵循了开放-封闭原则。但这其实也有问题，如果产品数量足够多，要维护的量就会增加，好在一般工厂子类只用来生成产品类，只要产品子类的名称不发生变化，那么基本工厂子类就不需要修改，每次只需要修改产品子类就可以了。

3.2 应用场景

　　基本与简单工厂模式一致，只不过是改进了简单工厂模式中的开放-封闭原则的缺陷，使得模式更具有弹性。将实例化的过程推迟到子类中，由子类来决定实例化哪个。

　　同样工厂模式一般应该于程序中大部分地方都只使用其中一种产品，工厂类也不用频繁创建产品类的情况。这样修改的时候只需要修改有限的几个地方即可。

3.3 类图

3.4 代码

3.4.1 产品类

//AbstractProduct.h#ifndef _ABSTRACTPRODUCT_H_#define _ABSTRACTPRODUCT_H_#include 
     
      class AbstractProduct{public:    AbstractProduct();    virtual ~AbstractProduct();    public:    virtual void operation() = 0;};class ProductA:public AbstractProduct{public:    ProductA();    virtual ~ProductA();    public:    void operation();};class ProductB:public AbstractProduct{public:    ProductB();    ~ProductB();    public:    void operation();};#endif

//AbstractProduct.cpp#include "AbstractProduct.h"AbstractProduct::AbstractProduct(){}AbstractProduct::~AbstractProduct(){}ProductA::ProductA(){}ProductA::~ProductA(){}void ProductA::operation(){    fprintf(stderr,"productA operation!\n");}ProductB::ProductB(){}ProductB::~ProductB(){}void ProductB::operation(){    fprintf(stderr,"productB operation!\n");}

3.4.2 工厂类

//AbstractFactory.h#ifndef _SIMPLEFACTORY_H_#define _SIMPLEFACTROY_H_#include 
     
      #include "AbstractProduct.h"class AbstractFactory{public:    AbstractFactory();    virtual ~AbstractFactory();    public:    virtual AbstractProduct* createProduct() = 0;    };class FactoryA:public AbstractFactory{public:    FactoryA();    ~FactoryA();    public:    AbstractProduct* createProduct();};class FactoryB:public AbstractFactory{public:    FactoryB();    ~FactoryB();    public:    AbstractProduct* createProduct();};#endif

//AbstractFactory.cpp#include "AbstractFactory.h"AbstractFactory::AbstractFactory(){}AbstractFactory::~AbstractFactory(){}FactoryA::FactoryA(){}FactoryA::~FactoryA(){}AbstractProduct* FactoryA::createProduct(){    AbstractProduct* temp = NULL;    temp = new ProductA();    return temp;}FactoryB::FactoryB(){}FactoryB::~FactoryB(){}AbstractProduct* FactoryB::createProduct(){    AbstractProduct* temp = NULL;    temp = new ProductB();    return temp;}

3.4.3 调用

//client.cpp#include "AbstractFactory.h"int main(){    AbstractFactory* factory = new FactoryA();    AbstractProduct* product = factory->createProduct();    product->operation();    delete product;    product = NULL;    delete factory;    factory = NULL;        factory = new FactoryB();    product = factory->createProduct();    product->operation();    delete product;    product = NULL;    delete factory;    factory = NULL;    return 0;}

3.5 优缺点

3.5.1 优点

　　1.基本与简单工厂模式一致，多的一点优点就是遵循了开放-封闭原则，使得模式的灵活性更强。

　　2.良好的封装性，代码结构清晰。一个对象创建是有条件约束的，如一个调用者需要一个具体的产品对象，只要知道这个产品的类型就可以了，不用知道创建对象的艰辛过程，降低模块间的耦合。

　　3.工厂方法模式的扩展性非常优秀。在增加产品类的情况下，只要适当地修改具体的工厂类或扩展一个工厂类，就可以完成“拥抱变化”。

　　4.屏蔽产品类。这一特点非常重要，产品类的实现如何变化，调用者都不需要关心，它只需要关心产品的接口，只要接口保持不变，系统中的上层模块就不要发生变化。因为产品类的实例化工作是由工厂类负责的，一个产品对象具体由哪一个产品生成是由工厂类决定的。

　　5.工厂方法模式是典型的解耦框架。高层模块值需要知道产品的抽象类，其他的实现类都不用关心，符合迪米特法则，我不需要的就不要去交流；也符合依赖倒置原则，只依赖产品类的抽象；当然也符合里氏替换原则，使用产品子类替换产品父类，没问题！

3.5.2 缺点

　　和简单工厂模式一致。

4、抽象工厂模式

4.1 定义

　　Provide an interface for creating families of related or dependent objects without specifyingtheir concrete classes.（为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。）

　　抽象工厂模式就变得比工厂模式更为复杂，就像上面提到的缺点一样，工厂模式和简单工厂模式要求产品子类必须要是同一类型的，拥有共同的方法，这就限制了产品子类的扩展。于是为了更加方便的扩展，抽象工厂模式就将同一类的产品子类归为一类，让他们继承同一个抽象子类，我们可以把他们一起视作一组，然后好几组产品构成一族。

　　此时，客户端要使用时必须知道是哪一个工厂并且是哪一组的产品抽象类。每一个工厂子类负责产生一族产品，而子类的一种方法产生一种类型的产品。在客户端看来只有AbstractProductA和AbstractProductB两种产品，使用的时候也是直接使用这两种产品。而通过工厂来识别是属于哪一族产品。

4.2 类图

　　产品ProductA_1和ProductB_1构成一族产品，对应于有Factory1来创建，也就是说Factory1总是创建的ProductA_1和ProductB_1的产品，在客户端看来只需要知道是哪一类工厂和产品组就可以了。一般来说， ProductA_1和ProductB_1都是适应同一种环境的，所以他们会被归为一族。

4.3 使用场景

　　例如Linux和windows两种操作系统下，有2个挂件A和B，他们在Linux和Windows下面的实现方式不同，Factory1负责产生能在Linux下运行的挂件A和B，Factory2负责产生能在Windows下运行的挂件A和B，这样如果系统环境发生变化了，我们只需要修改工厂就行了。

4.4 代码

4.4.1 产品类

//AbstractProductA.h#ifndef _ABSTRACTPRODUCTA_H_#define _ABSTRACTPRODUCTA_H_#include 
     
      class AbstractProductA{public:    AbstractProductA();    virtual ~AbstractProductA();    public:    virtual void operationA() = 0;};class ProductA_1:public AbstractProductA{public:    ProductA_1();    virtual ~ProductA_1();    public:    void operationA();};class ProductA_2:public AbstractProductA{public:    ProductA_2();    ~ProductA_2();    public:    void operationA();};#endif

//AbstractProductA.cpp#include "AbstractProductA.h"AbstractProductA::AbstractProductA(){}AbstractProductA::~AbstractProductA(){}ProductA_1::ProductA_1(){}ProductA_1::~ProductA_1(){}void ProductA_1::operationA(){    fprintf(stderr,"productA_1 operation!\n");}ProductA_2::ProductA_2(){}ProductA_2::~ProductA_2(){}void ProductA_2::operationA(){    fprintf(stderr,"productA_2 operation!\n");}

//AbstractProductB.h#ifndef _ABSTRACTPRODUCTB_H_#define _ABSTRACTPRODUCTB_H_#include 
     
      class AbstractProductB{public:    AbstractProductB();    virtual ~AbstractProductB();    public:    virtual void operationB() = 0;};class ProductB_1:public AbstractProductB{public:    ProductB_1();    virtual ~ProductB_1();    public:    void operationB();};class ProductB_2:public AbstractProductB{public:    ProductB_2();    ~ProductB_2();    public:    void operationB();};#endif

//AbstractProductB.cpp#include "AbstractProductB.h"AbstractProductB::AbstractProductB(){}AbstractProductB::~AbstractProductB(){}ProductB_1::ProductB_1(){}ProductB_1::~ProductB_1(){}void ProductB_1::operationB(){    fprintf(stderr,"productB_1 operation!\n");}ProductB_2::ProductB_2(){}ProductB_2::~ProductB_2(){}void ProductB_2::operationB(){    fprintf(stderr,"productB_2 operation!\n");}

4.4.2 工厂类

//AbstractFactory.h#ifndef _SIMPLEFACTORY_H_#define _SIMPLEFACTROY_H_#include 
     
      #include "AbstractProductA.h"#include "AbstractProductB.h"class AbstractFactory{public:    AbstractFactory();    virtual ~AbstractFactory();    public:    virtual AbstractProductA* createProductA() = 0;        virtual AbstractProductB* createProductB() = 0;    };class Factory1:public AbstractFactory{public:    Factory1();    ~Factory1();    public:    AbstractProductA* createProductA();    AbstractProductB* createProductB();};class Factory2:public AbstractFactory{public:    Factory2();    ~Factory2();    public:    AbstractProductA* createProductA();    AbstractProductB* createProductB();};#endif

//AbstractFactory.cpp#include "AbstractFactory.h"AbstractFactory::AbstractFactory(){}AbstractFactory::~AbstractFactory(){}Factory1::Factory1(){}Factory1::~Factory1(){}AbstractProductA* Factory1::createProductA(){    AbstractProductA* temp = NULL;    temp = new ProductA_1();    return temp;}AbstractProductB* Factory1::createProductB(){    AbstractProductB* temp = NULL;    temp = new ProductB_1();    return temp;}Factory2::Factory2(){}Factory2::~Factory2(){}AbstractProductA* Factory2::createProductA(){    AbstractProductA* temp = NULL;    temp = new ProductA_2();    return temp;}AbstractProductB* Factory2::createProductB(){    AbstractProductB* temp = NULL;    temp = new ProductB_2();    return temp;}

4.4.3 调用

//client.cpp#include "AbstractFactory.h"int main(){    AbstractFactory* factory = new Factory1();    AbstractProductA* productA = factory->createProductA();    AbstractProductB* productB = factory->createProductB();    productA->operationA();    productB->operationB();        delete factory;    factory = NULL;    delete productA;    productA = NULL;    delete productB;    productB = NULL;        factory = new Factory2();    productA = factory->createProductA();    productB = factory->createProductB();    productA->operationA();    productB->operationB();        delete factory;    factory = NULL;    delete productA;    productA = NULL;    delete productB;    productB = NULL;    return 0;}