设计模式-工厂模式（Factory Pattern）

承接Qt/C++软件开发项目，高质量交付，灵活沟通，长期维护支持。需求所寻，技术正适，共创完美，欢迎私信联系！

一、工厂模式说明

        工厂模式是一种创建型设计模式，它提供了一种将对象的创建与使用分离的方式。工厂模式通过引入一个公共的接口来创建对象，而不是通过直接调用构造函数来创建对象。这样做的好处是使得代码更加灵活，更容易维护和扩展。

        工厂模式通常包含以下几个角色：

        产品（Product）： 产品是工厂模式所创建的对象。它可以是一个接口、抽象类或者具体类，用来描述工厂创建的对象所具有的特性和行为。

        工厂接口（Factory Interface）： 工厂接口是用来创建产品对象的接口，它定义了一个或多个工厂方法用来创建产品。通常情况下，工厂接口是一个抽象类或者接口，其中的工厂方法可以是抽象方法或者默认实现方法。

        具体工厂（Concrete Factory）： 具体工厂是工厂模式的实现者，它实现了工厂接口，负责创建具体的产品对象。每个具体工厂类通常都与一个特定的产品相关联，用来创建该产品的实例。

        客户端（Client）： 客户端是使用工厂模式的地方，它通过工厂接口来创建产品对象，而不需要知道具体的产品类。客户端通常只与工厂接口和产品接口交互，而不直接依赖具体的产品类。

二、工厂模式应用

        在实际应用中的例子时，有几个常见的场景：

        数据库连接池： 在大多数现代应用程序中，需要频繁地与数据库进行交互。为了提高性能和效率，通常会使用数据库连接池。连接池是一组预先创建的数据库连接，可以在需要时重新使用。工厂模式可用于创建这些数据库连接，以便统一管理连接的创建和销毁。例如，可以使用工厂方法模式创建不同类型的数据库连接对象，如 MySQL 连接、PostgreSQL 连接等。

        日志记录器： 许多应用程序需要记录事件和错误信息以便后期分析和调试。日志记录器是用于记录这些信息的工具。工厂模式可用于创建不同类型的日志记录器，如文件日志记录器、数据库日志记录器、控制台日志记录器等。根据应用程序的需求，可以选择合适的日志记录器类型。例如，可以使用抽象工厂模式来创建不同类型的日志记录器对象，并使用配置文件或其他参数来确定要创建的日志记录器类型。

        UI控件库： 在图形用户界面（GUI）应用程序中，UI控件库用于创建和管理各种用户界面元素，如按钮、文本框、标签等。工厂模式可用于创建这些UI控件。例如，可以使用简单工厂模式创建不同类型的UI控件对象，并提供统一的接口来访问这些控件。这样可以降低客户端代码与具体控件实现之间的耦合，并提高代码的灵活性和可维护性。

        加密算法库： 在安全领域中，加密算法是非常重要的组成部分。工厂模式可用于创建不同类型的加密算法对象，如对称加密算法、非对称加密算法等。例如，可以使用工厂方法模式创建不同类型的加密算法对象，并提供统一的接口来加密和解密数据。这样可以方便地切换和使用不同类型的加密算法，而不影响客户端代码。

        游戏开发： 在游戏开发中，经常需要创建各种游戏对象，如角色、道具、怪物等。工厂模式可用于创建这些游戏对象。例如，可以使用工厂方法模式创建不同类型的游戏对象，并提供统一的接口来处理游戏逻辑。这样可以方便地扩展和修改游戏中的对象，而不需要修改客户端代码。

三、 工厂模式的实现

(一) 简单工厂模式

        简单工厂模式（Simple Factory Pattern）是一种创建型设计模式，它提供了一个专门的工厂类用于创建对象，而不需要将对象的创建逻辑暴露给客户端。简单工厂模式通过将对象的创建过程封装在工厂类中，使得客户端无需知道具体的实例化逻辑，只需要通过工厂类来获取所需的对象。

        简单工厂模式由三个主要组成部分构成：

        工厂类（Factory Class）：工厂类负责创建对象的实例。通常包含一个静态方法或成员方法，根据客户端的请求创建并返回具体的对象实例。客户端通过调用工厂类的方法获取所需的对象。

        抽象产品类（Abstract Product Class）：抽象产品类定义了所创建的对象的通用接口，客户端通过该接口与具体产品进行交互。工厂类负责创建的对象都是抽象产品类的子类对象。

        具体产品类（Concrete Product Class）：具体产品类是抽象产品类的具体实现，它实现了抽象产品类定义的接口，并提供了具体的功能和行为。

#include <iostream>
#include <memory>

