设计模式C++007__抽象工厂方法模式

抽象工厂方法

1、动机：

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

定义：

2、示例：

例如一个数据库连接的工具：
需要对数据库进行连接、命令，读数据等操作，这些操作有关联性。如果我们最开始只提供了对SqlServer的支持，之后如果要扩展到能支持其他数据库的连接Orcal, MongoDB等，那么其中这些连接，命令，读数据的这些个操作也会不一样。

初始代码：

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()){

        }
    }
};

为了支持多数据库，我们需要面向接口编程。把创建对象（connection ，command ，reader ）用接口实现。
我们尝试使用工厂模式创建这3个对象。

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

class IDBCommand{
    //虚方法...
};
class IDBCommandFactory{
public:
    virtual IDBCommand* CreateDBCommand()=0;
    //...
};

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


//Sql连接相关的实例类和对应的工厂类
class SqlConnection: public IDBConnection {

};
class SqlConnectionFactory: public IDBConnectionFactory{
    //虚函数具体实现
};
//SqlServer 命令类和对应的工厂类
class SqlCommand: public IDBCommand {
    
};
class SqlCommandFactory: public IDBCommandFactory{
    //虚函数具体实现
};

//SqlServer 读数据类和对应的工厂类
class SqlDataReader: public IDataReader {
    
};
class SqlDataReaderFactory: public IDataReaderFactory{
      //虚函数具体实现
};


//支持Oracle相关的子类，和Sql类似，不再实现
class ISqlDBConnection::IDBConnection{
    //虚方法
};
class ISqlDBCommand::IDBCommand{
    //虚方法
};
class ISqlReader::IDataReader{
    //虚方法
};

//。。。其他数据库连接,

class EmployeeDAO{
    //声明3个工厂类。这里有一个隐患，由于这里是抽象类的变量声明，将来这里可能传递的是某一个具体子类，例如：connection是SqlServer的实例，command是Oracle的实例。这样显然不合适
    //因为connection，command, reader是同一个体系下的一系列相关操作。不可能用SqlServer的连接去执行Oracle的命令。如何解决？？
    //答案是：抽象工厂。我们把这三个工厂类放到一起。
    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()){

        }

    }
};

抽象工厂。如何实现？？
我们把三个相关性很强的工厂方法放到一个类里面。

//把下面三个抽象类合并为一个类。
class IDBConnectionFactory{
public:
    virtual IDBConnection* CreateDBConnection()=0;
    virtual ~IDBConnectionFactory(){}
};

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

class IDataReaderFactory: public IDataReaderFactory{
      //虚函数具体实现
      virtual IDataReader* IDataReader()=0;
};

//合并后
class IDBFactory{
public:
    virtual IDBConnection* CreateDBConnection()=0;
    virtual IDBCommand* CreateDBCommand()=0;
    virtual IDataReader* IDataReader()=0;

    virtual ~IDBFactory(){}
};

//把下面3个具体工厂类也合并为一个
class SqlConnectionFactory: public IDBConnectionFactory{
    //虚函数具体实现
};
class SqlCommandFactory: public IDBCommandFactory{
    //虚函数具体实现
};
class SqlDataReaderFactory: public IDataReaderFactory{
      //虚函数具体实现
};

//↓ 合并为一个实现工厂
class SqlDBFactory:public IDBFactory {
    virtual IDBConnection* CreateDBConnection()=0;
    virtual IDBCommand* CreateDBCommand()=0;
    virtual IDataReader* IDataReader()=0;
};

//EmployeeDAO中声明一个工厂类即可
class EmployeeDAO{
  IDBFactory *dbFactory;  //同一个工厂之内，中生成的对象，都是具有一定关联性的实例，不会出现Sql相关connection实例和Oracle实例混合的情况。

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

最终的代码结构：

//数据库访问有关的基类
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 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()){

        }

    }
};

结构：

要点总结：

• 如果没有应对“多西系列对象构建”的需求变化，则没有必要使用Abstract Factory模式，这时候使用简单的工厂完全可以。
• “系列对象”指的是在某一特点系列下的对象之间有相互依赖、或作用的关系。不同系列的对象之间不能相互依赖。
• Abstract Factory模式主要在于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动。