在軟體開發中，處理複雜物件的建立常常會使程式碼變得冗長且難以維護。建造者模式提供了一種優雅的解決方案，將物件的建構過程分解成多個步驟，並由一個 Builder 類別負責管理這些步驟。這種方式不僅提升了程式碼的可讀性，也更容易擴充套件和修改。本文以 Python 建立披薩的流程為例，實際示範建造者模式的應用。透過定義不同的 Builder 類別，例如製作瑪格麗特披薩的 MargaritaBuilder 和製作奶油培根披薩的 CreamyBaconBuilder，我們可以將披薩的製作步驟（準備麵團、新增醬料、新增配料和烘烤）封裝在各自的 Builder 中。如此一來，建立不同種類的披薩變得更加簡潔明瞭，也更容易新增或修改披薩的製作流程。
工廠模式
工廠模式是一種建立物件的模式，允許您在單一步驟中建立物件。它通常涉及一個工廠類別，負責建立物件。工廠模式的主要優點是，它可以讓您建立具有不同型別的物件，而不需要知道具體的實作細節。
主要區別
建立者模式和工廠模式之間的主要區別是：
- 建立者模式建立物件的過程是分步驟的，而工廠模式建立物件的過程是單一步驟的。
- 建立者模式通常涉及一個導演物件，而工廠模式不需要導演物件。
- 建立者模式允許您建立具有不同組態的物件，而工廠模式建立的物件通常具有固定的組態。
實際應用
以下是一個實際的例子，展示了建立者模式和工廠模式的區別：
假設您想要購買一臺新電腦。如果您決定購買一臺預先組態好的電腦模型，例如最新的 Apple 1.4 GHz Mac mini，您使用的是工廠模式。所有的硬體規格都已經預先定義好了，製造商只需要接收到一個單一的指令。
MINI14 = '1.4GHz Mac mini'
class AppleFactory:
class MacMini14:
def __init__(self):
self.memory = 4 # in gigabytes
self.hdd = 500 # in gigabytes
self.gpu = 'Intel HD Graphics 5000'
def __str__(self):
info = (f'Model: {MINI14}',
f'Memory: {self.memory}GB',
f'Hard Disk: {self.hdd}GB',
f'Graphics Card: {self.gpu}')
return '\n'.join(info)
def build_computer(self, model):
if model == MINI14:
return self.MacMini14()
如果您想要購買一臺自定義的電腦，您可以使用建立者模式。您可以分步驟地組態電腦的硬體規格，例如記憶體、硬碟和顯示卡。
class ComputerBuilder:
def __init__(self):
self.memory = 0
self.hdd = 0
self.gpu = ''
def set_memory(self, memory):
self.memory = memory
return self
def set_hdd(self, hdd):
self.hdd = hdd
return self
def set_gpu(self, gpu):
self.gpu = gpu
return self
def build(self):
return Computer(self.memory, self.hdd, self.gpu)
class Computer:
def __init__(self, memory, hdd, gpu):
self.memory = memory
self.hdd = hdd
self.gpu = gpu
def __str__(self):
info = (f'Memory: {self.memory}GB',
f'Hard Disk: {self.hdd}GB',
f'Graphics Card: {self.gpu}')
return '\n'.join(info)
# 使用建立者模式建立一臺自定義的電腦
builder = ComputerBuilder()
computer = (builder.set_memory(16)
.set_hdd(1000)
.set_gpu('NVIDIA GeForce GTX 1080')
.build())
print(computer)
建立電腦的工廠模式
在電腦硬體的世界中，工廠模式可以用來建立不同的電腦型號。以下是一個簡單的例子：
class AppleFactory:
def build_computer(self, model):
if model == "MINI14":
return self.MacMini14()
elif model == "AIR13":
return self.MacAir13()
else:
msg = f"不支援 {model} 型號"
print(msg)
class MacMini14:
def __init__(self):
self.model = "Mac Mini 14"
self.processor = "Apple M1"
self.memory = 16 # GB
self.storage = 512 # GB
def __str__(self):
return f"{self.model} - 處理器：{self.processor}, 記憶體：{self.memory}GB, 儲存空間：{self.storage}GB"
class MacAir13:
def __init__(self):
self.model = "Mac Air 13"
self.processor = "Apple M2"
self.memory = 8 # GB
self.storage = 256 # GB
def __str__(self):
return f"{self.model} - 處理器：{self.processor}, 記憶體：{self.memory}GB, 儲存空間：{self.storage}GB"
if __name__ == '__main__':
afac = AppleFactory()
mac_mini = afac.build_computer("MINI14")
print(mac_mini)
建立電腦的建造者模式
如果您想要建立一臺符合自己需求的電腦，可以使用建造者模式。以下是一個簡單的例子：
class Computer:
def __init__(self, serial_number):
self.serial = serial_number
self.memory = None # GB
self.storage = None # GB
self.processor = None
def __str__(self):
return f"序號：{self.serial}, 處理器：{self.processor}, 記憶體：{self.memory}GB, 儲存空間：{self.storage}GB"
class ComputerBuilder:
def __init__(self):
self.computer = Computer("123456")
def with_processor(self, processor):
self.computer.processor = processor
return self
def with_memory(self, memory):
self.computer.memory = memory
return self
def with_storage(self, storage):
self.computer.storage = storage
return self
def build(self):
return self.computer
if __name__ == '__main__':
builder = ComputerBuilder()
computer = (builder
.with_processor("Intel Core i7")
.with_memory(16)
.with_storage(512)
.build())
print(computer)
內容解密：
在上述程式碼中，我們定義了兩個類別：AppleFactory 和 ComputerBuilder。AppleFactory 類別使用工廠模式建立不同的電腦型號，而 ComputerBuilder 類別使用建造者模式建立一臺符合自己需求的電腦。
在 AppleFactory 類別中，我們定義了兩個內部類別：MacMini14 和 MacAir13。這些內部類別代表不同的電腦型號，並且包含了各自的屬性和方法。
在 ComputerBuilder 類別中，我們定義了三個方法：with_processor、with_memory 和 with_storage。這些方法用於設定電腦的處理器、記憶體和儲存空間。
圖表翻譯：
flowchart TD
A[使用者] --> B[AppleFactory]
B --> C[MacMini14]
B --> D[MacAir13]
C --> E[建立 Mac Mini 14]
D --> F[建立 Mac Air 13]
E --> G[印出 Mac Mini 14 的詳細資訊]
F --> H[印出 Mac Air 13 的詳細資訊]
在這個圖表中，我們展示了使用者如何使用 AppleFactory 類別建立不同的電腦型號，並且如何印出各自的詳細資訊。
flowchart TD
A[使用者] --> B[ComputerBuilder]
B --> C[設定處理器]
B --> D[設定記憶體]
B --> E[設定儲存空間]
C --> F[建立電腦]
D --> F
E --> F
F --> G[印出電腦的詳細資訊]
在這個圖表中，我們展示了使用者如何使用 ComputerBuilder 類別建立一臺符合自己需求的電腦，並且如何印出其詳細資訊。
建立電腦和平板電腦電腦的Builder模式
引言
在軟體開發中，Builder模式是一種設計模式，允許我們分步驟地構建複雜的物件。這種模式尤其適合於需要根據不同的組態來建造物件的情況。在本文中，我們將探討如何使用Builder模式來建造電腦和平板電腦電腦。
電腦建造者
首先，我們定義一個Computer類別，代表我們要建造的電腦：
class Computer:
def __init__(self):
self.memory = None # in gigabytes
self.hdd = None # in gigabytes
self.gpu = None
def __str__(self):
info = (
f"Memory: {self.memory}GB",
f"Hard Disk: {self.hdd}GB",
f"Graphics Card: {self.gpu}"
)
return "\n".join(info)
接下來，我們定義一個ComputerBuilder類別，負責建造電腦：
class ComputerBuilder:
def __init__(self):
self.computer = Computer()
def configure_memory(self, amount):
self.computer.memory = amount
return self
def configure_hdd(self, amount):
self.computer.hdd = amount
return self
def configure_gpu(self, gpu_model):
self.computer.gpu = gpu_model
return self
def build(self):
return self.computer
平板電腦電腦建造者
現在，我們要新增對平板電腦電腦的支援。首先，我們定義一個Tablet類別，代表我們要建造的平板電腦電腦：
class Tablet:
def __init__(self):
self.memory = None # in gigabytes
self.storage = None # in gigabytes
self.screen_size = None # in inches
def __str__(self):
info = (
f"Memory: {self.memory}GB",
f"Storage: {self.storage}GB",
f"Screen Size: {self.screen_size} inches"
)
return "\n".join(info)
接下來，我們定義一個TabletBuilder類別，負責建造平板電腦電腦：
class TabletBuilder:
def __init__(self):
self.tablet = Tablet()
def configure_memory(self, amount):
self.tablet.memory = amount
return self
def configure_storage(self, amount):
self.tablet.storage = amount
return self
def configure_screen_size(self, size):
self.tablet.screen_size = size
return self
def build(self):
return self.tablet
硬體工程師
現在，我們定義一個HardwareEngineer類別，負責使用建造者來建造電腦和平板電腦電腦：
class HardwareEngineer:
def __init__(self):
self.builder = None
def construct_computer(self, memory, hdd, gpu):
self.builder = ComputerBuilder()
computer = (
self.builder.configure_memory(memory)
.configure_hdd(hdd)
.configure_gpu(gpu)
.build()
)
return computer
def construct_tablet(self, memory, storage, screen_size):
self.builder = TabletBuilder()
tablet = (
self.builder.configure_memory(memory)
.configure_storage(storage)
.configure_screen_size(screen_size)
.build()
)
return tablet
主函式
最後，我們定義一個main函式來示範如何使用建造者來建造電腦和平板電腦電腦：
def main():
engineer = HardwareEngineer()
computer = engineer.construct_computer(8, 256, "GeForce GTX 650 Ti")
print(computer)
tablet = engineer.construct_tablet(4, 128, 10.1)
print(tablet)
if __name__ == "__main__":
main()
這個程式會輸出：
Memory: 8GB
Hard Disk: 256GB
Graphics Card: GeForce GTX 650 Ti
Memory: 4GB
Storage: 128GB
Screen Size: 10.1 inches
這示範瞭如何使用Builder模式來建造電腦和平板電腦電腦，兩者都有不同的組態。
訂購應用程式實作
讓我們探討如何使用建造者設計模式來實作一個訂購應用程式。以製作披薩為例，特別有趣的是，因為披薩的製作需要按照特定的步驟進行。為了新增醬料，首先需要準備面團。為了新增配料，首先需要新增醬料。而且，除非醬料和配料都放在面團上，否則不能開始烘烤披薩。此外，根據面團的厚度和使用的配料，每個披薩通常需要不同的烘烤時間。
建造者設計模式
我們首先定義一些列舉類別，例如 PizzaProgress、PizzaDough、PizzaSauce 和 PizzaTopping，以便於描述披薩的製作進度、面團型別、醬料型別和配料型別。同時，我們定義一個常數 STEP_DELAY，用於在不同的步驟之間新增時間延遲。
from enum import Enum
import time
PizzaProgress = Enum('PizzaProgress', 'queued preparation baking ready')
PizzaDough = Enum('PizzaDough', 'thin thick')
PizzaSauce = Enum('PizzaSauce', 'tomato creme_fraiche')
PizzaTopping = Enum('PizzaTopping', 'mozzarella double_mozzarella bacon ham mushrooms red_onion oregano')
STEP_DELAY = 3 # in seconds
披薩類別
我們的最終產品是披薩，描述為 Pizza 類別。當使用建造者模式時，最終產品不應該直接例項化，因此 Pizza 類別相對簡單。它基本上初始化所有資料為合理的預設值。一個例外是 prepare_dough 方法，它定義在 Pizza 類別中，而不是在建造者中，以便闡明最終產品通常是最小的，並不意味著你永遠不應該為它分配任何責任。
class Pizza:
def __init__(self, name):
self.name = name
self.dough = None
self.sauce = None
self.topping = []
def __str__(self):
return self.name
def prepare_dough(self, dough):
# ...
建造者類別
接下來，我們需要定義一個建造者類別，負責建立和準備披薩。建造者類別應該提供方法來設定面團、醬料和配料，並最終傳回一個準備好的披薩。
class PizzaBuilder:
def __init__(self):
self.pizza = Pizza("")
def with_name(self, name):
self.pizza.name = name
return self
def with_dough(self, dough):
self.pizza.dough = dough
return self
def with_sauce(self, sauce):
self.pizza.sauce = sauce
return self
def with_topping(self, topping):
self.pizza.topping.append(topping)
return self
def build(self):
return self.pizza
使用建造者模式
現在，我們可以使用建造者模式來建立一個披薩。
pizza = (PizzaBuilder()
.with_name("My Pizza")
.with_dough(PizzaDough.thin)
.with_sauce(PizzaSauce.tomato)
.with_topping(PizzaTopping.mozzarella)
.build())
這樣，我們就使用建造者模式實作了一個簡單的訂購應用程式，允許使用者定製自己的披薩。
精簡版 Pizza 建立流程
為了簡化 Pizza 的建立流程，我們可以使用 Builder 模式。這個模式允許我們分步驟地建立物件，並且可以根據不同的需求建立不同的 Builder。
MargaritaBuilder 類別
class MargaritaBuilder:
def __init__(self):
self.pizza = Pizza('margarita')
self.progress = PizzaProgress.queued
self.baking_time = 5 # in seconds for the sake of the example
def prepare_dough(self):
self.progress = PizzaProgress.preparation
self.pizza.prepare_dough(PizzaDough.thin)
def add_sauce(self):
print('adding the tomato sauce to your margarita...')
self.pizza.sauce = PizzaSauce.tomato
def add_topping(self):
print('adding the double mozzarella and oregano to your margarita...')
self.pizza.topping = PizzaTopping.mozzarella_oregano
def bake(self):
print(f'baking your margarita pizza for {self.baking_time} seconds...')
self.progress = PizzaProgress.done
CreamyBaconBuilder 類別
class CreamyBaconBuilder:
def __init__(self):
self.pizza = Pizza('creamy_bacon')
self.progress = PizzaProgress.queued
self.baking_time = 7 # in seconds for the sake of the example
def prepare_dough(self):
self.progress = PizzaProgress.preparation
self.pizza.prepare_dough(PizzaDough.thick)
def add_sauce(self):
print('adding the creamy sauce to your creamy bacon...')
self.pizza.sauce = PizzaSauce.creamy
def add_topping(self):
print('adding the mozzarella, bacon, ham, mushrooms, red onion, and oregano to your creamy bacon...')
self.pizza.topping = PizzaTopping.mozzarella_bacon_ham_mushrooms_red_onion_oregano
def bake(self):
print(f'baking your creamy bacon pizza for {self.baking_time} seconds...')
self.progress = PizzaProgress.done
Pizza 類別
class Pizza:
def __init__(self, name):
self.name = name
self.dough = None
self.sauce = None
self.topping = None
def prepare_dough(self, dough):
self.dough = dough
print(f'preparing the {dough.name} dough of your {self.name} pizza...')
使用範例
margarita_builder = MargaritaBuilder()
margarita_builder.prepare_dough()
margarita_builder.add_sauce()
margarita_builder.add_topping()
margarita_builder.bake()
creamy_bacon_builder = CreamyBaconBuilder()
creamy_bacon_builder.prepare_dough()
creamy_bacon_builder.add_sauce()
creamy_bacon_builder.add_topping()
creamy_bacon_builder.bake()
內容解密：
上述程式碼示範瞭如何使用 Builder 模式建立 Pizza 物件。每個 Builder 類別都負責建立特定的 Pizza 型別，並且可以根據不同的需求建立不同的 Builder。這個模式可以讓我們分步驟地建立物件，並且可以根據不同的需求建立不同的 Builder。
圖表翻譯：
flowchart TD
A[建立 Pizza 物件] --> B[選擇 Builder]
B --> C[MargaritaBuilder]
B --> D[CreamyBaconBuilder]
C --> E[prepare_dough]
C --> F[add_sauce]
C --> G[add_topping]
C --> H[bake]
D --> I[prepare_dough]
D --> J[add_sauce]
D --> K[add_topping]
D --> L[bake]
這個圖表示範瞭如何使用 Builder 模式建立 Pizza 物件。每個 Builder 類別都負責建立特定的 Pizza 型別，並且可以根據不同的需求建立不同的 Builder。
建立者模式（Builder Pattern）在實際應用中的運用
在軟體開發中，Builder Pattern是一種常見的設計模式，主要用於複雜物件的建立。以下是使用Python實作Builder Pattern的範例，該範例模擬了一個披薩製作過程。
從程式碼實作與設計模式的應用層面來看，本文深入探討了工廠模式和建立者模式的差異與應用場景。透過電腦和披薩製作的案例，清晰地展示了兩種模式的使用方法，並以程式碼和圖表輔助說明，讓讀者更容易理解其核心概念和運作機制。技術架構視角的分析顯示，工廠模式適用於單步驟建立物件，而建立者模式則更適合於分步驟建構複雜物件，尤其在需要彈性組態物件屬性的情境下更具優勢。
然而，本文並未深入探討兩種模式的效能差異和適用性限制。例如，在物件建立數量龐大時，建立者模式可能會引入額外的效能開銷。此外，對於極為簡單的物件建立，工廠模式可能更為簡潔高效。同時，兩種模式在面對需求變化時的擴充套件性也值得進一步探討。
展望未來，隨著軟體系統複雜度的提升，建立者模式的應用場景將會更加廣泛。預期未來會有更多工具和框架出現，以簡化建立者模式的實作流程，並提升其效能。而工廠模式也將持續在快速建立簡單物件的場景中發揮作用。
玄貓認為，開發者應根據實際專案需求選擇合適的設計模式。對於需要高度客製化的複雜物件，建立者模式是更佳的選擇；而對於簡單物件的快速建立，工廠模式則更為簡潔高效。深入理解兩種模式的優缺點，並結合實際應用場景進行選擇，才能最大程度地發揮設計模式的效用。
