物件建構模式深入探討Builder與Prototype

– 9 分鐘閱讀

物件導向程式設計中，設計模式有效解決常見軟體設計問題。Builder 模式和 Prototype 模式是兩種重要的建立型模式，分別適用於不同情境。Builder 模式逐步建構複雜物件，而 Prototype 模式則透過複製現有物件來建立新物件。理解它們的差異及應用場景，能提升程式碼的彈性與可維護性。本文將以 Python 程式碼示例說明兩種模式的實作方式，並探討它們的優缺點，以及如何根據實際需求選擇合適的模式。更進一步，我們將探討 Prototype 模式的深度複製與淺度複製的差異，以及如何結合其他設計模式，例如 Singleton 和 Factory Method，來最佳化物件建立和管理流程。

建立物件的建造者模式

建造者模式是一種設計模式，允許您分步驟地建立複雜物件，同時保持其結構和表示的分離。這種模式在需要建立具有多個組成部分的物件時尤其有用。

建造者模式的基本結構

建造者模式由以下幾個部分組成：

  • 建造者（Builder）：負責建立物件的各個部分。
  • 導演（Director）：負責控制建造過程，定義建立物件的步驟順序。
  • 產品（Product）：被建立的複雜物件。

建造者模式的優點

  • 減少程式碼重複：建造者模式允許您在不修改現有程式碼的情況下建立具有不同組成部分的物件。
  • 提高可讀性：建造者模式使得建立複雜物件的程式碼更容易閱讀和理解。
  • 提高靈活性：建造者模式允許您輕鬆地修改或擴充套件建立物件的過程。

建造者模式的實作

以下是一個使用 Python 實作的建造者模式範例：

class HouseBuilder:
    def __init__(self):
        self.walls = None
        self.roof = None
        self.windows = None
        self.doors = None

    def build_walls(self, material):
        self.walls = material
        return self

    def build_roof(self, type):
        self.roof = type
        return self

    def build_windows(self, num):
        self.windows = num
        return self

    def build_doors(self, num):
        self.doors = num
        return self

    def get_result(self):
        return {
            "walls": self.walls,
            "roof": self.roof,
            "windows": self.windows,
            "doors": self.doors
        }

class HouseDirector:
    def __init__(self, builder):
        self.builder = builder

    def construct_basic_house(self):
        self.builder.build_walls("brick")
        self.builder.build_roof("flat")
        self.builder.build_windows(4)
        self.builder.build_doors(2)
        return self.builder.get_result()

    def construct_luxury_house(self):
        self.builder.build_walls("granite")
        self.builder.build_roof("curved")
        self.builder.build_windows(10)
        self.builder.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:", basic_house)
print("Luxury House:", luxury_house)

建設者模式的應用與擴充套件

在軟體開發中，建設者模式（Builder Pattern）是一種重要的設計模式，它允許我們將複雜物件的構建過程與其表示分離，使得相同的構建過程可以建立出不同的表示形式。這種模式在處理複雜物件構建時尤其有用，因為它可以讓我們一步一步地構建物件，並且可以根據不同的需求建立出不同的物件。

基本應用

建設者模式的基本應用是定義一個抽象的建設者類別，該類別定義了物件構建的步驟。然後，建立具體的建設者類別，這些類別實作了抽象建設者的方法，以構建具體的物件。最後，使用一個監督者（Director）類別來控制建設者的構建過程。

from abc import ABC, abstractmethod

# 抽象建設者
class HouseBuilder(ABC):
    @abstractmethod
    def build_walls(self):
        pass

    @abstractmethod
    def build_roof(self):
        pass

    @abstractmethod
    def build_windows(self):
        pass

    @abstractmethod
    def build_doors(self):
        pass

    @abstractmethod
    def get_result(self):
        pass

# 具體建設者
class BasicHouseBuilder(HouseBuilder):
    def __init__(self):
        self.house = None

    def build_walls(self):
        self.house = "Basic house with walls"
        return self

    def build_roof(self):
        self.house += " and roof"
        return self

    def build_windows(self):
        self.house += " and windows"
        return self

    def build_doors(self):
        self.house += " and doors"
        return self

    def get_result(self):
        return self.house

class LuxuryHouseBuilder(HouseBuilder):
    def __init__(self):
        self.house = None

    def build_walls(self):
        self.house = "Luxury house with marble walls"
        return self

    def build_roof(self):
        self.house += " and a large roof"
        return self

    def build_windows(self):
        self.house += " and stained glass windows"
        return self

    def build_doors(self):
        self.house += " and golden doors"
        return self

    def get_result(self):
        return self.house

# 監督者
class Director:
    def __init__(self, builder):
        self.builder = builder

    def construct_house(self):
        return (self.builder.build_walls()
                          .build_roof()
                          .build_windows()
                          .build_doors()
                          .get_result())

# 使用範例
basic_builder = BasicHouseBuilder()
luxury_builder = LuxuryHouseBuilder()

director = Director(basic_builder)
basic_house = director.construct_house()
print(basic_house)

director = Director(luxury_builder)
luxury_house = director.construct_house()
print(luxury_house)

與不可變物件的整合

