重構程式碼設計模式應用與策略

– 19 分鐘閱讀

軟體系統隨著時間推移和需求變化，程式碼往往變得難以維護。重構是改善程式碼品質的關鍵步驟，設計模式則提供了有效重構策略。本文將探討如何應用建立模式、結構模式和行為模式重構程式碼。建立模式著重於物件的建立機制，例如使用工廠方法和建構者模式封裝物件建立過程，提升程式碼模組化。結構模式關注物件組合方式，例如使用介面卡模式解決介面不相容問題，或用外觀模式簡化子系統互動。行為模式則關注物件間的溝通和責任分配，例如觀察者模式實作狀態變化通知，策略模式提供演算法替換機制，而命令模式則將請求封裝成物件，提升程式碼靈活性。這些模式都能有效改善程式碼可讀性、可維護性和可擴充套件性，是重構過程中不可或缺的工具。

建立模式在重構中的應用

建立模式是軟體設計中的一些經典和成熟的解決方案，可以用於重構程式碼。以下是建立模式在重構中的應用：

1. 工廠方法模式

工廠方法模式是一種建立模式，用於封裝物件的建立過程。它可以用於重構程式碼中的物件建立過程，使得程式碼更加模組化和可維護。

2. 建築者模式

建築者模式是一種建立模式，用於複雜物件的建立。它可以用於重構程式碼中的複雜物件建立過程，使得程式碼更加模組化和可維護。

重構工具和技術

重構工具和技術包括靜態分析工具、效能最佳化工具、版本控制系統和自動化測試框架等。這些工具和技術可以幫助發現和解決重構過程中的問題，提高程式碼的品質和安全性。

使用建構者模式改善程式碼可讀性

在軟體開發中，當我們需要建立一個物件時，往往需要傳入多個引數。這種情況下，使用建構者模式（Builder pattern）可以有效地改善程式碼的可讀性和維護性。

問題描述

假設我們有一個 Config 類別，需要傳入多個引數，例如主機名稱、埠號、SSL 啟用狀態、超時時間和重試次數。直接例項化這個類別可能會導致程式碼難以閱讀和維護。

class Config:
    def __init__(self, host, port, use_ssl, timeout, retry_limit):
        self.host = host
        self.port = port
        self.use_ssl = use_ssl
        self.timeout = timeout
        self.retry_limit = retry_limit

config = Config('localhost', 8080, True, 30, 3)

建構者模式解決方案

為瞭解決這個問題，我們可以使用建構者模式來改善程式碼的可讀性。首先，我們定義一個 ConfigBuilder 類別，負責一步一步地構建 Config 物件。

class ConfigBuilder:
    def __init__(self):
        self.host = None
        self.port = None
        self.use_ssl = False
        self.timeout = None
        self.retry_limit = None

    def set_host(self, host):
        self.host = host
        return self

    def set_port(self, port):
        self.port = port
        return self

    def enable_ssl(self):
        self.use_ssl = True
        return self

    def set_timeout(self, timeout):
        self.timeout = timeout
        return self

    def set_retry_limit(self, retry_limit):
        self.retry_limit = retry_limit
        return self

    def build(self):
        return Config(self.host, self.port, self.use_ssl, self.timeout, self.retry_limit)

class Config:
    def __init__(self, host, port, use_ssl, timeout, retry_limit):
        self.host = host
        self.port = port
        self.use_ssl = use_ssl
        self.timeout = timeout
        self.retry_limit = retry_limit

# 客戶端程式碼使用建構者模式
builder = ConfigBuilder()
config = (builder.set_host('localhost')
                .set_port(8080)
                .enable_ssl()
                .set_timeout(30)
                .set_retry_limit(3)
                .build())

優點分析

使用建構者模式可以帶來以下優點：

  • 可讀性提高：程式碼變得更容易閱讀和理解，因為每一步都很明確。
  • 維護性提高：如果需要新增或修改引數，建構者模式使得這個過程變得更容易和更安全。
  • 錯誤風險降低：由於每一步都很明確，所以減少了出錯的風險。

物件建立模式：簡化複雜系統的建構

在軟體開發中，物件的建立和管理是非常重要的。傳統的建構子（constructor）方式雖然可以完成物件的初始化，但是在複雜系統中，可能會導致程式碼的混亂和難以維護。為瞭解決這個問題，開發者可以使用建立模式（creational pattern）來簡化物件的建立和管理。

建構者模式（Builder Pattern）

