目录
- 工厂模式简介
- 工厂模式的分类
- 工厂模式的优缺点
- 工厂模式的实现
- 4.1 简单工厂模式（Simple Factory）
- 4.2 工厂方法模式（Factory Method）
- 4.3 抽象工厂模式（Abstract Factory）
- 工厂模式的应用场景
- 出站链接
- 站内链接
- 参考资料
1. 工厂模式简介
工厂模式是一种创建型设计模式，它的核心思想是使用工厂方法代替直接实例化对象，从而提高代码的灵活性和可维护性。
为什么使用工厂模式？
- 解耦对象的创建和使用：客户端不需要知道具体类的实例化细节。
- 提高代码的可扩展性：添加新产品时，只需要扩展工厂类，而不影响已有代码。
- 符合开闭原则（OCP）：可以通过增加新的工厂或产品类，而不修改已有代码。
2. 工厂模式的分类
工厂模式主要有三种变体：
| 模式 | 描述 | 适用场景 |
|---|---|---|
| 简单工厂模式（Simple Factory） | 由一个工厂类创建所有产品实例 | 产品种类较少，变化不大 |
| 工厂方法模式（Factory Method） | 每个产品都有一个独立的工厂类 | 需要扩展新产品时，不影响已有代码 |
| 抽象工厂模式（Abstract Factory） | 提供一组相关或相互依赖的产品族 | 需要创建多个产品族，确保产品兼容性 |
3. 工厂模式的优缺点
✅ 优点
- 封装对象创建逻辑，客户端不需要关心对象的具体创建方式。
- 提高代码的灵活性，遵循开闭原则（OCP），可以方便地扩展新产品。
- 降低耦合度，可以方便地替换产品实现，符合依赖倒置原则（DIP）。
❌ 缺点
- 增加了代码复杂性，特别是抽象工厂模式可能引入额外的类和接口。
- 对于简单应用可能是“过度设计”，如果产品种类较少，使用工厂模式可能导致代码冗余。
4. 工厂模式的实现
4.1 简单工厂模式（Simple Factory）
定义：由一个工厂类负责创建所有产品的实例，客户端只需提供参数即可获取对应的对象。
适用场景：
- 需要创建少量不同类型的对象。
- 客户端不关心对象的具体实现。
示例（Python 实现）：
class Product:
def operation(self):
pass
class ConcreteProductA(Product):
def operation(self):
return "ConcreteProductA created"
class ConcreteProductB(Product):
def operation(self):
return "ConcreteProductB created"
class SimpleFactory:
@staticmethod
def create_product(product_type):
if product_type == "A":
return ConcreteProductA()
elif product_type == "B":
return ConcreteProductB()
else:
raise ValueError("Unknown product type")
# 客户端代码
product = SimpleFactory.create_product("A")
print(product.operation()) # Output: ConcreteProductA created
🔹 缺点：违反了开闭原则（OCP），如果要新增产品，需要修改 SimpleFactory。
4.2 工厂方法模式（Factory Method）
定义：定义一个创建对象的抽象方法，由子类决定具体实例化的产品。
适用场景：
- 需要扩展新的产品，而不影响现有代码。
- 需要不同工厂来生产不同类型的产品。
示例（Python 实现）：
from abc import ABC, abstractmethod
# 抽象产品类
class Product(ABC):
@abstractmethod
def operation(self):
pass
# 具体产品类
class ConcreteProductA(Product):
def operation(self):
return "ConcreteProductA created"
class ConcreteProductB(Product):
def operation(self):
return "ConcreteProductB created"
# 抽象工厂类
class Factory(ABC):
@abstractmethod
def create_product(self):
pass
# 具体工厂类
class ConcreteFactoryA(Factory):
def create_product(self):
return ConcreteProductA()
class ConcreteFactoryB(Factory):
def create_product(self):
return ConcreteProductB()
# 客户端代码
factory = ConcreteFactoryA()
product = factory.create_product()
print(product.operation()) # Output: ConcreteProductA created
🔹 优点：符合开闭原则（OCP），新产品只需创建新的工厂类，而不修改已有代码。
🔹 缺点：每增加一个新产品，都需要增加一个新的工厂类，可能导致类数量过多。
4.3 抽象工厂模式（Abstract Factory）
定义：提供一个接口，用于创建一系列相关的产品，而不需要指定具体的产品类。
适用场景：
- 需要创建多个产品族，并保证产品的兼容性（如 UI 组件库）。
- 需要保证不同产品对象可以协同工作。
示例（Python 实现）：
from abc import ABC, abstractmethod
# 抽象产品A
class Button(ABC):
@abstractmethod
def render(self):
pass
# 抽象产品B
class Checkbox(ABC):
@abstractmethod
def render(self):
pass
# 具体产品A1
class WindowsButton(Button):
def render(self):
return "Rendering Windows Button"
# 具体产品A2
class MacButton(Button):
def render(self):
return "Rendering Mac Button"
# 具体产品B1
class WindowsCheckbox(Checkbox):
def render(self):
return "Rendering Windows Checkbox"
# 具体产品B2
class MacCheckbox(Checkbox):
def render(self):
return "Rendering Mac Checkbox"
# 抽象工厂
class GUIFactory(ABC):
@abstractmethod
def create_button(self):
pass
@abstractmethod
def create_checkbox(self):
pass
# 具体工厂1
class WindowsFactory(GUIFactory):
def create_button(self):
return WindowsButton()
def create_checkbox(self):
return WindowsCheckbox()
# 具体工厂2
class MacFactory(GUIFactory):
def create_button(self):
return MacButton()
def create_checkbox(self):
return MacCheckbox()
# 客户端代码
factory = WindowsFactory()
button = factory.create_button()
checkbox = factory.create_checkbox()
print(button.render()) # Output: Rendering Windows Button
print(checkbox.render()) # Output: Rendering Windows Checkbox
🔹 优点：保证一系列产品的兼容性，符合开闭原则。
🔹 缺点：当产品族扩展时，所有工厂都需要修改，增加了复杂性。
5. 工厂模式的应用场景
- 日志系统：不同日志存储（本地、云端、数据库）。
- 数据库驱动：不同数据库（MySQL、PostgreSQL、MongoDB）。
- UI 组件库：适配不同平台（Windows、MacOS）。
6. 出站链接
7. 站内链接
8. 参考资料
- Gamma, E. Design Patterns (1994).
- Martin, R. C. Clean Code (2009).
发表回复