軟體架構分層與設計模式應用

– 13 分鐘閱讀

軟體系統設計中，良好的架構和設計模式至關重要。本文深入探討分層模式如何降低模組耦合，並以依賴反轉原則為核心，介紹介面卡、裝飾器等模式的應用場景。同時，文章也涵蓋觀察者模式、命令模式和複合模式，並以 Python 程式碼示例展示如何在事件驅動架構和使用者介面框架中靈活運用這些模式，實作系統的解耦、最佳化功能和提升可維護性。此外，文章也探討了事件匯流排模式在協調跨模式互動中的作用，以及如何結合多種設計模式構建複合模式，解決更複雜的系統設計問題。

依賴反轉原則（Dependency Inversion Principle）

玄貓的設計遵循依賴反轉原則，即高層模組不應該依賴低層模組，而是應該依賴抽象介面。這樣可以減少模組之間的耦合度，提高系統的可維護性和可擴充套件性。

介面卡模式（Adapter Pattern）

介面卡模式可以用於整合舊系統或第三方函式庫到現有的層次架構中。這個模式可以將外部介面的差異轉換為內部抽象介面，從而保證系統的結構完整性。

裝飾器模式（Decorator Pattern）

裝飾器模式可以用於增加跨越多個層次的功能，例如記錄、安全性、快取等。這個模式可以在不修改底層服務邏輯的情況下，增加新的功能。

記錄裝飾器示例

class OrderServiceDecorator(OrderServiceFacade):
    def __init__(self, wrapped_service):
        self.wrapped_service = wrapped_service

    def process_order(self, order_id):
        print(f"DEBUG: 處理訂單 ID: {order_id}")
        result = self.wrapped_service.process_order(order_id)
        print(f"DEBUG: 處理結果: {result}")

這個示例展示瞭如何使用裝飾器模式增加記錄功能到 OrderServiceFacade 類別中。這個裝飾器可以在不修改底層服務邏輯的情況下，增加記錄功能。

軟體架構中的分層模式

在軟體開發中，分層模式（Layering Pattern）是一種重要的設計原則，能夠幫助開發者建立可維護、可擴充套件和高效的系統。這種模式涉及將系統分成多個層次，每個層次都有其特定的責任和功能。

分層模式的優點

分層模式有許多優點，包括：

  • 提高可維護性：分層模式使得系統的各個部分之間的耦合度降低，從而使得維護和更新系統變得更加容易。
  • 提高可擴充套件性：分層模式使得系統可以更容易地擴充套件和修改，以應對新的需求和挑戰。
  • 提高安全性：分層模式可以幫助提高系統的安全性，透過將敏感的資料和功能隔離在不同的層次中。

分層模式的型別

分層模式可以分為多種型別，包括：

  • 建立型模式（Creational Pattern）：這種模式關注於物件的建立和初始化。
  • 結構型模式（Structural Pattern）：這種模式關注於物件之間的關係和結構。
  • 行為型模式（Behavioral Pattern）：這種模式關注於物件之間的行為和互動作用。

分層模式的應用

分層模式可以應用於多種不同的領域，包括：

  • 微服務架構：分層模式可以幫助微服務架構中的各個服務之間的溝通和協調。
  • 雲端計算：分層模式可以幫助雲端計算中的資源管理和排程。
  • 物聯網：分層模式可以幫助物聯網中的裝置管理和資料處理。
內容解密：

上述內容介紹了分層模式的基本概念、優點和型別，並且提供了多種不同的應用領域。透過這些知識，開發者可以更好地理解和應用分層模式，從而建立出更好的軟體系統。

圖表翻譯：

  graph LR
    A[建立型模式] --> B[結構型模式]
    B --> C[行為型模式]
    C --> D[微服務架構]
    D --> E[雲端計算]
    E --> F[物聯網]

上述圖表展示了分層模式的不同型別之間的關係，以及它們在不同領域中的應用。透過這個圖表，開發者可以更好地理解分層模式的整體架構和應用場景。

