C++ 设计者模式——抽象工厂

 

抽象工厂模式用于：一系列相互依赖的对象的创建工作，而且需求的变化会有更多系列对象需要创建；

前半句话可以这样理解：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;
}