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

设计模式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模式主要在于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动。
posted @ 2024-07-25 19:16  wjwdive  阅读(2)  评论(0编辑  收藏  举报