程式碼示例：

import threading
import time
import heapq
from collections import defaultdict

class Event:
    def __init__(self, name, payload):
        self.name = name
        self.payload = payload

class CoordinatedMediator:
    def __init__(self):
        self._observer_channels = defaultdict(list)
        self._lock = threading.Lock()

    def subscribe(self, event_type, observer, priority=0):
        with self._lock:
            heapq.heappush(self._observer_channels[event_type], (-priority, observer))

    def unsubscribe(self, event_type, observer):
        with self._lock:
            self._observer_channels[event_type] = [entry for entry in self._observer_channels[event_type] if entry[1]!= observer]
            heapq.heapify(self._observer_channels[event_type])

    def dispatch(self, event):
        with self._lock:
            for observer in self._observer_channels[event.name]:
                observer(event.payload)

上述程式碼示例展示了一個簡單的協調器（CoordinatedMediator）類別，該類別使用優先佇列（Priority Queue）來管理觀察者（Observer）之間的溝通。透過這個程式碼示例，開發者可以更好地理解分層模式在實際應用中的具體實作。

觀察者模式實作

在軟體設計中，觀察者模式是一種常見的設計模式，允許物件在不需要知道彼此細節的情況下相互溝通。以下是觀察者模式的一個實作範例：

觀察者介面

class BaseObserver:
    def handle_event(self, event):
        raise NotImplementedError("Subclasses must implement handle_event.")

記錄觀察者

class LoggingObserver(BaseObserver):
    def handle_event(self, event):
        print(f"[LoggingObserver] Event: {event.name} with payload {event.payload}")
        return False  # Continue propagation

安全觀察者

class SecurityObserver(BaseObserver):
    def handle_event(self, event):
        if event.payload.get("secure", False):
            print(f"[SecurityObserver] Handling secure event: {event.name}")
            return True  # Halt propagation if security demands isolation
        return False

事件類別

class Event:
    def __init__(self, name, payload):
        self.name = name
        self.payload = payload

中介者類別

class CoordinatedMediator:
    def __init__(self):
        self._observer_channels = {}
        self._lock = threading.Lock()

    def subscribe(self, event_name, observer, priority=0):
        with self._lock:
            if event_name not in self._observer_channels:
                self._observer_channels[event_name] = []
            self._observer_channels[event_name].append((priority, observer))

    def notify(self, event):
        observers = []
        with self._lock:
            if event.name in self._observer_channels:
                observers = list(self._observer_channels[event.name])

        # Process each observer sequentially and allow for chain modifications
        for priority, observer in sorted(observers, reverse=True):
            if observer.handle_event(event):
                break

範例使用

if __name__ == "__main__":
    mediator = CoordinatedMediator()
    mediator.subscribe("data_update", LoggingObserver(), priority=5)
    mediator.subscribe("data_update", SecurityObserver(), priority=10)
    event = Event("data_update", {"value": 42, "secure": True})
    mediator.notify(event)

在這個範例中，CoordinatedMediator 類別負責管理觀察者和事件的通訊。BaseObserver 介面定義了觀察者的基本行為，而 LoggingObserver 和 SecurityObserver 類別則實作了這個介面以提供不同的功能。事件的傳播可以被觀察者中斷或繼續，取決於觀察者的 handle_event 方法的傳回值。

事件排程與安全考量的協調

在事件驅動的系統中，事件排程器（Mediator）扮演著至關重要的角色，負責協調各個事件之間的互動和處理。例如，當一個事件發生時，排程器需要考慮到日誌記錄和安全性等多個方面，以確保系統的完整性和安全。

class Event:
    def __init__(self, name):
        self.name = name

class Mediator:
    def __init__(self):
        self.observers = []

    def add_observer(self, observer):
        self.observers.append(observer)

    def dispatch(self, event):
        for observer in self.observers:
            observer.handle_event(event)

class Logger:
    def handle_event(self, event):
        print(f"Logging: {event.name}")