// 抽象产品类
class Product {
public:
    virtual void showInfo() = 0;
    virtual ~Product() {}
};

// 具体产品接口1：颜色属性 <- 这边是为了实现 接口隔离原则 
class Colorable {
public:
    virtual void setColor(const std::string& color) = 0;
    virtual std::string getColor() const = 0;
    virtual ~Colorable() {}
};

// 具体产品类：电子产品
class ElectronicProduct : public Product {
public:
    void showInfo() override {
        std::cout << "Electronic Product: Smart Phone\n";
    }
};

// 具体产品类：服装
class ClothingProduct : public Product, public Colorable {
private:
    std::string color;
public:
    void showInfo() override {
        std::cout << "Clothing Product: T-Shirt\n";
    }

    void setColor(const std::string& color) override {
        this->color = color;
    }

    std::string getColor() const override {
        return color;
    }
};

// 具体产品类：食品
class FoodProduct : public Product {
public:
    void showInfo() override {
        std::cout << "Food Product: Chocolate\n";
    }
};

// 简单工厂类
class ProductFactory {
public:
    // 根据传入的参数创建不同类型的产品对象
    std::unique_ptr<Product> createProduct(char type) {
        switch (type) {
            case 'E':
                return std::make_unique<ElectronicProduct>();
            case 'C':
                return std::make_unique<ClothingProduct>();
            case 'F':
                return std::make_unique<FoodProduct>();
            default:
                std::cerr << "Invalid product type\n";
                return nullptr;
        }
    }
};

int main() {
    // 使用简单工厂创建不同类型的商品对象
    ProductFactory factory;
    
    std::unique_ptr<Product> product1 = factory.createProduct('E');
    if (product1) {
        product1->showInfo();
    }

    std::unique_ptr<Product> product2 = factory.createProduct('C');
    if (product2) {
        product2->showInfo();
        Colorable* colorableProduct = dynamic_cast<Colorable*>(product2.get());
        if (colorableProduct) {
            colorableProduct->setColor("Red");
            std::cout << "Color: " << colorableProduct->getColor() << std::endl;
        }
    }

    std::unique_ptr<Product> product3 = factory.createProduct('F');
    if (product3) {
        product3->showInfo();
    }

    return 0;
}

(二) 工厂方法模式

        工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它定义了一个用于创建对象的接口，但是将具体对象的创建延迟到了子类中。这样，工厂方法模式允许一个类的实例化延迟到子类中，从而使得一个类的实例化与子类的具体实现解耦。

        工厂方法模式由四个主要组成部分构成：

        抽象产品类（Abstract Product Class）：定义了工厂方法所创建的对象的接口，客户端通过该接口与具体产品进行交互。

        具体产品类（Concrete Product Class）：具体产品类是抽象产品类的实现，它定义了具体产品的属性和行为。

        抽象工厂类（Abstract Factory Class）：抽象工厂类定义了一个抽象的工厂方法，该方法返回一个抽象产品类的实例。该类可以是抽象类或接口。

        具体工厂类（Concrete Factory Class）：具体工厂类是抽象工厂类的实现，它实现了抽象工厂类定义的工厂方法，负责创建具体的产品对象。

#include <iostream>
#include <memory>

// 抽象产品类
class Product {
public:
    virtual void showInfo() = 0;
    virtual ~Product() {}
};

// 具体产品类：电子产品
class ElectronicProduct : public Product {
public:
    void showInfo() override {
        std::cout << "Electronic Product: Smart Phone\n";
    }
};

// 具体产品类：服装
class ClothingProduct : public Product {
public:
    void showInfo() override {
        std::cout << "Clothing Product: T-Shirt\n";
    }
};

// 具体产品类：食品
class FoodProduct : public Product {
public:
    void showInfo() override {
        std::cout << "Food Product: Chocolate\n";
    }
};

// 抽象工厂类
class ProductFactory {
public:
    virtual std::unique_ptr<Product> createProduct() = 0;
    virtual ~ProductFactory() {}
};

// 具体工厂类：电子产品工厂
class ElectronicProductFactory : public ProductFactory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ElectronicProduct>();
    }
};

// 具体工厂类：服装工厂
class ClothingProductFactory : public ProductFactory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ClothingProduct>();
    }
};

// 具体工厂类：食品工厂
class FoodProductFactory : public ProductFactory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<FoodProduct>();
    }
};

