设计模式：抽象工厂模式

1、代理模式

1）定义

提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类。

2）动机

> 在软件系统中，经常面临着“一系列相互依赖对象”的创建工作；同时，由于需求的变化，往往存在更多系列对象的创建工作。

> 如何应对这种变化？如何绕过常规的对象创建方法（new），提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？

3）类图

 

4）代码实现

#include<vector>
#include<memory>
#include<string>
#include<iostream>

using namespace std;

//数据库连接基类
class IDBConnection {
public:
	virtual void ConnectionString(std::string str) = 0;
	virtual void Open() = 0;
};

// 数据读取基类
class IDataReader {
public:
	virtual bool Read() = 0;
};

// 数据库命令基类
class IDBCommand {
public:
	virtual void CommandText(std::string str) = 0;
	virtual void SetConnection(unique_ptr<IDBConnection> connect) = 0;
	virtual unique_ptr<IDataReader> ExecuteReader() = 0;
};

class IDBFactory {   //系列工厂
public:
	virtual unique_ptr<IDBConnection> CreateDBConnection() = 0;
	virtual unique_ptr<IDBCommand> CreateDBCommand() = 0;
	virtual unique_ptr<IDataReader> CreateDataReader() = 0;
};

//支持My SQL
class SqlConnection : public IDBConnection {
public:
	virtual void ConnectionString(std::string str) override {
		cout << " +++++++++++++ SqlConnection ConnectionString +++++++++++++ " << endl;
	}
	virtual void Open() override {
		cout << " +++++++++++++ SqlConnection open +++++++++++++ " << endl;
	}
};
class SqlDataReader : public IDataReader {
public:
	virtual bool Read() override {
		cout << " +++++++++++++ SqlDataReader Read +++++++++++++ " << endl;
		return true;
	}
};
class SqlCommand : public IDBCommand {
public:
	virtual void CommandText(std::string str) override {
		cout << " +++++++++++++ SqlCommand CommandText +++++++++++++ " << endl;
	}
	virtual void SetConnection(unique_ptr<IDBConnection> connect) override {
		cout << " +++++++++++++ SqlCommand SetConnection +++++++++++++ " << endl;
	}
	virtual unique_ptr<IDataReader> ExecuteReader() override {
		cout << " +++++++++++++ SqlCommand ExecuteReader +++++++++++++ " << endl;
		unique_ptr<IDataReader> read = make_unique<SqlDataReader>();
		return read;
	}
};

class SqlDBFactory :public IDBFactory {
public:
	unique_ptr<IDBConnection> CreateDBConnection() override
	{
		cout << " ---------------- SqlDBFactory CreateDBConnection ---------------- " << endl;
		unique_ptr<IDBConnection> db_connection = make_unique<SqlConnection>();
		return db_connection;
	}

	unique_ptr<IDBCommand> CreateDBCommand() override
	{
		cout << " ---------------- SqlDBFactory CreateDBCommand ---------------- " << endl;
		unique_ptr<IDBCommand> db_command = make_unique<SqlCommand>();
		return db_command;
	}

	unique_ptr<IDataReader> CreateDataReader() override
	{
		cout << " ---------------- SqlDBFactory CreateDataReader ---------------- " << endl;
		unique_ptr<IDataReader> read = make_unique<SqlDataReader>();
		return read;
	}

private:
};

//支持Oracle
class OracleConnection : public IDBConnection {
public:
	virtual void ConnectionString(std::string str) override {
		cout << " +++++++++++++ OracleConnection ConnectionString +++++++++++++ " << endl;
	}
	virtual void Open() override {
		cout << " +++++++++++++ OracleConnection Open +++++++++++++ " << endl;
	}
};

class OracleDataReader : public IDataReader {
public:
	virtual bool Read() override {
		cout << " +++++++++++++ OracleDataReader Read +++++++++++++ " << endl;
		return true;
	}
};

class OracleCommand : public IDBCommand {
	virtual void CommandText(std::string str) override {
		cout << " +++++++++++++ OracleCommand CommandText +++++++++++++ " << endl;
	}
	virtual void SetConnection(unique_ptr<IDBConnection> connect) override {
		cout << " +++++++++++++ OracleCommand SetConnection +++++++++++++ " << endl;
	}
	virtual unique_ptr<IDataReader> ExecuteReader() override {
		cout << " +++++++++++++ OracleCommand ExecuteReader +++++++++++++ " << endl;
		unique_ptr<IDataReader> read = make_unique<OracleDataReader>();
		return read;
	}
};

class OracleDBFactory :public IDBFactory {
public:
	unique_ptr<IDBConnection> CreateDBConnection() override
	{
		cout << " ---------------- OracleDBFactory CreateDBConnection ---------------- " << endl;
		unique_ptr<IDBConnection> db_connection = make_unique<OracleConnection>();
		return db_connection;
	}

	unique_ptr<IDBCommand> CreateDBCommand() override
	{
		cout << " ---------------- OracleDBFactory CreateDBCommand ---------------- " << endl;
		unique_ptr<IDBCommand> db_command = make_unique<OracleCommand>();
		return db_command;
	}

	unique_ptr<IDataReader> CreateDataReader() override
	{
		cout << " ---------------- OracleDBFactory CreateDataReader ---------------- " << endl;
		unique_ptr<IDataReader> read = make_unique<OracleDataReader>();
		return read;
	}
};

//.........................
class EmployeeDAO {

public:
	EmployeeDAO(unique_ptr<IDBFactory>& dbFactory) : dbFactory(std::move(dbFactory))
	{}

	void GetEmployees() 
	{
		unique_ptr<IDBConnection> connection = dbFactory->CreateDBConnection();
		connection->ConnectionString("...");

		unique_ptr<IDBCommand> command = dbFactory->CreateDBCommand();
		command->CommandText("...");
		command->SetConnection(std::move(connection)); //关联性

		unique_ptr<IDataReader> reader = command->ExecuteReader(); //关联性
		reader->Read();
	}

private:
	unique_ptr<IDBFactory> dbFactory;// SqlDBFactory, OracleDBFactory...
};

int main()
{
	unique_ptr<IDBFactory> sql_factory = make_unique<SqlDBFactory>();
	EmployeeDAO employee_dao1(sql_factory);
	employee_dao1.GetEmployees();
	cout << "\n\n";

	unique_ptr<IDBFactory> oracle_factory = make_unique<OracleDBFactory>();
	EmployeeDAO employee_dao2(oracle_factory);
	employee_dao2.GetEmployees();
	system("pause");
	return 0;
}

运行结果：

5）总结

> 如果没有应对“多系列对象构建”的需求变化，则没有必要使用Abstract Factory模式，这时候使用简单工厂模式完全可以。

> “系列对象”指的是在某一特定系列下的对象之间有相互依赖、或作用的关系。不同系列对对象之间不能相互依赖。

> Abstract Factory模式主要在于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动。