class SecurityChecker:
    def handle_event(self, event):
        print(f"Security Check: {event.name}")

# Example usage
if __name__ == "__main__":
    mediator = Mediator()
    logger = Logger()
    security_checker = SecurityChecker()

    mediator.add_observer(logger)
    mediator.add_observer(security_checker)

    event = Event("Test Event")
    mediator.dispatch(event)

命令模式與複合模式的互動

命令模式（Command Pattern）和複合模式（Composite Pattern）可以互動使用，以管理一系列相關的操作。命令模式封裝了具體的動作，而複合模式則允許將多個命令組合成一個單一的複合命令。

from abc import ABC, abstractmethod

class Command(ABC):
    @abstractmethod
    def execute(self):
        pass

class SimpleCommand(Command):
    def __init__(self, action):
        self.action = action

    def execute(self):
        return self.action()

class CompositeCommand(Command):
    def __init__(self):
        self.commands = []

    def add(self, command):
        self.commands.append(command)

    def execute(self):
        results = []
        for command in self.commands:
            results.append(command.execute())
        return results

# Example usage
if __name__ == "__main__":
    def action_one():
        return "Action One Executed"

    def action_two():
        return "Action Two Executed"

    simple1 = SimpleCommand(action_one)
    simple2 = SimpleCommand(action_two)

    composite = CompositeCommand()
    composite.add(simple1)
    composite.add(simple2)

    results = composite.execute()
    for result in results:
        print(result)

這種互動不僅能夠減少系統狀態的不一致性，也能夠增強事務的完整性。高階命令通常使用依賴注入（Dependency Injection）來管理分享狀態，進一步完善系統行為。

內容解密：

在上述程式碼中，我們定義了一個 Mediator 類別，負責協調事件之間的互動。Logger 和 SecurityChecker 類別實作了 handle_event 方法，以處理事件。Command 類別是命令模式的抽象基礎類別，而 SimpleCommand 和 CompositeCommand 類別則實作了具體的命令。CompositeCommand 類別允許將多個命令組合成一個單一的複合命令。

圖表翻譯：

  flowchart TD
    A[事件發生] --> B[Mediator]
    B --> C[Logger]
    B --> D[SecurityChecker]
    C --> E[記錄日誌]
    D --> F[進行安全檢查]

這個流程圖展示了事件發生時，排程器如何協調日誌記錄和安全檢查。

設計模式的應用：命令模式與依賴注入

在軟體設計中，命令模式是一種常見的設計模式，允許我們將請求封裝成物件，從而使得請求的傳送者和接收者之間的耦合度降低。這種模式使得我們可以輕鬆地新增新的命令或修改現有的命令，而不需要改變現有的程式碼。

命令模式的實作

命令模式的核心思想是將請求封裝成物件，這樣我們就可以將請求的傳送者和接收者解耦。下面的例子展示瞭如何使用命令模式實作一個簡單的系統：

class Command:
    def execute(self):
        pass

class SimpleCommand(Command):
    def execute(self):
        print("SimpleCommand executing")

class CompositeCommand(Command):
    def __init__(self):
        self.commands = []

    def add(self, command):
        self.commands.append(command)

    def execute(self):
        for command in self.commands:
            command.execute()

# 使用命令模式
composite = CompositeCommand()
composite.add(SimpleCommand())
composite.execute()

在這個例子中，Command 類別是命令模式的抽象類別，SimpleCommand 類別是具體的命令類別，而 CompositeCommand 類別是複合命令類別。複合命令類別可以新增多個命令，並在 execute 方法中執行所有新增的命令。

依賴注入的應用

當我們需要將多個模式組合在一起時，依賴注入（Dependency Injection）模式就變得非常重要。依賴注入模式允許我們將物件之間的依賴關係宣告在外部，這樣我們就可以輕鬆地更改依賴關係，而不需要改變現有的程式碼。

下面的例子展示瞭如何使用依賴注入模式實作一個簡單的系統：

class Service:
    def perform(self):
        raise NotImplementedError("Subclass implementation required.")

