【设计模式】Head First 设计模式——抽象工厂模式 C++实现

设计模式最大的作用就是在变化和稳定中间寻找隔离点，然后分离它们，从而管理变化。将变化像小兔子一样关到笼子里，让它在笼子里随便跳，而不至于跳出来把你整个房间给污染掉。

设计思想

提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定他们具体的类。

动机

在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时，由于需求的变化，往往存在更多系列对象的创建工作。

如何应对这种变化？如何绕过常规的对象创建方法（new)，提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？

如果没有应对“多系列对象构建”的需求变化，则没有必要使用Abstract Factory模式，这时候使用简单的工厂完全可以。

“系列对象”指的是在某一特定系列下的对象之间有相互依赖或作用关系。不同系列的对象之间不能相互依赖。

Abstract Factory模式主要在于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动。

抽象工厂和工厂方法非常相像，区别就在于抽象工厂需要一系列对应的对象，而工厂方法就是唯一对象，因此工厂方法也可以理解成抽象工厂的一个特例。

业务场景

要对 SQL Server 数据库进行操作，需要有 Connection，Command，DataReader等一系列配套的操作。而当需要更换数据库的时候，也是这套操作

如何提高代码复用性

一个非常直观的思路是：

class EmployeeDAO {
public:
    vector<EmployeeDO> GetEmployees() {
        SqlConnection* connection = new SqlConnection();
        connection->ConnectionString("...");

        SqlCommand* command = new SqlCommand();
        command->CommandText("...");
        command->SetConnection(connection);

        SqlDataReader* reader = command->ExecuteReader();
        while (reader->Read()) {
        }
    }
};

看见这些熟悉的代码：

 SqlConnection* connection = new SqlConnection();
 SqlCommand* command = new SqlCommand();

如果你看过前面的工厂方法模式，你会很自然的联想到那个，然后将代码改进成这样：

// 数据库访问有关的基类
class IDBConnection {};
class IDBConnectionFactory {
public:
    virtual IDBConnection* CreateDBConnection() = 0;
};

class IDBCommand {};
class IDBCommandFactory {
public:
    virtual IDBCommand* CreateDBCommand() = 0;
};

class IDataReader {};
class IDataReaderFactory {
public:
    virtual IDataReader* CreateDataReader() = 0;
};

// 支持SQL Server
class SqlConnection : public IDBConnection {};
class SqlConnectionFactory : public IDBConnectionFactory {};

class SqlCommand : public IDBCommand {};
class SqlCommandFactory : public IDBCommandFactory {};

class SqlDataReader : public IDataReader {};
class SqlDataReaderFactory : public IDataReaderFactory {};

// 支持Oracle
class OracleConnection : public IDBConnection {};
class OracleConnectionFactory : public IDBConnectionFactory {};

class OracleCommand : public IDBCommand {};
class OracleCommandFactory : public IDBCommandFactory {};

class OracleDataReader : public IDataReader {};
class OracleDataReaderFactory : public IDataReaderFactory {};

class EmployeeDAO {
    IDBConnectionFactory* dbConnectionFactory;
    IDBCommandFactory* dbCommandFactory;
    IDataReaderFactory* dataReaderFactory;

public:
    vector<EmployeeDO> GetEmployees() {
        IDBConnection* connection = dbConnectionFactory->CreateDBConnection();
        connection->ConnectionString("...");

        IDBCommand* command = dbCommandFactory->CreateDBCommand();
        command->CommandText("...");
        command->SetConnection(connection);  // 关联性

        IDBDataReader* reader = command->ExecuteReader();  // 关联性
        while (reader->Read()) {
        }
    }
};

有没有解决问题呢？确实解决了，但是如果细心一点，你会发现：这三个工厂实例化出来的对象应该是一套的：SQL只能用SQL的connection，command以及dataReader，MYSQL只能用MYSQL的，也就是说在构造EmployeeDAO的时候，虽然需要传入三个工厂对象：dbConnectionFactory，dbCommandFactory，dataReaderFactory，但是这三个对象却必须是一套的，这就带来了问题：1. 用户有可能传错对象；2.既然必须是一套的，那么完全可以将其封装成一个对象传进来

于是，便有了抽象工厂模式：将三个配套的操作再封装成一个类，避免产生配套错误

代码案例

// 数据库访问有关的基类
class IDBConnection {};

class IDBCommand {};

class IDataReader {};

// 三个操作，绑定到一起
// 此处是这个模式的稳定部分
class IDBFactory {
public:
    virtual IDBConnection* CreateDBConnection() = 0;
    virtual IDBCommand* CreateDBCommand() = 0;
    virtual IDataReader* CreateDataReader() = 0;
};

// 支持SQL Server
class SqlConnection : public IDBConnection {};
class SqlCommand : public IDBCommand {};
class SqlDataReader : public IDataReader {};

class SqlDBFactory : public IDBFactory {
public:
    virtual IDBConnection* CreateDBConnection() = 0;
    virtual IDBCommand* CreateDBCommand() = 0;
    virtual IDataReader* CreateDataReader() = 0;
};

// 支持Oracle
class OracleConnection : public IDBConnection {};
class OracleCommand : public IDBCommand {};
class OracleDataReader : public IDataReader {};

class OracleDBFactory : public IDBFactory {
public:
    virtual IDBConnection* CreateDBConnection() = 0;
    virtual IDBCommand* CreateDBCommand() = 0;
    virtual IDataReader* CreateDataReader() = 0;
};

class EmployeeDAO {
    // 保证是同一个工厂
    // 是一个 family
    IDBFactory* dbFactory;

public:
    vector<EmployeeDO> GetEmployees() {
        IDBConnection* connection = dbFactory->CreateDBConnection();
        connection->ConnectionString("...");

        IDBCommand* command = dbFactory->CreateDBCommand();
        command->CommandText("...");
        command->SetConnection(connection);  // 关联性

        IDBDataReader* reader = command->ExecuteReader();  // 关联性
        while (reader->Read()) {
        }
    }
};