在某些情況下，我們可能需要構建不可變物件。為了實作這一點，我們可以使用dataclasses模組來定義一個不可變的類別。然後，建立一個建設者類別，這個類別負責構建不可變物件。

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("flat")
                                   .build_windows(10)
                                   .build_doors(2)
                                   .get_result())
print(immutable_house)

物件建構模式：Builder Pattern

在軟體開發中，Builder Pattern 是一種重要的設計模式，允許我們將複雜物件的建構過程與其表示分離。這使得我們可以建立多個具有不同屬性的物件，而不需要建立多個建構函式。

以下是一個使用 Python 實作 Builder Pattern 的例子：

class ImmutableHouse:
    def __init__(self, roof_type, num_windows, num_doors):
        self.roof_type = roof_type
        self.num_windows = num_windows
        self.num_doors = num_doors

    def __str__(self):
        return f"ImmutableHouse(roof_type={self.roof_type}, num_windows={self.num_windows}, num_doors={self.num_doors})"

class HouseBuilder:
    def __init__(self):
        self.roof_type = None
        self.num_windows = None
        self.num_doors = None

    def build_roof(self, roof_type):
        self.roof_type = roof_type
        return self

    def build_windows(self, num_windows):
        self.num_windows = num_windows
        return self

    def build_doors(self, num_doors):
        self.num_doors = num_doors
        return self

    def get_result(self):
        return ImmutableHouse(self.roof_type, self.num_windows, self.num_doors)

# 使用Builder Pattern建立ImmutableHouse物件
builder = HouseBuilder()
immutable_house = (builder
                 .build_roof("domed")
                 .build_windows(8)
                 .build_doors(3)
                 .get_result())

print(immutable_house)

這個例子展示瞭如何使用 Builder Pattern 建立一個 ImmutableHouse 物件。HouseBuilder 類別負責建構 ImmutableHouse 物件，並提供了一系列的方法來設定其屬性。

原型模式：Prototype Pattern

原型模式是一種建立物件的方法，透過複製現有的物件來建立新的物件。這種模式在某些情況下非常有用，例如當建立物件的成本很高，或者需要複製一個物件的狀態時。

以下是一個使用 Python 實作原型模式的例子：

import copy

class Product:
    def __init__(self, name, components):
        self.name = name
        self.components = components

    def __str__(self):
        return f"Product(name={self.name}, components={self.components})"

# 建立原始物件
original_product = Product("Gadget", ["Component A", "Component B"])

# 淺複製：分享相同的nested objects
shallow_clone = copy.copy(original_product)

# 深複製：獨立複製所有nested objects
deep_clone = copy.deepcopy(original_product)

# 修改nested list
original_product.components.append("Component C")

print("原始物件:")
print(original_product)

print("淺複製:")
print(shallow_clone)

print("深複製:")
print(deep_clone)

這個例子展示瞭如何使用原型模式建立新的 Product 物件。copy 模組提供了淺複製和深複製的功能，允許我們根據需要選擇合適的複製方法。

深度複製與淺度複製的差異

在物件導向程式設計中，複製物件是一個常見的需求。然而，複製的方式有兩種：淺度複製（Shallow Copy）和深度複製（Deep Copy）。淺度複製只複製物件的參照，而深度複製則複製物件本身。

淺度複製

淺度複製是指只複製物件的參照，而不是複製物件本身。這意味著，如果原始物件被修改，則所有複製的物件也會受到影響。下面的程式碼示範了淺度複製：

import copy

class Prototype:
    def __init__(self, data):
        self.data = data

    def __copy__(self):
        cls = self.__class__
        new_obj = cls.__new__(cls)
        new_obj.data = self.data  # 淺度複製
        return new_obj

prototype = Prototype([1, 2, 3])
shallow_clone = copy.copy(prototype)

print(shallow_clone.data)  # [1, 2, 3]

prototype.data.append(4)
print(shallow_clone.data)  # [1, 2, 3, 4]

如上所示，當原始物件的 data 屬性被修改時，淺度複製的物件也會受到影響。

深度複製

深度複製是指複製物件本身，而不是隻複製參照。這意味著，如果原始物件被修改，則深度複製的物件不會受到影響。下面的程式碼示範了深度複製：

import copy

class Prototype:
    def __init__(self, data):
        self.data = data

    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)  # 深度複製
        return new_obj

prototype = Prototype([1, 2, 3])
deep_clone = copy.deepcopy(prototype)

print(deep_clone.data)  # [1, 2, 3]

prototype.data.append(4)
print(deep_clone.data)  # [1, 2, 3]

如上所示，當原始物件的 data 屬性被修改時，深度複製的物件不會受到影響。

自訂複製行為

在某些情況下，您可能需要自訂複製行為，以便在複製物件時進行特定的處理。例如，您可能需要複製某些屬性，但不需要複製其他屬性。為此，您可以實作 __copy__ 和 __deepcopy__ 方法，以自訂複製行為。

下面的程式碼示範瞭如何實作自訂複製行為：

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([1, 2, 3], "non_copyable_resource")
shallow_clone = copy.copy(prototype)
deep_clone = copy.deepcopy(prototype)

