好的，我们开始今天的讲座，主题是生成器模式 (Builder Pattern) 在 Python 中的应用。
引言：复杂对象的构建挑战
在软件开发中，我们经常需要创建复杂的对象。这些对象可能包含多个组成部分，并且每个组成部分都需要经过特定的初始化过程。直接在构造函数中处理所有这些逻辑会导致代码变得臃肿、难以维护和测试。
考虑一个简单的例子：构建一个计算机对象。计算机包含 CPU、内存、硬盘、显卡、操作系统等组件。如果我们在 Computer 类的构造函数中负责创建和配置所有这些组件，代码会变得非常复杂。
生成器模式的定义与优势
生成器模式是一种创建型设计模式，它将一个复杂对象的构建过程与其表示分离，使得相同的构建过程可以创建不同的表示。
简单来说，生成器模式允许我们：
- 分步构建对象： 将对象的创建分解为一系列独立的步骤。
- 隐藏构建细节： 客户端无需了解对象的内部结构和构建过程。
- 灵活构建对象： 可以使用相同的构建过程创建不同的对象变体。
生成器模式的主要角色包括：
- Director（指挥者）： 负责定义构建对象的步骤顺序。它知道生成器的接口，并调用生成器的方法来完成构建过程。
- Builder（生成器）： 定义构建对象的抽象接口。它声明了构建对象各个部分的方法。
- ConcreteBuilder（具体生成器）： 实现生成器接口，负责实际构建对象的各个部分。每个具体生成器可以创建不同类型的对象变体。
- Product（产品）： 表示最终构建的复杂对象。
生成器模式的 Python 实现
让我们通过一个具体的例子来说明如何在 Python 中实现生成器模式。我们以构建一个简单的 HTML 文档为例。
class HtmlElement:
"""HTML 文档的元素"""
def __init__(self, name, text=''):
self.name = name
self.text = text
self.elements = []
def __str__(self):
indent_size = 2
lines = []
lines.append(f'<{self.name}>')
if self.text:
lines.append(' ' * indent_size + self.text)
for e in self.elements:
lines.append(str(e))
lines.append(f'</{self.name}>')
return 'n'.join(lines)
class HtmlBuilder:
"""HTML 文档生成器"""
def __init__(self, root_name):
self.root_name = root_name
self.root = HtmlElement(root_name)
def add_child(self, child_name, child_text):
self.root.elements.append(HtmlElement(child_name, child_text))
def add_child_fluent(self, child_name, child_text):
"""流畅接口 (Fluent Interface)"""
self.add_child(child_name, child_text)
return self
def __str__(self):
return str(self.root)
# 使用示例
builder = HtmlBuilder('ul')
builder.add_child('li', 'hello')
builder.add_child('li', 'world')
print(builder)
# 使用流畅接口
builder = HtmlBuilder('ul')
builder.add_child_fluent('li', 'hello')
.add_child_fluent('li', 'world')
print(builder)在这个例子中：
HtmlElement类表示 HTML 文档的元素，例如<ul>、<li>等。HtmlBuilder类是 HTML 文档的生成器。它负责创建HtmlElement对象，并将它们组合成一个完整的 HTML 文档。add_child方法用于添加子元素。add_child_fluent方法提供了一个流畅接口，允许我们链式调用方法。
这个例子虽然简单，但演示了生成器模式的基本思想：将对象的构建过程分解为一系列独立的步骤，并使用生成器类来负责实际的构建过程。
加入Director，解耦构建过程
上面的例子中，客户端代码直接与 HtmlBuilder 交互，负责定义构建对象的步骤顺序。我们可以引入一个 Director 类来进一步解耦构建过程。
class HtmlElement:
"""HTML 文档的元素"""
def __init__(self, name, text=''):
self.name = name
self.text = text
self.elements = []
def __str__(self):
indent_size = 2
lines = []
lines.append(f'<{self.name}>')
if self.text:
lines.append(' ' * indent_size + self.text)
for e in self.elements:
lines.append(str(e))
lines.append(f'</{self.name}>')
return 'n'.join(lines)
class HtmlBuilder:
"""HTML 文档生成器"""
def __init__(self, root_name):
self.root_name = root_name
self.root = HtmlElement(root_name)
def add_child(self, child_name, child_text):
self.root.elements.append(HtmlElement(child_name, child_text))
return self # 返回self，支持链式调用
def get_root(self):
return self.root
class HtmlDirector:
"""HTML 文档构建指挥者"""
def __init__(self, builder: HtmlBuilder):
self.builder = builder
def construct_list(self, items):
for item in items:
self.builder.add_child("li", item)
return self.builder.get_root()
# 使用示例
builder = HtmlBuilder('ul')
director = HtmlDirector(builder)
html_tree = director.construct_list(['hello', 'world'])
print(html_tree)
在这个例子中：
HtmlDirector类负责定义构建 HTML 文档的步骤顺序。construct_list方法接受一个列表，并使用生成器来创建包含列表项的 HTML 列表。
通过引入 Director 类，我们将构建过程与客户端代码解耦，使得客户端代码无需了解对象的构建细节。
更复杂的例子：计算机对象构建
让我们回到最初的例子：构建一个计算机对象。我们可以使用生成器模式来解决这个问题。
class CPU:
"""CPU 组件"""
def __init__(self, brand, speed):
self.brand = brand
self.speed = speed
def __str__(self):
return f"CPU: {self.brand} @ {self.speed} GHz"
class Memory:
"""内存组件"""
def __init__(self, capacity, type):
self.capacity = capacity
self.type = type
def __str__(self):
return f"Memory: {self.capacity} GB {self.type}"
class HardDrive:
"""硬盘组件"""
def __init__(self, capacity, type):
self.capacity = capacity
self.type = type
def __str__(self):
return f"Hard Drive: {self.capacity} GB {self.type}"
class GraphicsCard:
"""显卡组件"""
def __init__(self, brand, memory):
self.brand = brand
self.memory = memory
def __str__(self):
return f"Graphics Card: {self.brand} with {self.memory} GB memory"
class Computer:
"""计算机对象"""
def __init__(self):
self.cpu = None
self.memory = None
self.hard_drive = None
self.graphics_card = None
self.operating_system = None
def __str__(self):
components = []
if self.cpu:
components.append(str(self.cpu))
if self.memory:
components.append(str(self.memory))
if self.hard_drive:
components.append(str(self.hard_drive))
if self.graphics_card:
components.append(str(self.graphics_card))
if self.operating_system:
components.append(f"Operating System: {self.operating_system}")
return "n".join(components)
class ComputerBuilder:
"""计算机生成器接口"""
def __init__(self):
self.computer = Computer()
def reset(self):
self.computer = Computer()
def build_cpu(self, brand, speed):
pass
def build_memory(self, capacity, type):
pass
def build_hard_drive(self, capacity, type):
pass
def build_graphics_card(self, brand, memory):
pass
def install_operating_system(self, os):
pass
def get_computer(self):
return self.computer
class GamingComputerBuilder(ComputerBuilder):
"""游戏计算机生成器"""
def build_cpu(self, brand, speed):
self.computer.cpu = CPU(brand, speed)
def build_memory(self, capacity, type):
self.computer.memory = Memory(capacity, type)
def build_hard_drive(self, capacity, type):
self.computer.hard_drive = HardDrive(capacity, 'SSD') # 游戏电脑标配SSD
def build_graphics_card(self, brand, memory):
self.computer.graphics_card = GraphicsCard(brand, memory)
def install_operating_system(self, os):
self.computer.operating_system = os
class OfficeComputerBuilder(ComputerBuilder):
"""办公计算机生成器"""
def build_cpu(self, brand, speed):
self.computer.cpu = CPU(brand, speed)
def build_memory(self, capacity, type):
self.computer.memory = Memory(capacity, type)
def build_hard_drive(self, capacity, type):
self.computer.hard_drive = HardDrive(capacity, 'HDD') # 办公电脑通常用HDD
def install_operating_system(self, os):
self.computer.operating_system = os
class ComputerAssembler: # 原来的Director改名为Assembler更贴切
"""计算机组装者 (原 Director)"""
def __init__(self, builder: ComputerBuilder):
self.builder = builder
def assemble_gaming_computer(self, cpu_brand, cpu_speed, memory_capacity, memory_type, graphics_card_brand, graphics_card_memory, os):
self.builder.reset()
self.builder.build_cpu(cpu_brand, cpu_speed)
self.builder.build_memory(memory_capacity, memory_type)
self.builder.build_hard_drive(1000, 'SSD') # 假设硬盘容量固定
self.builder.build_graphics_card(graphics_card_brand, graphics_card_memory)
self.builder.install_operating_system(os)
return self.builder.get_computer()
def assemble_office_computer(self, cpu_brand, cpu_speed, memory_capacity, memory_type, os):
self.builder.reset()
self.builder.build_cpu(cpu_brand, cpu_speed)
self.builder.build_memory(memory_capacity, memory_type)
self.builder.build_hard_drive(500, 'HDD') # 假设硬盘容量固定
self.builder.install_operating_system(os)
return self.builder.get_computer()
# 使用示例
gaming_builder = GamingComputerBuilder()
office_builder = OfficeComputerBuilder()
assembler = ComputerAssembler(gaming_builder)
gaming_computer = assembler.assemble_gaming_computer('Intel', 3.5, 16, 'DDR4', 'Nvidia', 8, 'Windows 10')
print(gaming_computer)
assembler = ComputerAssembler(office_builder)
office_computer = assembler.assemble_office_computer('AMD', 2.5, 8, 'DDR3', 'Linux')
print(office_computer)在这个例子中：
CPU、Memory、HardDrive、GraphicsCard类表示计算机的各个组件。Computer类表示计算机对象，包含各个组件的引用。ComputerBuilder类是计算机生成器接口，声明了构建计算机各个部分的方法。GamingComputerBuilder和OfficeComputerBuilder类是具体生成器，分别负责构建游戏计算机和办公计算机。ComputerAssembler类是计算机组装者，负责定义构建计算机的步骤顺序。
通过使用生成器模式，我们可以灵活地创建不同类型的计算机对象，而无需在 Computer 类的构造函数中处理复杂的构建逻辑。
生成器模式的适用场景
生成器模式适用于以下场景：
- 需要创建复杂的对象，并且对象的构建过程比较复杂。
- 需要使用相同的构建过程创建不同的对象变体。
- 希望将对象的构建过程与对象的表示分离。
- 当对象的构造函数参数过多时，可以使用生成器模式来简化对象的创建过程。
生成器模式的优缺点
优点：
- 将对象的构建过程与对象的表示分离，提高了代码的可读性和可维护性。
- 可以灵活地创建不同类型的对象变体。
- 隐藏了对象的内部结构和构建过程，降低了客户端代码的复杂性。
- 可以通过不同的具体生成器来控制对象的构建过程。
缺点：
- 增加了代码的复杂性，需要定义额外的生成器类和指挥者类。
- 可能导致类的数量增加，增加了系统的复杂性。
生成器模式与其他创建型模式的比较
- 生成器模式 vs. 工厂模式： 工厂模式用于创建不同类型的对象，而生成器模式用于构建复杂的对象。工厂模式关注的是对象的类型，而生成器模式关注的是对象的构建过程。
- 生成器模式 vs. 抽象工厂模式： 抽象工厂模式用于创建一组相关的对象，而生成器模式用于构建单个复杂的对象。抽象工厂模式关注的是对象之间的关系，而生成器模式关注的是对象的内部结构。
表格总结：生成器模式的关键要素
| 角色 | 职责 |
|---|---|
| Product | 表示最终构建的复杂对象。 |
| Builder | 定义构建对象的抽象接口，声明构建对象各个部分的方法。 |
| ConcreteBuilder | 实现生成器接口，负责实际构建对象的各个部分，每个具体生成器可以创建不同类型的对象变体。 |
| Director | 定义构建对象的步骤顺序，它知道生成器的接口，并调用生成器的方法来完成构建过程。 |
总结：分步构建，灵活多变，解耦复杂性
生成器模式通过将复杂对象的构建过程分解为一系列步骤，使得相同的构建过程可以创建不同的对象变体。这种模式提高了代码的可读性和可维护性，并且降低了客户端代码的复杂性。通过引入 Director，可以进一步解耦构建过程，使得客户端代码无需了解对象的构建细节。