建構者模式是一種常用的建立模式，它允許開發者分步驟地建立複雜的物件。這種模式不僅簡化了物件的建立，也允許開發者在建構過程中插入驗證步驟或條件邏輯。透過建構者模式，開發者可以引入檢查和平衡機制，以確保物件的正確性和完整性。

以下是建構者模式的一個簡單範例：

class Button:
    def __init__(self, os_type):
        self.os_type = os_type

    def render(self):
        if self.os_type == 'Windows':
            print("Rendering Windows button")
        elif self.os_type == 'MacOS':
            print("Rendering MacOS button")

class ButtonBuilder:
    def __init__(self):
        self.os_type = None

    def set_os_type(self, os_type):
        self.os_type = os_type
        return self

    def build(self):
        return Button(self.os_type)

# 使用建構者模式建立按鈕物件
button = (ButtonBuilder()
         .set_os_type('Windows')
         .build())
button.render()  # Rendering Windows button

在這個範例中，ButtonBuilder 類別負責建立 Button 物件。開發者可以使用 set_os_type 方法設定按鈕的作業系統型別，然後使用 build 方法建立按鈕物件。

抽象工廠模式（Abstract Factory Pattern）

抽象工廠模式是一種更高層次的建立模式，它允許開發者建立相互依賴的物件，而不需要知道具體的實作細節。這種模式在 legacy 系統中尤其有用，因為它可以幫助開發者管理複雜的物件階層。

以下是抽象工廠模式的一個簡單範例：

from abc import ABC, abstractmethod

class Button(ABC):
    @abstractmethod
    def render(self):
        pass

class WindowsButton(Button):
    def render(self):
        print("Rendering Windows button")

class MacOSButton(Button):
    def render(self):
        print("Rendering MacOS button")

class GUIFactory(ABC):
    @abstractmethod
    def create_button(self) -> Button:
        pass

class WindowsFactory(GUIFactory):
    def create_button(self) -> Button:
        return WindowsButton()

class MacOSFactory(GUIFactory):
    def create_button(self) -> Button:
        return MacOSButton()

# 使用抽象工廠模式建立按鈕物件
factory = WindowsFactory()
button = factory.create_button()
button.render()  # Rendering Windows button

在這個範例中，GUIFactory 類別定義了一個抽象工廠介面，WindowsFactory 和 MacOSFactory 類別實作了這個介面。開發者可以使用這些工廠類別建立按鈕物件，而不需要知道具體的實作細節。

建立按鈕和工廠模式

在軟體開發中，工廠模式（Factory Pattern）是一種常用的設計模式，用於建立物件而無需指定要建立的物件型別。這種模式可以幫助我們實作程式碼的解耦和重用。

以下是一個簡單的例子，展示瞭如何使用工廠模式建立按鈕：

from abc import ABC, abstractmethod

class Button(ABC):
    @abstractmethod
    def render(self):
        pass

class MacOSButton(Button):
    def render(self):
        return "MacOS 按鈕"

class WindowsButton(Button):
    def render(self):
        return "Windows 按鈕"

class GUIFactory(ABC):
    @abstractmethod
    def create_button(self) -> Button:
        pass

class MacOSFactory(GUIFactory):
    def create_button(self) -> Button:
        return MacOSButton()

class WindowsFactory(GUIFactory):
    def create_button(self) -> Button:
        return WindowsButton()

def get_factory(os_type: str) -> GUIFactory:
    if os_type == "MacOS":
        return MacOSFactory()
    elif os_type == "Windows":
        return WindowsFactory()
    else:
        raise ValueError("不支援的作業系統")

# 客戶端程式碼
factory = get_factory("MacOS")
button = factory.create_button()
print(button.render())  # 輸出：MacOS 按鈕

在這個例子中，我們定義了一個 Button 介面和兩個實作類別 MacOSButton 和 WindowsButton。我們還定義了一個 GUIFactory 介面和兩個實作類別 MacOSFactory 和 WindowsFactory。客戶端程式碼使用 get_factory 函式來取得適合的工廠物件，並使用工廠物件來建立按鈕。

單例模式

單例模式（Singleton Pattern）是一種設計模式，用於確保一個類別只有一個例項。這種模式可以幫助我們實作資源的分享和控制。

以下是一個簡單的例子，展示瞭如何使用單例模式實作一個組態管理器：

class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class ConfigManager(metaclass=SingletonMeta):
    def __init__(self):
        pass

    def load(self, filename):
        # 載入組態檔
        pass

    def get(self, key):
        # 取得組態值
        pass

# 客戶端程式碼
config_manager = ConfigManager()
config_manager.load("config.txt")
print(config_manager.get("key"))  # 輸出：組態值

