C++设计模式：抽象工厂模式（七）

时间：2024-04-10 13:49:49
1、定义与动机
  • 抽象工厂定义：提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类
  • 动机：
    • 在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时，由于需求的变化，往往存在更多系列对象的创建工作。
    • 如何应对这种变化？如何绕过常规的对象创建方法（new），提供一种“封装机制来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？
  • 个人理解：在工厂方法的基础上套上了一层封装接口，封装的意义就是为了在工厂方法的基础上返回一套或者同类的相互依赖的一系列对象！
2、案例分析

假设现在有一个DAO层需要获取员工的信息，通过数据库访问获取数据。

2.1、普通代码结构（一）
  • 很容易编写出这样一份朴素简单的代码
  • 分析下面这份代码存在的问题：
    • 首先很明显的可以发现这里存在紧耦合，不符合工厂方法模式
    • 一旦需要换数据库源，这两个new对象就需要更改硬编码（违背开闭原则）
    • 因此可能很容易的发现通过工厂方法模式来优化这个代码
#include <vector>
class EmployeeMapper{
public:
    vector<EmployeeDO> GetEmployees(){
        SqlConnection* connection = new SqlConnection();
        connection->ConnectionDB("...");

        SqlCommand* command = new SqlCommand();
        command->CommandSQL("....");
        // .....
    }
};
2.2、工厂方法（二）
  • SqlConnector：ConnectionDB操作提炼一个抽象方法，然后给MySQLConnectDB和OracleConnectDB继承并且实现连接的具体操作
  • ConnectorFactory：连接对象创建工厂，然后MySQLConnectorFactory和OracleConnectorFactory分别继承并且创建各自的实例化对象
  • SqlCommand和CommanderFactory的实现方式同上。这样就完美的隔离了紧耦合的绑定
  • 一旦需要增加一种数据源只需要编写XXXConnectDB、XXXConnectorFactory和XXXCommand、XXXCommanderFactory。很明显拓展是开放的，修改关闭
//
// Created by splay on 24-4-9.
//
#include <vector>
class SqlConnector{
public:
    virtual void ConnectionDB(string info) = 0;
    virtual ~SqlConnector(){

    }
};
class MySQLConnector: public SqlConnector{
public:
    virtual void ConnectionDB(string info){

    }
};

class OracleConnector: public SqlConnector{
public:
    virtual void ConnectionDB(string info){

    }
};

class ConnectorFactory{
public:
    virtual SqlConnector* CreateConnector() = 0;
    virtual ~ConnectorFactory(){

    }
};
class MySQLConnectorFactory: public ConnectorFactory{
public:
    virtual SqlConnector* CreateConnector(){
        SqlConnector* mysqlConnector = new MySQLConnector();
        return mysqlConnector;
    }
};

class OracleConnectorFactory: public ConnectorFactory{
public:
    virtual SqlConnector* CreateConnector(){
        SqlConnector* oracleConnector = new OracleConnector();
        return oracleConnector;
    }
};





class SqlCommand{
public:
    virtual void CommandSQL(string sql) = 0;
    virtual ~SqlCommand(){

    }
};
class MySQLCommand: public SqlCommand{
public:
    virtual void CommandSQL(string sql){

    }
};
class OracleCommand: public SqlCommand{
public:
    virtual void CommandSQL(string sql){

    }
};

class CommanderFactory{
public:
    virtual SqlCommand* CreateCommander() = 0;
    virtual ~CommanderFactory(){

    }
};
class MySQLCommanderFactory: public CommanderFactory{
public:
    virtual SqlCommand* CreateCommander(){
        SqlCommand* mySqlCommand = new MySQLCommand();
        return mySqlCommand;
    }
};

class OracleCommanderFactory: public CommanderFactory{
public:
    virtual SqlCommand* CreateCommander(){
        SqlCommand* oracleCommand = new OracleCommand();
        return oracleCommand;
    }
};



class EmployeeMapper{
private:
    ConnectorFactory* connectorFactory;
    CommanderFactory* commanderFactory;
public:
    vector<EmployeeDO> GetEmployees(){
        SqlConnector* connector = connectorFactory->CreateConnector();
        connector->ConnectionDB("...");

        SqlCommand* command = commanderFactory->CreateCommander();
        command->CommandSQL("....");
        // .....
    }
};
3、抽象工厂模式

  • 工厂方法帮助我们解决了这份代码的的耦合问题，达到了松耦合的层次，但是并没有高内聚

  • 工厂方法实现的这个代码好吗，其实它并不完美，不完美的点在于Connector和Commander是来自同一种数据库

  • 如果传入MySQLConnectorFactory和OracleCommanderFactory，会导致Connector和Commander来自不同的数据源，很明显这里存在一定的风险隐患。

  • 抽象工厂的核心：在工厂方法的前提下，解决一系列相关联对象的创建问题，使得有关联性的对象具有高度的内聚性

  • 提炼一个DBFactory接口，

    • 里面包含创建CreateConnector、CreateCommander的虚方法
    • 对于不同的数据库源继承这个DBFactory并且实现这两个创建对象的方法
    • 在需要的地方注入抽象工厂，通过抽象工厂创建**同类（相关联）**对象
#include <vector>
class SqlConnector{
public:
    virtual void ConnectionDB(string info) = 0;
    virtual ~SqlConnector(){

    }
};
class SqlCommand{
public:
    virtual void CommandSQL(string sql) = 0;
    virtual ~SqlCommand(){

    }
};
class MySQLConnector: public SqlConnector{
public:
    virtual void ConnectionDB(string info){

    }
};
class MySQLCommand: public SqlCommand{
public:
    virtual void CommandSQL(string sql){

    }
};

class OracleConnector: public SqlConnector{
public:
    virtual void ConnectionDB(string info){

    }
};
class OracleCommand: public SqlCommand{
public:
    virtual void CommandSQL(string sql){

    }
};


class DBFactory{
public:
    virtual SqlConnector* CreateConnector() = 0;
    virtual SqlCommand* CreateCommander() = 0;
    virtual ~DBFactory(){

    }
};

class MySQLFactory: public DBFactory{
public:
    virtual SqlConnector* CreateConnector(){
        SqlConnector* mysqlConnector = new MySQLConnector();
        return mysqlConnector;
    }
    virtual SqlCommand* CreateCommander(){
        SqlCommand* mySqlCommand = new MySQLCommand();
        return mySqlCommand;
    }
};

class OracleFactory: public DBFactory{
public:
    virtual SqlConnector* CreateConnector(){
        SqlConnector* oracleConnector = new OracleConnector();
        return oracleConnector;
    }
    virtual SqlCommand* CreateCommander(){
        SqlCommand* oracleCommand = new OracleCommand();
        return oracleCommand;
    }
};


class EmployeeMapper{
private:
    DBFactory *dbFactory;
public:
    vector<EmployeeDO> GetEmployees(){
        SqlConnector* connector = dbFactory->CreateConnector();
        connector->ConnectionDB("...");

        SqlCommand* command = dbFactory->CreateCommander();
        command->CommandSQL("....");
        // .....
    }
};
4、总结

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

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

  • Abstract Factory模式主要在于应对“新的一系列”的需求变动。其缺点在于难以应对“新对象”的需求变动
    在这里插入图片描述

相关文章