淘宝高并发请求接口设计与实战指南（2026版）

┌─────────────────────────────────────────┐
│  接入层：负载均衡 + 限流 + 鉴权          │
│  （Nginx / Kong / Spring Cloud Gateway） │
├─────────────────────────────────────────┤
│  应用层：异步处理 + 连接池 + 熔断降级     │
│  （协程 / 线程池 / Hystrix）             │
├─────────────────────────────────────────┤
│  数据层：多级缓存 + 消息队列 + 批量合并   │
│  （Redis / Kafka / 请求合并器）          │
├─────────────────────────────────────────┤
│  调用层：多账号轮询 + 智能路由 + 熔断     │
│  （账号池 / 代理池 / 自适应限流）          │
└─────────────────────────────────────────┘

import asyncioimport aiohttpimport timefrom typing import List, Dictimport logging

logging.basicConfig(level=logging.INFO)logger = logging.getLogger(__name__)class AsyncTaobaoClient:
    """
    高性能异步淘宝API客户端
    支持连接池、自动限流、批量合并
    """
    
    def __init__(self, 
                 api_keys: List[str],
                 max_concurrent: int = 100,
                 qps_limit: float = 8.0):  # 留20%安全余量
        self.api_keys = api_keys
        self.key_index = 0
        self.max_concurrent = max_concurrent
        self.qps_limit = qps_limit
        self.min_interval = 1.0 / qps_limit        
        # 连接池配置（关键：复用TCP连接）
        self.connector = aiohttp.TCPConnector(
            limit=100,                    # 总连接数上限
            limit_per_host=20,            # 单域名连接数
            enable_cleanup_closed=True,   # 自动清理关闭连接
            force_close=False,            # 保持长连接
            ttl_dns_cache=300             # DNS缓存5分钟
        )
        
        # 会话配置
        timeout = aiohttp.ClientTimeout(total=10, connect=2)
        self.session = aiohttp.ClientSession(
            connector=self.connector,
            timeout=timeout,
            headers={"Connection": "keep-alive"}
        )
        
        # 限流控制
        self.last_request_time = 0
        self.semaphore = asyncio.Semaphore(max_concurrent)
        
        # 请求合并器（10ms窗口）
        self.pending_requests = {}
        self.batch_window = 0.01  # 10ms
        self.batch_task = None
    
    async def _rate_limit(self):
        """令牌桶限流"""
        now = time.time()
        elapsed = now - self.last_request_time        if elapsed < self.min_interval:
            await asyncio.sleep(self.min_interval - elapsed)
        self.last_request_time = time.time()
    
    def _get_next_key(self) -> str:
        """轮询获取API密钥（负载均衡）"""
        key = self.api_keys[self.key_index]
        self.key_index = (self.key_index + 1) % len(self.api_keys)
        return key    
    async def _batch_request(self, num_iids: List[str]) -> Dict:
        """批量请求（合并多个单商品查询）"""
        await self._rate_limit()
        
        key = self._get_next_key()
        url = "https://o0b.cn/ibrad/taobao/item_get/"
        
        # 批量接口（假设支持最多40个）
        params = {
            "key": key,
            "num_iids": ",".join(num_iids[:40]),
            "is_promotion": 1
        }
        
        try:
            async with self.semaphore:
                async with self.session.get(url, params=params) as resp:
                    if resp.status == 200:
                        return await resp.json()
                    else:
                        logger.error(f"HTTP错误: {resp.status}")
                        return {}
        except Exception as e:
            logger.error(f"请求异常: {e}")
            return {}
    
    async def get_price(self, num_iid: str) -> Dict:
        """
        获取单个商品券后价（支持请求合并）
        """
        # 如果已有待处理的批量请求，加入等待
        if self.batch_task and not self.batch_task.done():
            future = asyncio.Future()
            self.pending_requests[num_iid] = future            return await future        
        # 启动新的批量窗口
        self.pending_requests[num_iid] = asyncio.Future()
        self.batch_task = asyncio.create_task(self._execute_batch())
        
        # 等待结果
        result = await self.pending_requests[num_iid]
        return result    
    async def _execute_batch(self):
        """执行批量请求并分发结果"""
        await asyncio.sleep(self.batch_window)  # 等待窗口收集请求
        
        # 复制当前批次
        batch = self.pending_requests.copy()
        self.pending_requests = {}
        self.batch_task = None
        
        num_iids = list(batch.keys())
        if not num_iids:
            return
        
        # 分批处理（每批40个）
        for i in range(0, len(num_iids), 40):
            chunk = num_iids[i:i+40]
            result = await self._batch_request(chunk)
            
            # 解析并分发结果
            items = result.get("items", [])
            for item in items:
                iid = str(item.get("num_iid"))
                if iid in batch:
                    batch[iid].set_result(item)
            
            # 处理未找到的商品
            for iid in chunk:
                if not batch[iid].done():
                    batch[iid].set_result({})
    
    async def get_prices_concurrent(self, num_iids: List[str], max_per_second: int = 50) -> List[Dict]:
        """
        高并发获取多个商品价格（带全局限速）
        """
        semaphore = asyncio.Semaphore(max_per_second)
        
        async def fetch_with_limit(iid):
            async with semaphore:
                result = await self.get_price(iid)
                await asyncio.sleep(1.0 / max_per_second)  # 全局限速
                return result
        
        tasks = [fetch_with_limit(iid) for iid in num_iids]
        return await asyncio.gather(*tasks, return_exceptions=True)
    
    async def close(self):
        """优雅关闭"""
        await self.session.close()
        await self.connector.close()# 使用示例async def main():
    # 多密钥配置（应对单账号限流）
    api_keys = ["key1", "key2", "key3", "key4"]
    
    client = AsyncTaobaoClient(
        api_keys=api_keys,
        max_concurrent=100,
        qps_limit=8.0  # 每个密钥8QPS，4密钥共32QPS
    )
    
    # 模拟高并发：1000个商品查询
    test_ids = [f"123456{i}" for i in range(1000)]
    
    start = time.time()
    results = await client.get_prices_concurrent(test_ids, max_per_second=30)
    elapsed = time.time() - start
    
    success = sum(1 for r in results if isinstance(r, dict) and r.get("final_price"))
    logger.info(f"完成: {success}/{len(test_ids)} 成功, 耗时: {elapsed:.2f}s, QPS: {len(test_ids)/elapsed:.1f}")
    
    await client.close()if __name__ == "__main__":
    asyncio.run(main())