在這個例子中，我們定義了一個 SingletonMeta 類別，該類別實作了單例模式。我們還定義了一個 ConfigManager 類別，該類別使用 SingletonMeta 類別作為其 metaclass。客戶端程式碼可以使用 ConfigManager 類別來取得組態管理器的例項。

依賴注入

依賴注入（Dependency Injection）是一種設計模式，用於實作物件之間的解耦。這種模式可以幫助我們實作程式碼的模組化和測試。

以下是一個簡單的例子，展示瞭如何使用依賴注入實作一個服務：

from abc import ABC, abstractmethod

class Service(ABC):
    @abstractmethod
    def do_something(self):
        pass

classServiceImpl(Service):
    def do_something(self):
        # 實作服務邏輯
        pass

class ServiceFactory:
    def create_service(self) -> Service:
        return ServiceImpl()

# 客戶端程式碼
service_factory = ServiceFactory()
service = service_factory.create_service()
service.do_something()  # 輸出：服務邏輯

在這個例子中，我們定義了一個 Service 介面和一個實作類別 ServiceImpl。我們還定義了一個 ServiceFactory 類別，該類別負責建立服務例項。客戶端程式碼可以使用 ServiceFactory 類別來取得服務例項。

這些設計模式可以幫助我們實作程式碼的解耦、重用和模組化，從而提高程式碼的品質和可維護性。

結構模式在程式碼重構中的應用

在軟體開發中，結構模式（Structural Patterns）扮演著重要的角色，特別是在重構（Refactoring）過程中。這些模式提供了一種系統化的方法來組織複雜的程式碼基礎（Codebase），使其更容易維護、擴充套件和理解。

什麼是結構模式？

結構模式是一類別設計模式，關注於如何組織和結構化物件和類別之間的關係，以提高程式碼的可維護性、可擴充套件性和可讀性。這些模式提供了抽象和封裝物件建立和管理的機制，使得程式碼基礎更容易演化和適應變化的需求。

結構模式在重構中的應用

在重構過程中，結構模式可以幫助解決多個挑戰，例如：

  1. 減少耦合性：結構模式可以幫助減少物件和類別之間的耦合性，使得程式碼更容易維護和擴充套件。
  2. 提高凝聚性：結構模式可以幫助提高物件和類別的凝聚性，使得程式碼更容易理解和維護。
  3. 增強擴充套件性：結構模式可以提供了一種機制來擴充套件功能而不影響現有的程式碼基礎。

例子：介面卡模式（Adapter Pattern）

介面卡模式是一種常用的結構模式，用於解決不同介面之間的相容性問題。以下是 Python 中的一個例子：

from abc import ABC, abstractmethod

# Legacy 服務
class LegacyService:
    def old_method(self, data):
        # Legacy 處理
        return f"Processed {data}"

# 標準介面
class StandardInterface(ABC):
    @abstractmethod
    def process(self, data):
        pass

# 介面卡
class Adapter(LegacyService, StandardInterface):
    def process(self, data):
        return self.old_method(data)

# 客戶端
class Client:
    def __init__(self, service):
        self.service = service

    def do_something(self, data):
        result = self.service.process(data)
        print(result)

# 使用介面卡
legacy_service = LegacyService()
adapter = Adapter()
client = Client(adapter)
client.do_something("Hello, World!")

在這個例子中，介面卡模式被用來將 Legacy 服務的介面轉換為標準介面，使得客戶端可以使用標準介面來存取 Legacy 服務。

介面適配與外觀模式：解決複雜系統的關鍵

在軟體開發中，尤其是在進行系統重構或整合時，常會遇到不同系統或模組之間的介面不相容問題。為瞭解決這種問題，軟體設計中引入了介面卡（Adapter）模式和外觀（Facade）模式。這兩種模式都用於簡化複雜系統的介面，但它們的適用情境和解決問題的方法有所不同。

介面卡模式

介面卡模式是一種結構性模式，主要用於使兩個不相容的介面可以一起工作。它透過建立一個新的介面（介面卡），使得客戶端可以無需改動就能使用舊有的介面。介面卡模式在系統重構中尤其有用，因為它允許我們逐步替換舊有的系統元件，而不需要一次性改動整個系統。

以下是一個簡單的 Python 範例，展示瞭如何使用介面卡模式來使一個新的介面與一個舊的介面相容：

class LegacyService:
    def old_method(self, payload):
        # 舊有的方法實作
        pass

class StandardInterface:
    def process(self, payload):
        # 新的標準介面
        pass

