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

清疚 2023-10-15 14:06 15阅读 0赞

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

### 设计思想 ###

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

### 动机 ###

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

如何应对这种变化？如何绕过常规的对象创建方法（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()) {
            }
        }
    };