int main() {
    // 使用具体工厂类来创建产品对象
    std::unique_ptr<ProductFactory> electronicFactory = std::make_unique<ElectronicProductFactory>();
    std::unique_ptr<Product> product1 = electronicFactory->createProduct();
    product1->showInfo();

    std::unique_ptr<ProductFactory> clothingFactory = std::make_unique<ClothingProductFactory>();
    std::unique_ptr<Product> product2 = clothingFactory->createProduct();
    product2->showInfo();

    std::unique_ptr<ProductFactory> foodFactory = std::make_unique<FoodProductFactory>();
    std::unique_ptr<Product> product3 = foodFactory->createProduct();
    product3->showInfo();

    return 0;
}

(三) 抽象工厂模式

        抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一个接口用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。抽象工厂模式通过引入抽象工厂类和具体工厂类来实现对象的创建，使得客户端可以从抽象工厂类中获取具体工厂类的实例，进而创建所需的产品对象。

        抽象工厂模式由四个主要组成部分构成：

        抽象产品类（Abstract Product Class）：定义了工厂方法所创建的对象的接口，客户端通过该接口与具体产品进行交互。

        具体产品类（Concrete Product Class）：具体产品类是抽象产品类的实现，它定义了具体产品的属性和行为。

        抽象工厂类（Abstract Factory Class）：抽象工厂类定义了一个抽象的工厂方法，该方法返回一个抽象产品类的实例。抽象工厂类可以是一个接口或者抽象类。

        具体工厂类（Concrete Factory Class）：具体工厂类是抽象工厂类的实现，它实现了抽象工厂类定义的工厂方法，并负责创建具体的产品对象。

#include <iostream>
#include <memory>

// 抽象产品类
class ElectronicProduct {
public:
    virtual void showInfo() = 0;
    virtual ~ElectronicProduct() {}
};

class ClothingProduct {
public:
    virtual void showInfo() = 0;
    virtual ~ClothingProduct() {}
};

// 具体产品类：手机
class SmartPhone : public ElectronicProduct {
public:
    void showInfo() override {
        std::cout << "Smart Phone\n";
    }
};

// 具体产品类：T恤
class TShirt : public ClothingProduct {
public:
    void showInfo() override {
        std::cout << "T-Shirt\n";
    }
};

// 抽象工厂类
class AbstractFactory {
public:
    virtual std::unique_ptr<ElectronicProduct> createElectronicProduct() = 0;
    virtual std::unique_ptr<ClothingProduct> createClothingProduct() = 0;
    virtual ~AbstractFactory() {}
};

// 具体工厂类：电子产品工厂
class ElectronicFactory : public AbstractFactory {
public:
    std::unique_ptr<ElectronicProduct> createElectronicProduct() override {
        return std::make_unique<SmartPhone>();
    }

    std::unique_ptr<ClothingProduct> createClothingProduct() override {
        // 在这个工厂中，我们无法创建服装产品，因此返回 nullptr
        return nullptr;
    }
};

// 具体工厂类：服装工厂
class ClothingFactory : public AbstractFactory {
public:
    std::unique_ptr<ElectronicProduct> createElectronicProduct() override {
        // 在这个工厂中，我们无法创建电子产品，因此返回 nullptr
        return nullptr;
    }

    std::unique_ptr<ClothingProduct> createClothingProduct() override {
        return std::make_unique<TShirt>();
    }
};

int main() {
    // 创建电子产品工厂并使用
    std::unique_ptr<AbstractFactory> electronicFactory = std::make_unique<ElectronicFactory>();
    std::unique_ptr<ElectronicProduct> electronicProduct = electronicFactory->createElectronicProduct();
    if (electronicProduct) {
        electronicProduct->showInfo();
    }

    // 创建服装工厂并使用
    std::unique_ptr<AbstractFactory> clothingFactory = std::make_unique<ClothingFactory>();
    std::unique_ptr<ClothingProduct> clothingProduct = clothingFactory->createClothingProduct();
    if (clothingProduct) {
        clothingProduct->showInfo();
    }

    return 0;
}
 

四、工厂模式总结

工厂模式类型	优点	缺点	适用场景
简单工厂模式 （Simple Factory Pattern）	- 实现简单易懂 - 将对象创建和使用解耦	- 违反开闭原则 - 工厂类集中了所有产品的创建逻辑	- 产品较少 - 产品不经常变化
工厂方法模式 （Factory Method Pattern）	- 符合开闭原则 - 延迟对象的创建 - 增加灵活性	- 每次新增产品都需要编写一个具体工厂类	- 产品具有相同接口 - 创建逻辑相对复杂的情况
抽象工厂模式 （Abstract Factory Pattern）	- 将对象创建和使用解耦 - 符合开闭原则	- 新增产品族比较困难 - 需要修改抽象工厂接口及实现类	- 创建一系列相关产品对象 - 保证产品族一致性