class ServiceAdapter(StandardInterface):
    def __init__(self, legacy_service: LegacyService):
        self.legacy_service = legacy_service

    def process(self, payload):
        # 將新的方法呼叫轉換為舊有的介面
        return self.legacy_service.old_method(payload)

# 使用介面卡
legacy = LegacyService()
adapter = ServiceAdapter(legacy)
result = adapter.process("input data")

外觀模式

外觀模式是另一種結構性模式，主要用於簡化一個複雜系統的介面。它透過建立一個單一的介面（外觀），來隱藏系統的複雜性，並提供一個統一的存取點給客戶端。外觀模式在處理具有多個子系統且這些子系統之間有複雜互動作用的系統時尤其有用。

以下是一個 Python 範例，展示瞭如何使用外觀模式來簡化一個複雜系統的介面：

class SubsystemA:
    def operation_a(self):
        return "A"

class SubsystemB:
    def operation_b(self):
        return "B"

class SubsystemC:
    def operation_c(self):
        return "C"

class SystemFacade:
    def __init__(self):
        self.subsystem_a = SubsystemA()
        self.subsystem_b = SubsystemB()
        self.subsystem_c = SubsystemC()

    def execute(self):
        result = []
        result.append(self.subsystem_a.operation_a())
        result.append(self.subsystem_b.operation_b())
        result.append(self.subsystem_c.operation_c())
        return result

# 使用外觀
facade = SystemFacade()
result = facade.execute()

圖表翻譯：介面卡與外觀模式的比較

  flowchart TD
    A[介面卡模式] -->|用於介面轉換|> B[使兩個不相容的介面可以一起工作]
    C[外觀模式] -->|用於簡化複雜系統|> D[提供一個統一的介面給客戶端]
    E[介面卡模式] -->|適用於系統重構|> F[逐步替換舊有的系統元件]
    G[外觀模式] -->|適用於複雜系統|> H[隱藏系統的複雜性]

瞭解 Facade 模式和 Composite 模式的優勢

在軟體設計中，Facade 模式和 Composite 模式是兩種重要的設計模式，它們可以幫助我們簡化複雜系統的結構，提高程式碼的可維護性和可擴充套件性。

Facade 模式

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

以下是一個簡單的例子，展示瞭如何使用 Facade 模式來簡化客戶端的程式碼：

class SubsystemA:
    def operation_a(self):
        return "Subsystem A"

class SubsystemB:
    def operation_b(self):
        return "Subsystem B"

class SubsystemC:
    def operation_c(self):
        return "Subsystem C"

class Facade:
    def __init__(self):
        self.subsystem_a = SubsystemA()
        self.subsystem_b = SubsystemB()
        self.subsystem_c = SubsystemC()

    def execute(self):
        result = []
        result.append(self.subsystem_a.operation_a())
        result.append(self.subsystem_b.operation_b())
        result.append(self.subsystem_c.operation_c())
        return "-".join(result)

# 客戶端程式碼
facade = Facade()
output = facade.execute()
print(output)

在這個例子中，Facade 模式簡化了客戶端的程式碼，使得客戶端不需要知道子系統的具體實作細節。

Composite 模式

Composite 模式是一種結構型模式，它允許客戶端將個體物件和組合物件統一對待。這種模式可以幫助我們管理複雜的樹狀結構或巢狀資料表示。

以下是一個簡單的例子，展示瞭如何使用 Composite 模式來管理 UI 元件的樹狀結構：

from abc import ABC, abstractmethod

class UIComponent(ABC):
    @abstractmethod
    def render(self):
        pass

class Button(UIComponent):
    def render(self):
        return "Rendering Button"

class TextField(UIComponent):
    def render(self):
        return "Rendering TextField"

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

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

    def render(self):
        rendered_components = [child.render() for child in self.children]
        return "Panel[" + "; ".join(rendered_components) + "]"

# 建立一個複合UI結構
button = Button()
text_field = TextField()
panel = Panel()
panel.add(button)
panel.add(text_field)

print(panel.render())

在這個例子中，Composite 模式允許我們將個體 UI 元件（如 Button 和 TextField）和組合 UI 元件（如 Panel）統一對待。

結合模式與裝飾器模式在軟體設計中的應用

在軟體設計中，結合模式（Composite pattern）和裝飾器模式（Decorator pattern）是兩種重要的設計模式，分別用於處理物件的結構和行為。結合模式允許客戶端程式碼以統一的方式對待個別物件和物件集合，而裝飾器模式則提供了一種動態地擴充套件物件功能的方法。

結合模式

