Abstract Factory（抽象工厂）

1. 意图

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

2. 动机

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

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

3. 示例

在企业人员管理系统中，我们使用员工类对员工进行管理，需要用到数据库相关函数辅助查询员工数据。

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()){
​
        }
​
    }
};

但是上面的代码在数据库的变化后就不能使用，这时我们需要使用接口及其对应的工厂使其能应对这种变化。

//数据库访问有关的基类
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;
};

随后我们使其能够支持多种数据库。

专属学习链接：https://xxetb.xetslk.com/s/32bi94

//支持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 OracleCommand: public IDBCommand{
    
};
​
class OracleDataReader: public IDataReader{
    
};

相应地，EmployeeDAO类也要做出改变。

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 Server的Connection和Oracle的Command相搭配，同时IDBConnection、IDBCommand、IDBDataReader有关联性，我们应该避免发生这个错误，将三个类的创建放入一个工厂。

//支持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 EmployeeDAO{
    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()){
​
        }
​
    }
};

4. 结构

5. 定义

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

6. 要点总结

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

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

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