設計模式混合應用與程式碼範例

– 12 分鐘閱讀

在軟體開發中，設計模式是解決常見問題的有效工具。本文將探討如何結合多個設計模式，例如 Builder 和 Prototype、Composite 和 Decorator，以及 Adapter，來構建更具彈性且高效的軟體系統。這些模式的組合應用可以簡化複雜物件的建立和管理，最佳化計算流程，並解決系統整合時遇到的介面不相容問題。以下將透過 Python 程式碼示例，分別說明這些模式的組合應用及其優勢。同時，也將探討如何使用介面卡模式解決不同系統或模組之間的介面不相容問題，以及如何結合建造者和原型模式來建立和複製複雜物件。

混合模式應用

在實際應用中，往往需要結合多個建立模式來解決複雜的問題。例如，使用 Abstract Factory 和 Builder 的組合，可以實作複雜物件的動態建立和組態。又如，使用 Prototype 和 Singleton 的組合，可以實作高效的物件複製和全域性存取。

程式碼示例：混合使用 Builder 和 Prototype

import copy

class ComplexObject:
    def __init__(self, part1, part2, settings):
        self.part1 = part1
        self.part2 = part2
        self.settings = settings

    def __str__(self):
        return f"ComplexObject(part1={self.part1}, part2={self.part2}, settings={self.settings})"

class Builder:
    def __init__(self):
        self.part1 = None
        self.part2 = None
        self.settings = None

    def set_part1(self, part1):
        self.part1 = part1
        return self

    def set_part2(self, part2):
        self.part2 = part2
        return self

    def set_settings(self, settings):
        self.settings = settings
        return self

    def build(self):
        return ComplexObject(self.part1, self.part2, self.settings)

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

    def clone(self):
        return copy.deepcopy(self.obj)

# 使用 Builder 建立 ComplexObject
builder = Builder()
complex_obj = builder.set_part1("part1").set_part2("part2").set_settings({"setting1": 1}).build()

# 使用 Prototype 複製 ComplexObject
prototype = Prototype(complex_obj)
cloned_obj = prototype.clone()

print(complex_obj)
print(cloned_obj)

這個示例展示瞭如何使用 Builder 和 Prototype 的組合來建立和複製複雜物件。Builder 負責構建 ComplexObject，而 Prototype 則負責複製已經構建好的物件。這種組合提供了一種高效和靈活的方式來管理複雜物件的建立和複製過程。

建立複雜物件的建構者模式

在軟體設計中，建構者模式（Builder Pattern）是一種建立複雜物件的設計模式。它允許使用者透過一步一步的過程來建立複雜物件，並且可以根據不同的需求定製物件的各個部分。

ComplexObject 類別

首先，我們定義一個 ComplexObject 類別，它代表了我們要建立的複雜物件。這個類別有三個屬性：part1、part2 和 settings，它們分別代表了物件的不同部分。

class ComplexObject:
    def __init__(self, part1, part2, settings):
        self.part1 = part1
        self.part2 = part2
        self.settings = settings

    def __str__(self):
        return f"ComplexObject({self.part1}, {self.part2}, {self.settings})"

ComplexBuilder 類別

接下來，我們定義一個 ComplexBuilder 類別，它負責建立 ComplexObject 例項。這個類別有一個 product 屬性，代表了正在建立的 ComplexObject 例項。

class ComplexBuilder:
    def __init__(self):
        self.product = ComplexObject(None, None, {})

    def build_part1(self, value):
        self.product.part1 = value
        return self

    def build_part2(self, value):
        self.product.part2 = value
        return self

    def set_settings(self, settings):
        self.product.settings = settings
        return self

    def get_result(self):
        return self.product

建立複雜物件

現在，我們可以使用 ComplexBuilder 類別來建立 ComplexObject 例項。首先，我們建立一個 ComplexBuilder 例項，然後透過呼叫 build_part1、build_part2 和 set_settings 方法來設定物件的各個部分。最後，我們呼叫 get_result 方法來取得建立好的 ComplexObject 例項。

builder = ComplexBuilder()
prototype_complex = builder.build_part1("ModuleA").build_part2("ModuleB").set_settings({"debug": True}).get_result()
print(prototype_complex)