結合模式是一種結構模式，它允許客戶端程式碼以統一的方式對待個別物件和物件集合。這種模式透過定義一個抽象的元件介面，使得客戶端程式碼可以以相同的方式對待個別物件和物件集合。

例如，假設我們有一個 GUI 系統，需要渲染不同的元件，包括按鈕和文字欄位。使用結合模式，我們可以定義一個抽象的元件介面，然後讓按鈕和文字欄位實作這個介面。這樣，客戶端程式碼就可以以統一的方式對待按鈕和文字欄位，無需關心它們的具體實作。

class Component:
    def render(self):
        pass

class Button(Component):
    def render(self):
        # 渲染按鈕
        pass

class TextField(Component):
    def render(self):
        # 渲染文字欄位
        pass

class Panel:
    def __init__(self):
        self.components = []

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

    def render(self):
        for component in self.components:
            component.render()

panel = Panel()
panel.add(Button())
panel.add(TextField())
panel.render()

裝飾器模式

裝飾器模式是一種結構模式，它允許客戶端程式碼動態地擴充套件物件的功能，而無需改變其介面。這種模式透過定義一個抽象的裝飾器介面，然後讓具體的裝飾器實作這個介面。

例如，假設我們有一個資料來源類別，需要提供加密和壓縮功能。使用裝飾器模式，我們可以定義一個抽象的裝飾器介面，然後讓加密和壓縮裝飾器實作這個介面。這樣，客戶端程式碼就可以動態地擴充套件資料來源的功能，而無需改變其介面。

from abc import ABC, abstractmethod

class DataSource(ABC):
    @abstractmethod
    def read_data(self):
        pass

class FileDataSource(DataSource):
    def __init__(self, filename):
        self.filename = filename

    def read_data(self):
        with open(self.filename, 'r') as file:
            return file.read()

class DataSourceDecorator(DataSource):
    def __init__(self, wrappee: DataSource):
        self.wrappee = wrappee

    def read_data(self):
        return self.wrappee.read_data()

class EncryptionDecorator(DataSourceDecorator):
    def read_data(self):
        data = self.wrappee.read_data()
        # 執行解密
        return f"decrypted({data})"

class CompressionDecorator(DataSourceDecorator):
    def read_data(self):
        data = self.wrappee.read_data()
        # 執行解壓縮
        return f"decompressed({data})"

# 使用裝飾器建立資料來源
data_source = FileDataSource("data.txt")
encrypted_data_source = EncryptionDecorator(data_source)
compressed_data_source = CompressionDecorator(encrypted_data_source)

# 讀取資料
data = compressed_data_source.read_data()
print(data)

行為模式在重構中的應用

在軟體重構中，行為模式（Behavioral Patterns）扮演著重要的角色，它們能夠幫助開發者重新組織程式碼，改善系統的可擴充套件性、靈活性和可維護性。行為模式關注的是物件之間的互動和溝通，透過使用這些模式，可以減少程式碼的耦合度，提高模組的獨立性和重用性。

觀察者模式（Observer Pattern）

觀察者模式是一種常用的行為模式，它允許物件之間的解耦，實作了當一個物件的狀態發生變化時，所有依賴於它的物件都能夠接收到通知並做出相應的反應。這種模式在事件驅動架構中尤其有用，因為它可以幫助簡化事件處理邏輯，提高系統的可擴充套件性。

觀察者模式的優點

  1. 解耦: 觀察者模式可以將主題（Subject）和觀察者（Observer）之間的耦合度降低，使得兩者之間的依賴關係變得更加鬆散。
  2. 擴充套件性: 新的觀察者可以在任何時候被新增到系統中，而不需要修改現有的程式碼。
  3. 靈活性: 觀察者模式使得系統可以根據需要動態地新增或刪除觀察者。

觀察者模式的實作

from abc import ABC, abstractmethod

# 主題（Subject）介面
class Subject(ABC):
    @abstractmethod
    def register_observer(self, observer):
        pass

    @abstractmethod
    def remove_observer(self, observer):
        pass

    @abstractmethod
    def notify_observers(self):
        pass

# 觀察者（Observer）介面
class Observer(ABC):
    @abstractmethod
    def update(self, data):
        pass

# 具體主題類別
class WeatherStation(Subject):
    def __init__(self):
        self.observers = []
        self.temperature = 0
        self.humidity = 0

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

    def remove_observer(self, observer):
        self.observers.remove(observer)

    def notify_observers(self):
        for observer in self.observers:
            observer.update({"temperature": self.temperature, "humidity": self.humidity})

    def set_measurements(self, temperature, humidity):
        self.temperature = temperature
        self.humidity = humidity
        self.notify_observers()