import redisimport jsonimport hashlibfrom functools import wrapsfrom typing import Optionalimport timeclass MultiLevelCache:
    """
    L1: 本地LRU缓存（Caffeine/缓存字典）
    L2: Redis分布式缓存
    L3: 淘宝API（兜底）
    """
    
    def __init__(self, 
                 redis_host="localhost", 
                 redis_port=6379,
                 local_ttl=60,      # 本地缓存60秒
                 redis_ttl=300):    # Redis缓存5分钟
        self.redis = redis.Redis(host=redis_host, port=redis_port, decode_responses=True)
        self.local_cache = {}  # 生产环境用Caffeine/py-cache
        self.local_ttl = local_ttl
        self.redis_ttl = redis_ttl        
        # 缓存统计
        self.stats = {"L1_hit": 0, "L2_hit": 0, "L3_miss": 0}
    
    def _generate_key(self, num_iid: str, params: dict) -> str:
        """生成缓存键"""
        key_str = f"{num_iid}:{json.dumps(params, sort_keys=True)}"
        return f"taobao:price:{hashlib.md5(key_str.encode()).hexdigest()}"
    
    def get(self, num_iid: str, params: dict = None) -> Optional[dict]:
        """多级缓存读取"""
        cache_key = self._generate_key(num_iid, params or {})
        
        # L1: 本地缓存
        if cache_key in self.local_cache:
            value, expire_time = self.local_cache[cache_key]
            if time.time() < expire_time:
                self.stats["L1_hit"] += 1
                return value            else:
                del self.local_cache[cache_key]
        
        # L2: Redis缓存
        cached = self.redis.get(cache_key)
        if cached:
            self.stats["L2_hit"] += 1
            data = json.loads(cached)
            # 回填L1
            self.local_cache[cache_key] = (data, time.time() + self.local_ttl)
            return data
        
        self.stats["L3_miss"] += 1
        return None
    
    def set(self, num_iid: str, data: dict, params: dict = None):
        """多级缓存写入"""
        cache_key = self._generate_key(num_iid, params or {})
        
        # 写入L1
        self.local_cache[cache_key] = (data, time.time() + self.local_ttl)
        
        # 写入L2（带随机过期，防止雪崩）
        import random
        jitter = random.randint(0, 60)  # 0-60秒随机偏移
        self.redis.setex(cache_key, self.redis_ttl + jitter, json.dumps(data))
    
    def invalidate(self, num_iid: str):
        """主动失效缓存（价格变动时）"""
        pattern = f"taobao:price:*{num_iid}*"
        for key in self.redis.scan_iter(match=pattern):
            self.redis.delete(key)
        # 清理L1
        keys_to_del = [k for k in self.local_cache if num_iid in k]
        for k in keys_to_del:
            del self.local_cache[k]# 装饰器模式：自动缓存def cached_price(cache_manager: MultiLevelCache, ttl: int = 300):
    def decorator(func):
        @wraps(func)
        async def wrapper(self, num_iid: str, *args, **kwargs):
            # 尝试读缓存
            cached = cache_manager.get(num_iid, kwargs)
            if cached:
                return cached            
            # 调用API
            result = await func(self, num_iid, *args, **kwargs)
            
            # 写入缓存（仅成功响应）
            if result and result.get("final_price"):
                cache_manager.set(num_iid, result, kwargs)
            
            return result        return wrapper    return decorator