複製複雜物件

如果我們想要建立另一個具有不同組態的複雜物件，我們可以複製已經建立好的 ComplexObject 例項，然後修改它的屬性。

new_complex = ComplexObject(prototype_complex.part1, prototype_complex.part2, prototype_complex.settings.copy())
new_complex.part1 = "ModuleC"
new_complex.settings["debug"] = False
print(new_complex)

圖表翻譯：

  classDiagram
    class ComplexObject {
        -part1: str
        -part2: str
        -settings: dict
    }
    class ComplexBuilder {
        -product: ComplexObject
        +build_part1(value): ComplexBuilder
        +build_part2(value): ComplexBuilder
        +set_settings(settings): ComplexBuilder
        +get_result(): ComplexObject
    }
    ComplexBuilder --* ComplexObject

內容解密：

在上面的程式碼中，我們定義了兩個類別：ComplexObject 和 ComplexBuilder。ComplexObject 類別代表了我們要建立的複雜物件，它有三個屬性：part1、part2 和 settings。ComplexBuilder 類別負責建立 ComplexObject 例項，它有一個 product 屬性，代表了正在建立的 ComplexObject 例項。

我們可以使用 ComplexBuilder 類別來建立 ComplexObject 例項。首先，我們建立一個 ComplexBuilder 例項，然後透過呼叫 build_part1、build_part2 和 set_settings 方法來設定物件的各個部分。最後，我們呼叫 get_result 方法來取得建立好的 ComplexObject 例項。

如果我們想要建立另一個具有不同組態的複雜物件，我們可以複製已經建立好的 ComplexObject 例項，然後修改它的屬性。

結合建造者和原型模式的實踐

在軟體開發中，結合不同的設計模式可以帶來更強大的解決方案。以下是一個結合建造者（Builder）和原型（Prototype）模式的例子，展示如何使用這兩種模式來建立複雜物件並高效地複製它們。

建造者模式

建造者模式是一種建立型模式，允許你分步驟地構建複雜物件，並且可以根據需要定製物件的各個部分。這個模式尤其適合於構建具有多個可變部分的物件。

原型模式

原型模式是另一種建立型模式，允許你建立現有物件的複製品，而無需使程式碼依賴於物件的類別。這個模式在需要複製具有大量狀態或資源密集型物件時特別有用。

結合建造者和原型模式

以下是一個結合了建造者和原型模式的例子，展示如何使用這兩種模式來建立和複製複雜物件。

import copy

class ComplexObject:
    def __init__(self):
        self.settings = {"debug": True}

    def __str__(self):
        return f"ComplexObject: {self.settings}"

class Builder:
    def __init__(self):
        self.complex_object = ComplexObject()

    def set_debug(self, debug):
        self.complex_object.settings["debug"] = debug
        return self

    def build(self):
        return self.complex_object

# 建立一個原型物件
prototype_complex = Builder().set_debug(True).build()

# 複製原型物件
cloned_complex = copy.deepcopy(prototype_complex)

# 修改複製物件的設定
cloned_complex.settings["debug"] = False

print("原型物件:")
print(prototype_complex)

print("複製物件:")
print(cloned_complex)

這個例子展示瞭如何使用建造者模式建立一個複雜物件，並使用原型模式複製該物件。這種結合提供了一種高效且靈活的方式來建立和管理複雜物件。

結構性模式：打造靈活的結構

結構性模式是一類別設計模式，關注於打造靈活且可適應的軟體結構。這些模式包括介面卡（Adapter）、合成（Composite）、裝飾器（Decorator）、外觀（Facade）、飛重（Flyweight）和代理（Proxy）等。

介面卡模式

介面卡模式是一種結構性模式，允許你將兩個不相容的介面轉換為相容的介面。這個模式在需要將舊有的系統或程式碼整合到新的系統中時特別有用。

合成模式

合成模式是一種結構性模式，允許你將多個物件組合成一個單一的物件。這個模式在需要管理多個物件之間的複雜關係時特別有用。

裝飾器模式