# 具體觀察者類別
class TemperatureDisplay(Observer):
    def update(self, data):
        print(f"Temperature: {data['temperature']}")

class HumidityDisplay(Observer):
    def update(self, data):
        print(f"Humidity: {data['humidity']}")

# 客戶端程式碼
weather_station = WeatherStation()
temperature_display = TemperatureDisplay()
humidity_display = HumidityDisplay()

weather_station.register_observer(temperature_display)
weather_station.register_observer(humidity_display)

weather_station.set_measurements(80, 65)

策略模式（Strategy Pattern）

策略模式是一種行為模式，它允許你定義一系列演算法，把它們封裝起來，並且使它們之間可以相互替換。這種模式使得演算法的變化不會影響到客戶端。

策略模式的優點

  1. 解耦: 策略模式可以將演算法的實作與使用演算法的客戶端程式碼解耦。
  2. 擴充套件性: 新的策略可以在任何時候被新增到系統中，而不需要修改現有的程式碼。
  3. 靈活性: 策略模式使得系統可以根據需要動態地選擇不同的演算法。

策略模式的實作

from abc import ABC, abstractmethod

# 策略（Strategy）介面
class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount):
        pass

# 具體策略類別
class CreditCardStrategy(PaymentStrategy):
    def __init__(self, name, card_number, cvv, expiry_date):
        self.name = name
        self.card_number = card_number
        self.cvv = cvv
        self.expiry_date = expiry_date

    def pay(self, amount):
        print(f"Paid {amount} using credit/debit card {self.card_number}")

class PayPalStrategy(PaymentStrategy):
    def __init__(self, email_id):
        self.email_id = email_id

    def pay(self, amount):
        print(f"Paid {amount} using PayPal {self.email_id}")

# 上下文（Context）類別
class PaymentContext:
    def __init__(self, payment_strategy):
        self.payment_strategy = payment_strategy

    def set_payment_strategy(self, payment_strategy):
        self.payment_strategy = payment_strategy

    def execute_payment(self, amount):
        self.payment_strategy.pay(amount)

# 客戶端程式碼
credit_card_strategy = CreditCardStrategy("John Doe", "1234-5678-9012-3456", "123", "12/25")
paypal_strategy = PayPalStrategy("johndoe@example.com")

payment_context = PaymentContext(credit_card_strategy)
payment_context.execute_payment(100)

payment_context.set_payment_strategy(paypal_strategy)
payment_context.execute_payment(200)

命令模式（Command Pattern）

命令模式是一種行為模式，它將請求封裝成一個物件，這樣可以使用不同的請求、排隊或記錄請求來實作可復原的操作。

命令模式的優點

  1. 解耦: 命令模式可以將請求的傳送者與請求的接收者解耦。
  2. 擴充套件性: 新的命令可以在任何時候被新增到系統中，而不需要修改現有的程式碼。
  3. 靈活性: 命令模式使得系統可以根據需要動態地選擇不同的命令。

命令模式的實作

from abc import ABC, abstractmethod

# 命令（Command）介面
class Command(ABC):
    @abstractmethod
    def execute(self):
        pass

# 接收者（Receiver）類別
class Light:
    def on(self):
        print("The light is on")

    def off(self):
        print("The light is off")

# 具體命令類別
class TurnOnCommand(Command):
    def __init__(self, light):
        self.light = light

    def execute(self):
        self.light.on()

class TurnOffCommand(Command):
    def __init__(self, light):
        self.light = light

    def execute(self):
        self.light.off()

# 呼叫者（Invoker）類別
class RemoteControl:
    def __init__(self):
        self.commands = {}

    def set_command(self, button, command):
        self.commands[button] = command

    def press_button(self, button):
        if button in self.commands:
            self.commands[button].execute()
        else:
            print("No command assigned to this button")

# 客戶端程式碼
light = Light()
turn_on_command = TurnOnCommand(light)
turn_off_command = TurnOffCommand(light)

remote_control = RemoteControl()
remote_control.set_command("ON", turn_on_command)
remote_control.set_command("OFF", turn_off_command)

remote_control.press_button("ON")
remote_control.press_button("OFF")

觀察者模式：提升系統可擴充套件性

觀察者模式是一種行為設計模式，允許物件在不需要知道彼此細節的情況下相互通訊。這種模式尤其適合於需要在系統中動態新增或刪除觀察者的情況。

