9. “对象创建“模式 之 Abstract Factory

1. 动机

• 在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时，由于需求的变化，往往存在更多系列对象的创建工作。
• 如何应对这种变化？如何绕过常规对象创建方法new，提供一种“封装机制”来避免客户程序这种“多系列具体对象的创建工作”的紧耦合？

2. 代码示例

class EmployeeManger
{
public:
    vector<EmployeeD0> GetEmployee()
    {
        SqlConnection * connection = new SqlConnection();
        connection->ConnectoinString("...");
        
        SqlCommand *command = new SqlCommand();
        command->CommandText("...");
        command->SetConnection(connection);
        
        SqlDataReader *reader = command->ExcuteReader();
        while(reader->Read())
        {
        }

    }
}

大概是上面代码，数据库的调用，使用的数据库是SqlServer，且从上述代码可以看到存在强耦合，后期扩展很麻烦，比如需要支持oracle的数据库，那该怎么避免这种new呢，前面一节降到的工厂模式，在这里能用吗，可以尝试下：

class IDBConnection{
}

class IDBConnectionFactory{
    virtual IDBConnection * CreateDBConnection() = 0;
}

class IDBCommand{
}
class IDBCommandFactor{
    virtual IDBCommand * CreateDBCommand() = 0;
}

class IDBReader{
}
class IDBReaderFactory{
    virtual IDBReader * CreateDBReader() = 0;
}

// 支持SQL Server
class SqlConnection: public IDBConnection{
}

class SqlConnectionFactory: public IDBConnectionFactory{
}

class SqlCommand: public IDBCommand{
}

class SqlCommandFactory: public IDBCommandFactor{
}

class SqlReader: public IDBReader{
}

class SqlSqlReaderFactory: public IDBReader{
}


// 支持Oracle
class OracleConnection: public IDBConnection{
}

class OracleConnectionFactory: public IDBConnectionFactory{
}

class OracleCommand: public IDBCommand{
}

class OracleCommandFactory: public IDBCommandFactor{
}

class OracleReader: public IDBReader{
}

class OracleReaderFactory: public IDBReader{
}

class EmployeeManger
{
    IDBConnectionFactory *dbconnection_factory;
    IDBCommandFactor *dbcommand_factory;
    IDBReaderFactory *dbreader_factory;
    
public:
    vector<EmployeeD0> GetEmployee()
    {
        IDBConnection * connection = dbconnection_factory->CreateDBConnection();
        connection->ConnectoinString("...");
        
        IDBCommand *command = dbcommand_factory->CreateDBCommand();
        command->CommandText("...");
        command->SetConnection(connection);

        IDBReader *reader = dbreader_factory->CreateDBReader();
        while(reader->Read())
        {
        }

    }
}

EmployManager中集成了3个相互依赖的关系的工厂类。

问题

这就会有一种风险，外部传进来的connection工厂是SQL Server的，但是Command却是Oracle的，这样必然会出现问题。

那怎么办呢？

解决：

        那直接将这三个工厂里面的虚方法集成到一个类里面不就可以了？

class IDBFactory{
public:
    virtual IDBConnection *CreateDBConnection() = 0;
    virtual IDBCommand *CreateDBCommadn() = 0;
    virtual IDBReader *CreateDBReader() = 0;
};

// 支持SQL Server
class SqlServerFactory : public IDBFactory{
public:
    virtual IDBConnection *CreateDBConnection(){

    };
    virtual IDBCommand *CreateDBCommadn(){

    };
    virtual IDBReader *CreateDBReader(){
        
    };
}

class EmployeeManger
{
    IDBFactory *dbFactory;
    
public:
    vector<EmployeeD0> GetEmployee()
    {
        IDBConnection * connection = dbFactory->CreateDBConnection();
        connection->ConnectoinString("...");
        
        IDBCommand *command = dbFactory->CreateDBCommand();
        command->CommandText("...");
        command->SetConnection(connection);              // 关联性

        IDBReader *reader = command->CreateDBReader(); // 关联性
        while(reader->Read())
        {
        }

    }
}

模式定义

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

                                                                                                                ----《设计模式》GOF

结构

 要点总结：

• 如果没有应对“多系列对象构建”的需求变化，则没有必要使用该模式，这时候使用简单的工厂模式就可以
• “系列对象”指的是在某一特定系列下的对象之间有相互依赖、或作用的关系。不同系列的对象之间不能相互依赖（比如前面例子中sqlsever的connection不能和oracle的command相互依赖）
• 抽象工厂模式主要在于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动

其实工厂方法可以认为是抽象工厂的一个特例，将IDBFactory中的虚方法仅保留一个就是工厂方法。