裝飾器模式是一種結構性模式，允許你動態地為一個物件新增額外的功能。這個模式在需要為物件新增新的功能而不改變其原始結構時特別有用。

外觀模式

外觀模式是一種結構性模式，提供了一個簡單的介面來存取一個複雜的系統。這個模式在需要簡化複雜系統的介面時特別有用。

飛重模式

飛重模式是一種結構性模式，允許你分享多個物件之間的共同狀態。這個模式在需要減少多個物件之間的記憶體使用時特別有用。

代理模式

代理模式是一種結構性模式，允許你控制對一個物件的存取。這個模式在需要為物件新增額外的功能或控制其存取時特別有用。

以下是一個使用介面卡模式的例子，展示如何將兩個不相容的介面轉換為相容的介面。

class LegacyInterface:
    def specific_request(self):
        return "Legacy result"

class ModernInterface:
    def request(self):
        raise NotImplementedError("Subclasses should implement this!")

class Adapter(ModernInterface):
    def __init__(self, legacy_obj):
        self.legacy_obj = legacy_obj

    def request(self):
        result = self.legacy_obj.specific_request()
        return f"Adapted: {result}"

這個例子展示瞭如何使用介面卡模式將一個舊有的介面轉換為一個新的介面。這種方法可以幫助你將舊有的系統或程式碼整合到新的系統中。

進階設計模式：介面卡與複合模式

在軟體開發中，常遇到不同系統或模組之間的介面不相容問題，這時介面卡模式（Adapter Pattern）就派上用場了。介面卡模式是一種結構性模式，讓兩個不相容的物件能夠一起工作。它提供了一個轉換層，使得一個介面能夠以另一個介面的形式呈現，從而使得原本不相容的系統能夠進行通訊。

介面卡模式實作

class LegacyInterface:
    def request(self):
        return "Legacy Request"

class Adapter:
    def __init__(self, legacy):
        self.legacy = legacy

    def request(self):
        return self.legacy.request()

legacy = LegacyInterface()
adapter = Adapter(legacy)
print(adapter.request())  # Output: Legacy Request

在上述例子中，LegacyInterface 代表了舊有的系統介面，而 Adapter 則是介面卡，它包裝了 LegacyInterface 並提供了一個新的介面 request()。這樣一來，新的系統就可以透過介面卡與舊有的系統進行通訊。

複合模式（Composite Pattern）

複合模式是一種結構性模式，讓客戶端能夠以統一的方式處理個別物件和複合物件。它提供了一個樹狀結構，讓客戶端能夠透過相同的介面存取個別物件和複合物件。

複合模式實作

class Component:
    def operation(self):
        raise NotImplementedError

class Leaf(Component):
    def operation(self):
        return "Leaf"

class Composite(Component):
    def __init__(self):
        self._children = []
        self._cached_result = None

    def add(self, component):
        self._children.append(component)
        self._cached_result = None  # Invalidate cache

    def operation(self):
        if self._cached_result is None:
            results = []
            for child in self._children:
                results.append(child.operation())
            self._cached_result = 'Composite(' + ', '.join(results) + ')'
        return self._cached_result

# 使用範例
composite = Composite()
composite.add(Leaf())
composite.add(Leaf())
print(composite.operation())  # Output: Composite(Leaf, Leaf)

在上述例子中，Component 代表了抽象的元件介面，而 Leaf 和 Composite 則是具體的元件實作。Composite 類別提供了一個樹狀結構，讓客戶端能夠透過相同的介面存取個別物件和複合物件。

結合介面卡和複合模式

在實際應用中，介面卡和複合模式可以結合使用，以提供更強大的功能。例如，在一個大型系統中，可能需要將多個舊有的系統整合到新的系統中，這時可以使用介面卡模式將舊有的系統介面轉換為新的介面，而後使用複合模式提供統一的存取介面。

結合實作

class LegacySystem:
    def request(self):
        return "Legacy Request"

class Adapter:
    def __init__(self, legacy):
        self.legacy = legacy

    def request(self):
        return self.legacy.request()