觀察者模式的優點

  • 提高系統的可擴充套件性：觀察者模式使得系統可以動態地新增或刪除觀察者，而不需要修改現有的程式碼。
  • 減少耦合度：觀察者模式降低了觀察者之間的耦合度，使得系統更容易維護和擴充套件。

觀察者模式的實作

from typing import Callable, Any

class Subject:
    def __init__(self):
        self._observers = set()
        self._state = None

    def attach(self, observer: Callable[[Any], None]) -> None:
        self._observers.add(observer)

    def detach(self, observer: Callable[[Any], None]) -> None:
        self._observers.discard(observer)

    def notify(self) -> None:
        for observer in self._observers:
            observer(self._state)

    def update_state(self, new_state):
        self._state = new_state
        self.notify()

# 使用示例
subject = Subject()
subject.attach(lambda state: print("觀察者X收到:", state))
subject.attach(lambda state: print("觀察者Y收到:", state))

subject.update_state("新的動態狀態")

這種結構不僅提供了管理訂閱者的靈活性，也允許動態地適應回應邏輯。高階開發人員可以進一步擴充套件觀察者模式，以根據優先順序的通知或非同步事件分發，利用事件迴圈和並發原語實作更回應的設計。

命令模式：封裝請求為物件

命令模式是一種行為設計模式，將請求封裝為物件，從而使得請求可以被 parameterize、queued 和 logged。這種模式特別適合於重構傳統系統，其中動作處理嵌入在條件陳述式中。

命令模式的優點

  • 提高系統的可擴充套件性：命令模式使得系統可以動態地新增或刪除命令，而不需要修改現有的程式碼。
  • 減少耦合度：命令模式降低了命令之間的耦合度，使得系統更容易維護和擴充套件。

命令模式的實作

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

    def execute(self):
        if self.action == "create":
            # 執行建立動作
            print("建立:", self.data)
        elif self.action == "update":
            # 執行更新動作
            print("更新:", self.data)
        elif self.action == "delete":
            # 執行刪除動作
            print("刪除:", self.data)

# 使用示例
command = Command("create", "新資料")
command.execute()

命令模式抽象了操作為離散的物件，封裝了所有執行所需的資訊，從而實作了動態命令排程和任務佇列。考慮一個單體設計，其中 UI 動作由以下函式表示：

def execute_action(action, data):
    if action == "create":
        # 執行建立動作
        print("建立:", data)
    elif action == "update":
        # 執行更新動作
        print("更新:", data)
    elif action == "delete":
        # 執行刪除動作
        print("刪除:", data)

內容解密：

上述程式碼示範瞭如何使用命令模式重構傳統系統中的動作處理。透過封裝請求為物件，命令模式提供了一種靈活和可擴充套件的方式來管理系統中的動作。

圖表翻譯：

  flowchart TD
    A[開始] --> B[建立命令]
    B --> C[執行命令]
    C --> D[更新命令]
    D --> E[執行命令]
    E --> F[刪除命令]
    F --> G[執行命令]

上述流程圖示範了命令模式的工作流程。首先，建立一個命令物件，然後執行該命令。根據命令的型別，執行不同的動作。

命令模式的優雅實作

在軟體設計中，命令模式（Command Pattern）是一種行為設計模式，讓你能將請求封裝成一個物件，從而使其可被引數化、佇列化、記錄化和復原。這種模式對於處理不同型別的請求非常有用，特別是在需要將請求者和接收者解耦的情況下。

基礎實作

首先，我們定義一個抽象命令類別 Command，它包含一個抽象方法 execute。這個方法必須由所有具體命令類別實作，以定義命令的執行行為。

from abc import ABC, abstractmethod

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

接下來，我們建立具體命令類別，例如 CreateCommand、UpdateCommand 和 DeleteCommand。每個類別都實作了 execute 方法，以執行相應的動作。

class CreateCommand(Command):
    def __init__(self, data):
        self.data = data

    def execute(self):
        create_entity(self.data)

class UpdateCommand(Command):
    def __init__(self, data):
        self.data = data

    def execute(self):
        update_entity(self.data)

class DeleteCommand(Command):
    def __init__(self, data):
        self.data = data

    def execute(self):
        delete_entity(self.data)

命令登入檔

為了動態呼叫命令，我們使用一個命令登入檔 COMMAND_REGISTRY。這個表是一個字典，將命令名稱對映到對應的命令類別。

COMMAND_REGISTRY = {
    "create": CreateCommand,
    "update": UpdateCommand,
    "delete": DeleteCommand
}

使用命令模式

現在，我們可以使用命令模式來執行不同型別的請求。首先，我們根據請求的型別從命令登入檔中取得對應的命令類別。然後，我們建立一個命令物件，並呼叫其 execute 方法以執行請求。