from enum import Enumimport timefrom typing import Callableimport asyncioclass CircuitState(Enum):
    CLOSED = "closed"      # 正常
    OPEN = "open"          # 熔断
    HALF_OPEN = "half_open" # 探测class CircuitBreaker:
    """
    熔断器模式（防止API故障拖垮系统）
    """
    
    def __init__(self, 
                 failure_threshold: int = 5,      # 连续失败5次熔断
                 recovery_timeout: float = 30.0,  # 30秒后尝试恢复
                 half_open_max_calls: int = 3):   # 半开状态最多3次试探
        self.failure_threshold = failure_threshold
        self.recovery_timeout = recovery_timeout
        self.half_open_max_calls = half_open_max_calls
        
        self.state = CircuitState.CLOSED
        self.failure_count = 0
        self.last_failure_time = None
        self.half_open_calls = 0
        
        # 备用策略
        self.fallback_cache = {}  # 过期缓存兜底
    
    async def call(self, func: Callable, *args, **kwargs):
        """带熔断保护的调用"""
        
        if self.state == CircuitState.OPEN:
            if time.time() - self.last_failure_time > self.recovery_timeout:
                self.state = CircuitState.HALF_OPEN
                self.half_open_calls = 0
                logger.info("熔断器进入半开状态，尝试恢复")
            else:
                # 熔断中，直接走降级
                return await self._fallback(*args, **kwargs)
        
        if self.state == CircuitState.HALF_OPEN:
            if self.half_open_calls >= self.half_open_max_calls:
                return await self._fallback(*args, **kwargs)
            self.half_open_calls += 1
        
        try:
            result = await func(*args, **kwargs)
            self._on_success()
            return result        except Exception as e:
            self._on_failure()
            raise e    
    def _on_success(self):
        """成功处理"""
        self.failure_count = 0
        if self.state == CircuitState.HALF_OPEN:
            self.state = CircuitState.CLOSED
            logger.info("熔断器关闭，服务恢复")
    
    def _on_failure(self):
        """失败处理"""
        self.failure_count += 1
        self.last_failure_time = time.time()
        
        if self.failure_count >= self.failure_threshold:
            self.state = CircuitState.OPEN
            logger.error(f"熔断器打开，连续失败{self.failure_count}次")
    
    async def _fallback(self, *args, **kwargs):
        """降级策略"""
        num_iid = args[0] if args else kwargs.get("num_iid")
        
        # 策略1：返回过期缓存
        if num_iid in self.fallback_cache:
            logger.warning(f"熔断降级：返回过期缓存 {num_iid}")
            return self.fallback_cache[num_iid]
        
        # 策略2：返回友好提示
        return {
            "num_iid": num_iid,
            "error": "服务暂时不可用，请稍后重试",
            "final_price": None,
            "is_fallback": True
        }
    
    def update_fallback_cache(self, num_iid: str, data: dict):
        """更新兜底缓存"""
        self.fallback_cache[num_iid] = data# 集成到客户端class ResilientTaobaoClient(AsyncTaobaoClient):
    """带熔断器的淘宝客户端"""
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.breaker = CircuitBreaker()
        self.cache = MultiLevelCache()
    
    @cached_price(cache_manager=MultiLevelCache())  # 先走缓存
    async def get_price_safe(self, num_iid: str) -> dict:
        """带熔断保护的查询"""
        return await self.breaker.call(self._fetch_from_api, num_iid)
    
    async def _fetch_from_api(self, num_iid: str) -> dict:
        """实际API调用"""
        result = await super().get_price(num_iid)
        
        # 更新熔断器的兜底缓存
        if result and result.get("final_price"):
            self.breaker.update_fallback_cache(num_iid, result)
        
        return result

