【设计模式】工厂模式

1、工厂模式概述

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

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

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

2、简单工厂模式

2.1 应用

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

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

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

2.2  类图

2.3 代码

2.3.1 产品类

//AbstractProduct.h

#ifndef _ABSTRACTPRODUCT_H_
#define _ABSTRACTPRODUCT_H_

#include <stdio.h>

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!
");
}

ProductB::ProductB(){}

ProductB::~ProductB(){}

void ProductB::operation()
{
    fprintf(stderr,"productB operation!
");
}

2.3.2 工厂类

//SimpleFactory.h

#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTROY_H_

#include <stdio.h>
#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 <stdio.h>

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!
");
}

ProductB::ProductB(){}

ProductB::~ProductB(){}

void ProductB::operation()
{
    fprintf(stderr,"productB operation!
");
}

3.4.2 工厂类

//AbstractFactory.h

#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTROY_H_

#include <stdio.h>
#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 <stdio.h>

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!
");
}

ProductA_2::ProductA_2(){}

ProductA_2::~ProductA_2(){}

void ProductA_2::operationA()
{
    fprintf(stderr,"productA_2 operation!
");
}

//AbstractProductB.h

#ifndef _ABSTRACTPRODUCTB_H_
#define _ABSTRACTPRODUCTB_H_

#include <stdio.h>

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!
");
}

ProductB_2::ProductB_2(){}

ProductB_2::~ProductB_2(){}

void ProductB_2::operationB()
{
    fprintf(stderr,"productB_2 operation!
");
}

4.4.2 工厂类

//AbstractFactory.h

#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTROY_H_

#include <stdio.h>
#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;
}

4.5 优缺点

4.5.1 优点

　　1.封装了产品的创建，使得不需要知道具体是哪种产品，只需要知道是哪个工厂就行了。

　　2.可以支持不同类型的产品，使得模式灵活性更强。

　　3.可以非常方便的使用一族中间的不同类型的产品。

4.5.2 缺点

　　1.结构太过臃肿，如果产品类型比较多，或者产品族类比较多，就会非常难于管理。

　　2.每次如果添加一组产品，那么所有的工厂类都必须添加一个方法，这样违背了开放-封闭原则。所以一般适用于产品组合产品族变化不大的情况。