建構者模式有效地分離了物件的建構過程和表示，使得相同的建構過程可以產生不同的物件表示。這對於需要構建具有多個組成部分的複雜物件特別有用，可以避免建構函式過於臃腫，並提高程式碼的可讀性和可維護性。原型模式則提供了一種透過複製現有物件來建立新物件的方式，這在需要大量相似物件或建立成本較高的情況下非常有效。它可以減少物件建立的開銷，並簡化物件的初始化過程。兩種模式各有優勢，適用於不同的場景。選擇哪種模式取決於專案的具體需求和複雜度。
建構者模式：複雜物件的逐步構建
建構者模式（Builder Pattern）是一種建立型設計模式，它透過將複雜物件的構建過程分解為多個簡單步驟，實作了物件建構的靈活性和可擴充套件性。該模式的核心思想是將物件的構建與表示分離，使得相同的構建過程可以建立不同的表示形式。
建構者模式的基本結構
建構者模式主要包含以下幾個角色：
- 產品（Product）：要構建的複雜物件。
- 建構者（Builder）：定義構建產品的各個步驟的介面。
- 具體建構者（Concrete Builder）：實作建構者介面，提供具體的產品構建邏輯。
- 指揮者（Director）：負責呼叫建構者的方法來構建產品。
Python 中的建構者模式實作
以下是一個簡單的房屋構建範例，展示瞭如何使用建構者模式來構建不同型別的房屋：
class House:
def __init__(self):
self.walls = None
self.roof = None
self.windows = None
self.doors = None
def __str__(self):
return f"House with {self.walls}, {self.roof}, {self.windows} windows, and {self.doors} doors"
class HouseBuilder:
def __init__(self):
self.house = House()
def build_walls(self, material: str):
self.house.walls = f"{material} walls"
return self
def build_roof(self, style: str):
self.house.roof = f"{style} roof"
return self
def build_windows(self, count: int):
self.house.windows = f"{count} windows"
return self
def build_doors(self, count: int):
self.house.doors = f"{count} doors"
return self
def get_result(self) -> House:
return self.house
class HouseDirector:
def __init__(self, builder: HouseBuilder):
self.builder = builder
def construct_basic_house(self):
self.builder.build_walls("brick").build_roof("flat").build_windows(4).build_doors(2)
return self.builder.get_result()
def construct_luxury_house(self):
self.builder.build_walls("granite").build_roof("curved").build_windows(10).build_doors(5)
return self.builder.get_result()
# 使用範例：
director = HouseDirector(HouseBuilder())
basic_house = director.construct_basic_house()
luxury_house = director.construct_luxury_house()
print(basic_house)
print(luxury_house)
內容解密：
House類別：代表要構建的產品，具有牆壁、屋頂、窗戶和門等屬性。HouseBuilder類別：負責逐步構建House物件，提供了一系列的build_方法來設定房屋的不同部分，並最終透過get_result方法傳回構建完成的房屋物件。HouseDirector類別：指揮HouseBuilder按照特定的順序和方法來構建不同型別的房屋，如基本房屋和豪華房屋。
建構者模式的高階應用
- 與不可變物件結合：可以利用建構者模式來建立不可變物件，透過在建構者中累積狀態，然後一次性地建立不可變物件例項。這種方式保證了執行緒安全和狀態的不可變性。
from dataclasses import dataclass
@dataclass(frozen=True)
class ImmutableHouse:
walls: str
roof: str
windows: str
doors: str
class ImmutableHouseBuilder:
def __init__(self):
self._attributes = {}
def build_walls(self, material: str):
self._attributes["walls"] = f"{material} walls"
return self
def build_roof(self, style: str):
self._attributes["roof"] = f"{style} roof"
return self
def build_windows(self, count: int):
self._attributes["windows"] = f"{count} windows"
return self
def build_doors(self, count: int):
self._attributes["doors"] = f"{count} doors"
return self
def get_result(self) -> ImmutableHouse:
return ImmutableHouse(
walls=self._attributes.get("walls", "default walls"),
roof=self._attributes.get("roof", "default roof"),
windows=self._attributes.get("windows", "default windows"),
doors=self._attributes.get("doors", "default doors")
)
# 使用範例：
immutable_builder = ImmutableHouseBuilder()
immutable_house = immutable_builder.build_walls("concrete").build_roof("domed").build_windows(8).build_doors(3).get_result()
print(immutable_house)
內容解密：
ImmutableHouse類別：使用@dataclass(frozen=True)裝飾器定義了一個不可變的房屋類別。ImmutableHouseBuilder類別：負責構建ImmutableHouse物件，透過逐步設定屬性並最終建立不可變的房屋例項。
- 與其他設計模式結合：建構者模式可以與原型模式、抽象工廠模式等其他設計模式結合使用，以實作更複雜的物件建立和管理邏輯。
Prototype 設計模式：物件複製與動態建立的最佳實踐
Prototype 設計模式是一種建立型模式，透過複製現有物件來建立新物件，而非直接例項化類別。這種方法在需要動態建立物件或簡化組態管理的場景中特別有用。
淺複製與深複製的差異
在 Python 中，Prototype 模式通常使用 copy 模組實作淺複製和深複製。淺複製僅複製物件的頂層結構，而巢狀物件則被參考；深複製則遞迴複製所有巢狀物件。以下範例展示了兩者的差異：
import copy
class Product:
def __init__(self, name, components):
self.name = name
self.components = components
def __str__(self):
return f"Product: {self.name}, Components: {self.components}"
# 建立原始產品
original_product = Product("Gadget", ["Component A", "Component B"])
# 淺複製：components 清單被共用
shallow_clone = copy.copy(original_product)
# 深複製：components 清單被獨立複製
deep_clone = copy.deepcopy(original_product)
# 修改巢狀清單
original_product.components.append("Component C")
print("Original:")
print(original_product)
print("Shallow Clone:")
print(shallow_clone)
print("Deep Clone:")
print(deep_clone)
內容解密：
copy.copy(original_product)進行淺複製，僅複製original_product的頂層結構，而components清單被共用。copy.deepcopy(original_product)進行深複製，遞迴複製所有巢狀物件，components清單被獨立複製。- 修改
original_product.components後，shallow_clone.components也被修改，因為兩者共用同一個清單。 deep_clone.components保持不變，因為它是獨立複製的。
自定義複製行為
在某些情況下，需要對複製過程進行精細控制，例如當物件包含不可複製的資源（如檔案控制程式碼或網路連線）時。可以透過實作自定義的 __copy__ 和 __deepcopy__ 方法來覆寫預設行為：
import copy
class CustomPrototype:
def __init__(self, data, resource):
self.data = data
self.resource = resource
def __copy__(self):
cls = self.__class__
new_obj = cls.__new__(cls)
new_obj.data = self.data
new_obj.resource = None # 省略不可複製資源的複製
return new_obj
def __deepcopy__(self, memo):
cls = self.__class__
new_obj = cls.__new__(cls)
memo[id(self)] = new_obj
new_obj.data = copy.deepcopy(self.data, memo)
new_obj.resource = None # 重新初始化不可複製資源
return new_obj
# 使用範例：
prototype = CustomPrototype({"key": [1, 2, 3]}, resource="non_copyable_resource")
cloned_object = copy.deepcopy(prototype)
內容解密：
__copy__方法建立一個新例項，重用不可變資料並設定資源為None。__deepcopy__方法深度複製可變結構，同時適當處理不可複製資源。- 在複製過程中，開發者可以決定如何處理需要重新初始化的物件。
物件身份與等價性的管理
在使用 Prototype 模式時，必須確保新例項在記憶體中是獨立的，但語義上等同於原始物件。這需要適當實作相等運算元，並確保複製例程不會無意中共用可變子結構。
動態註冊與原型登入檔
Prototype 模式可以與登入檔機制結合，實作動態例項化。以下範例展示瞭如何使用登入檔來建立新物件：
prototype_registry = {}
def register_prototype(name, prototype):
prototype_registry[name] = prototype
def clone_prototype(name):
if name in prototype_registry:
return copy.deepcopy(prototype_registry[name])
raise ValueError(f"No prototype registered under {name}")
# 範例原型
class Widget:
def __init__(self, size, color):
self.size = size
self.color = color
def __str__(self):
return f"Widget(Size: {self.size}, Color: {self.color})"
# 註冊原型
register_prototype("small_blue", Widget(size="small", color="blue"))
register_prototype("large_red", Widget(size="large", color="red"))
# 執行階段克隆
widget_clone = clone_prototype("small_blue")
print(widget_clone)
內容解密：
register_prototype函式將原型註冊到登入檔中。clone_prototype函式根據名稱從登入檔中克隆原型。- 這種方法支援動態例項化，並允許外部模組註冊自己的原型。
建立模式的比較分析與進階應用
在軟體開發中，建立模式（Creational Patterns）扮演著至關重要的角色，它們提供瞭解決物件例項化挑戰的不同策略。Singleton、Factory Method、Abstract Factory、Builder 和 Prototype 等模式各自具有獨特的優勢，能夠滿足系統在效能、可組態性、彈性和可測試性等方面的需求。對於進階開發者而言，深入比較和分析這些模式有助於做出更明智的設計決策，以選擇最合適的模式組合來應對特定的領域需求。
Singleton 模式：全域例項的權衡
Singleton 模式強制規定在整個應用程式中僅存在一個例項。其主要優點在於確保狀態的一致性和資源分享，尤其是在需要單一存取點的場景中，如日誌記錄、組態管理和連線池。然而，其缺點在於隱含的耦合性和對單元測試的潛在挑戰，因為其全域狀態可能引入隱藏的副作用。進階實作，如使用元類別（metaclasses）或根據裝飾器的 Singleton，提供對例項化和執行緒安全性的額外控制，但需要謹慎管理以避免在高度平行環境中的效能瓶頸。
內容解密：
此段落闡述了 Singleton 模式的核心特點和應用場景，並對其優缺點進行了分析。開發者需權衡其利弊，並考慮進階實作方式以最佳化效能和安全性。
Factory Method 模式：介面抽象與動態適應性
Factory Method 模式透過將物件建立抽象化為介面，促進了鬆散耦合。這使得客戶端程式碼無需明確瞭解具體類別，從而增強了可擴充套件性。其優勢在於能夠結合執行時決策，例如根據組態標誌或環境條件選擇產品，從而提供動態適應性。然而，當產品家族變得更加龐大時，工廠方法中的條件邏輯可能導致緊密耦合的程式碼，需要動態註冊技術或反射來提高可擴充套件性。
內容解密：
本段重點介紹了 Factory Method 模式如何透過抽象化物件建立過程來實作鬆散耦合和動態適應性。同時，也指出了在大規模產品家族場景下可能出現的問題及其解決方案。
結合 Prototype 模式的最佳化策略
將 Prototype 模式與 Singleton 或 Factory Method 模式結合，可以進一步最佳化物件建立和複製過程。在資源受限的環境中，這種混合方法能夠顯著提升效能。例如，使用 Singleton 維護原型例項的快取，可以減少複製的開銷。
class PrototypeCache:
_cache = {}
@classmethod
def add_prototype(cls, key, prototype):
cls._cache[key] = prototype
@classmethod
def get_clone(cls, key):
if key in cls._cache:
return copy.deepcopy(cls._cache[key])
raise ValueError("Prototype not found in cache.")
# 使用範例：
prototype_instance = Widget(size="medium", color="green")
PrototypeCache.add_prototype("medium_green", prototype_instance)
cloned_widget = PrototypeCache.get_clone("medium_green")
print(cloned_widget)
內容解密：
此程式碼展示瞭如何結合 Prototype 和 Singleton 模式來實作原型例項的快取和複製。PrototypeCache 類別維護了一個快取字典，透過 add_prototype 方法新增原型例項，並透過 get_clone 方法取得克隆物件。這種結構有效地利用了快取和複製的優勢，確保頻繁需要的物件能夠高效地被複製。
非同步程式設計與 Prototype 模式的整合
在涉及 I/O 繫結操作或網路呼叫的場景中，將非同步程式設計概念整合到 Prototype 模式中，可以提高效能和回應速度。例如，當原型必須從遠端位置取得時，使用 asyncio 與複製機制結合，可以避免主執行緒被阻塞。
內容解密：
此段落討論瞭如何將非同步程式設計與 Prototype 模式結合，以提升涉及 I/O 操作或網路呼叫場景下的效能。雖然核心的複製邏輯仍然是同步的，但輔助的非同步包裝器確保資源初始化不會阻塞主執行緒。
