抽象工厂模式（Abstract Factory Pattern）

概念

抽象工厂模式是一种创建型设计模式，它提供了一种将相关的对象组合成家族或系列的方式，而无需指定具体类的方法。

思想

抽象工厂模式通过引入抽象工厂接口和具体工厂类，以及一组抽象产品接口和具体产品类，将对象的创建委托给工厂类。客户端通过抽象工厂接口与具体工厂进行交互，而不需要直接实例化具体产品类。这样可以提高代码的灵活性和可维护性，使得系统更易于扩展和切换产品系列。

角色

• 抽象工厂（AbstractFactory）：定义创建一组相关产品对象的接口。
• 具体工厂（ConcreteFactory）：实现抽象工厂接口，具体工厂负责实例化具体产品对象。
• 抽象产品（AbstractProduct）：定义产品对象的接口。
• 具体产品（ConcreteProduct）：实现抽象产品接口，具体产品是工厂创建的目标对象。

优点

• 将产品的创建和使用分离，客户端通过抽象工厂接口使用产品，无需了解具体产品的创建细节。
• 可以轻松切换不同的产品系列，只需要替换具体工厂即可。
• 保持了产品族内的一致性，确保一组相关的产品对象被一起创建。

缺点

• 新增产品需要修改抽象工厂接口和所有的具体工厂类，违反了开闭原则。
• 增加了系统的复杂性，引入了更多的类和接口。

类图

@startuml

skinparam class {
    BackgroundColor FloralWhite
    BorderColor Black
}

class AbstractFactory {
    +CreateProductA(): AbstractProductA
    +CreateProductB(): AbstractProductB
}

class ConcreteFactory1 {
    +CreateProductA(): AbstractProductA
    +CreateProductB(): AbstractProductB
}

class ConcreteFactory2 {
    +CreateProductA(): AbstractProductA
    +CreateProductB(): AbstractProductB
}

interface AbstractProductA {
    +OperationA(): void
}

class ConcreteProductA1 {
    +OperationA(): void
}

class ConcreteProductA2 {
    +OperationA(): void
}

interface AbstractProductB {
    +OperationB(): void
}

class ConcreteProductB1 {
    +OperationB(): void
}

class ConcreteProductB2 {
    +OperationB(): void
}

AbstractFactory <|-- ConcreteFactory1
AbstractFactory <|-- ConcreteFactory2
AbstractProductA <|.. ConcreteProductA1
AbstractProductA <|.. ConcreteProductA2
AbstractProductB <|.. ConcreteProductB1
AbstractProductB <|.. ConcreteProductB2

note top of AbstractFactory : +CreateProductA(): AbstractProductA\n+CreateProductB(): AbstractProductB
note top of ConcreteFactory1 : +CreateProductA(): AbstractProductA\n+CreateProductB(): AbstractProductB
note top of ConcreteFactory2 : +CreateProductA(): AbstractProductA\n+CreateProductB(): AbstractProductB
note top of AbstractProductA : +OperationA(): void
note top of ConcreteProductA1 : +OperationA(): void
note top of ConcreteProductA2 : +OperationA(): void
note top of AbstractProductB : +OperationB(): void
note top of ConcreteProductB1 : +OperationB(): void
note top of ConcreteProductB2 : +OperationB(): void

@enduml

时序图

@startuml

skinparam sequence {
    ParticipantFontSize 16
    ArrowFontSize 16
    ActorBorderColor Black
}

actor Client
participant AbstractFactory
participant ConcreteFactory1
participant ConcreteFactory2
participant AbstractProductA
participant ConcreteProductA1
participant AbstractProductB
participant ConcreteProductB1

Client -> AbstractFactory: CreateProductA()
activate AbstractFactory
AbstractFactory -> ConcreteFactory1: CreateProductA()
activate ConcreteFactory1
ConcreteFactory1 -> ConcreteProductA1: CreateProductA()
activate ConcreteProductA1
ConcreteProductA1 --> ConcreteFactory1
ConcreteFactory1 --> AbstractFactory
AbstractFactory --> Client
deactivate ConcreteProductA1
deactivate ConcreteFactory1
deactivate AbstractFactory

Client -> AbstractFactory: CreateProductB()
activate AbstractFactory
AbstractFactory -> ConcreteFactory1: CreateProductB()
activate ConcreteFactory1
ConcreteFactory1 -> ConcreteProductB1: CreateProductB()
activate ConcreteProductB1
ConcreteProductB1 --> ConcreteFactory1
ConcreteFactory1 --> AbstractFactory
AbstractFactory --> Client
deactivate ConcreteProductB1
deactivate ConcreteFactory1
deactivate AbstractFactory

@enduml

示例代码

下面是使用C++实现的抽象工厂模式示例代码：

#include <iostream>

// Abstract Product A
class AbstractProductA {
public:
    virtual void OperationA() = 0;
};

// Concrete Product A1
class ConcreteProductA1 : public AbstractProductA {
public:
    void OperationA() override {
        std::cout << "ConcreteProductA1 OperationA" << std::endl;
    }
};

// Concrete Product A2
class ConcreteProductA2 : public AbstractProductA {
public:
    void OperationA() override {
        std::cout << "ConcreteProductA2 OperationA" << std::endl;
    }
};

// Abstract Product B
class AbstractProductB {
public:
    virtual void OperationB() = 0;
};

// Concrete Product B1
class ConcreteProductB1 : public AbstractProductB {
public:
    void OperationB() override {
        std::cout << "ConcreteProductB1 OperationB" << std::endl;
    }
};

// Abstract Factory
class AbstractFactory {
public:
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
};

// Concrete Factory 1
class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* CreateProductA() override {
        return new ConcreteProductA1();
    }

    AbstractProductB* CreateProductB() override {
        return new ConcreteProductB1();
    }
};

int main() {
    // Create Concrete Factory 1
    AbstractFactory* factory = new ConcreteFactory1();

    // Create Product A1
    AbstractProductA* productA = factory->CreateProductA();
    productA->OperationA();

    // Create Product B1
    AbstractProductB* productB = factory->CreateProductB();
    productB->OperationB();

    delete productA;
    delete productB;
    delete factory;

    return 0;
}

示例代码中定义了抽象产品（AbstractProductA和AbstractProductB）以及具体产品（ConcreteProductA1、ConcreteProductA2和ConcreteProductB1）。抽象工厂（AbstractFactory）定义了创建抽象产品的接口，并由具体工厂（ConcreteFactory1）实现。在示例代码中，通过创建具体工厂1（ConcreteFactory1），然后使用工厂的CreateProductA方法创建具体产品A1（ConcreteProductA1）和CreateProductB方法创建具体产品B1（ConcreteProductB1）。最后，通过调用具体产品的操作方法，输出相应的信息。

示例代码运行结果：

ConcreteProductA1 OperationA
ConcreteProductB1 OperationB

工厂模式和抽象工厂模式的对比

工厂方法模式	抽象工厂模式
针对的是单个产品等级结构	针对的是面向多个产品等级结构
一个抽象产品类	多个抽象产品类
可以派生出多个具体产品类	每个抽象产品类可以派生出多个具体产品类
一个抽象工厂类，可以派生出多个具体工厂类	一个抽象工厂类，可以派生出多个具体工厂类
每个具体工厂类只能创建一个具体产品类的实例	每个具体工厂类可以创建多个具体产品类的实例