class Composite:
    def __init__(self):
        self._children = []
        self._cached_result = None

    def add(self, component):
        self._children.append(component)
        self._cached_result = None  # Invalidate cache

    def operation(self):
        if self._cached_result is None:
            results = []
            for child in self._children:
                results.append(child.request())
            self._cached_result = 'Composite(' + ', '.join(results) + ')'
        return self._cached_result

# 使用範例
legacy = LegacySystem()
adapter = Adapter(legacy)
composite = Composite()
composite.add(adapter)
print(composite.operation())  # Output: Composite(Legacy Request)

在上述例子中，LegacySystem 代表了舊有的系統，而 Adapter 則是介面卡，它包裝了 LegacySystem 並提供了一個新的介面 request()。Composite 類別提供了一個樹狀結構，讓客戶端能夠透過相同的介面存取個別物件和複合物件。這樣一來，新的系統就可以透過介面卡和複合模式與舊有的系統進行通訊。

結合設計模式實作高效計算

在軟體開發中，結合多個設計模式可以帶來更強大的功能和更高的效率。例如，結合 Composite 和 Decorator 模式，可以實作一個高效的計算系統。

Composite 模式

Composite 模式是一種結構型模式，允許客戶端將物件視為單一實體或集合來處理。這個模式可以用於實作樹狀結構的物件，例如檔案系統或組織架構。

class Component:
    def operation(self):
        pass

class Leaf(Component):
    def operation(self):
        return "Leaf"

class Composite(Component):
    def __init__(self):
        self.children = []

    def add(self, component):
        self.children.append(component)

    def operation(self):
        results = []
        for child in self.children:
            results.append(child.operation())
        return results

Decorator 模式

Decorator 模式是一種結構型模式，允許動態地將新的責任新增到物件上。這個模式可以用於實作日誌記錄、快取或其他功能。

from functools import wraps

