对象创建_AbstractFactory

作者出版于 design_patterns

2023-07-15 约 1008 字预计阅读 3 分钟

对象创建模式

通过“对象创建”模式绕开 new，来避免对象创建(new)过程中所导致的紧耦合 (依赖具体类)，从而支持对象创建的稳定。它是接口抽象之后的第一步工作。

典型模式

Factory Method
Abstract Factory
Prototype
Builder

1 Abstract Factory 抽象工厂模式

1.1 模式动机

在软件系统中，经常面临着”一系列相互依赖的对象”的创建工作；

同时，由于需求的变化，往往存在更多系列对象的创建工作。

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

1.2 模式定义

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

1.3 模式示例代码

# include <iostream>
# include <string>

// 抽象产品：数据库连接
class DBConnection {
public:
    virtual void connect() = 0;
    virtual void disconnect() = 0;
};

// 具体产品：MySQL连接
class MySQLConnection : public DBConnection {
public:
    void connect() {
        std::cout << "连接到MySQL数据库" << std::endl;
    }

    void disconnect() {
        std::cout << "断开MySQL数据库连接" << std::endl;
    }
};

// 具体产品：SQL Server连接
class SQLServerConnection : public DBConnection {
public:
    void connect() {
        std::cout << "连接到SQL Server数据库" << std::endl;
    }

    void disconnect() {
        std::cout << "断开SQL Server数据库连接" << std::endl;
    }
};

// 具体产品：Oracle连接
class OracleConnection : public DBConnection {
public:
    void connect() {
        std::cout << "连接到Oracle数据库" << std::endl;
    }

    void disconnect() {
        std::cout << "断开Oracle数据库连接" << std::endl;
    }
};

// 抽象工厂：数据库连接工厂
class DBConnectionFactory {
public:
    virtual DBConnection* createConnection() = 0;
};

// 具体工厂：MySQL连接工厂
class MySQLConnectionFactory : public DBConnectionFactory {
public:
    DBConnection* createConnection() {
        return new MySQLConnection();
    }
};

// 具体工厂：SQL Server连接工厂
class SQLServerConnectionFactory : public DBConnectionFactory {
public:
    DBConnection* createConnection() {
        return new SQLServerConnection();
    }
};

// 具体工厂：Oracle连接工厂
class OracleConnectionFactory : public DBConnectionFactory {
public:
    DBConnection* createConnection() {
        return new OracleConnection();
    }
};

int main() {
    // 创建MySQL连接工厂
    DBConnectionFactory* mySQLFactory = new MySQLConnectionFactory();

    // 使用MySQL连接工厂创建MySQL连接对象
    DBConnection* mySQLConnection = mySQLFactory->createConnection();
    mySQLConnection->connect();
    mySQLConnection->disconnect();

    // 创建SQL Server连接工厂
    DBConnectionFactory* sqlServerFactory = new SQLServerConnectionFactory();

    // 使用SQL Server连接工厂创建SQL Server连接对象
    DBConnection* sqlServerConnection = sqlServerFactory->createConnection();
    sqlServerConnection->connect();
    sqlServerConnection->disconnect();

    // 创建Oracle连接工厂
    DBConnectionFactory* oracleFactory = new OracleConnectionFactory();

    // 使用Oracle连接工厂创建Oracle连接对象
    DBConnection* oracleConnection = oracleFactory->createConnection();
    oracleConnection->connect();
    oracleConnection->disconnect();

    // 释放内存
    delete mySQLFactory;
    delete mySQLConnection;
    delete sqlServerFactory;
    delete sqlServerConnection;
    delete oracleFactory;
    delete oracleConnection;

    return 0;
}

2 要点总结

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

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

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

目录