设计模式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模式主要在于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动。