设计模式(五)抽象工厂 C++

每一个设计模式的产生都是 为了应对某些应用场景。

        简单工厂可以由一个工厂生产不同的产品，缺点是如果不断增加产品，则需要不断修改工厂，违反了开放封闭原则，(类、模块、函数可以扩展，但是不可以修改)。

        于是，就出现了工厂方法模式。所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。打个比方

现在有A、B两种产品，那么久开两个工厂。工厂A负责生产A产品，工厂B负责生产B种产品。这时候客户不需要告诉工厂生产哪种产品了。需要A产品，直接通知A工厂就好了，需要B产品，直接通知B工厂就好了。工厂方法和简单工厂的区别，在于开放封闭原则。

        但是随着业务的变化，设计模式可能也需要随着变化。比如说，我们为客户安装了一个MySQL数据库，里面有两张表，UserTable(用户表)和ApartmentTable(部门表),但是未来某一天用户可能会用Access来存放这两张表，怎么办？工厂方法？但是工厂方法是一对一的，一个工厂生产一个产品，在这里如果说把MySQL下的User表作为一个产品，然后为MySQL下的User表创建一个工厂？这样一来在整个过程中会有四个工厂。为每张表创建一个工厂也能够解决问题，但是这不是最好的方法。因为无论两个数据库下的两张User表，还是Apartment表还是有相似性的，换句话说需要创建的对象是一系列相互关联或相互依赖的产品族，能不能根据这些相似性进行抽象呢？

这个时候要考虑抽象工厂模式。还是开设两家工厂，工厂A负责生产A1 、A2型号产品，B工厂负责生产B1、B2型号的产品。  

在这个业务场景下就是两个数据工厂，MySQL生产AccessUser,AccessApartment,Access生产 AccessUser ，AccessApartment。

代码实现如下

#include <iostream>    
#include <windows.h>
using namespace std;

//定义抽象类(用户表) 
class productUserTable
{
public:
	virtual void show() = 0;
};

//定义抽象类 (部门表) 
class productAprtmentTable
{
public:
	virtual void show() = 0;
};

// 数据库抽象类作为抽象工厂
class FactoryDB
{
public:
	virtual productUserTable *CreateUserTable() = 0;
	virtual productAprtmentTable *CreateApartmentTable() = 0;
};

//定义具体类  ,具体的用户表
class MySQLUserTable :public productUserTable
{
public:
	void show() 
	{ 
		cout << "product MySQLUserTable" << endl; 
	}
};

class AccessUserTable :public productUserTable
{
public:
	void show() 
	{ 
		cout << "product AccessUserTable" << endl;
	}
};

//定义具体类 ,具体的产品表 
class MySQLAprtmentTable :public productAprtmentTable
{
public:
	void show() 
	{ 
		cout << "product MySQLAprtmentTable" << endl; 
	}
};

class AccessAprtmentTable :public productAprtmentTable
{
public:
	void show()
	{ 
		cout << "product AccessAprtmentTable" << endl; 
	}
};

// MySQL数据库下的 User 表、Apartment表、所以MySQL为当前工厂
class FactoryMySQL:public FactoryDB
{
public:
	productUserTable *CreateUserTable() 
	{ 
		return new MySQLUserTable();
	}
	productAprtmentTable *CreateApartmentTable()
	{ 
		return new MySQLAprtmentTable(); 
	}
};

// Access数据库下的 User 表、Apartment表，所以Access为当前工厂
class FactoryAccess :public FactoryDB
{
public:
	productUserTable *CreateUserTable() 
	{ 
		return new AccessUserTable();
	}
	productAprtmentTable *CreateApartmentTable()
	{ 
		return new AccessAprtmentTable();
	}
};

int main()
{
	FactoryMySQL *factoryA = new FactoryMySQL();
	factoryA->CreateUserTable()->show();
	factoryA->CreateApartmentTable()->show();

	FactoryAccess *factoryB = new FactoryAccess();
	factoryB->CreateUserTable()->show();
	factoryB->CreateApartmentTable()->show();

	system("pause");
	return 0;
}

抽象工厂模式的优点

抽象工厂模式除了具有工厂方法模式的优点外，最主要的优点就是可以在类的内部对产品族进行约束。所谓的产品族，一般或多或少的都存在一定的关联，抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述，而不必专门引入一个新的类来进行管理。

抽象工厂模式的缺点

产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。

适用场景

当需要创建的对象是一系列相互关联或相互依赖的产品族时，便可以使用抽象工厂模式。说的更明白一点，就是一个继承体系中，如果存在着多个等级结构（即存在着多个抽象类），并且分属各个等级结构中的实现类之间存在着一定的关联或者约束，就可以使用抽象工厂模式。假如各个等级结构中的实现类之间不存在关联或约束，则使用多个独立的工厂来对产品进行创建，则更合适一点。

总结

无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。

所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。