class ConcreteService(Service):
    def perform(self):
        print("ConcreteService performing task.")

class Client:
    def __init__(self, service: Service):
        self.service = service

    def run(self):
        self.service.perform()

# 依賴注入容器模擬
class Container:
    def __init__(self):
        self._services = {}

    def register(self, key, instance):
        self._services[key] = instance

    def resolve(self, key):
        return self._services.get(key)

if __name__ == "__main__":
    container = Container()
    container.register("service", ConcreteService())

    client = Client(container.resolve("service"))
    client.run()

在這個例子中，Service 類別是服務的抽象類別，ConcreteService 類別是具體的服務類別，而 Client 類別是客戶端類別。客戶端類別需要一個服務例項才能運作，而服務例項是透過依賴注入容器模擬注入的。

事件驅動設計中的跨模式互動

在複雜系統中，依賴注入（DI）框架可以實作模式互動的動態重新組態。元件可以在執行時根據組態例項化和連線，從而實作玄貓的技術要求。跨模式互動的協調涉及對生命週期管理的仔細考慮，特別是在模式跨越非同步執行或多執行緒環境時。

模式互動的挑戰

模式之間的互動涉及到多個層面的考慮，包括同步機制、監控、優雅退化和背壓技術，以確保事件傳播在高負載下保持穩定。高併發場景下的跨模式互動管理是一個挑戰。

訊息代理或事件匯流排

應用訊息代理或事件匯流排作為解耦機制，是管理跨模式互動的一種有效方法。透過事件匯流排，各個模式可以在沒有直接依賴的情況下進行互動。例如，一個系統可以使用事件匯流排將域級別觀察者通知轉發給多個命令呼叫，以協調非同步方式執行。

事件匯流排實作

以下是一個簡化的事件匯流排實作示例：

import queue
import threading
from collections import defaultdict

class EventBus:
    def __init__(self):
        self.subscribers = defaultdict(list)
        self.event_queue = queue.Queue()
        self._dispatcher_thread = threading.Thread(target=self._dispatch_loop)
        self._dispatcher_thread.start()

    def subscribe(self, event_type, callback):
        self.subscribers[event_type].append(callback)

    def publish(self, event):
        self.event_queue.put(event)

    def _dispatch_loop(self):
        while True:
            event = self.event_queue.get()
            if event.name in self.subscribers:
                for callback in self.subscribers[event.name]:
                    callback(event)

class SimpleEvent:
    def __init__(self, name, payload):
        self.name = name
        self.payload = payload

# 示例事件處理器，協調命令執行
def command_handler(event):
    print(f"Command handler processing event: {event.name} with payload: {event.payload}")

# 示例用法
event_bus = EventBus()
event_bus.subscribe("example_event", command_handler)
event = SimpleEvent("example_event", "Hello, World!")
event_bus.publish(event)

事件匯流排模式：解耦事件生產者和消費者

事件匯流排模式是一種強大的工具，用於協調互動作用，透過解耦事件生產者和消費者。它的整合與其他模式，如觀察者或中介者模式，建立了一個高階的訊息路由機制，這在分散式架構和微服務生態系統中是不可或缺的。

事件匯流排模式的優點

  • 解耦: 事件匯流排模式允許事件生產者和消費者之間的解耦，使得系統更加模組化和靈活。
  • 可擴充套件性: 事件匯流排模式使得系統可以輕鬆地擴充套件和修改，而不需要改變現有的程式碼。
  • 容錯性: 事件匯流排模式可以提供容錯性和還原能力，使得系統可以從錯誤中還原。

事件匯流排模式的實作

import time

class EventBus:
    def __init__(self):
        self.subscribers = {}

    def subscribe(self, event_type, handler):
        if event_type not in self.subscribers:
            self.subscribers[event_type] = []
        self.subscribers[event_type].append(handler)

    def publish(self, event):
        if event.event_type in self.subscribers:
            for handler in self.subscribers[event.event_type]:
                handler(event)

