【设计模式】抽象工厂模式（含与工厂方法模式的对比）

本期我们来学习一下设计模式之抽象工厂模式，在软件开发中，工厂模式 和 抽象工厂模式 都用于创建对象，但它们的应用场景和实现方式有所不同。本文将基于 C++ 代码，分析抽象工厂模式的实现，并对比其与工厂方法模式的区别。

1. 抽象工厂模式简介

抽象工厂模式（Abstract Factory Pattern） 是创建型设计模式，用于创建一系列相关或相互依赖的对象，而无需指定其具体类。它提供了一个接口，允许客户端通过工厂方法创建不同类型的对象，而无需关心具体实现。

适用场景

• 当系统需要创建一系列相关的产品（例如同一风格的桌子和椅子）。
• 希望确保不同产品之间的兼容性（即，现代风格的桌子应当搭配现代风格的椅子）。
• 隐藏对象创建的细节，并遵循开放封闭原则。

2. 代码分析：抽象工厂模式

我们先看一下接下来实现的示例代码UML图：

(1) 产品接口

我们定义了**椅子（Chair）和桌子（Desk）**两个产品接口，并为它们的不同风格（现代、维多利亚）提供具体实现。

class Chair {
public:
  virtual ~Chair() {}
  virtual std::string SitOn() const = 0; // 坐在椅子上的行为
};

class ModernChair : public Chair {
public:
  std::string SitOn() const override {
    return "Sitting on a modern chair.";
  }
};

class VictorianChair : public Chair {
public:
  std::string SitOn() const override {
    return "Sitting on a Victorian chair.";
  }
};

类似地，我们定义了**桌子（Desk）**接口：

class Desk {
public:
  virtual ~Desk() {}
  virtual std::string WorkOn() const = 0; // 在桌子上工作的行为
  virtual std::string PairWithChair(const Chair &collaborator) const = 0; // 桌子与椅子配对
};

每种桌子都可以与同风格的椅子进行搭配：

class ModernDesk : public Desk {
public:
  std::string WorkOn() const override {
    return "Working on a modern desk.";
  }
  std::string PairWithChair(const Chair &collaborator) const override {
    return "Pairing modern desk with ( " + collaborator.SitOn() + " )";
  }
};

(2) 抽象工厂接口

class AbstractFactory {
public:
  virtual Chair *CreateChair() const = 0;
  virtual Desk *CreateDesk() const = 0;
  virtual ~AbstractFactory() {}
};

这个接口定义了创建相关产品的方法。

(3) 具体工厂

具体工厂负责生产特定风格的家具：

class ModernFurnitureFactory : public AbstractFactory {
public:
  Chair *CreateChair() const override {
    return new ModernChair();
  }
  Desk *CreateDesk() const override {
    return new ModernDesk();
  }
};

class VictorianFurnitureFactory : public AbstractFactory {
public:
  Chair *CreateChair() const override {
    return new VictorianChair();
  }
  Desk *CreateDesk() const override {
    return new VictorianDesk();
  }
};

每个工厂都会创建一组相关联的对象（现代风格 or 维多利亚风格）。

(4) 客户端代码

void ClientCode(const AbstractFactory &factory) {
  const Chair *chair = factory.CreateChair();
  const Desk *desk = factory.CreateDesk();
  std::cout << desk->WorkOn() << "\n";
  std::cout << desk->PairWithChair(*chair) << "\n";
  delete chair;
  delete desk;
}

客户端只与抽象工厂接口交互，而不需要知道具体的工厂实现。

int main() {
  ModernFurnitureFactory *f1 = new ModernFurnitureFactory();
  ClientCode(*f1);
  delete f1;

  VictorianFurnitureFactory *f2 = new VictorianFurnitureFactory();
  ClientCode(*f2);
  delete f2;
  return 0;
}

运行结果：

Client: Testing client code with the first factory type:
Working on a modern desk.
Pairing modern desk with ( Sitting on a modern chair. )

Client: Testing the same client code with the second factory type:
Working on a Victorian desk.
Pairing Victorian desk with ( Sitting on a Victorian chair. )

3. 抽象工厂模式 vs. 工厂方法模式

示例代码对比

工厂方法模式

class ChairFactory {
public:
  static Chair* CreateChair() {
    return new ModernChair(); // 或者 VictorianChair
  }
};

在工厂方法模式中，每个工厂只负责创建一个对象，而不是一组相关的对象。

抽象工厂模式

class AbstractFactory {
public:
  virtual Chair *CreateChair() const = 0;
  virtual Desk *CreateDesk() const = 0;
};

在抽象工厂模式中，一个工厂负责创建一组产品（例如：现代风格的桌子 + 现代风格的椅子）。

4. 什么时候使用抽象工厂模式？

✅ 当多个产品需要搭配使用时

• 例如 GUI 库中，需要同时创建Windows 风格的按钮、窗口，或者Mac 风格的按钮、窗口。

✅ 希望减少依赖并保持代码的可扩展性

• 未来如果要新增 “复古风格家具”，只需创建新的 RetroFurnitureFactory，无需修改原有代码。

✅ 保证产品之间的兼容性

• 例如，现代椅子只能搭配现代桌子，而不能搭配维多利亚桌子。

5. 总结

• 工厂方法模式 只创建单一产品，而 抽象工厂模式 可以创建一组相关产品。
• 抽象工厂模式的优势 在于确保产品之间的兼容性，并降低客户端对具体类的依赖。
• 适用于需要生产一系列相关对象的场景，例如 GUI 组件、数据库驱动等。

如果你的需求仅是创建单个对象，可以使用工厂方法模式。
如果你的需求是创建多个相互关联的对象，建议使用抽象工厂模式。