# deployment.yamlapiVersion: apps/v1kind: Deploymentmetadata:
  name: taobao-price-servicespec:
  replicas: 3  # 多实例部署
  selector:
    matchLabels:
      app: taobao-price  template:
    metadata:
      labels:
        app: taobao-price    spec:
      containers:
      - name: api        image: taobao-price-service:v1.2        resources:
          requests:
            memory: "512Mi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "2000m"
        env:
        - name: API_KEYS          valueFrom:
            secretKeyRef:
              name: taobao-secrets              key: api-keys  # 密钥从K8s Secret注入
        livenessProbe:
          httpGet:
            path: /health            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5---apiVersion: v1kind: Servicemetadata:
  name: taobao-price-servicespec:
  selector:
    app: taobao-price  ports:
  - port: 80
    targetPort: 8080
  type: ClusterIP---apiVersion: autoscaling/v2kind: HorizontalPodAutoscalermetadata:
  name: taobao-price-hpaspec:
  scaleTargetRef:
    apiVersion: apps/v1    kind: Deployment    name: taobao-price-service  minReplicas: 3
  maxReplicas: 20
  metrics:
  - type: Resource    resource:
      name: cpu      target:
        type: Utilization        averageUtilization: 70
  - type: Pods    pods:
      metric:
        name: http_requests_per_second      target:
        type: AverageValue        averageValue: "1000"

from prometheus_client import Counter, Histogram, Gauge, start_http_server# 指标定义api_requests_total = Counter('taobao_api_requests_total', 'Total requests', ['status'])api_request_duration = Histogram('taobao_api_request_duration_seconds', 'Request latency')cache_hit_rate = Gauge('taobao_cache_hit_rate', 'Cache hit rate')circuit_breaker_state = Gauge('circuit_breaker_state', 'Circuit breaker state', ['name'])# 在代码中埋点class MonitoredClient(ResilientTaobaoClient):
    async def get_price(self, num_iid: str):
        with api_request_duration.time():
            result = await super().get_price(num_iid)
            
            if result and result.get("final_price"):
                api_requests_total.labels(status='success').inc()
            else:
                api_requests_total.labels(status='failure').inc()
            
            return result