def process_request(action, data):
    command_class = COMMAND_REGISTRY.get(action)
    if command_class:
        command = command_class(data)
        command.execute()
    else:
        raise ValueError("Unknown action")

指令重構及命令模式

在軟體設計中，命令模式（Command Pattern）是一種重要的設計模式，能夠幫助我們將請求封裝成物件，使得系統更容易擴充套件和維護。以下是命令模式的一個基本實作：

class Command:
    def execute(self):
        pass

class ConcreteCommand(Command):
    def __init__(self, receiver):
        self.receiver = receiver

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

class Receiver:
    def action(self):
        print("Receiver action")

class Invoker:
    def __init__(self):
        self.commands = {}

    def register_command(self, command_name, command):
        self.commands[command_name] = command

    def execute_command(self, command_name):
        if command_name in self.commands:
            self.commands[command_name].execute()
        else:
            print("Unknown command")

# 使用
receiver = Receiver()
command = ConcreteCommand(receiver)
invoker = Invoker()
invoker.register_command("action", command)
invoker.execute_command("action")

在這個例子中，Command 類別定義了命令的介面，ConcreteCommand 類別實作了具體的命令，Receiver 類別代表了命令的接收者，Invoker 類別負責呼叫命令。

中介者模式

中介者模式（Mediator Pattern）是一種設計模式，能夠幫助我們減少物件之間的耦合度，改善系統的結構。以下是中介者模式的一個基本實作：

class Mediator:
    def __init__(self):
        self.components = {}

    def register_component(self, component_name, component):
        self.components[component_name] = component

    def send_message(self, sender_name, message):
        for component_name, component in self.components.items():
            if component_name!= sender_name:
                component.receive_message(message)

class Component:
    def __init__(self, mediator, name):
        self.mediator = mediator
        self.name = name
        mediator.register_component(name, self)

    def send_message(self, message):
        self.mediator.send_message(self.name, message)

    def receive_message(self, message):
        print(f"Component {self.name} received: {message}")

# 使用
mediator = Mediator()
component1 = Component(mediator, "Component1")
component2 = Component(mediator, "Component2")
component1.send_message("Hello, Component2!")

在這個例子中，Mediator 類別定義了中介者的介面，Component 類別代表了系統中的元件，中介者負責管理元件之間的通訊。

內容解密：

以上程式碼示範了命令模式和中介者模式的基本實作。命令模式能夠幫助我們封裝請求成物件，使得系統更容易擴充套件和維護。中介者模式能夠幫助我們減少物件之間的耦合度，改善系統的結構。這兩種設計模式在軟體設計中非常重要，能夠幫助我們寫出更好的程式碼。

圖表翻譯：

  graph LR
    A[Client] -->| request | B[Invoker]
    B -->| execute | C[Command]
    C -->| action | D[Receiver]

以上圖表示範了命令模式的工作流程。Client 將請求傳遞給 Invoker，Invoker 將請求封裝成 Command 物件，然後將其傳遞給 Receiver。Receiver 執行具體的動作。

  graph LR
    A[Component1] -->| send_message | B[Mediator]
    B -->| send_message | C[Component2]

以上圖表示範了中介者模式的工作流程。Component1 將訊息傳遞給 Mediator，Mediator 將訊息傳遞給 Component2。

行為重構：中介者模式與責任鏈模式

在軟體設計中，行為重構是一個重要的步驟，旨在改善系統的可維護性、可擴充套件性和可讀性。其中，中介者模式和責任鏈模式是兩種常用的行為重構模式。

從技術架構視角來看，本文深入探討了建立模式、結構模式和行為模式在程式碼重構中的應用，涵蓋工廠、建構者、單例、介面卡、外觀、組合、裝飾器、觀察者、策略、命令和中介者等多種設計模式，並佐以簡潔的 Python 程式碼範例。分析階段的多維比較和實務落地分析，清晰地展現了這些模式如何提升程式碼的可讀性、可維護性和可擴充套件性，例如建構者模式如何簡化複雜物件的建立，以及觀察者模式如何實作物件間的解耦。然而，模式的選擇並非一成不變，需根據具體場景權衡利弊。隨著軟體系統日趨複雜，設計模式的應用將更加普及，開發者需深入理解各種模式的特性，才能在重構過程中做出最佳選擇。玄貓認為，熟練掌握設計模式是提升程式碼品質和軟體設計能力的關鍵，值得所有開發者投入時間學習和實踐。

玄貓

玄貓

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