print(shallow_clone.data)  # [1, 2, 3]
print(shallow_clone.resource)  # None

print(deep_clone.data)  # [1, 2, 3]
print(deep_clone.resource)  # None

如上所示，自訂的 __copy__ 和 __deepcopy__ 方法可以控制哪些屬性需要被複製，以及如何進行複製。

圖表翻譯：

  flowchart TD
    A[原始物件] --> B[淺度複製]
    B --> C[深度複製]
    C --> D[自訂複製行為]
    D --> E[控制屬性複製]

圖表示範了物件的複製過程，從淺度複製到深度複製，再到自訂的複製行為。

原型模式的高階應用

在深入探討原型模式的應用之前，首先需要了解其基本概念。原型模式是一種建立型模式，允許你複製現有的物件，而不需要使你的程式碼依賴於他們的類別。

自定義複製

在某些情況下，你可能需要自定義複製行為，以滿足特定的需求。例如，你可能需要複製一個物件，但不需要複製其中的一些屬性。這時，你可以透過覆寫 __deepcopy__ 方法來實作自定義複製。

import copy

class CustomPrototype:
    def __init__(self, value):
        self.value = value

    def __deepcopy__(self, memo):
        # 自定義複製行為
        cloned_object = CustomPrototype(self.value)
        return cloned_object

# 示例用法
prototype = CustomPrototype("original")
cloned_object = copy.deepcopy(prototype)
print(cloned_object.value)  # 輸出: original

物件身份與等價性

在使用原型模式時，需要考慮物件身份與等價性的問題。當你複製一個物件時，新物件應該是原物件的獨立複製，但同時也應該保持語義上的等價性。這意味著新物件應該具有相同的屬性和行為，但不應該分享相同的記憶體空間。

動態註冊和克隆

原型模式也可以用於實作動態註冊和克隆。透過使用一個登入檔，你可以在執行時動態新增新的原型，並根據名稱進行克隆。

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("small", "blue"))
register_prototype("large_red", Widget("large", "red"))

# 克隆原型
widget_clone = clone_prototype("small_blue")
print(widget_clone)  # 輸出: Widget(size=small, color=blue)

高階技巧：結合其他模式

原型模式可以與其他模式結合使用，以實作更高階的功能。例如，你可以將原型模式與單例模式或工廠方法模式結合使用，以最佳化物件建立和克隆過程。

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_cache = PrototypeCache()
prototype_cache.add_prototype("small_blue", Widget("small", "blue"))
cloned_widget = prototype_cache.get_clone("small_blue")
print(cloned_widget)  # 輸出: Widget(size=small, color=blue)

透過結合原型模式與其他模式，你可以實作更高階的物件建立和管理功能，從而提高你的程式碼的靈活性和可維護性。

物件建立模式比較分析

在物件導向設計中，建立模式（Creational Patterns）扮演著重要的角色，幫助開發者管理複雜的物件建立過程。這些模式包括 Singleton、Factory Method、Abstract Factory、Builder 和 Prototype 等。每個模式都有其優缺點，適用於不同的場景和需求。

Singleton 模式

Singleton 模式確保系統中只有一個例項存在，通常用於需要全域性存取的物件，如日誌記錄或組態管理。然而，這種模式可能導致隱式耦合和單元測試困難。

Factory Method 模式

Factory Method 模式提供了一種方式，讓客戶端可以在不知道具體類別的情況下建立物件。這種模式提高了系統的可擴充套件性和靈活性，但當產品家族變得龐大時，工廠方法中的條件邏輯可能會變得複雜。

Abstract Factory 模式

Abstract Factory 模式根據 Factory Method 模式，提供了一種方式，讓客戶端可以建立一系列相關的物件，而無需知道具體類別。這種模式確保了所建立的物件之間的一致性，但可能會增加系統的複雜性。

Builder 模式

Builder 模式解決了複雜物件的建立問題，透過將物件的建立過程分解為多個步驟。這種模式提高了系統的可讀性和可維護性，但可能會增加狀態管理的複雜性。

Prototype 模式

Prototype 模式透過複製現有的物件來建立新的物件，減少了建立新物件的成本。這種模式適用於物件建立成本高或需要動態建立物件的情況，但需要注意對於可變物件的複製和狀態管理。

從技術架構視角來看，建造者模式有效分離了複雜物件的構建過程和表示，提升了程式碼的靈活性與可維護性。分析不同物件的構建需求，可以發現建造者模式尤其適用於需要逐步構建，且構建步驟相對穩定的場景。它避免了大量的建構函式過載，並提升了程式碼的可讀性。然而，對於結構簡單的物件，建造者模式可能會顯得過於繁瑣，反而增加了程式碼的複雜度。此外，在處理不可變物件時，需要仔細設計構建步驟，確保物件狀態的一致性。隨著不可變資料結構的普及，預計建造者模式將與不可變物件的整合更加緊密，例如結合使用 Python 的 dataclasses 或其他類別似機制。對於追求程式碼簡潔性和可維護性的開發者而言，深入理解並應用建造者模式將是提升程式碼品質的關鍵策略。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。