class SimpleEvent:
    def __init__(self, event_type, data):
        self.event_type = event_type
        self.data = data

def command_handler(event):
    print(f"Received event: {event.event_type} with data: {event.data}")

bus = EventBus()
bus.subscribe("execute_command", command_handler)
bus.publish(SimpleEvent("execute_command", {"id": 101}))

time.sleep(1)

複合模式：最佳化系統設計

複合模式是一種高階的系統設計策略，透過將多個模式結合起來解決複雜的問題。它可以最佳化系統的功能、可擴充套件性和維護性。

複合模式的優點

  • 最佳化功能: 複合模式可以最佳化系統的功能，透過結合多個模式來解決複雜的問題。
  • 可擴充套件性: 複合模式可以提高系統的可擴充套件性，使得系統可以輕鬆地擴充套件和修改。
  • 維護性: 複合模式可以提高系統的維護性，使得系統可以輕鬆地維護和更新。

複合模式的實作

class Command:
    def execute(self):
        raise NotImplementedError("Subclass must implement execute")

    def rollback(self):
        raise NotImplementedError("Subclass must implement rollback")

class CreateUserCommand(Command):
    def __init__(self, user_service, user_data):
        self.user_service = user_service
        self.user_data = user_data

    def execute(self):
        self.user_id = self.user_service.create(self.user_data)
        return self.user_id

    def rollback(self):
        self.user_service.delete(self.user_id)

class CreateOrderCommand(Command):
    def __init__(self, order_service, order_data):
        self.order_service = order_service
        self.order_data = order_data

    def execute(self):
        self.order_id = self.order_service.create(self.order_data)
        return self.order_id

    def rollback(self):
        self.order_service.delete(self.order_id)

合成命令模式與複合模式在使用者介面框架中的應用

在軟體開發中，合成命令模式（Composite Command Pattern）和複合模式（Composite Pattern）是兩種重要的設計模式。合成命令模式允許我們將多個命令合成一個單一的命令，從而實作對多個命令的統一管理和執行。複合模式則允許我們將多個物件合成一個單一的物件，從而實作對多個物件的統一管理和操作。

以下是一個示例程式碼，展示瞭如何使用合成命令模式和複合模式來實作一個動態使用者介面框架：

class Command:
    def execute(self):
        raise NotImplementedError("Subclasses must implement execute")

class CompositeCommand(Command):
    def __init__(self):
        self.commands = []

    def add(self, command):
        self.commands.append(command)

    def execute(self):
        results = []
        try:
            for cmd in self.commands:
                results.append(cmd.execute())
        except Exception as e:
            # Rollback previous commands if one command fails
            self.rollback()
            raise e
        return results

    def rollback(self):
        try:
            for cmd in reversed(self.commands):
                cmd.rollback()
        except Exception:
            # Logging or alternate error handling should occur here
            pass

class UIComponent:
    def render(self):
        raise NotImplementedError("Subclasses must implement render")

class LeafComponent(UIComponent):
    def __init__(self, content):
        self.content = content

    def render(self):
        return self.content

class CompositeComponent(UIComponent):
    def __init__(self):
        self.children = []

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

    def render(self):
        rendered_children = "".join(child.render() for child in self.children)
        return f"<div class='composite'>{rendered_children}</div>"

class CommandButton(UIComponent):
    def __init__(self, command):
        self.command = command

    def render(self):
        return f"<button onclick='{self.command.execute()}'>Click me</button>"

在這個示例中，CompositeCommand 類別實作了合成命令模式，允許我們將多個命令合成一個單一的命令。CompositeComponent 類別實作了複合模式，允許我們將多個使用者介面元件合成一個單一的元件。CommandButton 類別則實作了使用者介面按鈕的行為，當按鈕被點選時，會執行相應的命令。

透過使用合成命令模式和複合模式，我們可以實作一個動態使用者介面框架，該框架允許我們將多個使用者介面元件合成一個單一的元件，並且可以統一管理和執行多個命令。這種設計模式可以幫助我們提高軟體的模組性、靈活性和可維護性。

