异步装饰器实战指南：从原理到高级应用_python 异步装饰器-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_54490473/article/details/146185273

异步装饰器实战指南：从原理到高级应用

在Python 3.5+版本中，async/await语法彻底改变了异步编程的方式。本文将深入探讨如何为异步函数构建装饰器，并通过5个生产级案例展示其强大能力。

一、异步编程核心概念

1.1 异步函数特性

使用async def定义
内部包含await表达式
返回coroutine对象
必须通过事件循环执行

1.2 装饰器特殊要求

必须返回coroutine对象
装饰器本身可以是普通函数或异步函数
需要处理async with/for语法

二、基础异步装饰器实现

2.1 最简结构示例

import asyncio
from functools import wraps

def async_timer(func):
    @wraps(func)
    async def wrapper(*args, **kwargs):
        start = asyncio.get_event_loop().time()
        result = await func(*args, **kwargs)  # 关键await
        end = asyncio.get_event_loop().time()
        print(f"执行耗时: {end - start:.2f}s")
        return result
    return wrapper

@async_timer
async def fetch_data():
    await asyncio.sleep(1)
    return "数据获取成功"

# 执行测试
async def main():
    print(await fetch_data())

asyncio.run(main())
# 输出：
# 执行耗时: 1.00s
# 数据获取成功

2.2 同步装饰器陷阱

# 错误示范：忘记处理await
def bad_decorator(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)  # 缺少await导致返回coroutine对象
    return wrapper

三、5个生产级案例

3.1 异步重试机制

def async_retry(max_retries=3, delay=1):
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            for attempt in range(1, max_retries+1):
                try:
                    return await func(*args, **kwargs)
                except Exception as e:
                    print(f"尝试 {attempt} 失败: {str(e)}")
                    if attempt < max_retries:
                        await asyncio.sleep(delay)
            raise RuntimeError("超出最大重试次数")
        return wrapper
    return decorator

@async_retry(max_retries=3)
async def unstable_operation():
    if random.random() > 0.3:
        raise ConnectionError("模拟网络错误")
    return "操作成功"

3.2 并发限流器

from collections import deque

def async_throttle(rate_limit=5, period=1):
    """限制单位时间内最大调用次数"""
    history = deque(maxlen=rate_limit)
    
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            now = asyncio.get_event_loop().time()
            if len(history) >= rate_limit:
                elapsed = now - history[0]
                if elapsed < period:
                    await asyncio.sleep(period - elapsed)
                history.popleft()
            result = await func(*args, **kwargs)
            history.append(now)
            return result
        return wrapper
    return decorator

@async_throttle(rate_limit=3, period=2)
async def api_request():
    print("执行API请求")

3.3 异步缓存系统

import aiocache
from aiocache import cached

@cached(ttl=60, cache=aiocache.SimpleMemoryCache)
async def get_user_profile(user_id):
    print(f"查询数据库获取用户{user_id}信息")
    await asyncio.sleep(0.5)
    return {"id": user_id, "name": "测试用户"}

async def main():
    print(await get_user_profile(1))  # 实际查询
    print(await get_user_profile(1))  # 从缓存获取

asyncio.run(main())

3.4 分布式锁装饰器

from redis.asyncio import Redis

def async_distributed_lock(key, timeout=10):
    async def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            redis = Redis.from_url("redis://localhost")
            lock = redis.lock(key, timeout=timeout)
            async with lock:
                print("成功获取分布式锁")
                return await func(*args, **kwargs)
        return wrapper
    return decorator

@async_distributed_lock("order:create")
async def create_order(user_id):
    await asyncio.sleep(1)
    return {"order_id": 123}

3.5 链路追踪装饰器

from opentelemetry import trace

def async_trace(name):
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            tracer = trace.get_tracer(__name__)
            with tracer.start_as_current_span(name):
                print(f"开始追踪: {name}")
                result = await func(*args, **kwargs)
                print(f"结束追踪: {name}")
                return result
        return wrapper
    return decorator

@async_trace("用户注册流程")
async def user_signup(email):
    await asyncio.sleep(0.5)
    return {"status": "success"}

四、进阶开发技巧

4.1 类形式的异步装饰器

class AsyncDecorator:
    def __init__(self, func):
        self.func = func
    
    async def __call__(self, *args, **kwargs):
        print("前置处理")
        result = await self.func(*args, **kwargs)
        print("后置处理")
        return result

@AsyncDecorator
async def sample_task():
    await asyncio.sleep(0.1)
    return "完成"

asyncio.run(sample_task())

4.2 装饰器参数传递

def async_retry_v2(max_retries):
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            # 实现带参数的装饰器逻辑
            return await func(*args, **kwargs)
        return wrapper
    return decorator