Abstract Factory（抽象工厂）模式

1.意图

提供一个创建一系列相关或相互依赖对象的接口，而无需制定它们具体的类。

2.适用性

• 一个系统要独立于它的产品创建、组合和表示时。
• 一个系统要由多个产品系列中的一个来配置时。
• 当你强调一系列相关的产品对象的设计以便进行联合使用时。
• 当你提供一个产品的类库，而只想显示它们的接口而不是实现时。

3.结构图

如上图所示为抽象工厂的结构图，每一个工厂负责创建一系列产品。

4.C++代码实例

#include <cstdlib>
#include <string>
class AbstractFactory;

class Client
{
public:
    Client(){};
    ~Client(){};
    AbstractFactory *GetFactory(std::string type);
private:
    AbstractFactory *pFactory;

};

Client.h

 class AbstractProductA
 {
 public:
     AbstractProductA()
     {
     }
     virtual ~AbstractProductA()
     {
     };
 };

 class AbstractProductB
 {
 public:
     AbstractProductB()
     {
     }
     virtual ~AbstractProductB()
     {
     };
 };

AbstractProduct

 class AbstractProductA;
 class AbstractProductB;

 class AbstractFactory
 {
 public:
      AbstractFactory()
      {
      };
      ~AbstractFactory(){};
     virtual AbstractProductA * CreateProductA()=;
     virtual AbstractProductB * CreateProductB()=;
 };

AbstractFactory

 #include "AbstractFactory.h"

 class AbstractProductA;
 class AbstractProductB;

 class ConcreteFactory1 : public AbstractFactory
 {
 public:
     ConcreteFactory1();
     ~ConcreteFactory1();
     AbstractProductA * CreateProductA();
     AbstractProductB * CreateProductB();
 };

 class ConcreteFactory2 : public AbstractFactory
 {
 public:
     ConcreteFactory2();
     ~ConcreteFactory2();
     AbstractProductA * CreateProductA();
     AbstractProductB * CreateProductB();
 };

ConcreteFactory

 #include <cstdio>
 #include <cstdlib>
 #include <iostream>
 #include "AbstractProduct.h"

 class ConcreteProductA1 : public AbstractProductA
 {
 public:
     ConcreteProductA1()
     {
         std::cout << "ConcreteProductA1 is Created" << std::endl;
     }
     ~ConcreteProductA1()
     {
     }
 };

 class ConcreteProductA2 : public AbstractProductA
 {
 public:
     ConcreteProductA2()
     {
         std::cout << "ConcreteProductA2 is Created" << std::endl;
     }
     ~ConcreteProductA2()
     {
     }
 };

 class ConcreteProductB1 : public AbstractProductB
 {
 public:
     ConcreteProductB1()
     {
         std::cout << "ConcreteProductB1 is Created" << std::endl;
     }

     ~ConcreteProductB1()
     {
     }

 };

 class ConcreteProductB2 : public AbstractProductB
 {
 public:
     ConcreteProductB2()
     {
         std::cout << "ConcreteProductB2 is Created" << std::endl;
     }

     ~ConcreteProductB2()
     {
     }
 };

ConcereteProduct

#include "ConcreteFactory.h"
#include "ConcreteProduct.h"

ConcreteFactory1::ConcreteFactory1()
{
}

ConcreteFactory1::~ConcreteFactory1()
{
}

AbstractProductA * ConcreteFactory1::CreateProductA()
{
    auto product = new ConcreteProductA1();
    return product;
}

AbstractProductB * ConcreteFactory1::CreateProductB()
{
    auto product = new ConcreteProductB1();
    return product;
}

ConcreteFactory2::ConcreteFactory2()
{
}

ConcreteFactory2::~ConcreteFactory2()
{
}

AbstractProductA * ConcreteFactory2::CreateProductA()
{
    auto product = new ConcreteProductA2();
    return product;
}

AbstractProductB * ConcreteFactory2::CreateProductB()
{
    auto product = new ConcreteProductB2();
    return product;
}

ConcreteFactory.cpp

#include "Client.h"
#include "ConcreteFactory.h"

 AbstractFactory *Client::GetFactory(std::string type)
 {
     if("" == type)
     {
         auto pFactory = new ConcreteFactory1();
         return pFactory;
     }
     else if ("" == type)
     {
         auto pFactory = new ConcreteFactory2();
         return pFactory;
     }
 }

Client.cpp

#include "Client.h"
#include "AbstractFactory.h"
#include "AbstractProduct.h"

int main()
{
    auto client = new Client();
    auto pFactory = client->GetFactory("");
    auto pProductA = pFactory->CreateProductA();
    auto pProductB = pFactory->CreateProductB();
    delete pProductB;
    pProductB = NULL;
    delete pProductA;
    pProductA = NULL;
    delete pFactory;
    pFactory = NULL;

    pFactory = client->GetFactory("");
    pProductA = pFactory->CreateProductA();
    pProductB = pFactory->CreateProductB();
    delete pProductB;
    pProductB = NULL;
    delete pProductA;
    pProductA = NULL;
    delete pFactory;
    pFactory = NULL;
    delete client;
    client=NULL;

    while();

}

TestCode.cpp

测试结果：

如测试代码中所写，先创建1系列的产品A和B，后创建2系列的产品A和B。

5.效果

• 分离了具体的类，产品的类名不出现在测试代码（即客户代码）中。
• 使得易于交换产品系列。
• 利于产品的一致性。
• 难以支持新种类的产品

6.相关模式

抽象工厂类通常用工厂方法实现，但是也可以用原型实现。一个具体的工厂通常是一个单件。