內容解密：

  • CompositeCommand 類別的 execute 方法會執行所有新增到合成命令中的命令，如果任何一個命令執行失敗，則會回復所有之前執行的命令。
  • CompositeComponent 類別的 render 方法會渲染所有新增到複合元件中的子元件。
  • CommandButton 類別的 render 方法會渲染一個按鈕元件，當按鈕被點選時，會執行相應的命令。

圖表翻譯：

  flowchart TD
    A[使用者點選按鈕] --> B[執行命令]
    B --> C[渲染使用者介面]
    C --> D[更新使用者介面]

這個流程圖展示了當使用者點選按鈕時，會執行相應的命令，然後渲染使用者介面，最終更新使用者介面。

結合設計模式的力量：建立複合模式

在軟體工程中，設計模式是解決常見問題的最佳實踐。然而，當我們面臨複雜的系統時，單一的設計模式往往不足以滿足需求。這時，複合模式（Composite Pattern）就成了我們的救星。透過結合多個設計模式，複合模式可以建立出更強大、更靈活的解決方案。

什麼是複合模式？

複合模式是一種設計模式，它允許您將多個設計模式結合起來，建立出一個新的、更強大的模式。這種模式可以用於解決複雜的系統問題，例如實作多個功能、管理多個物件等。

如何建立複合模式？

建立複合模式需要以下步驟：

  1. 選擇設計模式：選擇您想要結合的設計模式，例如觀察者模式（Observer Pattern）、命令模式（Command Pattern）等。
  2. 定義介面：定義每個設計模式的介面，以便於之間的溝通。
  3. 實作設計模式：實作每個設計模式的具體實作。
  4. 結合設計模式：結合多個設計模式，建立出一個新的、更強大的模式。

例子：觀察者模式和命令模式的結合

以下是一個例子，展示瞭如何結合觀察者模式和命令模式：

class Observer:
    def notify(self, data):
        print(f"Observer notified with: {data}")

class Command:
    def execute(self):
        pass

class ObservableCommand(Command):
    def __init__(self, func):
        self.func = func
        self.observers = []

    def execute(self):
        result = self.func()
        for observer in self.observers:
            observer.notify(result)

def observable_command(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        if hasattr(func, "observers"):
            for observer in func.observers:
                observer.notify(result)
        return result
    return wrapper

@observable_command
def process_data(data):
    return f"Processed {data}"

process_data.observers = [Observer()]

result = process_data("payload")
print(result)

在這個例子中，我們結合了觀察者模式和命令模式，建立出一個新的、更強大的模式。當 process_data 函式被執行時，它會通知觀察者，並將結果傳遞給觀察者。

封裝複合操作的設計模式

在軟體設計中，封裝複合操作是一種常見的需求。為了滿足這種需求，我們可以使用 Facade 設計模式。Facade 是一種結構設計模式，它提供了一個簡單的介面來存取一個複雜的系統。

從技術架構視角來看，本文探討了多種設計模式如何提升軟體系統的靈活性與可維護性，特別著重於依賴反轉原則的應用和不同設計模式的組合。分析比較了介面卡、裝飾器、觀察者、命令以及複合模式的特性與應用場景，並以程式碼示例展示了它們的實際運用。然而，單一模式的應用往往存在侷限性，例如觀察者模式在大規模事件處理時可能面臨效能瓶頸，命令模式在處理複雜事務時需要更精細的狀態管理。整合不同設計模式的複合模式則能有效彌補這些不足，例如結合命令模式和觀察者模式，可以實作更具彈性的事件驅動架構。隨著系統複雜度的提升，預期複合模式的應用將更加普及，開發者需要更深入地理解不同模式的互動方式以及潛在的衝突點，才能更好地駕馭複合模式的威力。玄貓認為，深入理解並靈活運用這些設計模式，將是構建高品質軟體系統的關鍵所在。

玄貓

玄貓

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