Python裝飾器與導向切面程式設計

Python 的裝飾器提供一種優雅的機制，可在不修改原始函式程式碼的情況下擴充套件其功能，是實作 AOP 的利器。本文除了基本概念外，也涵蓋了引數化裝飾器，允許根據不同需求調整裝飾器行為；根據類別的裝飾器，賦予更強的狀態管理能力，例如實作快取機制。文章也說明多重灌飾器的應用順序，並以交易管理為例，展示裝飾器如何簡化程式碼結構。更進一步，本文探討如何利用超程式設計動態建立單例和工廠模式，以提升程式碼彈性，並示範如何結合兩者，以及如何根據執行時後設資料動態選擇產品類別。

探討Python中的裝飾器與導向切面程式設計

在軟體開發中，導向切面程式設計（Aspect-Oriented Programming, AOP）是一種重要的程式設計正規化，旨在將橫切關注點（cross-cutting concerns）與主要業務邏輯分離。Python中的裝飾器（decorators）是實作AOP的一種強大工具。本文將探討Python裝飾器的進階用法，包括引數化裝飾器、根據類別的裝飾器，並探討如何在應用導向切面原則時保持程式碼的可讀性和效能。

裝飾器的基本概念

裝飾器是一種特殊的函式，能夠在不修改原始函式程式碼的前提下，擴充套件或修改其行為。這是透過將目標函式封裝在一個包裝函式（wrapper function）中實作的。簡單來說，裝飾器是一個可呼叫的物件，它接收一個函式並傳回一個新的可呼叫物件，以增強原始函式的功能。例如，以下是一個簡單的日誌記錄裝飾器：

import functools

def log_calls(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"呼叫 {func.__name__} 時引數為 args={args}, kwargs={kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} 傳回 {result}")
        return result
    return wrapper

@log_calls
def compute_sum(a, b):
    return a + b

compute_sum(5, 7)

內容解密：

log_calls裝飾器：此裝飾器用於記錄函式的呼叫資訊和傳回值。
functools.wraps(func)：確保原始函式的元資料（如名稱、檔案字串和簽名）在包裝後仍然保留，對於除錯和內省非常重要。
wrapper函式：包裝原始函式，實作額外的日誌記錄功能。

引數化裝飾器

引數化裝飾器允許在應用裝飾器時動態組態其行為。這透過增加額外的包裝層來實作。以下是一個引數化日誌記錄裝飾器的範例：

def log(level):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            if level == "DEBUG":
                print(f"[DEBUG] {func.__name__} 被呼叫，引數為 {args} {kwargs}")
            elif level == "INFO":
                print(f"[INFO] 正在呼叫 {func.__name__}")
            result = func(*args, **kwargs)
            if level == "DEBUG":
                print(f"[DEBUG] {func.__name__} 傳回 {result}")
            return result
        return wrapper
    return decorator

@log("DEBUG")
def multiply(a, b):
    return a * b

multiply(3, 4)

內容解密：

log(level)函式：傳回一個裝飾器，該裝飾器的行為由level引數決定。
decorator(func)：實際的裝飾器，根據level的不同，實作不同的日誌記錄策略。
wrapper函式：根據設定的日誌級別，輸出不同的日誌資訊。

根據類別的裝飾器

根據類別的裝飾器提供了更多的控制和狀態管理能力，特別是在需要跨多個呼叫維護內部狀態或組態時非常有用。以下是一個使用類別實作的快取裝飾器範例：

class CacheDecorator:
    def __init__(self, func):
        functools.update_wrapper(self, func)
        self.func = func
        self.cache = {}

    def __call__(self, *args, **kwargs):
        key = (args, frozenset(kwargs.items()))
        if key in self.cache:
            print(f"快取命中：{self.func.__name__}，鍵值為 {key}")
            return self.cache[key]
        print(f"快取未命中：{self.func.__name__}，鍵值為 {key}")
        result = self.func(*args, **kwargs)
        self.cache[key] = result
        return result

@CacheDecorator
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))

內容解密：

CacheDecorator類別：實作了一個快取機制，將之前計算的結果儲存起來，避免重複計算。
__call__方法：使例項可呼叫，當呼叫被裝飾的函式時，先檢查快取中是否存在結果。
self.cache：用於儲存已計算結果的字典。

多重灌飾器的應用與順序管理

在實際開發中，可能需要對一個函式應用多個裝飾器。裝飾器的應用順序對最終的行為有著重要影響。Python中，裝飾器從內到外依次應用。以下是一個結合日誌記錄和效能測量的範例：

import time

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start_time
        print(f"{func.__name__} 執行時間為 {elapsed:.5f} 秒")
        return result
    return wrapper

@log("INFO")
@timer
def process_data(data):
    total = 0
    for item in data:
        total += item
    time.sleep(0.01)  # 模擬延遲
    return total

process_data(list(range(10)))

內容解密：

timer裝飾器：測量函式的執行時間。
log("INFO")裝飾器：在INFO級別記錄函式呼叫資訊。
裝飾器順序：@timer最靠近函式，確保測量的是實際執行時間，而非包括日誌記錄在內的總時間。

