抽象工厂模式用于:一系列相互依赖的对象的创建工作,而且需求的变化会有更多系列对象需要创建;
前半句话可以这样理解:Oracle数据库,和Oracle命令相依赖;MySql数据库和MySql命令相互依赖;如果Oracle数据库使用MySql命令,可能就会报错;
后半句话:除了有O染成了数据库,还可能有MySql数据库,还可以有其他的数据库;
抽象工厂模式是特殊的工厂模式;
代码如下:
产品Product实现方式和工厂模式是一模一样的;
主要区别在与工厂方法的实现:抽象工厂方法和工厂方法的区别会在代码里说明;
AbtractProductB;
Command.h
#pragma once
#include<iostream>
using namespace std;
//AbtractProductB
class IDBCommand
{
public:
virtual void ExecCommand() =0;
};
//ProductB1
class MySqlCommand:public IDBCommand
{
public:
void ExecCommand()
{
cout << "MySql Command" << endl;
}
};
//ProductB2
class OracleCommand :public IDBCommand
{
public:
void ExecCommand()
{
cout << "Oracle Command" << endl;
}
};
//
AbstractProductA:
#pragma once
#include<iostream>
using namespace std;
//连接接口,AbstractProductA
class IDBConnection
{
public:
virtual void CreateDBConnection() = 0;
};
//SqlServerDBConnection——ProductA1;
class SqlServerDBConnection:public IDBConnection
{
public:
void CreateDBConnection()
{
cout << "SQLServer Connection" << endl;
}
};
//OracleServerDBConnection——ProductA2
class OracleServerDBConnection :public IDBConnection
{
public:
void CreateDBConnection()
{
cout << " OracleServer Connection" << endl;
}
};
#pragma once
#include"Command.h"
#include"Connection.h"
/*
工厂模式下
class IDBConnectionFactory
{
public:
virtual IDBConnection* CreateDBConnection() = 0;
};
class IDBCommandFactory
{
public:
virtual void CreateDBCommand() = 0;
};
class MySQlConnectionFactory :public IDBConnectionFactory
{
public:
IDBConnection* CreateDBConnection()
{
new SqlServerDBConnection();
}
};
class OracleConnectionFactory :public IDBConnectionFactory
{
public:
IDBConnection* CreateDBConnection()
{
new OracleServerDBConnection();
}
};
*/
//AbstractFactory
class IDBFactory
{
public:
virtual IDBConnection* CreateDBConnection() = 0;
virtual IDBCommand* CreateDBCommand() = 0;
};
//ConcreteFactory1
class MySqlFactory:public IDBFactory
{
public:
IDBConnection* CreateDBConnection()
{
return new SqlServerDBConnection();
}
IDBCommand* CreateDBCommand()
{
return new MySqlCommand();
}
};
//ConcreteFactory2
class OracleFactory :public IDBFactory
{
public:
IDBConnection* CreateDBConnection()
{
return new OracleServerDBConnection();
}
IDBCommand* CreateDBCommand()
{
return new OracleCommand();
}
};
客户端:需要new 对象的程序
#pragma once
#include<vector>
#include"DBFactory.h"
class EmployeeDAD
{
public:
EmployeeDAD(IDBFactory* Factory)
{
this->m_lpFactory = Factory;
}
/*
在工厂模式,如果是一个系列有关联的产品,那构造函数这里就有可能是一个传入SQLConnectionFactory,
OracleCommandFactory;那在GetEmployes中就会出现连接的时候MySQl,但是命令执行的缺失Oracle,那么sql语言可能会报错
所以需要将俩个操作放在一个工厂中
EmployeeDAD(IDBConnectionFactory* lpConnectionFactory, IDBCommandFactory* lpCommandFactory)
{
this->m_lpConnectionFactory = lpConnectionFactory;
this->m_lpCommandFactory = lpCommandFactory;
}
*/
public:
void GetEmployes()
{
IDBConnection* connection = m_lpFactory->CreateDBConnection();
connection->CreateDBConnection();
IDBCommand* command = m_lpFactory->CreateDBCommand();
command->ExecCommand();
}
/*
//工厂模式下
void GetEmployes()
{
IDBConnection* connection = m_lpConnectionFactory->CreateDBConnection();
connection->CreateDBConnection();
IDBCommand* command = m_lpCommandFactory->CreateDBCommand();
command->ExecCommand();
}
*/
private:
IDBFactory* m_lpFactory;
vector<EmployeeDAD*> m_vecEmploy;
/*
工厂模式下
IDBConnectionFactory* m_lpConnectionFactory;
IDBCommandFactory* m_lpCommandFactory;
*/
};
测试程序:
#include"EmployeeDAB.h"
int main()
{
IDBFactory* db = new MySqlFactory();
EmployeeDAD EmpDB(db);
EmpDB.GetEmployes();
return 0;
}