Python 装饰器的洋葱哲学：理解执行顺序与元编程

三、洋葱的核心：多个装饰器的执行顺序

3.1 装饰顺序 vs 执行顺序

这是最容易混淆的概念。让我们用一个详细的例子揭示真相：

import functools

def decorator_a(func):
    print("A: 装饰器 A 被调用")
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("A: 进入装饰器 A 的 wrapper")
        result = func(*args, **kwargs)
        print("A: 离开装饰器 A 的 wrapper")
        return result
    return wrapper

def decorator_b(func):
    print("B: 装饰器 B 被调用")
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("B: 进入装饰器 B 的 wrapper")
        result = func(*args, **kwargs)
        print("B: 离开装饰器 B 的 wrapper")
        return result
    return wrapper

def decorator_c(func):
    print("C: 装饰器 C 被调用")
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("C: 进入装饰器 C 的 wrapper")
        result = func(*args, **kwargs)
        print("C: 离开装饰器 C 的 wrapper")
        return result
    return wrapper

@decorator_a
@decorator_b
@decorator_c
def target_function():
    print(">>> 原始函数执行 <<<")
    return "结果"

print("\n=== 开始调用函数 ===")
result = target_function()
print(f"=== 返回值：{result} ===")

完整输出：

C: 装饰器 C 被调用
B: 装饰器 B 被调用
A: 装饰器 A 被调用
=== 开始调用函数 ===
A: 进入装饰器 A 的 wrapper
B: 进入装饰器 B 的 wrapper
C: 进入装饰器 C 的 wrapper
>>> 原始函数执行 <<<
C: 离开装饰器 C 的 wrapper
B: 离开装饰器 B 的 wrapper
A: 离开装饰器 A 的 wrapper
=== 返回值：结果 ===

3.2 洋葱模型的视觉化理解

装饰阶段（从下往上）：
target_function 
↓ 被 @decorator_c 装饰
wrapped_by_c = decorator_c(target_function) 
↓ 被 @decorator_b 装饰
wrapped_by_b = decorator_b(wrapped_by_c) 
↓ 被 @decorator_a 装饰
final_function = decorator_a(wrapped_by_b)

执行阶段（洋葱模型）：
┌─────────────────────────────────┐
│ A: wrapper 外层                 │
│ ┌───────────────────────────┐   │
│ │ B: wrapper 中层           │   │
│ │ ┌─────────────────────┐   │   │
│ │ │ C: wrapper 内层     │   │   │
│ │ │ ┌───────────────┐   │   │   │
│ │ │ │ 原始函数      │   │   │   │
│ │ │ └───────────────┘   │   │   │
│ │ └─────────────────────┘   │   │
│ └───────────────────────────┘   │
└─────────────────────────────────┘

关键规律：

• 装饰顺序：从下往上（C → B → A）
• 执行顺序：从上往下，再从下往上（A 进入 → B 进入 → C 进入 → 原函数 → C 离开 → B 离开 → A 离开）

3.3 实战案例：构建请求处理链

import time
import json
from functools import wraps

def measure_time(func):
    """性能监控装饰器"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"⏱️ {func.__name__} 耗时：{elapsed:.4f}秒")
        return result
    return wrapper

def validate_input(func):
    """输入验证装饰器"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("正在验证输入参数...")
        if not args:
            raise ValueError("缺少必需参数")
        result = func(*args, **kwargs)
        return result
    return wrapper

@validate_input
@measure_time
def process_data(data):
    time.sleep(0.5)
    return f"Processed: {data}"

process_data("test")