交易管理中的裝飾器應用

在資料密集型應用中，可以使用裝飾器來實作交易管理，將交易的開始、提交或回復抽象出來，使業務邏輯更加清晰。以下是一個簡單的交易管理裝飾器範例：

class TransactionManager:
    def __enter__(self):
        print("交易開始")
        # 初始化交易上下文
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type:
            print("由於異常，交易回復")
            # 執行回復操作
        else:
            print("交易提交")
            # 提交交易

def transactional(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        with TransactionManager():
            return func(*args, **kwargs)
    return wrapper

@transactional
def perform_database_operation():
    # 模擬資料函式庫操作
    print("執行資料函式庫操作")

perform_database_operation()

內容解密：

TransactionManager類別：管理交易的上下文，利用Python的上下文管理器協定（__enter__和__exit__方法）來控制交易的生命週期。
transactional裝飾器：將被裝飾的函式包裝在交易管理邏輯中，確保函式執行過程中交易的正確處理。

動態建立單例模式與工廠模式

動態例項化設計模式，尤其是單例模式和工廠模式，利用Python中的超程式設計技術來最小化樣板程式碼並最大化系統的靈活性。進階開發者可以利用元類別、動態例項快取和執行時類別組合，建立可適應的系統，自動管理物件生命週期和例項建立策略。本文將探討動態建立單例模式和工廠模式背後的機制，詳細介紹使用Python的內省和動態型別建構功能來確保執行緒安全和高效例項化的實作。

單例模式的元類別實作

單例模式強制一個類別只有一個例項，並提供一個全域存取點來存取該例項。傳統的實作通常依賴於模組級別的變數或靜態方法；然而，超程式設計透過攔截類別建立過程，提供了一個更優雅的解決方案。自定義的元類別可以透過在字典中快取例項並在後續呼叫中傳回它來覆寫例項化程式。以下程式碼範例演示了用於單例模式的強壯元類別實作：

import threading

class SingletonMeta(type):
    _instances = {}
    _lock = threading.Lock()

    def __call__(cls, *args, **kwargs):
        # 雙重檢查鎖定以確保執行緒安全
        if cls not in cls._instances:
            with cls._lock:
                if cls not in cls._instances:
                    instance = super().__call__(*args, **kwargs)
                    cls._instances[cls] = instance
        return cls._instances[cls]

class SingletonExample(metaclass=SingletonMeta):
    def __init__(self, value):
        self.value = value

# 展示執行緒安全的單例行為
singleton1 = SingletonExample(10)
singleton2 = SingletonExample(20)

print(singleton1.value)  # 輸出：10
print(singleton2.value)  # 輸出：10
print(singleton1 is singleton2)  # 輸出：True

內容解密：

SingletonMeta 元類別使用 _instances 字典來儲存已建立的例項，並使用 _lock 來確保執行緒安全。
__call__ 方法被覆寫以實作雙重檢查鎖定機制，確保即使在平行條件下，也只建立一個例項。
SingletonExample 類別使用 SingletonMeta 元類別，展示了執行緒安全的單例行為。

工廠模式的動態建立

除了確保單一例項外，超程式設計還促進了根據執行時條件例項化物件的工廠的動態建立。工廠模式抽象了物件建立，從而允許程式碼與具體實作解耦。一種有效的技術涉及使用類別登入檔和動態型別生成來產生可以根據組態建立元件例項的工廠類別。

class Factory:
    _registry = {}

    @classmethod
    def register(cls, name):
        def decorator(class_):
            cls._registry[name] = class_
            return class_
        return decorator

    @classmethod
    def create_instance(cls, name, *args, **kwargs):
        class_ = cls._registry.get(name)
        if class_ is None:
            raise ValueError(f"Unknown class name: {name}")
        return class_(*args, **kwargs)

@Factory.register('singleton')
class SingletonExample:
    def __init__(self, value):
        self.value = value

# 使用工廠建立例項
instance = Factory.create_instance('singleton', 10)
print(instance.value)  # 輸出：10

內容解密：

Factory 類別提供了一個序號產生器制，允許類別透過裝飾器註冊到工廠。
create_instance 方法根據註冊的名稱建立類別的例項。
SingletonExample 類別被註冊到工廠，可以透過工廠建立其例項。

動態工廠模式的進階應用與單例模式的結合

在軟體開發中，工廠模式是一種常見的設計模式，用於建立物件而不需要指定將要建立的物件的確切類別。本文將探討動態工廠模式，並展示如何透過元類別（meta-class）實作自動註冊產品類別，同時探討其與單例模式的結合。

使用元類別實作動態工廠

動態工廠模式允許在執行時根據輸入引數建立不同的物件。以下程式碼展示瞭如何使用元類別 ProductFactoryMeta 自動註冊產品類別：

class ProductFactoryMeta(type):
    _registry = {}

    def __new__(mcls, name, bases, namespace):
        cls = super().__new__(mcls, name, bases, namespace)
        # 跳過抽象基礎類別的註冊
        if not namespace.get('abstract', False):
            mcls._registry[name] = cls
        return cls

    @classmethod
    def create(cls, product_name, *args, **kwargs):
        # 從登入檔中檢索產品類別
        if product_name not in cls._registry:
            raise ValueError(f"Product {product_name} not registered.")
        product_cls = cls._registry[product_name]
        return product_cls(*args, **kwargs)

class BaseProduct(metaclass=ProductFactoryMeta):
    abstract = True

    def use(self):
        raise NotImplementedError("Must implement in subclass")

class ProductA(BaseProduct):
    def __init__(self, feature):
        self.feature = feature

    def use(self):
        return f"ProductA with feature {self.feature}"

class ProductB(BaseProduct):
    def __init__(self, capacity):
        self.capacity = capacity

    def use(self):
        return f"ProductB with capacity {self.capacity}"

# 透過工廠元類別動態建立產品
product_a = ProductFactoryMeta.create("ProductA", feature="X")
product_b = ProductFactoryMeta.create("ProductB", capacity=100)

print(product_a.use())
print(product_b.use())

內容解密：

ProductFactoryMeta 元類別：負責自動註冊所有非抽象的產品類別到 _registry 字典中。
create 方法：根據產品名稱動態建立相應的產品例項。
BaseProduct 類別：定義了產品的基本介面，並標記為抽象類別以避免被註冊。
ProductA 和 ProductB：具體的產品類別，實作了 use 方法。

根據執行時後設資料的動態工廠擴充套件

進一步擴充套件動態工廠模式，可以根據執行時後設資料（如組態檔案或環境變數）來決定例項化哪個產品子類別。以下示例展示瞭如何透過 ConfigurableFactoryMeta 實作這一功能：

class ConfigurableFactoryMeta(type):
    _registry = {}

    def __new__(mcls, name, bases, namespace):
        cls = super().__new__(mcls, name, bases, namespace)
        identifier = namespace.get('IDENTIFIER')
        if identifier:
            mcls._registry[identifier] = cls
        return cls

    @classmethod
    def create_by_identifier(mcls, identifier, *args, **kwargs):
        if identifier not in mcls._registry:
            raise ValueError(f"Identifier {identifier} not mapped to any class")
        return mcls._registry[identifier](*args, **kwargs)

class AbstractComponent(metaclass=ConfigurableFactoryMeta):
    IDENTIFIER = None

    def operate(self):
        raise NotImplementedError

class ComponentX(AbstractComponent):
    IDENTIFIER = "X"

    def __init__(self, config):
        self.config = config

    def operate(self):
        return f"ComponentX operating with config {self.config}"

class ComponentY(AbstractComponent):
    IDENTIFIER = "Y"

    def __init__(self, threshold):
        self.threshold = threshold

    def operate(self):
        return f"ComponentY operating with threshold {self.threshold}"

# 根據組態在執行時建立元件
component = ConfigurableFactoryMeta.create_by_identifier("Y", threshold=42)
print(component.operate())

內容解密：

ConfigurableFactoryMeta 元類別：維護一個對映識別符號到類別的登入檔。
create_by_identifier 方法：根據識別符號建立相應的元件例項。
AbstractComponent 類別：定義了元件的基本介面，並使用 IDENTIFIER 屬性進行註冊。
ComponentX 和 ComponentY：具體的元件類別，實作了 operate 方法。

結合單例模式與工廠模式

將單例模式與工廠模式結合，可以建立出既能控制例項數量又能靈活建立物件的工廠。以下示例展示瞭如何透過 SingletonFactoryMeta 實作這一結合：

class SingletonFactoryMeta(type):
    _instances = {}
    _registry = {}

    def __new__(mcls, name, bases, namespace):
        cls = super().__new__(mcls, name, bases, namespace)
        product_id = namespace.get('PRODUCT_ID')
        if product_id:
            mcls._registry[product_id] = cls
        return cls

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

    @classmethod
    def create_singleton(mcls, product_id, *args, **kwargs):
        if product_id not in mcls._registry:
            raise ValueError(f"No registered product with id {product_id}")
        product_cls = mcls._registry[product_id]
        return product_cls(*args, **kwargs)

class AbstractSingletonProduct(metaclass=SingletonFactoryMeta):
    PRODUCT_ID = None

    def operation(self):
        raise NotImplementedError

class UniqueProduct(AbstractSingletonProduct):
    PRODUCT_ID = "unique"

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

    def operation(self):
        return f"UniqueProduct operating with data {self.data}"

# 建立單例例項
singleton_instance1 = SingletonFactoryMeta.create_singleton("unique", data="alpha")
singleton_instance2 = SingletonFactoryMeta.create_singleton("unique", data="beta")

print(singleton_instance1.operation())
print(singleton_instance2.operation())
print(singleton_instance1 is singleton_instance2)

內容解密：

SingletonFactoryMeta 元類別：結合了單例模式和工廠模式，確保每個類別只有一個例項。
create_singleton 方法：根據產品ID建立單例例項。
AbstractSingletonProduct 類別：定義了單例產品的基本介面。
UniqueProduct 類別：具體的單例產品類別，實作了 operation 方法。

玄貓 BlackCat

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