def logging_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print(f"LOG: Called function: {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

def caching_decorator(func):
    cache = {}
    @wraps(func)
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrapper

結合 Composite 和 Decorator 模式

現在，我們可以結合 Composite 和 Decorator 模式來實作一個高效的計算系統。

@logging_decorator
@caching_decorator
def compute(value):
    return value * value

composite = Composite()
leaf1 = Leaf()
leaf2 = Leaf()
composite.add(leaf1)
composite.add(leaf2)

result = composite.operation()
print(result)

在這個例子中，compute函式被裝飾器logging_decorator和caching_decorator裝飾。這意味著每次呼叫compute函式時，都會記錄日誌並快取結果。同時，Composite類別被用於實作樹狀結構的物件，允許客戶端將物件視為單一實體或集合來處理。

圖表翻譯：

  graph LR
    A[Composite] -->|add|> B[Leaf1]
    A -->|add|> C[Leaf2]
    D[logging_decorator] -->|decorate|> E[compute]
    E -->|cache|> F[caching_decorator]

這個圖表展示了 Composite 和 Decorator 模式的結合。Composite類別被用於實作樹狀結構的物件，而logging_decorator和caching_decorator被用於裝飾compute函式。

內容解密：

在這個例子中，compute函式被裝飾器logging_decorator和caching_decorator裝飾。這意味著每次呼叫compute函式時，都會記錄日誌並快取結果。同時，Composite類別被用於實作樹狀結構的物件，允許客戶端將物件視為單一實體或集合來處理。

這種結合可以帶來更高的效率和更強大的功能。例如，客戶端可以將物件視為單一實體或集合來處理，而裝飾器可以動態地將新的責任新增到物件上。同時，快取機制可以避免重複的計算，提高系統的效能。

結構模式在軟體設計中的應用

在軟體設計中，結構模式（Structural Patterns）扮演著重要的角色，幫助開發者建立出更為模組化、可維護和可擴充套件的系統。這些模式提供了一種方法，讓開發者可以組織和結構化程式碼，從而使系統更容易理解和修改。

1. Facade 模式

Facade 模式是一種結構模式，它提供了一個統一的介面給子系統，讓客戶端可以更容易地存取子系統的功能。這種模式可以幫助減少客戶端和子系統之間的耦合度，從而使系統更容易維護和擴充套件。

例如，在一個分散式系統中，Facade 模式可以用來提供一個統一的介面給遠端服務，讓客戶端可以更容易地存取遠端服務的功能。以下是 Facade 模式的一個簡單範例：

class RemoteServiceFacade:
    def __init__(self, service_endpoints):
        self._services = service_endpoints

    def request_service(self, service_name, payload):
        service = self._services.get(service_name)
        if service:
            # The facade handles retry policies, error translation, etc.
            return service.execute(payload)
        raise ValueError("Service not found")

2. Flyweight 模式

Flyweight 模式是一種結構模式，它用來減少物件的數量，從而節省記憶體空間。這種模式可以幫助提高系統的效能，特別是在大資料的情況下。

例如，在一個檔案編輯器中，Flyweight 模式可以用來分享相同的字型和顏色設定，從而減少物件的數量。以下是 Flyweight 模式的一個簡單範例：

class Font:
    def __init__(self, name, size):
        self.name = name
        self.size = size

class FontFactory:
    _fonts = {}

    @classmethod
    def get_font(cls, name, size):
        key = (name, size)
        if key not in cls._fonts:
            cls._fonts[key] = Font(name, size)
        return cls._fonts[key]

3. Proxy 模式

Proxy 模式是一種結構模式，它提供了一個代理物件，讓客戶端可以更容易地存取實際物件的功能。這種模式可以幫助控制物件的存取，從而提高系統的安全性和效能。

例如，在一個網頁瀏覽器中，Proxy 模式可以用來提供一個代理伺服器，讓客戶端可以更容易地存取網頁的內容。以下是 Proxy 模式的一個簡單範例：

class WebPage:
    def __init__(self, url):
        self.url = url

    def get_content(self):
        # Simulate getting content from the web page
        return "This is the content of the web page"

class WebPageProxy:
    def __init__(self, web_page):
        self.web_page = web_page

    def get_content(self):
        # Add some logic to control access to the web page
        print("Accessing the web page...")
        return self.web_page.get_content()

4. Adapter 模式

Adapter 模式是一種結構模式，它提供了一個介面卡物件，讓客戶端可以更容易地存取實際物件的功能。這種模式可以幫助解決不同物件之間的介面不相容問題。

例如，在一個資料函式庫系統中，Adapter 模式可以用來提供一個介面卡物件，讓客戶端可以更容易地存取不同的資料函式庫系統。以下是 Adapter 模式的一個簡單範例：

class Database:
    def query(self, query_string):
        # Simulate querying the database
        return "This is the result of the query"

class DatabaseAdapter:
    def __init__(self, database):
        self.database = database

    def execute_query(self, query_string):
        # Add some logic to adapt the query string
        adapted_query_string = query_string.upper()
        return self.database.query(adapted_query_string)

結構模式在軟體設計中扮演著重要的角色，它們可以幫助開發者建立出更為模組化、可維護和可擴充套件的系統。透過使用這些模式，開發者可以提高系統的效能、安全性和可靠性。

時間戳轉換為人類可讀日期和格式化值

在處理時間戳資料時，常需要將其轉換為人類可讀的日期格式。以下是一個示例程式碼，展示如何使用 Python 的datetime模組來實作此功能。

從技術架構視角來看，混合使用建立型模式能有效提升軟體開發的彈性與效率。本文探討瞭如何結合 Builder、Prototype、Composite、Decorator 等模式，解決複雜物件建立、複製、組合及功能擴充套件等問題。分析顯示，混合模式應用並非簡單的模式堆積疊，而是需要根據實際場景巧妙組合，例如 Builder 和 Prototype 的結合能簡化複雜物件的建立和複製流程，Composite 和 Decorator 的結合則能實作高效的計算和功能擴充套件。然而，模式的濫用也會增加系統的複雜度，因此需謹慎評估。隨著軟體系統日趨複雜，預期更多混合模式的應用場景將湧現，開發者需要更深入理解各模式的特性及應用限制，才能在實務中靈活運用。對於追求高效和可維護程式碼的開發團隊而言，深入研究並實踐混合模式應用將是提升軟體設計能力的關鍵途徑。

玄貓

玄貓

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