C++设计模式 #8 抽象工厂（Abstract Factory）

抽象工厂这个名字比较难以帮助理解，可以把抽象工厂理解为“品牌工厂”或者“家族工厂”。

动机

在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时，由于需求的变化，往往存在更多系列对象的创建工作。
如何应对这种变化？如何绕过常规的创建方法（new），提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？

举个栗子

我们有一个控制数据库连接和操作的类

class EmployeeDAO{public:vector<EmployeeDAO> GetEmployees(){SqlConnection* connection = new SqlConnection();connection->ConnectionString("...");SqlCommand* command = new SqlCommand();command->CommandText("...");command->SetConnection(connection);SqlDataReader* reader = command->ExecuteReader();while(reader->Read()){}}
};

我们使用这个类来连接一个数据库，并使用一些SQL语句来对数据库进行操作。然后使用reader来读取SQL语句得到的数据。

由于可以使用的数据库种类很多，比如针对oracle的数据库，我们可能需要另外再一个类来实现不同的实际操作。

在学习了工厂方法之后，我们可以根据工厂模式将SqlConnection,SqlCommand,SqlDataReader改写成以下模式。

class IDBconnection {
public:virtual void ConnectionString(string) = 0;
};
class SqlConnection : public IDBconnection {
public:virtual void ConnectionString(string s) {//do connection}
};
class OracleConnection : public IDBconnection {
public:virtual void ConnectionString(string s) {//do connection}
};class IDBconnectionFactory {
public:virtual IDBconnection* create() = 0;
};
class SqlConnectionFactory : public IDBconnectionFactory {IDBconnection* create() {return new SqlConnection();}
};
class OracleConnectionFactory : public IDBconnectionFactory {IDBconnection* create() {return new OracleConnection();}
};class ISqlCommand {
public:virtual void CommandText(string) = 0;virtual void SetConnection(IDBconnection*) = 0;virtual IDataReader* ExecuteReader() = 0;
};
class SqlCommand : public ISqlCommand {
public:virtual void CommandText(string) {//...}virtual void SetConnection(IDBconnection*) {//...}virtual IDataReader* ExecuteReader() {return new SqlDataReader();}
};
class OracleCommand : public ISqlCommand {
public:virtual void CommandText(string) {//...}virtual void SetConnection(IDBconnection*) {//...}virtual IDataReader* ExecuteReader() {return new OracleDataReader();}
};class ISqlCommandFactory {
public:virtual ISqlCommand* create() = 0;
};
class SqlCommandFactory : public ISqlCommandFactory {ISqlCommand* create() {return new SqlCommand();}
};
class OracleCommandFactory : public ISqlCommandFactory {ISqlCommand* create() {return new OracleCommand();}
};class IDataReader {
public:virtual bool Read() = 0;
};
class SqlDataReader : public IDataReader {
public:virtual bool Read() {//...return true;}
};
class OracleDataReader : public IDataReader {
public:virtual bool Read() {//...return true;}
};class EmployeeDAO {
private:IDBconnection* connection;ISqlCommand* command;IDataReader* reader;public:vector<EmployeeDAO> GetEmployees(IDBconnectionFactory* connectionFactory, ISqlCommandFactory* commanFactory) {connection = connectionFactory->create();connection->ConnectionString("...");command = commanFactory->create();command->CommandText("...");command->SetConnection(connection);reader = command->ExecuteReader();while (reader->Read()) {}}
};

我们使用工厂模式在运行时创建EmployeeDAO的connection和command指针。

问题

我们使用单纯的工厂模式来创建不同的connection和command的子类来操作不同的数据库。这表面上看起来已经解决了这个问题。

但是，假如出现了这种情况，在调用GetEmployees时，我们传入的参数是，

GetEmployees(SqlConnectionFactory, OracleCommandFactory)

这样的代码当然可以通过编译，但是我们用Oracle数据库的命令其他的数据库，当然会导致一系列的错误。

重构

class IDBFactory {
public:virtual IDBconnection* create_connection() = 0;virtual ISqlCommand* create_command() = 0;
};class SqlFactory : public IDBFactory {
public:virtual IDBconnection* create_connection() {return new SqlConnection();}virtual ISqlCommand* create_command() {return new SqlCommand();}
};class OracleFactory : public IDBFactory {
public:virtual IDBconnection* create_connection() {return new OracleConnection();}virtual ISqlCommand* create_command() {return new OracleCommand();}
};class EmployeeDAO {
private:IDBconnection* connection;ISqlCommand* command;IDataReader* reader;public:vector<EmployeeDAO> GetEmployees(IDBFactory* factory) {connection = factory->create_connection();connection->ConnectionString("...");command = factory->create_command();command->CommandText("...");command->SetConnection(connection);reader = command->ExecuteReader();while (reader->Read()) {}}
};

将两个connection和command工厂合并，让它只能生产“同一种类的产品”。这样，我们既降低了耦合，又避免“产品种类”不同导致不能使用的情况。